Пример #1
0
    def JoinWindow(self, title, text, allowCancel=0, width=50, entryWidth=37, buttons=["Join"], hlp=None):
        bb = ButtonBar(self.screen, buttons)
        t = TextboxReflowed(width, text)

        sg = Grid(2, 2)

        entryList = []
        e = Entry(entryWidth)
        sg.setField(Label("User name"), 0, 0, padding=(0, 0, 1, 0), anchorLeft=1)
        sg.setField(e, 1, 0, anchorLeft=1)
        entryList.append(e)
        e = Entry(entryWidth, password=1)
        sg.setField(Label("Password"), 0, 1, padding=(0, 0, 1, 0), anchorLeft=1)
        sg.setField(e, 1, 1, anchorLeft=1)
        entryList.append(e)

        g = GridForm(self.screen, title, 1, 3)

        g.add(t, 0, 0, padding=(0, 0, 0, 1))
        g.add(sg, 0, 1, padding=(0, 0, 0, 1))
        g.add(bb, 0, 2, growx=1)

        result = g.runOnce()

        entryValues = []
        for entry in entryList:
            entryValues.append(entry.value())

        return (bb.buttonPressed(result), tuple(entryValues))
Пример #2
0
def process():
    global NvLtDrvURL, LatestFile, LatestHeader, DownloadFlag, SymlinkFlag
    screen = SnackScreen()
    bb = ButtonBar(screen, (("End", "end"), ))
    tbTittle = Textbox(65, 3, "Processing Input... ", 0, 1)

    tbDownload = Textbox(65, 3, " ", 0, 1)

    tbSymlink = Textbox(65, 3, " ", 0, 1)

    g = GridForm(screen, "chkltdr (NvDrIn) - by Trodskovich", 1, 6)
    g.add(tbTittle, 0, 2)
    g.add(tbDownload, 0, 3, growx=1)
    g.add(tbSymlink, 0, 4, growx=1)
    g.add(bb, 0, 5, growx=1)

    if DownloadFlag:
        tbDownload.setText("Downloading Please Wait...")
        result = g.runOnce()
        screen.finish()
        urllib.request.urlretrieve(NvLtDrvURL, "./" + LatestFile)
    else:
        tbDownload.setText("Download Skipped")

    if SymlinkFlag:
        subprocess.call(
            ["ln -nfs ./" + LatestFile + " NVIDIA-Linux-x86_64-Latest.run"],
            shell=True)
        tbSymlink.setText("Symlink Created")
    else:
        tbSymlink.setText("Symlink Skipped")
    result = g.runOnce()
    screen.finish()
    return bb.buttonPressed(result)
Пример #3
0
def create_select_checkbox(screen,
                           title,
                           text,
                           items,
                           buttons=(('Cancel', 'cancel', 'F12'), 'Ok'),
                           width=40,
                           scroll=0,
                           height=-1,
                           help=None):
    """Helper class for displaying a windows with a checkbox list.
    On exit, list of selected items is returned"""
    if (height == -1):
        height = len(items)
    if len(items) > height:
        scroll = 1
    bb = ButtonBar(screen, buttons)
    t = TextboxReflowed(width, text)
    cb = CheckboxTree(height, scroll=scroll)
    count = 0
    for count, item in enumerate(items):
        if isinstance(item, types.TupleType):
            (text, key, selected) = item
        else:
            text = item
            key = count
            selected = 0

        cb.append(text, key, selected)

    g = GridFormHelp(screen, title, help, 1, 3)
    g.add(t, 0, 0)
    g.add(cb, 0, 1, padding=(0, 1, 0, 1))
    g.add(bb, 0, 2, growx=1)
    rc = g.runOnce()
    return (bb.buttonPressed(rc), cb.getSelection())
Пример #4
0
def display_create_template(screen, title, vm_type, templates, help=None):
    """Helper function for displaying a form for creating a new VM template"""
    label_base = Textbox(
        40, 2,
        'Select %s VM to be used as a basis\n(only stopped VMs are allowed)' %
        vm_type, 0, 0)

    base_tmpl = Listbox(7, 1, 0, 30, 1)
    for vm in templates.keys():
        base_tmpl.append(templates[vm], vm)

    label_newname = Textbox(40, 2, 'Name of the template to be created', 0, 0)
    spacer1 = Textbox(1, 1, "", 0, 0)
    spacer2 = Textbox(1, 1, "", 0, 0)
    entry_newname = Entry(30, 'template_name')
    bb = ButtonBar(screen, ('Create new template', ('Back to menu', 'back')))
    form = GridFormHelp(screen, title, help, 1, 7)
    form.add(label_base, 0, 0)
    form.add(base_tmpl, 0, 1)
    form.add(spacer1, 0, 2)
    form.add(label_newname, 0, 3)
    form.add(entry_newname, 0, 4)
    form.add(spacer2, 0, 5)
    form.add(bb, 0, 6)
    form_result = form.runOnce()
    tmpl_name = entry_newname.value()
    # remove whitespaces from the template name
    tmpl_name = re.sub(r'\s', '', tmpl_name)
    return (bb.buttonPressed(form_result), str(base_tmpl.current()), tmpl_name)
Пример #5
0
def display_create_template(screen, title, vm_type, templates, help=None):
    """Helper class for displaying a form for creating a new VM template"""
    label_base = Textbox(40, 2, 
        'Select %s VM to be used as a basis\n(only stopped VMs are allowed)' % 
        vm_type, 0, 0)
    
    base_tmpl = Listbox(7, 1, 0, 30, 1)
    for vm in templates.keys():
        base_tmpl.append(templates[vm], vm)
    
    label_newname = Textbox(40, 2, 'Name of the template to be created', 0, 0)
    spacer1 = Textbox(1, 1, "", 0, 0)
    spacer2 = Textbox(1, 1, "", 0, 0)
    entry_newname = Entry(30, 'template_name')
    bb = ButtonBar(screen, ('Create new template', ('Back to menu', 'back')))
    form = GridFormHelp(screen, title, help, 1, 7)
    form.add(label_base, 0, 0)
    form.add(base_tmpl, 0, 1)
    form.add(spacer1, 0, 2)
    form.add(label_newname, 0, 3)
    form.add(entry_newname, 0, 4)
    form.add(spacer2, 0, 5)
    form.add(bb, 0, 6)
    form_result = form.runOnce()
    tmpl_name = entry_newname.value()
    # remove whitespaces from the template name
    tmpl_name = re.sub(r'\s', '', tmpl_name)
    return (bb.buttonPressed(form_result), str(base_tmpl.current()), tmpl_name)
Пример #6
0
def create_select_checkbox(screen, title, text, items, buttons=('Ok', 'Cancel'),
            width=40, scroll=0, height=-1, help=None):
    """Helper class for displaying a windows with a checkbox list.
    On exit, list of selected items is returned"""
    if (height == -1): height = len(items)
    if len(items) > height: scroll = 1
    bb = ButtonBar(screen, buttons)
    t = TextboxReflowed(width, text)
    cb = CheckboxTree(height, scroll = scroll)
    count = 0
    for count, item in enumerate(items):
        if isinstance(item, types.TupleType):
            (text, key, selected) = item
        else:
            text = item
            key = count
            selected = 0

        cb.append(text, key, selected)

    g = GridFormHelp(screen, title, help, 1, 3)
    g.add(t, 0, 0)
    g.add(cb, 0, 1, padding = (0, 1, 0, 1))
    g.add(bb, 0, 2, growx = 1)
    rc = g.runOnce()
    return (bb.buttonPressed(rc), cb.getSelection())
Пример #7
0
def display_yesno(screen, title, question_text="Yes / No", width=50, height=2):
    """Display yes/no dialog. Return True on yes and False on no."""
    g = GridFormHelp(screen, title, help, 1, 2)
    bb = ButtonBar(screen, (('No', 'no', 'F12'), 'Yes'))
    g.add(Textbox(width, height, question_text, 0, 0), 0, 0, padding=(0, 1, 0, 1))
    g.add(bb, 0, 1)
    rc = g.runOnce()
    return bb.buttonPressed(rc) == 'yes'
Пример #8
0
def display_yesno(screen, title, question_text="Yes / No", width=50, height=2):
    """Display yes/no dialog. Return True on yes and False on no."""
    g = GridFormHelp(screen, title, help, 1, 2)
    bb = ButtonBar(screen, (('No', 'no', 'F12'), 'Yes'))
    g.add(Textbox(width, height, question_text, 0, 0),
          0,
          0,
          padding=(0, 1, 0, 1))
    g.add(bb, 0, 1)
    rc = g.runOnce()
    return bb.buttonPressed(rc) == 'yes'
Пример #9
0
def ExtButtonChoiceWindow(screen, title, text,
                          buttons=['Ok', 'Cancel'],
                          width=40, x=None, y=None, help=None):

    bb = ButtonBar(screen, buttons, compact=1)
    t = TextboxReflowed(width, text, maxHeight=screen.height - 12)

    g = GridFormHelp(screen, title, help, 1, 2)
    g.add(t, 0, 0, padding=(0, 0, 0, 1))
    g.add(bb, 0, 1, growx=1)
    return bb.buttonPressed(g.runOnce(x, y))
Пример #10
0
def ExtEntryRadioWindow(screen, title, text, prompts,
                        allowCancel=1, width=40, entryWidth=20,
                        buttons=['Ok', 'Cancel'], help=None, radio_prompts=''):

    bb = ButtonBar(screen, buttons, compact=1)
    t = TextboxReflowed(width, text)
    radio_grid = Grid(3, len(radio_prompts))
    sg = Grid(2, len(prompts))

    max_name_length = 0
    for n in prompts:
        if isinstance(n, types.TupleType):
            n = n[0]
        if len(n) > max_name_length:
            max_name_length = len(n)

    radioList = parse_radio_prompts(radio_prompts, radio_grid, entryWidth,
                                    max_name_length)
    entryList = []
    entry_row = 0
    for n in prompts:
        if isinstance(n, types.TupleType):
            (n, e) = n
            if (type(e) in types.StringTypes):
                e = Entry(entryWidth, e)
        else:
            e = Entry(entryWidth)

        sg.setField(Label(n), 0, entry_row, padding=(0, 0, 1, 0), anchorLeft=1)
        sg.setField(e, 1, entry_row, anchorLeft=1)
        entry_row += 1
        entryList.append(e)

    g = GridFormHelp(screen, title, help, 1, 4)
    g.add(t, 0, 0, padding=(0, 0, 0, 1))
    g.add(radio_grid, 0, 1, padding=(0, 0, 0, 1))
    g.add(sg, 0, 2, padding=(0, 0, 0, 1))
    g.add(bb, 0, 3, growx=1)

    result = g.runOnce()

    entryValues = []
    for rowRadioList in radioList:
        for radio, radio_text in rowRadioList:
            if radio.selected():
                entryValues.append(radio_text)
                break
    for entry in entryList:
        entryValues.append(entry.value())

    return (result, bb.buttonPressed(result), tuple(entryValues))
Пример #11
0
def welcome():
    screen = SnackScreen()
    bb = ButtonBar(screen, (("Continue", "continue"), ("Cancel", "cancel")))
    tb = Textbox(
        65,
        4,
        "Python Script to Initialize New openSUSE Tumbleweed Installation,\nlike Installing Applications, Enabling & Starting Services, \nand Performing Distrubution Update.",
    )
    g = GridForm(screen, "TW-Init - by Trodskovich", 1, 4)

    g.add(tb, 0, 2)
    g.add(bb, 0, 3, growx=1)

    result = g.runOnce()
    screen.finish()
    return bb.buttonPressed(result)
Пример #12
0
def dup():
    screen = SnackScreen()
    bb = ButtonBar(screen, (("Yes", "yes"), ("No", "no")))
    tb = Textbox(
        70,
        4,
        "It's recomended to run the Distribution Update after Initiliazation. \nDo you want to run Distribution Update after Initiliazation ?",
    )
    g = GridForm(screen, "Distribution Update", 1, 4)

    g.add(tb, 0, 2)
    g.add(bb, 0, 3, growx=1)

    result = g.runOnce()
    screen.finish()
    return bb.buttonPressed(result)
def ButtonWindow(screen, title, text, allowCancel = 1, width = 40,
        entryWidth = 20, buttons = [ 'Ok', 'Cancel' ], help = None):
    """
    EntryWindow(screen, title, text, prompts, allowCancel = 1, width = 40,
        entryWidth = 20, buttons = [ 'Ok', 'Cancel' ], help = None):
    """
    from snack import ButtonBar, TextboxReflowed, GridFormHelp  
    bb = ButtonBar(screen, buttons);
    t = TextboxReflowed(width, text)

    g = GridFormHelp(screen, title, help, 1, 3)
    g.add(t, 0, 0, padding = (0, 0, 0, 1))
    g.add(bb, 0, 1, growx = 1)

    result = g.runOnce()
 
    return [bb.buttonPressed(result)]
Пример #14
0
 def create_ui(self):
     """ Creates/Draws the UI """
     self.button_bar = ButtonBar(self.screen, ((_("Cancel"), "cancel"),
                                               (_("Install"), "ok")),
                                 compact=True)
     self.textview_changes = Textbox(72, 8, "Changelog", True, True)
     self.checkbox_tree_updates = CheckboxTree(height=8, width=72, scroll=1)
     self.checkbox_tree_updates.setCallback(self.checkbox_changed)
     self.layout = GridForm(self.screen, "Updates", 1, 5)
     self.layout.add(self.checkbox_tree_updates, 0, 0)
     # empty line to make it look less crowded
     self.layout.add(Textbox(60, 1, " ", False, False), 0, 1)
     self.layout.add(self.textview_changes, 0, 2)
     # empty line to make it look less crowded
     self.layout.add(Textbox(60, 1, " ", False, False), 0, 3)
     self.layout.add(self.button_bar, 0, 4)
     # FIXME: better progress than the current suspend/resume screen thing
     self.screen.suspend()
Пример #15
0
def add_repo():
    screen = SnackScreen()
    bb = ButtonBar(screen, (("Add", "add"), ("Cancel", "cancel")))
    tb = Textbox(
        50,
        5,
        "Multimedia Applications and Codecs require Packman Repositary to be added in order to work correctly. \nDo you want add Packman repo now ?",
        0,
        1,
    )
    g = GridForm(screen, "Packman Repo", 1, 4)

    g.add(tb, 0, 2)
    g.add(bb, 0, 3, growx=1)

    result = g.runOnce()
    screen.finish()
    return bb.buttonPressed(result)
Пример #16
0
def ExtEntryWindow(screen, title, text, prompts,
                   allowCancel=1, width=40, entryWidth=20,
                   buttons=['Ok', 'Cancel'], help=None):

    bb = ButtonBar(screen, buttons, compact=1)
    t = TextboxReflowed(width, text)

    count = 0
    for n in prompts:
        count = count + 1

    sg = Grid(2, count)

    count = 0
    entryList = []
    for n in prompts:
        if isinstance(n, types.TupleType):
            (n, e) = n
            if (type(e) in types.StringTypes):
                e = Entry(entryWidth, e)
        else:
            e = Entry(entryWidth)

        sg.setField(Label(n), 0, count, padding=(0, 0, 1, 0), anchorLeft=1)
        sg.setField(e, 1, count, anchorLeft=1)
        count = count + 1
        entryList.append(e)

    g = GridFormHelp(screen, title, help, 1, 3)

    g.add(t, 0, 0, padding=(0, 0, 0, 1))
    g.add(sg, 0, 1, padding=(0, 0, 0, 1))
    g.add(bb, 0, 2, growx=1)

    result = g.runOnce()

    entryValues = []
    count = 0
    for n in prompts:
        entryValues.append(entryList[count].value())
        count = count + 1

    return (result, bb.buttonPressed(result), tuple(entryValues))
def ConfirmationWindow(screen, title, infolist, width=40, buttons=["Start", "Modify", "Save", "Exit"], help=None):
    from snack import ButtonBar, Label, GridFormHelp, Textbox

    bb = ButtonBar(screen, buttons)
    ig = Grid(2, len(infolist))
    i = 0
    for _info in infolist:
        ig.setField(Label("%s: " % _info.getName()), 0, i, padding=(0, 0, 1, 0), anchorLeft=1)
        ig.setField(Label("%s" % _info.getValue()), 1, i, padding=(0, 0, 1, 0), anchorLeft=1)
        i = i + 1

    g = GridFormHelp(screen, title, help, 1, 3)

    g.add(Textbox(20, 1, "Current settings:"), 0, 0, padding=(0, 0, 0, 1), anchorLeft=1)
    g.add(ig, 0, 1, padding=(0, 0, 0, 1))
    g.add(bb, 0, 2, growx=1)

    result = g.runOnce()

    return bb.buttonPressed(result)
def AssistantWindow(screen, title, info, width=40, buttons=["Next", "Previous", "Return"], help=None):
    from snack import ButtonBar, TextboxReflowed, GridFormHelp, Label

    """
    EntryWindow():
    """
    bb = ButtonBar(screen, buttons)
    rb = AssistantInfoRadioBar(screen, info)
    t = TextboxReflowed(width, info.getComment())

    g = GridFormHelp(screen, title, help, 1, 4)

    g.add(Label(info.getName()), 0, 0, padding=(0, 0, 1, 0), anchorLeft=0)
    g.add(t, 0, 1, padding=(0, 0, 0, 1))
    g.add(bb, 0, 3, growx=1)
    g.add(rb, 0, 2, padding=(0, 0, 0, 1))

    result = g.runOnce()

    return (bb.buttonPressed(result), rb.getSelection())
Пример #19
0
    def run(self):
        toplevel = GridForm(self.screen, _("Passphrase"), 1, 3)

        txt = TextboxReflowed(65, self.txt)
        toplevel.add(txt, 0, 0)

        passphraseentry = Entry(60, password=1)
        toplevel.add(passphraseentry, 0, 1, (0, 0, 0, 1))

        buttons = ButtonBar(self.screen, [TEXT_OK_BUTTON, TEXT_CANCEL_BUTTON])
        toplevel.add(buttons, 0, 2, growx=1)

        rc = toplevel.run()
        res = buttons.buttonPressed(rc)

        passphrase = None
        if res == TEXT_OK_CHECK or rc == "F12":
            passphrase = passphraseentry.value().strip()

        self.rc = passphrase
        return self.rc
Пример #20
0
    def run(self):
        toplevel = GridForm(self.screen, _("Passphrase"), 1, 3)

        txt = TextboxReflowed(65, self.txt)
        toplevel.add(txt, 0, 0)

        passphraseentry = Entry(60, password=1)
        toplevel.add(passphraseentry, 0, 1, (0, 0, 0, 1))

        buttons = ButtonBar(self.screen, [TEXT_OK_BUTTON, TEXT_CANCEL_BUTTON])
        toplevel.add(buttons, 0, 2, growx=1)

        rc = toplevel.run()
        res = buttons.buttonPressed(rc)

        passphrase = None
        if res == TEXT_OK_CHECK or rc == "F12":
            passphrase = passphraseentry.value().strip()

        self.rc = passphrase
        return self.rc
Пример #21
0
def ExtCheckboxWindow(screen, title, text, items,
                      buttons=('Ok', 'Cancel'), width=50, height=8):

    g = GridForm(screen, title, 1, 3)
    g.add(Textbox(width, 2, text), 0, 0)

    scroll = 0
    if len(items) > height:
        scroll = 1

    ct = CheckboxTree(height, scroll, width)
    if len(items) > 0:
        for i in items:
            ct.append(i, i, items[i])
        g.add(ct, 0, 1)

    bb = ButtonBar(screen, buttons, compact=1)
    g.add(bb, 0, 2, (0, 2, 0, 0), growx=1, growy=1)

    result = g.runOnce()
    return bb.buttonPressed(result), ct.getSelection()
    def __init__(self, datadir):
        self.screen = SnackScreen()
        # FIXME: self.screen.finish() clears the screen (and all messages)
        #        there too
        #atexit.register(self.restoreScreen)
        self.button_bar = ButtonBar(self.screen, ((_("Cancel"), "cancel"),
                                                  (_("Install"), "ok")),
                                    compact=True)
        self.textview_changes = Textbox(72, 8, _("Changelog"), True, True)
        self.checkbox_tree_updates = CheckboxTree(height=8, width=72, scroll=1)
        self.checkbox_tree_updates.setCallback(self.checkbox_changed)
        self.layout = GridForm(self.screen, _("Updates"), 1, 5)
        self.layout.add(self.checkbox_tree_updates, 0, 0)
        # empty line to make it look less crowded
        self.layout.add(Textbox(60, 1, " ", False, False), 0, 1)
        self.layout.add(self.textview_changes, 0, 2)
        # empty line to make it look less crowded
        self.layout.add(Textbox(60, 1, " ", False, False), 0, 3)
        self.layout.add(self.button_bar, 0, 4)
        # FIXME: better progress than the current suspend/resume screen thing
        self.screen.suspend()
        if not self.DEBUG:
            apt_pkg.pkgsystem_lock()
        self.openCache()
        print(_("Building Updates List"))
        self.fillstore()
        if self.list.distUpgradeWouldDelete > 0:
            print(
                _("""
A normal upgrade can not be calculated, please run:
  sudo apt-get dist-upgrade


This can be caused by:
 * A previous upgrade which didn't complete
 * Problems with some of the installed software
 * Unofficial software packages not provided by Ubuntu
 * Normal changes of a pre-release version of Ubuntu"""))
            sys.exit(1)
        self.screen.resume()
Пример #23
0
def select_packages():
    global sellist
    screen = SnackScreen()
    ct = CheckboxTree(height=20, scroll=1)

    for idx, key in enumerate(packages):
        ct.append(key)
        for val in packages[key]:
            ct.addItem(val, (idx, snackArgs["append"]))
            ct.setEntryValue(val)

    bb = ButtonBar(screen, (("Next", "next"), ("Cancel", "cancel")))
    g = GridForm(screen, "Packages", 1, 4)

    g.add(ct, 0, 2)
    g.add(bb, 0, 3, growx=1)

    result = g.runOnce()
    screen.finish()

    # format selected packages list for zypper  and print(result)
    sellist = (str(ct.getSelection()).replace("[",
                                              "").replace("]", "").replace(
                                                  "'", "").replace(",", ""))
    # to confirm Selected Packages
    screen = SnackScreen()
    bb = ButtonBar(screen, (("Next", "next"), ("Cancel", "cancel")))
    tb = Textbox(
        80, 10,
        "the packages selected to install are \n \n" + str(sellist.split(" ")),
        1, 1)
    g = GridForm(screen, "Selected Packages", 1, 4)

    g.add(tb, 0, 2)
    g.add(bb, 0, 3, growx=1)

    result = g.runOnce()
    screen.finish()
    return bb.buttonPressed(result)
Пример #24
0
def ExtListboxChoiceWindow(screen, title, text, items,
                           buttons=('Ok', 'Cancel'),
                           width=40, scroll=0, height=-1,
                           default=None, help=None):

    if (height == -1):
        height = len(items)

    bb = ButtonBar(screen, buttons, compact=1)
    t = TextboxReflowed(width, text)
    lb = Listbox(height, scroll=scroll, returnExit=1)
    count = 0
    for item in items:
        if isinstance(item, types.TupleType):
            (text, key) = item
        else:
            text = item
            key = count

        if (default == count):
            default = key
        elif (default == item):
            default = key

        lb.append(text, key)
        count = count + 1

    if (default is not None):
        lb.setCurrent(default)

    g = GridFormHelp(screen, title, help, 1, 3)
    g.add(t, 0, 0)
    g.add(lb, 0, 1, padding=(0, 1, 0, 1))
    g.add(bb, 0, 2, growx=1)

    rc = g.runOnce()

    return (rc, bb.buttonPressed(rc), lb.current())
def ButtonWindow(screen,
                 title,
                 text,
                 allowCancel=1,
                 width=40,
                 entryWidth=20,
                 buttons=['Ok', 'Cancel'],
                 help=None):
    """
    EntryWindow(screen, title, text, prompts, allowCancel = 1, width = 40,
        entryWidth = 20, buttons = [ 'Ok', 'Cancel' ], help = None):
    """
    from snack import ButtonBar, TextboxReflowed, GridFormHelp
    bb = ButtonBar(screen, buttons)
    t = TextboxReflowed(width, text)

    g = GridFormHelp(screen, title, help, 1, 3)
    g.add(t, 0, 0, padding=(0, 0, 0, 1))
    g.add(bb, 0, 1, growx=1)

    result = g.runOnce()

    return [bb.buttonPressed(result)]
def AssistantWindow(screen,
                    title,
                    info,
                    width=40,
                    buttons=['Next', 'Previous', 'Return'],
                    help=None):
    from snack import ButtonBar, TextboxReflowed, GridFormHelp, Label
    """
    EntryWindow():
    """
    bb = ButtonBar(screen, buttons)
    rb = AssistantInfoRadioBar(screen, info)
    t = TextboxReflowed(width, info.getComment())

    g = GridFormHelp(screen, title, help, 1, 4)

    g.add(Label(info.getName()), 0, 0, padding=(0, 0, 1, 0), anchorLeft=0)
    g.add(t, 0, 1, padding=(0, 0, 0, 1))
    g.add(bb, 0, 3, growx=1)
    g.add(rb, 0, 2, padding=(0, 0, 0, 1))

    result = g.runOnce()

    return (bb.buttonPressed(result), rb.getSelection())
def ConfirmationWindow(screen,
                       title,
                       infolist,
                       width=40,
                       buttons=['Start', 'Modify', 'Save', 'Exit'],
                       help=None):
    from snack import ButtonBar, Label, GridFormHelp, Textbox
    bb = ButtonBar(screen, buttons)
    ig = Grid(2, len(infolist))
    i = 0
    for _info in infolist:
        ig.setField(Label("%s: " % _info.getName()),
                    0,
                    i,
                    padding=(0, 0, 1, 0),
                    anchorLeft=1)
        ig.setField(Label("%s" % _info.getValue()),
                    1,
                    i,
                    padding=(0, 0, 1, 0),
                    anchorLeft=1)
        i = i + 1

    g = GridFormHelp(screen, title, help, 1, 3)

    g.add(Textbox(20, 1, "Current settings:"),
          0,
          0,
          padding=(0, 0, 0, 1),
          anchorLeft=1)
    g.add(ig, 0, 1, padding=(0, 0, 0, 1))
    g.add(bb, 0, 2, growx=1)

    result = g.runOnce()

    return (bb.buttonPressed(result))
    def __init__(self, datadir):
	self.screen = SnackScreen()
        # FIXME: self.screen.finish() clears the screen (and all messages)
        #        there too
        #atexit.register(self.restoreScreen)
	self.button_bar = ButtonBar(self.screen, 
				    ( (_("Cancel"), "cancel"),
				      (_("Install"), "ok")), 
				    compact = True)
	self.textview_changes = Textbox(72, 8, "Changelog", True, True)
	self.checkbox_tree_updates = CheckboxTree(height=8, width=72, scroll=1)
	self.checkbox_tree_updates.setCallback(self.checkbox_changed)
	self.layout = GridForm(self.screen, "Updates", 1, 5)
	self.layout.add(self.checkbox_tree_updates, 0, 0)
	# empty line to make it look less crowded
	self.layout.add(Textbox(60, 1," ",False, False), 0, 1)
	self.layout.add(self.textview_changes, 0, 2)
	# empty line to make it look less crowded
	self.layout.add(Textbox(60, 1," ",False, False), 0, 3)
	self.layout.add(self.button_bar, 0, 4)
        # FIXME: better progress than the current suspend/resume screen thing
	self.screen.suspend()
	if not self.DEBUG:
            apt_pkg.PkgSystemLock()
	self.openCache()
	print _("Building Updates List")
	self.fillstore()
        if self.list.distUpgradeWouldDelete > 0:
            print _("""
A normal upgrade can not be calculated, please run: 
  sudo apt-get dist-upgrade


This can be caused by:
 * A previous upgrade which didn't complete
 * Problems with some of the installed software
 * Unofficial software packages not provided by Ubuntu
 * Normal changes of a pre-release version of Ubuntu""")
            sys.exit(1)
	self.screen.resume()
Пример #29
0
def welcome():
    global NvLtDrvURL, LatestFile, LatestHeader, DownloadFlag, SymlinkFlag
    screen = SnackScreen()
    bb = ButtonBar(screen, (("Continue", "continue"), ("Cancel", "cancel")))
    tbTittle = Textbox(
        65, 3,
        "To check for latest Nvidia Driver form NVIDIA Website, download and optionaly create a symlink to the latest File",
        0, 1)
    for File in os.listdir(path):
        if File.find('.run') > 0 and os.path.isfile(path + "/" + File):
            FList.append(File)
            FList.sort()
    FileText = urllib.request.urlopen(NvLtTxtURL).read().decode('utf-8')
    for i in range(0, len(FileText)):
        if FileText[i] == ' ':
            LatestHeader = FileText[0:i]

    for i in range(0, len(FileText)):
        if FileText[i] == '/':
            LatestFile = FileText[i + 1:len(FileText) - 1]

    NvLtDrvURL = NvLtDrvURL + LatestHeader + "/" + LatestFile

    tbLatestL = Textbox(110, 2, "Latest Local Version: " + FList[-1], 0, 1)
    tbLatestR = Textbox(
        110, 4, "Latest Remote Version: " + LatestFile +
        "\nLatest Driver URL: " + NvLtDrvURL, 0, 1)

    if LatestFile > FList[-1]:
        cbDowload = Checkbox(
            "Download the Latest Driver",
            1,
        )
        cbSymlink = Checkbox(
            "Create / Update Symlink",
            1,
        )
    else:
        cbDowload = Checkbox(
            "Download the Latest Driver",
            0,
        )
        cbSymlink = Checkbox(
            "Create / Update Symlink",
            0,
        )

    g = GridForm(screen, "chkltdr (NvDrIn) - by Trodskovich", 1, 8)

    g.add(tbTittle, 0, 2)
    g.add(tbLatestL, 0, 3, growx=1)
    g.add(tbLatestR, 0, 4, growx=1)
    g.add(cbDowload, 0, 5, growx=1)
    g.add(cbSymlink, 0, 6, growx=1)
    g.add(bb, 0, 7, growx=1)
    result = g.runOnce()

    screen.finish()
    DownloadFlag = cbDowload.value()
    SymlinkFlag = cbSymlink.value()
    return bb.buttonPressed(result)
class UpdateManagerText(object):
    DEBUG = False

    def __init__(self, datadir):
	self.screen = SnackScreen()
        # FIXME: self.screen.finish() clears the screen (and all messages)
        #        there too
        #atexit.register(self.restoreScreen)
	self.button_bar = ButtonBar(self.screen, 
				    ( (_("Cancel"), "cancel"),
				      (_("Install"), "ok")), 
				    compact = True)
	self.textview_changes = Textbox(72, 8, "Changelog", True, True)
	self.checkbox_tree_updates = CheckboxTree(height=8, width=72, scroll=1)
	self.checkbox_tree_updates.setCallback(self.checkbox_changed)
	self.layout = GridForm(self.screen, "Updates", 1, 5)
	self.layout.add(self.checkbox_tree_updates, 0, 0)
	# empty line to make it look less crowded
	self.layout.add(Textbox(60, 1," ",False, False), 0, 1)
	self.layout.add(self.textview_changes, 0, 2)
	# empty line to make it look less crowded
	self.layout.add(Textbox(60, 1," ",False, False), 0, 3)
	self.layout.add(self.button_bar, 0, 4)
        # FIXME: better progress than the current suspend/resume screen thing
	self.screen.suspend()
	if not self.DEBUG:
            apt_pkg.PkgSystemLock()
	self.openCache()
	print _("Building Updates List")
	self.fillstore()
        if self.list.distUpgradeWouldDelete > 0:
            print _("""
A normal upgrade can not be calculated, please run: 
  sudo apt-get dist-upgrade


This can be caused by:
 * A previous upgrade which didn't complete
 * Problems with some of the installed software
 * Unofficial software packages not provided by Ubuntu
 * Normal changes of a pre-release version of Ubuntu""")
            sys.exit(1)
	self.screen.resume()

#    def restoreScreen(self):
#        self.screen.finish()
    
    def openCache(self):
	# open cache
        progress = apt.progress.OpTextProgress()
        if hasattr(self, "cache"):
            self.cache.open(progress)
            self.cache._initDepCache()
        else:
            self.cache = MyCache(progress)
	    self.actiongroup = apt_pkg.GetPkgActionGroup(self.cache._depcache)
	# lock the cache
        self.cache.lock = True
	    
    def fillstore(self):
	# populate the list
	self.list = UpdateList(self)
	self.list.update(self.cache)
	origin_list = self.list.pkgs.keys()
	origin_list.sort(lambda x,y: cmp(x.importance, y.importance))
	origin_list.reverse()
	for (i, origin) in enumerate(origin_list):
            self.checkbox_tree_updates.append(origin.description, selected=True)
	    for pkg in self.list.pkgs[origin]:
                self.checkbox_tree_updates.addItem(pkg.name, 
						   (i, snackArgs['append']),
						   pkg,
						   selected = True)

    def updateSelectionStates(self):
        """ 
        helper that goes over the cache and updates the selection 
        states in the UI based on the cache
        """
        for pkg in self.cache:
            if not self.checkbox_tree_updates.item2key.has_key(pkg):
                continue
            # update based on the status
            if pkg.markedUpgrade or pkg.markedInstall:
                self.checkbox_tree_updates.setEntryValue(pkg, True)
            else:
                self.checkbox_tree_updates.setEntryValue(pkg, False)
        self.updateUI()

    def updateUI(self):
        self.layout.draw()
        self.screen.refresh()
        
    def get_news_and_changelog(self, pkg):
        changes = ""
	name = pkg.name
        
        # if we don't have it, get it
        if (not self.cache.all_changes.has_key(name) and
            not self.cache.all_news.has_key(name)):
            self.textview_changes.setText(_("Downloading changelog"))
            lock = thread.allocate_lock()
            lock.acquire()
            thread.start_new_thread(self.cache.get_news_and_changelog,(name,lock))
            # this lock should never take more than 2s even with network down
            while lock.locked():
                time.sleep(0.03)

        # build changes from NEWS and changelog
        if self.cache.all_news.has_key(name):
            changes += self.cache.all_news[name]
        if self.cache.all_changes.has_key(name):
            changes += self.cache.all_changes[name]

	return changes

    def checkbox_changed(self):
        # item is either a apt.package.Package or a str (for the headers)
	pkg = self.checkbox_tree_updates.getCurrent()
	descr = ""
	if hasattr(pkg, "name"):
                need_refresh = False
		name = pkg.name
                if self.options.show_description:
                    descr = pkg.description
                else:
                    descr = self.get_news_and_changelog(pkg)
		# check if it is a wanted package
		selected = self.checkbox_tree_updates.getEntryValue(pkg)[1]
                marked_install_upgrade = pkg.markedInstall or pkg.markedUpgrade
		if not selected and marked_install_upgrade:
                    need_refresh = True
                    pkg.markKeep()
                if selected and not marked_install_upgrade:
                    if not (name in self.list.held_back):
                        # FIXME: properly deal with "fromUser" here
                        need_refresh = True
                        pkg.markInstall()
                # fixup any problems
                if self.cache._depcache.BrokenCount:
                    need_refresh = True
                    Fix = apt_pkg.GetPkgProblemResolver(self.cache._depcache)
                    Fix.ResolveByKeep()
                # update the list UI to reflect the cache state
                if need_refresh:
                    self.updateSelectionStates()
	self.textview_changes.setText(descr)
	self.updateUI()

    def main(self, options):
        self.options = options
        res = self.layout.runOnce()
	self.screen.finish()
	button = self.button_bar.buttonPressed(res)
	if button == "ok":
		self.screen.suspend()
		res = self.cache.commit(apt.progress.text.AcquireProgress(),
					apt.progress.base.InstallProgress())
Пример #31
0
    def show_menu(self, title, top_node):
        selection = 0

        while True:
            items = Menuconfig.menu_node_strings(top_node, 0)

            height = len(items)
            scroll = 0
            if height > self.screen.height - 13:
                height = self.screen.height - 13
                scroll = 1

            buttons = [('Save & Build', 'build', 'B'),
                       ('Save & Exit', 'save', 'S'), (' Help ', 'help', 'h'),
                       (' Exit ', 'exit', 'ESC')]
            buttonbar = ButtonBar(self.screen, buttons)
            listbox = Listbox(height, scroll=scroll, returnExit=1)
            count = 0
            for string, _ in items:
                listbox.append(string, count)
                if (selection == count):
                    listbox.setCurrent(count)
                count = count + 1

            grid = GridFormHelp(self.screen, title, None, 1, 2)
            grid.add(listbox, 0, 0, padding=(0, 0, 0, 1))
            grid.add(buttonbar, 0, 1, growx=1)
            grid.addHotKey(' ')

            rc = grid.runOnce()

            action = buttonbar.buttonPressed(rc)
            if action and action != 'help':
                return action

            if count == 0:
                continue

            selection = listbox.current()
            _, selected_node = items[selection]
            sym = selected_node.item

            if action == 'help':
                prompt, _ = selected_node.prompt
                if hasattr(selected_node, 'help') and selected_node.help:
                    help = selected_node.help
                else:
                    help = 'No help available.'
                ButtonChoiceWindow(screen=self.screen,
                                   title="Help on '{}'".format(prompt),
                                   text=help,
                                   width=60,
                                   buttons=['  Ok  '])
                continue

            show_submenu = False

            if type(sym) == Symbol:
                if rc == ' ':
                    if sym.type == BOOL:
                        sym.set_value('n' if sym.tri_value > 0 else 'y')
                else:
                    if selected_node.is_menuconfig:
                        show_submenu = True
                    elif sym.type in (STRING, INT, HEX):
                        action, values = EntryWindow(
                            screen=self.screen,
                            title=sym.name,
                            text='Enter a %s value:' % TYPE_TO_STR[sym.type],
                            prompts=[('', sym.str_value)],
                            buttons=[('  Ok  ', 'Ok'), ('Cancel', '', 'ESC')])
                        if action == 'Ok':
                            self.kconf.warnings = []
                            val = values[0]
                            if sym.type == HEX and not val.startswith('0x'):
                                val = '0x' + val
                            sym.set_value(val)
                            # only fetching triggers range check - how ugly...
                            sym.str_value
                            if len(self.kconf.warnings) > 0:
                                ButtonChoiceWindow(screen=self.screen,
                                                   title="Invalid entry",
                                                   text="\n".join(
                                                       self.kconf.warnings),
                                                   width=60,
                                                   buttons=['  Ok  '])
                                self.kconf.warnings = []
            elif selected_node.is_menuconfig and type(sym) != Choice:
                show_submenu = True

            if show_submenu:
                submenu_title, _ = selected_node.prompt
                action = self.show_menu(submenu_title, selected_node.list)
                if action != 'exit':
                    return action
class UpdateManagerText(object):
    DEBUG = False

    def __init__(self, datadir):
        self.screen = SnackScreen()
        # FIXME: self.screen.finish() clears the screen (and all messages)
        #        there too
        #atexit.register(self.restoreScreen)
        self.button_bar = ButtonBar(self.screen, ((_("Cancel"), "cancel"),
                                                  (_("Install"), "ok")),
                                    compact=True)
        self.textview_changes = Textbox(72, 8, _("Changelog"), True, True)
        self.checkbox_tree_updates = CheckboxTree(height=8, width=72, scroll=1)
        self.checkbox_tree_updates.setCallback(self.checkbox_changed)
        self.layout = GridForm(self.screen, _("Updates"), 1, 5)
        self.layout.add(self.checkbox_tree_updates, 0, 0)
        # empty line to make it look less crowded
        self.layout.add(Textbox(60, 1, " ", False, False), 0, 1)
        self.layout.add(self.textview_changes, 0, 2)
        # empty line to make it look less crowded
        self.layout.add(Textbox(60, 1, " ", False, False), 0, 3)
        self.layout.add(self.button_bar, 0, 4)
        # FIXME: better progress than the current suspend/resume screen thing
        self.screen.suspend()
        if not self.DEBUG:
            apt_pkg.pkgsystem_lock()
        self.openCache()
        print(_("Building Updates List"))
        self.fillstore()
        if self.list.distUpgradeWouldDelete > 0:
            print(
                _("""
A normal upgrade can not be calculated, please run:
  sudo apt-get dist-upgrade


This can be caused by:
 * A previous upgrade which didn't complete
 * Problems with some of the installed software
 * Unofficial software packages not provided by Ubuntu
 * Normal changes of a pre-release version of Ubuntu"""))
            sys.exit(1)
        self.screen.resume()


#    def restoreScreen(self):
#        self.screen.finish()

    def openCache(self):
        # open cache
        progress = apt.progress.text.OpProgress()
        if hasattr(self, "cache"):
            self.cache.open(progress)
            self.cache._initDepCache()
        else:
            self.cache = MyCache(progress)
            self.actiongroup = apt_pkg.ActionGroup(self.cache._depcache)
        # lock the cache
        self.cache.lock = True

    def fillstore(self):
        # populate the list
        self.list = UpdateList(self)
        self.list.update(self.cache)
        origin_list = sorted(self.list.pkgs,
                             key=operator.attrgetter("importance"),
                             reverse=True)
        for (i, origin) in enumerate(origin_list):
            self.checkbox_tree_updates.append(origin.description,
                                              selected=True)
            for pkg in self.list.pkgs[origin]:
                self.checkbox_tree_updates.addItem(pkg.name,
                                                   (i, snackArgs['append']),
                                                   pkg,
                                                   selected=True)

    def updateSelectionStates(self):
        """
        helper that goes over the cache and updates the selection
        states in the UI based on the cache
        """
        for pkg in self.cache:
            if pkg not in self.checkbox_tree_updates.item2key:
                continue
            # update based on the status
            if pkg.marked_upgrade or pkg.marked_install:
                self.checkbox_tree_updates.setEntryValue(pkg, True)
            else:
                self.checkbox_tree_updates.setEntryValue(pkg, False)
        self.updateUI()

    def updateUI(self):
        self.layout.draw()
        self.screen.refresh()

    def get_news_and_changelog(self, pkg):
        changes = ""
        name = pkg.name

        # if we don't have it, get it
        if (name not in self.cache.all_changes
                and name not in self.cache.all_news):
            self.textview_changes.setText(_("Downloading changelog"))
            lock = threading.Lock()
            lock.acquire()
            changelog_thread = threading.Thread(
                target=self.cache.get_news_and_changelog, args=(name, lock))
            changelog_thread.start()
            # this lock should never take more than 2s even with network down
            while lock.locked():
                time.sleep(0.03)

        # build changes from NEWS and changelog
        if name in self.cache.all_news:
            changes += self.cache.all_news[name]
        if name in self.cache.all_changes:
            changes += self.cache.all_changes[name]

        return changes

    def checkbox_changed(self):
        # item is either a apt.package.Package or a str (for the headers)
        pkg = self.checkbox_tree_updates.getCurrent()
        descr = ""
        if hasattr(pkg, "name"):
            need_refresh = False
            name = pkg.name
            if self.options.show_description:
                descr = getattr(pkg.candidate, "description", None)
            else:
                descr = self.get_news_and_changelog(pkg)
            # check if it is a wanted package
            selected = self.checkbox_tree_updates.getEntryValue(pkg)[1]
            marked_install_upgrade = pkg.marked_install or pkg.marked_upgrade
            if not selected and marked_install_upgrade:
                need_refresh = True
                pkg.mark_keep()
            if selected and not marked_install_upgrade:
                if not (name in self.list.held_back):
                    # FIXME: properly deal with "fromUser" here
                    need_refresh = True
                    pkg.mark_install()
            # fixup any problems
            if self.cache._depcache.broken_count:
                need_refresh = True
                Fix = apt_pkg.ProblemResolver(self.cache._depcache)
                Fix.resolve_by_keep()
            # update the list UI to reflect the cache state
            if need_refresh:
                self.updateSelectionStates()
        self.textview_changes.setText(descr)
        self.updateUI()

    def main(self, options):
        self.options = options
        res = self.layout.runOnce()
        self.screen.finish()
        button = self.button_bar.buttonPressed(res)
        if button == "ok":
            self.screen.suspend()
            res = self.cache.commit(apt.progress.text.AcquireProgress(),
                                    apt.progress.base.InstallProgress())
Пример #33
0
class NewtUI(object):
    """ Newt UI implementation """
    def __init__(self, frontend):
        self._frontend = frontend
        self.screen = SnackScreen()
        self.textview_changes = None
        self.button_bar = None
        self.checkbox_tree_updates = None
        self.layout = None
        self._app = None
        self._updates_received = False

    def create_ui(self):
        """ Creates/Draws the UI """
        self.button_bar = ButtonBar(self.screen, ((_("Cancel"), "cancel"),
                                                  (_("Install"), "ok")),
                                    compact=True)
        self.textview_changes = Textbox(72, 8, "Changelog", True, True)
        self.checkbox_tree_updates = CheckboxTree(height=8, width=72, scroll=1)
        self.checkbox_tree_updates.setCallback(self.checkbox_changed)
        self.layout = GridForm(self.screen, "Updates", 1, 5)
        self.layout.add(self.checkbox_tree_updates, 0, 0)
        # empty line to make it look less crowded
        self.layout.add(Textbox(60, 1, " ", False, False), 0, 1)
        self.layout.add(self.textview_changes, 0, 2)
        # empty line to make it look less crowded
        self.layout.add(Textbox(60, 1, " ", False, False), 0, 3)
        self.layout.add(self.button_bar, 0, 4)
        # FIXME: better progress than the current suspend/resume screen thing
        self.screen.suspend()

    def cache_reload_callback(self, percent, operation):
        """ Cache reloading callback

        :param percent: Percentage done
        :param operation: Current operation
        """
        if percent == RELOAD_CACHE_STATUS.DONE:
            sys.stdout.write(_('Finished loading package cache.') + '\n')
        elif percent == RELOAD_CACHE_STATUS.BEGIN:
            sys.stdout.write(_('Loading package cache.') + '\n')
        else:
            sys.stdout.write('[%2d] %s\r' % (percent, operation))

    def main(self, application):
        """ UI main loop

        :param application: class:`UpdateManager.Application.Application`
          object
        """
        self._app = application

        while not self._updates_received:
            time.sleep(0.3)

        self.screen.resume()
        res = self.layout.runOnce()
        self.screen.finish()
        button = self.button_bar.buttonPressed(res)
        if button == "ok":
            self.screen.suspend()

    def get_updates(self):
        sys.stdout.write(_("Building Updates List") + "\n")
        sys.stdout.flush()

        packages = self._app.get_available_updates()
        # download_size = 0
        categories = {}

        for pkg in packages:
            catid = pkg.get_update_category()
            if not catid in categories.keys():
                categories[catid] = [
                    pkg,
                ]
            else:
                categories[catid].append(pkg)

        for (i, cat_id) in enumerate(categories.keys()):
            cat_name = self._app.get_update_category_name(cat_id)
            self.checkbox_tree_updates.append(cat_name, selected=True)
            for pkg in categories[cat_id]:
                self.checkbox_tree_updates.addItem(pkg.get_package_name(),
                                                   (i, snackArgs['append']),
                                                   pkg,
                                                   selected=True)
        self._updates_received = True

    def update_ui(self):
        """ Redraws the UI """
        self.layout.draw()
        self.screen.refresh()

    def checkbox_changed(self):
        """ Handler for checkbox state-changes """
        pkg = self.checkbox_tree_updates.getCurrent()
        descr = ""

        if hasattr(pkg, "get_description"):
            descr = pkg.get_description()
        # TODO: changelog handling/selection of changelog instead of
        # description

        self.textview_changes.setText(descr)
        self.update_ui()