Python gtk 模块，Label() 实例源码

def create_text_hbox(self, label, value, trace, sensitivity_group, constraints=None):
        hbox_main = gtk.HBox()
        label_text = gtk.Label(label.title())
        label_text.set_alignment(0, 0.5)
        label_text.set_padding(8,8)
        entry_text = gtk.Entry()
        entry_text.set_text(value)
        hbox_main.pack_start(label_text)
        hbox_main.pack_start(entry_text)

        self.plugin_config_widgets.append(entry_text)
        self.plugin_config_traces.append(trace)
        sensitivity_group.append(label_text)
        sensitivity_group.append(entry_text)

        return hbox_main

def create_number_hbox(self, label, value, trace, sensitivity_group, constraints=None):
        hbox_main = gtk.HBox()
        label_text = gtk.Label(label.title())
        label_text.set_alignment(0, 0.5)
        label_text.set_padding(8,8)
        adjustment = gtk.Adjustment(value, 0, sys.maxint, 1)
        spinbutton_value = gtk.SpinButton(adjustment)
        spinbutton_value.set_value(value)
        hbox_main.pack_start(label_text)
        hbox_main.pack_start(spinbutton_value)

        self.plugin_config_widgets.append(spinbutton_value)
        self.plugin_config_traces.append(trace)
        sensitivity_group.append(label_text)
        sensitivity_group.append(spinbutton_value)

        return hbox_main

def create_option_hbox(self, label, value, trace, sensitivity_group, constraints=None):
        hbox_main = gtk.HBox()
        label_options = gtk.Label(label.title())
        label_options.set_alignment(0, 0.5)
        label_options.set_padding(8,8)
        combobox_options = gtk.combo_box_new_text()
        if constraints is None:
            options = []
        else:
            options = constraints
        for option in options:
            combobox_options.append_text(option)
        selected_index = options.index(value)
        combobox_options.set_active(selected_index)
        hbox_main.pack_start(label_options)
        hbox_main.pack_start(combobox_options)

        self.plugin_config_widgets.append(combobox_options)
        self.plugin_config_traces.append(trace)
        sensitivity_group.append(label_options)
        sensitivity_group.append(combobox_options)

        return hbox_main

def create_path_hbox(self, label, value, trace, sensitivity_group, constraints=None):
        hbox_main = gtk.HBox()
        label_text = gtk.Label(label.title())
        label_text.set_alignment(0, 0.5)
        label_text.set_padding(8,8)
        entry_filepath = gtk.Entry()
        entry_filepath.set_text(value)
        button_select_folder = gtk.ToolButton(
            gtk.image_new_from_file(os.path.join(definitions.ICONS_DIR, "open_small.png")))
        button_select_folder.connect("clicked", self.select_folder, entry_filepath)
        hbox_main.pack_start(label_text)
        hbox_main.pack_start(entry_filepath)
        hbox_main.pack_start(button_select_folder)

        self.plugin_config_widgets.append(entry_filepath)
        self.plugin_config_traces.append(trace)
        sensitivity_group.append(label_text)
        sensitivity_group.append(entry_filepath)
        sensitivity_group.append(button_select_folder)

        return hbox_main

def create_filepath_hbox(self, label, value, trace, sensitivity_group, constraints=None):
        hbox_main = gtk.HBox()
        label_text = gtk.Label(label.title())
        label_text.set_alignment(0, 0.5)
        label_text.set_padding(8,8)
        entry_filepath = gtk.Entry()
        entry_filepath.set_text(value)
        button_select_folder = gtk.ToolButton(
            gtk.image_new_from_file(os.path.join(definitions.ICONS_DIR, "open_small.png")))
        button_select_folder.connect("clicked", self.select_file, entry_filepath)
        hbox_main.pack_start(label_text)
        hbox_main.pack_start(entry_filepath)
        hbox_main.pack_start(button_select_folder)

        self.plugin_config_widgets.append(entry_filepath)
        self.plugin_config_traces.append(trace)
        sensitivity_group.append(label_text)
        sensitivity_group.append(entry_filepath)
        sensitivity_group.append(button_select_folder)

        return hbox_main

def __init__(self, *args, **kwargs):
        if 'default_value' in kwargs:
            default_value = kwargs['default_value']
            del kwargs['default_value']
        else:
            default_value = ''

        query = args[-1]
        args = args[:-1]

        super(EntryDialog, self).__init__(*args, **kwargs)

        label = gtk.Label(query)
        self.vbox.pack_start(label, True, True)

        entry = gtk.Entry()
        entry.set_text(str(default_value))
        entry.connect("activate",
                      lambda ent, dlg, resp: dlg.response(resp),
                      self, gtk.RESPONSE_OK)
        self.vbox.pack_end(entry, True, True, 0)
        self.vbox.show_all()
        self.entry = entry

def __init__(self):
        imageLoc = random.choice(os.listdir(os.path.join(WORKINGDIR, "data", "splashScreens")))
        imageSize = self.get_image_size(open(os.path.join(WORKINGDIR, "data", "splashScreens", imageLoc), 'rb').read())

        self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.window.set_decorated(False)
        self.window.set_title("Micro:Pi")
        self.window.set_icon_from_file(os.path.join(WORKINGDIR, "data", "icon.png"))
        self.window.set_size_request(imageSize[0], -1)
        self.window.set_position(gtk.WIN_POS_CENTER)
        main_vbox = gtk.VBox(False, 1)
        self.window.add(main_vbox)
        hbox = gtk.HBox(False, 0)
        self.img = gtk.Image()
        self.img.set_from_file(os.path.join(WORKINGDIR, "data", "splashScreens", imageLoc))
        main_vbox.pack_start(self.img, True, True)
        self.lbl = gtk.Label('')
        font = pango.FontDescription("Monospace 7")
        self.lbl.modify_font(font)
        main_vbox.pack_end(self.lbl, False, False)
        self.refresh()
        self.window.show_all()
        self.refresh()

def setup_gui_url_chooser(self):
        self.media_model = gtk.ListStore(str)
        self.media_type = gtk.ComboBox(self.media_model)
        cell = gtk.CellRendererText()
        self.media_type.pack_start(cell, True)
        self.media_type.add_attribute(cell, "text", 0)

        for t in ("file", "dvd", "tv", "dvb", "vcd", "radio", "cdda", "tivo"):
            self.media_model.append((t,))

        self.media_location = gtk.Entry()
        self.media_server = gtk.Label()
        self.media_server.set_alignment(0, 0.5)

        d = catota.ui.Dialog("Choose Location", self.parent_win,
                             extra_buttons=(gtk.STOCK_PREFERENCES, 1))

        t = catota.ui.new_table((("Server:", self.media_server),
                                 ("Type:", self.media_type),
                                 ("Location:", self.media_location)))
        d.vbox.pack_start(t, True, True)

        self.gui_url_chooser = d
    # setup_gui_url_chooser()

def addBgClick(self, widget=None, init=False):
        """Creates a new background and adds a new tab to the notebook."""
        n = self.bgNotebook.get_n_pages()

        if n > (self.defaults["bgCount"] + 2):
            if confirmDialog(self, "You already have %d background styles. Are you sure you would like another?" % n) == gtk.RESPONSE_NO:
                return

        self.addBg()

        newId = len(self.bgs)

        self.bgNotebook.append_page(self.bgs[newId-1], gtk.Label("Background ID %d" % (newId)))

        self.bgNotebook.show_all()

        self.updateComboBoxes(n, "add")

        self.bgNotebook.set_current_page(n)

        if not init:
            self.changeOccurred()

def quit(self, widget, event=None):
        """Asks if user would like to save file before quitting, then quits the program."""
        if self.toSave:
            if self.oneConfigFile:
                response = gtk.RESPONSE_YES
            else:
                dialog = gtk.Dialog("Save config?", self, gtk.DIALOG_MODAL, (gtk.STOCK_YES, gtk.RESPONSE_YES, gtk.STOCK_NO, gtk.RESPONSE_NO, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
                dialog.get_content_area().add(gtk.Label("Save config before quitting?"))
                dialog.get_content_area().set_size_request(300, 100)
                dialog.show_all()
                response = dialog.run()
                dialog.destroy()

            if response == gtk.RESPONSE_CANCEL:
                return True                         # Return True to stop it quitting when we hit "Cancel"
            elif response == gtk.RESPONSE_NO:
                gtk.main_quit()
            elif response == gtk.RESPONSE_YES:
                self.save()
                gtk.main_quit()
        else:
            gtk.main_quit()

def gui_add_task(self, task):
        label = gtk.Label(task.name)
        label.set_alignment(0.0, 0.0)
        row = self.task_count + 1
        col = 0  
        # col_left_attach, col_right_attach, row_top_attach, row_bottom_attach
        self.tbl_tasks.attach(label, col, col + 1, row, row + 1)
        label.show()

        col = 1 
        image = gtk.Image() 
        image.set_from_stock(gtk.STOCK_APPLY, gtk.ICON_SIZE_MENU)
        image.set_alignment(0.0, 0.0)
        self.tbl_tasks.attach(image, col, col + 1, row, row + 1)
        self.task_images.append(image)

        self.task_count += 1

def _fill_container(container, items, options, id_name):
    for item in items:
        hbox = gtk.HBox()

        label_id = gtk.Label()
        label_id.set_text(str(getattr(item, id_name)))
        hbox.pack_start(label_id, expand=False)

        widget = gtk.RadioButton(label=options[0]) # first widget
        hbox.pack_start(widget, expand=False, padding=4)
        for option in options[1:]: # create rest of the widgets, use first one as a group
            next_widget = gtk.RadioButton(widget, label=option)
            hbox.pack_start(next_widget, expand=False, padding=4)

        label = gtk.Label()
        label.set_text(item.name)
        hbox.pack_start(label, padding=16, expand=False)

        hbox.show_all()
        label_id.hide()
        container.pack_start(hbox)

def __init__(self, max_depth_value):
        self.on_max_depth_changed = None
        max_depth_entry = self.max_depth_entry = gtk.SpinButton(
            gtk.Adjustment(value=max_depth_value, lower=1, upper=100,
            step_incr=1, page_incr=10), digits=0)
        max_depth_entry.get_adjustment().connect('value_changed',
            self._max_depth_changed, max_depth_entry)
        max_depth_entry.set_alignment(0)
        max_depth_label = gtk.Label()
        max_depth_label.set_alignment(1, 0.5)
        max_depth_label.set_text_with_mnemonic('Maximum _Depth')
        max_depth_label.set_mnemonic_widget(max_depth_entry)
        legend = self._create_legend()
        table = self.view = gtk.Table(2, 3)
        table.set_border_width(8)
        table.set_row_spacings(8)
        table.set_col_spacings(8)
        table.attach(max_depth_label, 0, 1, 0, 1, gtk.FILL, gtk.FILL)
        table.attach(max_depth_entry, 1, 2, 0, 1, gtk.SHRINK, gtk.FILL)
        table.attach(gtk.Label(), 2, 3, 0, 1)  # space filler
        table.attach(legend, 0, 3, 1, 2)

def __init__(self, WinMain):
        #set main window
        self.WinMain = WinMain
        #build the window
        self.winMessage = gtk.Fixed()
        self.winMessage.set_has_window(True)
        self.imgBackground = gtk.Image()
        self.lblHeading = gtk.Label()
        self.lblMessage = gtk.Label()
        self.lblPrompt = gtk.Label()
        self.lblHeading.set_justify(gtk.JUSTIFY_CENTER)
        self.lblMessage.set_justify(gtk.JUSTIFY_CENTER)
        self.lblPrompt.set_justify(gtk.JUSTIFY_CENTER)
        self.winMessage.add(self.imgBackground)
        self.winMessage.add(self.lblHeading)
        self.winMessage.add(self.lblMessage)
        self.winMessage.add(self.lblPrompt)
        WinMain.fixd.add(self.winMessage)
        self.imgBackground.show()
        self.lblHeading.show()
        self.lblMessage.show()
        self.lblPrompt.show()
        self.winMessage.show()
        #
        self.wait_for_key = False

def display_splash(self):
        """show splash screen"""
        self.splash = gtk.Window()
        self.splash.set_decorated(False)
        self.splash.set_transient_for(self.winMain)
        self.splash.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
        self.splash.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
        self.splash.set_keep_above(True)
        self.splash.set_border_width(self.splash_border_width)
        vbox = gtk.VBox()
        img = gtk.Image()
        self.splash_gfx = os.path.join(CONFIG_DIR, 'layouts', self.layout, 'main-splash.png')
        if os.path.exists(self.splash_gfx):
            self.log_msg('Custom splash found, loading ' + str(self.splash_gfx))
            img.set_from_file(self.splash_gfx)
        else:
            self.splash_gfx = os.path.join(APP_PATH, 'pixmaps', 'wahcade-logo.png')
            self.log_msg('No custom splash found, loading ' + str(self.splash_gfx))
            img.set_from_file(self.splash_gfx)
        if self.splash_show_text == 1:
            lbl = gtk.Label()
            lbl.set_alignment(0.5, 0.5)
            lbl.set_justify(gtk.JUSTIFY_CENTER)
            lbl.set_use_markup(True)
            lbl.set_markup('<big><b>Wah!Cade</b></big>\n%s "%s"' % (VERSION, VERSION_NAME))
            vbox.pack_end(lbl)
        vbox.pack_start(img)
        self.splash.add(vbox)
        self.splash.show_all()
        if not self.tw_api:
            self.twitter_api = self.auth_twitter() ## Auth Twitter during startup
        self.wait_with_events(0.25)

def _create_list_labels(self):
        """create labels as rows"""
        #remove any existing rows
        [self.fixd.remove(row[0]) for row in self._rows]
        #create labels
        self._rows = []
        for i in range(self.num_rows):
            eb = gtk.EventBox()
            lbl = gtk.Label()
            lbl.modify_font(self._pango_font_desc)
            lbl.modify_fg(gtk.STATE_NORMAL, self._fg_col)
            lbl.modify_bg(gtk.STATE_NORMAL, self._hl_bg_col)
            lbl.set_property('xalign', self.properties['xalign'])
            lbl.set_angle(self.angle)
            lbl.show()
            eb.add(lbl)
            eb.add_events(gtk.gdk.BUTTON_PRESS_MASK)
            eb.connect('button-press-event', self._on_mouse_button, i)
            eb.show()
            eb.set_visible_window(False)
            self.fixd.add(eb)
            self._rows.append((eb, lbl))
        #colours
        self.modify_fg(gtk.STATE_NORMAL, self._fg_col)
        self.modify_highlight_bg(gtk.STATE_NORMAL, self._hl_bg_col)

def __init__(self, parent):
        gtk.Dialog.__init__(self, "Rename", parent, 0)

        self.set_default_size(150, 100)
        label1=gtk.Label()
        label1.set_markup("Enter New Name")

        self.newname=gtk.Entry()
        box = self.get_content_area()
        box.add(label1)
        box.add(self.newname)

        self.ok_button=gtk.Button("OK")
        box.add(self.ok_button)
        self.ok_button.connect("clicked",self.on_rename_ok_clicked)
        self.show_all()

def make_label(self):
        self.label = gtk.HBox(False, 0)

        self.text_label = gtk.Label("")
        self.text_label.show()
        self.label.pack_start(self.text_label, 1, 1, 1)

        button = gtk.Button()
        button.set_relief(gtk.RELIEF_NONE)
        button.set_focus_on_click(False)

        icon = gtk.image_new_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU)
        icon.show()
        button.add(icon)

        button.connect("clicked", lambda x: self.emit("want-close"))
        button.show()
        self.label.pack_start(button, 0, 0, 0)

        self.label.show()

def _add(self, tab, row, name, editor, text, colindex=0):
        label = gtk.Label(text + ":")
        label.set_alignment(0.0, 0.5)
        label.show()
        tab.attach(label, colindex, colindex + 1, row, row + 1,
                   xoptions=gtk.FILL, yoptions=0, xpadding=6, ypadding=3)

        widget = editor.get_widget()
        widget.show()
        tab.attach(widget, colindex + 1, colindex + 2, row, row + 1,
                   xoptions=gtk.FILL, yoptions=0, xpadding=3, ypadding=3)

        img = gtk.Image()
        img.set_size_request(16, -1)
        img.show()
        tab.attach(img, colindex + 2, colindex + 3, row, row + 1,
                   xoptions=gtk.FILL, yoptions=0, xpadding=3, ypadding=3)

        self._editors[name] = label, editor, img
        return label, editor, img

def _build_ui(self):
        self._entries = []
        self._update = True

        hexdigits = ((self._element.size() / 4) +
                     (self._element.size() % 4 and 1 or 0))
        formats = [('Hex', 16, '0x{:0%iX}' % hexdigits),
                   ('Dec', 10, '{:d}'),
                   ('Bin', 2, '{:0%ib}' % self._element.size())]
        for name, base, format_spec in formats:
            lab = gtk.Label(name)
            self.pack_start(lab, 0, 0, 0)
            lab.show()
            int(self._element)
            ent = IntegerEntry()
            self._entries.append((ent, format_spec))
            ent.connect('changed', self._changed, base)
            self.pack_start(ent, 0, 0, 0)
            ent.show()
        self._update_entries()

def _build_ui(self):
        lab = gtk.Label("Dec")
        lab.show()
        self.pack_start(lab, 0, 0, 0)
        ent = FixedEntry()
        ent.set_text(str(int(self._element)))
        ent.show()
        self.pack_start(ent, 1, 1, 1)

        lab = gtk.Label("Hex")
        lab.show()
        self.pack_start(lab, 0, 0, 0)

        hexent = FixedEntry()
        hexent.show()
        self.pack_start(hexent, 1, 1, 1)
        hexent.set_editable(False)

        ent.connect('changed', self._changed, hexent)
        self._format_hexent(hexent)

def __init__(self, title, parent=None):
        gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
        self.set_modal(True)
        self.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
        self.set_title(title)
        if parent:
            self.set_transient_for(parent)

        self.set_resizable(False)

        vbox = gtk.VBox(False, 2)

        self.label = gtk.Label("")
        self.label.set_size_request(100, 50)
        self.label.show()

        self.pbar = gtk.ProgressBar()
        self.pbar.show()

        vbox.pack_start(self.label, 0, 0, 0)
        vbox.pack_start(self.pbar, 0, 0, 0)

        vbox.show()

        self.add(vbox)

def __init__(self, msg, parent=None):
        gtk.Window.__init__(self)
        self.set_title("Please Wait")
        self.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
        if parent:
            self.set_transient_for(parent)
            self.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
        else:
            self.set_position(gtk.WIN_POS_CENTER)

        vbox = gtk.VBox(False, 2)

        l = gtk.Label(msg)
        l.show()
        vbox.pack_start(l)

        self.prog = gtk.ProgressBar()
        self.prog.show()
        vbox.pack_start(self.prog)

        vbox.show()
        self.add(vbox)

def __init__(self, rthread, parent=None):
        gtk.Dialog.__init__(self,
                            title=_("Shift"),
                            buttons=(gtk.STOCK_CLOSE, gtk.RESPONSE_OK))

        self.set_position(gtk.WIN_POS_CENTER_ALWAYS)

        self.rthread = rthread

        self.__prog = gtk.ProgressBar()
        self.__prog.show()

        self.__labl = gtk.Label("")
        self.__labl.show()

        self.vbox.pack_start(self.__prog, 1, 1, 1)
        self.vbox.pack_start(self.__labl, 0, 0, 0)

        self.quiet = False

        self.thread = None

def __init__(self, **args):
        buttons = (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
                   gtk.STOCK_OK, gtk.RESPONSE_OK)
        gtk.Dialog.__init__(self, buttons=buttons, **args)

        self.label = gtk.Label()
        self.label.set_size_request(300, 100)
        # pylint: disable-msg=E1101
        self.vbox.pack_start(self.label, 1, 1, 0)

        self.text = gtk.Entry()
        self.text.connect("activate", self.respond_ok, None)
        # pylint: disable-msg=E1101
        self.vbox.pack_start(self.text, 1, 1, 0)

        self.label.show()
        self.text.show()

def __init__(self, choices, **args):
        buttons = (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
                   gtk.STOCK_OK, gtk.RESPONSE_OK)
        gtk.Dialog.__init__(self, buttons=buttons, **args)

        self.label = gtk.Label()
        self.label.set_size_request(300, 100)
        # pylint: disable-msg=E1101
        self.vbox.pack_start(self.label, 1, 1, 0)
        self.label.show()

        try:
            default = choices[0]
        except IndexError:
            default = None

        self.choice = make_choice(sorted(choices), self.editable, default)
        # pylint: disable-msg=E1101
        self.vbox.pack_start(self.choice, 1, 1, 0)
        self.choice.show()

        self.set_default_response(gtk.RESPONSE_OK)

def add_field(self, label, widget, validator=None):
        box = gtk.HBox(True, 2)

        lab = gtk.Label(label)
        lab.show()

        widget.set_size_request(150, -1)
        widget.show()

        box.pack_start(lab, 0, 0, 0)
        box.pack_start(widget, 0, 0, 0)
        box.show()

        # pylint: disable-msg=E1101
        self.vbox.pack_start(box, 0, 0, 0)

        self.__fields[label] = widget

def delete_format(self, widget, data=None):
    # ???? ???????? gtk.RadioButton
    for format_id in self.format_radio:
      if format_id.get_active():
        # ?????????? ??????, ? ??????? ???????? ???????????? ?????????? ???? ?????
        dialog = gtk.Dialog('???????? ??????? "' + self.data['formats'][self.format_radio.index(format_id)]['name'] + '"', self.window, gtk.DIALOG_NO_SEPARATOR | gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_NO, gtk.RESPONSE_CANCEL, gtk.STOCK_YES, gtk.RESPONSE_OK))
        dialog.set_position(gtk.WIN_POS_CENTER_ALWAYS)
        dialog.set_resizable(False)
        dialog.set_border_width(10)
        self.confirmation_label = gtk.Label('?? ????????????? ?????? ??????? ?????? "' + self.data['formats'][self.format_radio.index(format_id)]['name'] + '"?')
        dialog.vbox.pack_start(self.confirmation_label, True, True, 5)
        dialog.show_all()
        response = dialog.run()
        if response == gtk.RESPONSE_CANCEL:
          dialog.hide()
          dialog.destroy()
        if response == gtk.RESPONSE_OK:
          # ??????? ??????
          name = self.data['formats'][self.format_radio.index(format_id)]['name']
          del self.data['formats'][self.format_radio.index(format_id)]
          config = open(self.path, 'wb')
          json.dump(self.data, config)
          config.close()
          self.format_radio[self.format_radio.index(format_id)].hide()
          if len(self.format_radio) == 1:
            pass
          elif self.format_radio.index(format_id) + 1 <= len(self.format_radio) - 1:
            self.format_radio[self.format_radio.index(format_id) + 1].set_active(True)
          elif self.format_radio.index(format_id) + 1 > len(self.format_radio) - 1:
            self.format_radio[self.format_radio.index(format_id) - 1].set_active(True)
          del self.format_radio[self.format_radio.index(format_id)]
          if len(self.format_radio) < 1:
            self.delete_button.set_sensitive(False)
            self.edit_button.set_sensitive(False)
          self.add_success_label.set_markup('<span foreground="#008600">"' + str(name) + '" ??????? ??????\n</span>')
          dialog.hide()
          dialog.destroy()
        break

  # ??? ??????? ???????????? ?????????? ?????? ???????

def get_password(self,parent):
        dialog = gtk.Dialog("Configure System Password",parent,gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT,(gtk.STOCK_CANCEL,gtk.RESPONSE_REJECT,gtk.STOCK_OK,gtk.RESPONSE_ACCEPT))
        self.pass1 = gtk.HBox()
                self.label1 = gtk.Label("          Passsword: ")
                self.pass1.pack_start(self.label1,False,True,0)
        self.password1 = gtk.Entry()
        self.password1.set_visibility(False)
        self.pass1.pack_start(self.password1,False,True,0)
        dialog.vbox.add(self.pass1)
        self.pass2 = gtk.HBox()
                self.label2 = gtk.Label("  Verify Password: ")
                self.pass2.pack_start(self.label2,False,True,0)
        self.password2 = gtk.Entry()
        self.password2.set_visibility(False)
        self.pass2.pack_start(self.password2,False,True,0)
        dialog.vbox.add(self.pass2)
        dialog.show_all()
        response = dialog.run()
        if response == gtk.RESPONSE_ACCEPT:
            self.a = self.password1.get_text()
            self.b = self.password2.get_text()
            dialog.destroy()
        else:
            self.a = ''
            self.b = ''
            dialog.destroy()


    # Configure Network Dialog

def _setup_table(self):
        """Called by __init__ to set up my main table.

        You can easily override me instead of clobbering __init__.
        """

        table = gtk.Table(len(self.propertyLabels), 2)
        self.container.add(table)
        table.set_name("PropertyTable")
        self.subtable['properties'] = table
        row = 0

        for p, name in self.propertyLabels:
            label = gtk.Label(name)
            label.set_name("PropertyName")
            label.set_data("property", p)
            table.attach(label, 0, 1, row, row + 1)
            label.set_alignment(0, 0)
            row = row + 1

        # XXX: make these guys collapsable
        for g, name in self.groupLabels:
            table = gtk.Table(1, 2)
            self.container.add(table)
            table.set_name("AttributeGroupTable")
            self.subtable[g] = table
            label = gtk.Label(name)
            label.set_name("AttributeGroupTitle")
            table.attach(label, 0, 2, 0, 1)

def fill_property(self, property, value):
        """Set a value for a particular property.

        'property' should be one of the keys in my propertyLabels.
        """
        row, name = self.propertyLabels.get(property)
        if type(value) is not types.InstanceType:
            widget = gtk.Label(str(value))
            widget.set_alignment(0, 0)
        else:
            widget = value.newAttributeWidget(self)
        widget.set_name("PropertyValue")

        self.subtable['properties'].attach(widget, 1, 2, row, row+1)

def fill_attributeGroup(self, group, attributes):
        """Provide members of an attribute group.

        'group' should be one of the keys in my groupLabels, and
        'attributes' a list of (name, value) pairs, with each value as
        either an Explorer or string.
        """

        # XXX: How to indicate detail level of members?

        table = self.subtable[group]
        if not attributes:
            table.hide()
            return

        table.resize(len(attributes)+1, 2)

        # XXX: Do I need to destroy previously attached children?

        row = 1 # 0 is title

        for name, value in attributes.items():
            label = gtk.Label(name)
            label.set_name("AttributeName")
            label.set_alignment(0, 0)

            if type(value) is types.StringType:
                widget = gtk.Label(value)
                widget.set_alignment(0, 0)
            else:
                widget = value.newAttributeWidget(self)

            table.attach(label, 0, 1, row, row + 1)
            table.attach(widget, 1, 2, row, row + 1)
            row = row + 1

        table.show_all()

def getTextForLabel(self):
        """Returns text for my label.

        The default implementation of AttributeWidget is a gtk.Label
        widget.  You may override this method to change the text which
        appears in the label.  However, if you don't want to be a
        label, override _makeWidgetObject instead.
        """
        return self.identifier

def _makeWidgetObject(self):
        """Make the GTK widget object that is me.

        Called by __init__ to construct the GtkObject I wrap-- the ._o
        member of a pygtk GtkObject.  Isn't subclassing GtkObjects in
        Python fun?
        """
        ebox = gtk.EventBox()
        label = gtk.Label(self.getTextForLabel())
        label.set_alignment(0,0)
        ebox.add(label)
        return ebox._o

def __init__(self, title=None):
        self.__title_text = None
        gtk.widget_push_composite_child()
        self.__title = gobject.new(gtk.Label, visible=True, xalign=0, yalign=0.5)
        self.__indent = gobject.new(gtk.Label, visible=True, label='    ')
        gtk.widget_pop_composite_child()
        gtk.Bin.__init__(self)
        self.__title.set_parent(self)
        self.__indent.set_parent(self)
        if title is not None:
            self.props.title = title

def __init__(self):
        assert Visualizer.INSTANCE is None
        Visualizer.INSTANCE = self
        super(Visualizer, self).__init__()
        self.nodes =  {} # node index -> Node
        self.channels = {} # id(ns3.Channel) -> Channel
        self.window = None # toplevel window
        self.canvas = None # goocanvas.Canvas
        self.time_label = None # gtk.Label
        self.play_button = None # gtk.ToggleButton
        self.zoom = None # gtk.Adjustment
        self._scrolled_window = None # gtk.ScrolledWindow

        self.links_group = goocanvas.Group()
        self.channels_group = goocanvas.Group()
        self.nodes_group = goocanvas.Group()

        self._update_timeout_id = None
        self.simulation = SimulationThread(self)
        self.selected_node = None # node currently selected
        self.speed = 1.0
        self.information_windows = []
        self._transmission_arrows = []
        self._last_transmissions = []
        self._drop_arrows = []
        self._last_drops = []
        self._show_transmissions_mode = None
        self.set_show_transmissions_mode(ShowTransmissionsMode.ALL)
        self._panning_state = None
        self.node_size_adjustment = None
        self.transmissions_smoothing_adjustment = None
        self.sample_period = SAMPLE_PERIOD
        self.node_drag_state = None
        self.follow_node = None
        self.shell_window = None

        self.create_gui()

        for plugin in plugins:
            plugin(self)

def create_collector_bbox(self, collector):
        frame = gtk.Frame(collector.name)

        if collector.is_enabled():
            layout = gtk.BUTTONBOX_SPREAD
            spacing = 10

            bbox = gtk.HButtonBox()
            bbox.set_border_width(1)
            bbox.set_layout(layout)
            bbox.set_spacing(spacing)
            frame.add(bbox)

            startCollectorButton = gtk.Button('Start Collector')
            startCollectorButton.connect("clicked", self.startIndividualCollector, collector)
            startCollectorButton.set_sensitive(not isinstance(collector, engine.collector.ManualCollector))
            bbox.add(startCollectorButton)

            stopCollectorButton = gtk.Button('Stop Collector')
            stopCollectorButton.connect("clicked", self.stopIndividualCollector, collector)
            stopCollectorButton.set_sensitive(not isinstance(collector, engine.collector.ManualCollector))
            bbox.add(stopCollectorButton)

            parseButton = gtk.Button('Parse Data')
            parseButton.connect("clicked", self.parser, collector)
            bbox.add(parseButton)
        else:
            label = gtk.Label("Collector Disabled")
            frame.add(label)

        return frame

def create_error_vbox(self, error_msg):
        vbox_error = gtk.VBox()

        traceback.print_exc()
        err_label = gtk.Label(error_msg)
        err_label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("red"))
        vbox_error.pack_start(err_label)

        return vbox_error

def create_options_hbox(self, label, value, trace, sensitivity_group, constraints=None):
        hbox_main = gtk.HBox()
        label_text = gtk.Label(label.title())
        label_text.set_alignment(0, 0.5)
        label_text.set_padding(8,8)
        checkbuttons = []
        selected_options = value
        if constraints is None:
            options = []
        else:
            options = constraints
        for option in options:
            new_button = gtk.CheckButton(option)
            if option in selected_options:
                new_button.set_active(True)
            checkbuttons.append(new_button)
        hbox_main.pack_start(label_text)
        for checkbutton in checkbuttons:
            hbox_main.pack_start(checkbutton)

        self.plugin_config_widgets.append(checkbuttons)
        self.plugin_config_traces.append(trace)
        sensitivity_group.append(label_text)
        sensitivity_group.append(checkbuttons)

        return hbox_main

def create_time_hbox(self, label, value, trace, sensitivity_group, constraints=None):
        hbox_main = gtk.HBox()
        label_text = gtk.Label(label.title())
        label_text.set_alignment(0, 0.5)
        label_text.set_padding(8,8)
        adjustment = gtk.Adjustment(value, 0, sys.maxint, 1)
        spinbutton_value = gtk.SpinButton(adjustment)
        combobox_units = gtk.combo_box_new_text()
        t_value, units = self.get_time_value_and_units(value)
        spinbutton_value.set_value(t_value)
        options = ["seconds", "minutes", "hours", "days", "weeks"]
        for option in options:
            combobox_units.append_text(option)
        selected_index = options.index(units)
        combobox_units.set_active(selected_index)
        hbox_main.pack_start(label_text)
        hbox_main.pack_start(spinbutton_value)
        hbox_main.pack_start(combobox_units)

        self.plugin_config_widgets.append([spinbutton_value, combobox_units])
        self.plugin_config_traces.append(trace)
        sensitivity_group.append(label_text)
        sensitivity_group.append(spinbutton_value)

        return hbox_main

    #TODO: Refactor these

def __call__(self, icon):
        try:
            return self.cache[icon]
        except KeyError: # element not in cache
            result = gtk.Label().render_icon(icon, self.size)
            self.cache[icon] = result
            return result

def __call__(self, icon):
        try:
            return self.cache[icon]
        except KeyError: # element not in cache
            result = gtk.Label().render_icon(icon, self.size)
            self.cache[icon] = result
            return result

def exitfc_button_cb(self, button):
        label = gtk.Label("Are you sure you want the FC to exit?")
        dialog = gtk.Dialog("Confirm Exit",
                       None,
                       gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
                       (gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
                       gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
        dialog.vbox.pack_start(label)
        label.show()
        response = dialog.run()
        dialog.destroy()

        if response == gtk.RESPONSE_ACCEPT:
            msg = ZarjExitCommand()
            self.zarj_comm.push_message(msg)

def __init__(self, label="", ellipsize=pango.ELLIPSIZE_END):
        gtk.Label.__init__(self)
        self.set_use_markup(True)
        self.set_justify(gtk.JUSTIFY_LEFT)
        self.set_alignment(xalign=0.0, yalign=0.5)
        self.set_markup(label)
        if ellipsize:
            self.set_ellipsize(ellipsize)
    # __init__()
# Label

def __init__(self, label=""):
        Label.__init__(self, label)
        self.set_line_wrap(True)
        self.set_single_line_mode(False)
        self.set_justify(gtk.JUSTIFY_FILL)
    # __init__()
# MultiLineLabel

def new_label_for(label, field, align_right=True):
    """Creates a new gtk.Label and associates it to field"""
    wid = gtk.Label(label)
    wid.set_mnemonic_widget(field)
    if align_right:
        wid.set_justify(gtk.JUSTIFY_RIGHT)
        wid.set_alignment(xalign=1.0, yalign=0.5)
    return wid
# new_label_for()

def new_table(wids):
    """Creates a gtk.Table with two rows, use it for forms"""
    p = gtk.Table(rows=len(wids) or 1, columns=2, homogeneous=False)
    p.set_col_spacings(5)
    p.set_row_spacings(5)
    if len(wids) < 1:
        wid = gtk.Label("Empty")
        p.attach(wid, 0, 2, 0, 1)
        p.show_all()
        return p

    for i, row in enumerate(wids):
        if isinstance(row, basestring):
            wid = Label("<b>%s</b>" % row)
            p.attach(wid, 0, 2, i, i+1)
            wid.show()
            if i > 0:
                p.set_row_spacing(i-1, 10)

        elif isinstance(row, (tuple, list)):
            label, field = row
            wid = new_label_for(label, field)
            p.attach(wid, 0, 1, i, i+1, xoptions=gtk.FILL)
            p.attach(field, 1, 2, i, i+1)
            wid.show()
            field.show()

    sw = gtk.ScrolledWindow()
    sw.set_shadow_type(gtk.SHADOW_NONE)
    sw.set_policy(hscrollbar_policy=gtk.POLICY_NEVER,
                  vscrollbar_policy=gtk.POLICY_AUTOMATIC)
    sw.add_with_viewport(p)
    p.show()
    sw.show()
    return sw
# new_table()

def setup_gui_button_contents(self):
        self.gui_button_contents = gtk.Label(self.__class__.__name__)
        self.gui_button_contents.show()
    # setup_gui_button_contents()

def _setup_ui_advanced(self):
        self.width = hildon.NumberEditor(100, 400)
        self.height = hildon.NumberEditor(100, 240)

        wids = ("Media",
                ("Width:", self.width),
                ("Height:", self.height),
                )

        self.tab.append_page(catota.ui.new_table(wids), gtk.Label("Advanced"))
    # _setup_ui_advanced()