Python gi.repository.Gtk 模块，VSeparator() 实例源码

def create(self):
        table = Gtk.Table()
        label = Gtk.Label()
        label.set_alignment(0.0, 0.5)
        label.set_markup(u"<b>%s</b>" % self.m_heading)
        self.pack_start(label, True, True, 0)
        for idx, (cell1, cell2) in enumerate(self.m_data):
            table.attach(label_from_key(self.m_statistics, cell1), 1, 2, idx*2+1, idx*2+2,
                         xoptions=Gtk.AttachOptions.SHRINK, xpadding=2)
            table.attach(Gtk.Label(label=cell2), 3, 4, idx*2+1, idx*2+2,
                         xoptions=Gtk.AttachOptions.SHRINK, xpadding=2)
        for idx in range(len(self.m_data) + 1):
            table.attach(Gtk.HSeparator(), 0, 5, idx*2, idx*2+1, xoptions=Gtk.AttachOptions.FILL)
        table.attach(Gtk.VSeparator(), 0, 1, 0, idx*2+2, xoptions=Gtk.AttachOptions.SHRINK)
        table.attach(Gtk.VSeparator(), 2, 3, 0, idx*2+2, xoptions=Gtk.AttachOptions.SHRINK)
        table.attach(Gtk.VSeparator(), 4, 5, 0, idx*2+2, xoptions=Gtk.AttachOptions.SHRINK)
        self.pack_start(table, False, False, 0)
        self.show_all()

def setup_widgets(self):
        self.parent = Gtk.Grid()
        self.parent.set_name("osd-gesture")

        self._left_draw  = GestureDraw(self.SIZE, self._left_detector)
        # self._right_draw = GestureDraw(self.SIZE, self._right_detector)
        sep = Gtk.VSeparator()
        sep.set_name("osd-gesture-separator")

        self.parent.attach(self._left_draw,  0, 0, 1, 1)
        # self.parent.attach(sep,              1, 0, 1, 1)
        # self.parent.attach(self._right_draw, 2, 0, 1, 1)

        self.add(self.parent)

def __init__(self, heading, st_data, st):
        """
        st_data is the statistics data we want displayled
        st is the statistics object the statistics are collected from.
        """
        Gtk.VBox.__init__(self)
        label = Gtk.Label(label=heading)
        label.set_name("StatisticsH2")
        label.set_alignment(0.0, 0.0)
        self.pack_start(label, False, False, 0)
        hbox = gu.bHBox(self, False)
        frame = Gtk.Frame()
        hbox.pack_start(frame, False, False, 0)
        t = Gtk.Table()
        frame.add(t)
        keys = st.get_keys(True)
        for x in range(len(keys)):
            t.attach(Gtk.VSeparator(), x*2+1, x*2+2, 0, len(keys)*2)
        for x in range(len(keys)-1):
            t.attach(Gtk.HSeparator(), 0, len(keys)*2+1, x*2+1, x*2+2)
        for y, key in enumerate(keys):
            l = label_from_key(st, key)
            t.attach(l, 0, 1, y*2, y*2+1, xpadding=gu.PAD)
            for x, skey in enumerate(keys):
                try:
                    s = st_data[key][skey]
                except KeyError:
                    s = '-'
                l = Gtk.Label(label=s)
                if x == y:
                    l.set_name('BoldText')
                t.attach(l, x*2+2, x*2+3, y*2, y*2+1, xpadding=gu.PAD)
        self.show_all()

def add_text(self, data_dict, version):
        '''data_dict ontains text to be added.
           Key will be the title
           Value will be... well, the value :)'''
        self.box = Gtk.HBox(False, 1)
        self._statusbar.pack_start(self.box, False, False, 1)
        ellipsize = Pango.EllipsizeMode.NONE
        for element in data_dict.keys():
            if element == 'Arch':
                _icon = Gtk.Image.new_from_file(self.icons[element])
            else:
                _icon = Gtk.Image.new_from_stock(self.icons[element], Gtk.IconSize.MENU)
            self.box.pack_start(_icon, False, False, 0)
            # Element label
            label = Gtk.Label()
            label.set_markup('<b>%s:</b>' % element)
            label.set_padding(1, 0)
            label.set_max_width_chars(len(element) + 1)
            label.set_single_line_mode(True)
            label.set_ellipsize(ellipsize)
            self.box.pack_start(label, True, True, 1)
            # Element content
            label = Gtk.Label(label=str(data_dict[element]))
            label.set_padding(1, 0)
            label.set_max_width_chars(len(str(data_dict[element])))
            label.set_single_line_mode(True)
            label.set_ellipsize(ellipsize)
            self.box.pack_start(label, True, True, 1)
            sep = Gtk.VSeparator()
            self.box.pack_start(sep, True, True, 1)

        if version:
            _icon = Gtk.Image.new_from_file(datafile_path('bokken-small.svg'))
            self.pack_start(_icon, False, False, 1)
            label = Gtk.Label()
            label.set_markup('<b>Bokken ' + version + '</b> (' + self.uicore.backend.capitalize() + ' ' + self.uicore.version + ')')
            label.set_padding(1, 0)
            self.pack_end(label, False, True, 0)

        self.show_all()

def update_answer_buttons(self, obj=None):
        """
        Only columns with question properties that are actually used
        in the lesson file will be displayed. This way, we can make a default
        configuration:
         qprops = "name", "toptone", "inversion"
         qprop_labels = _("Name"), _("Toptone"), _("Inversion")
        and only lesson files that require other properties have to define
        these two variables.
        """
        # This part will create the table with the buttons used to answer.
        try:
            self.g_atable.destroy()
        except AttributeError:
            pass
        self.g_atable = Gtk.Table()
        self.g_atable.show()
        if self.m_t.m_P.header.layout_orientation == 'horiz':
            self.g_contents.attach(self.g_atable, 1, 2, 2, 3)
        else:
            self.g_contents.attach(self.g_atable, 0, 1, 1, 2)
        # pprops say how many properties are we going to display.
        # We will not display a property if no questions use it.
        num_used_props = len(
            [x for x in self.m_t.m_P.m_props.keys() if self.m_t.m_P.m_props[x]])
        # tcols say how many columns we need. We need a column for each
        # column separator
        tcols = num_used_props * 2 - 1
        trows = max([len(x) for x in self.m_t.m_P.m_props.values()]) + 2
        # The column headings
        for idx, label in enumerate(self.m_t.m_P.header.qprop_labels):
            self.g_atable.attach(Gtk.Label(label=label), idx * 2, idx * 2 + 1, 0, 1,
                                 xoptions=Gtk.AttachOptions.FILL, yoptions=Gtk.AttachOptions.SHRINK,
                                 xpadding=gu.PAD_SMALL)
        # Then we create the buttons used to answer.
        for x, prop in enumerate(self.m_t.m_P.header.qprops):
            for y, proplabel in enumerate(self.m_t.m_P.m_props[prop]):
                button = Gtk.Button(unicode(proplabel))
                button.m_property_name = prop
                button.m_property_value = proplabel.cval
                button.connect('clicked', self.on_prop_button_clicked)
                button.connect('button_release_event', self.on_prop_button_right_clicked)
                self.g_atable.attach(button, x * 2, x * 2 + 1, y + 2, y + 3,
                    xpadding=gu.PAD_SMALL,
                    yoptions=Gtk.AttachOptions.SHRINK)
        # The separator below the column headings
        self.g_atable.attach(Gtk.HSeparator(), 0, tcols, 1, 2,
            xoptions=Gtk.AttachOptions.FILL, yoptions=Gtk.AttachOptions.FILL,
            xpadding=0, ypadding=gu.PAD_SMALL)
        # The vertical separator between columns
        for idx in range(len(self.m_t.m_P.header.qprops)-1):
            self.g_atable.attach(Gtk.VSeparator(),
            idx * 2 + 1, idx * 2 + 2, 0, trows,
            xoptions=Gtk.AttachOptions.FILL, yoptions=Gtk.AttachOptions.FILL,
            xpadding=0, ypadding=gu.PAD_SMALL)
        self.g_atable.show_all()
        #
        self.g_random_transpose.set_text(str(self.m_t.m_P.header.random_transpose))

def __init__(self, teacher):
        abstract.Gui.__init__(self, teacher)
        self.m_key_bindings = {'backspace_ak': self.on_backspace}
        self.g_answer_box = gu.NewLineBox()
        self.practise_box.pack_start(self.g_answer_box, False, False, 0)
        #-------
        hbox = gu.bHBox(self.practise_box)
        b = Gtk.Button(_("Play"))
        b.show()
        b.connect('clicked', self.play_users_answer)
        hbox.pack_start(b, False, True, 0)
        self.practise_box.pack_start(Gtk.HBox(False, 0), False, False,
                                     padding=gu.PAD_SMALL)
        self.g_rhythm_viewer = RhythmViewer(self)
        #FIXME the value 52 is dependant on the theme used
        self.g_rhythm_viewer.set_size_request(-1, 52)
        self.g_rhythm_viewer.create_holders()
        hbox.pack_start(self.g_rhythm_viewer, True, True, 0)

        # action area
        self.std_buttons_add(
            ('new', self.new_question),
            ('repeat', self.repeat_question),
            ('give_up', self.give_up),
            ('backspace', self.on_backspace))

        self.practise_box.show_all()
        ##############
        # config_box #
        ##############
        self.add_select_elements_gui()
        #--------
        self.config_box.pack_start(Gtk.HBox(False, 0), False, False,
                                   padding=gu.PAD_SMALL)
        self.add_select_num_beats_gui()
        #-----
        self.config_box.pack_start(Gtk.HBox(False, 0), False, False,
                                   padding=gu.PAD_SMALL)
        #------
        hbox = gu.bHBox(self.config_box, False)
        hbox.set_spacing(gu.PAD_SMALL)
        hbox.pack_start(gu.nCheckButton(self.m_exname,
                 "not_start_with_rest",
                 _("Don't start the question with a rest")), False, False, 0)
        sep = Gtk.VSeparator()
        hbox.pack_start(sep, False, False, 0)
        hbox.pack_start(Gtk.Label(_("Beats per minute:")), False, False, 0)
        spin = gu.nSpinButton(self.m_exname, 'bpm',
                 Gtk.Adjustment(60, 20, 240, 1, 10))
        hbox.pack_start(spin, False, False, 0)
        self._add_auto_new_question_gui(self.config_box)
        self.config_box.show_all()

def update_answer_buttons(self, obj=None):
        """
        Only columns with question properties that are actually used
        in the lesson file will be displayed. This way, we can make a default
        configuration:
         qprops = "name", "toptone", "inversion"
         qprop_labels = _("Name"), _("Toptone"), _("Inversion")
        and only lesson files that require other properties have to define
        these two variables.
        """
        # This part will create the table with the buttons used to answer.
        try:
            self.g_atable.destroy()
        except AttributeError:
            pass
        self.g_atable = Gtk.Table()
        self.g_atable.show()
        self.g_hbox.pack_start(self.g_atable, False, False, 0)
        self.g_hbox.reorder_child(self.g_atable, 1)
        # pprops say how many properties are we going to display.
        # We will not display a property if no questions use it.
        num_used_props = len(
            [x for x in self.m_t.m_P.m_props.keys() if self.m_t.m_P.m_props[x]])
        # tcols say how many columns we need. We need a column for each
        # column separator
        tcols = num_used_props * 2 - 1
        trows = max([len(x) for x in self.m_t.m_P.m_props.values()]) + 2
        # The column headings
        for idx, label in enumerate(self.m_t.m_P.header.qprop_labels):
            self.g_atable.attach(Gtk.Label(label=label), idx * 2, idx * 2 + 1, 0, 1,
                                 xoptions=Gtk.AttachOptions.FILL, yoptions=Gtk.AttachOptions.SHRINK,
                                 xpadding=gu.PAD_SMALL)
        # Then we create the buttons used to answer.
        for x, prop in enumerate(self.m_t.m_P.header.qprops):
            for y, proplabel in enumerate(self.m_t.m_P.m_props[prop]):
                button = Gtk.Button(unicode(proplabel))
                button.m_property_name = prop
                button.m_property_value = proplabel.cval
                button.connect('clicked', self.on_prop_button_clicked)
                button.connect('button_release_event', self.on_prop_button_right_clicked)
                self.g_atable.attach(button, x * 2, x * 2 + 1, y + 2, y + 3,
                    xpadding=gu.PAD_SMALL,
                    yoptions=Gtk.AttachOptions.SHRINK)
        # The separator below the column headings
        self.g_atable.attach(Gtk.HSeparator(), 0, tcols, 1, 2,
            xoptions=Gtk.AttachOptions.FILL, yoptions=Gtk.AttachOptions.FILL,
            xpadding=0, ypadding=gu.PAD_SMALL)
        # The vertical separator between columns
        for idx in range(len(self.m_t.m_P.header.qprops)-1):
            self.g_atable.attach(Gtk.VSeparator(),
            idx * 2 + 1, idx * 2 + 2, 0, trows,
            xoptions=Gtk.AttachOptions.FILL, yoptions=Gtk.AttachOptions.FILL,
            xpadding=0, ypadding=gu.PAD_SMALL)
        self.g_atable.show_all()
        #
        self.g_random_transpose.set_text(str(self.m_t.m_P.header.random_transpose))
        self.g_repeat.set_sensitive(False)
        self.g_repeat_arpeggio.set_sensitive(False)
        self.g_give_up.set_sensitive(False)

def createHud(self):
        self.tools = Gtk.ToolPalette()

        # general functions
        generalTools = Gtk.ToolItemGroup.new('General')
        self.tools.add(generalTools)

        loadItem = Gtk.ToolButton.new(None, 'Load')
        loadItem.connect("clicked", self.__loadGraph)
        generalTools.insert(loadItem, -1)

        saveItem = Gtk.ToolButton.new(None, 'Save')
        saveItem.connect("clicked", self.__saveGraph)
        generalTools.insert(saveItem, -1)

        runItem = Gtk.ToolButton.new(None, 'Run')
        runItem.connect("clicked", self.__executeGraph)
        generalTools.insert(runItem, -1)

        # node functions
        newNodeTools = Gtk.ToolItemGroup.new('New Node')
        self.tools.add(newNodeTools)

        constNodeItem = Gtk.ToolButton.new(None, 'FileRead')
        constNodeItem.connect("clicked", lambda w = None, d = None: self.__createNode('fileread', w, d))
        newNodeTools.insert(constNodeItem, -1)

        constNodeItem = Gtk.ToolButton.new(None, 'FileWrite')
        constNodeItem.connect("clicked", lambda w = None, d = None: self.__createNode('filewrite', w, d))
        newNodeTools.insert(constNodeItem, -1)

        constNodeItem = Gtk.ToolButton.new(None, 'Constant')
        constNodeItem.connect("clicked", lambda w = None, d = None: self.__createNode('const', w, d))
        newNodeTools.insert(constNodeItem, -1)

        printNodeItem = Gtk.ToolButton.new(None, 'Printer')
        printNodeItem.connect("clicked", lambda w = None, d = None: self.__createNode('print', w, d))
        newNodeTools.insert(printNodeItem, -1)

        adderNodeItem = Gtk.ToolButton.new(None, 'Adder')
        adderNodeItem.connect("clicked", lambda w = None, d = None: self.__createNode('add', w, d))
        newNodeTools.insert(adderNodeItem, -1)

        adderNodeItem = Gtk.ToolButton.new(None, 'Bash')
        adderNodeItem.connect("clicked", lambda w = None, d = None: self.__createNode('bash', w, d))
        newNodeTools.insert(adderNodeItem, -1)

        adderNodeItem = Gtk.ToolButton.new(None, 'MatLab')
        adderNodeItem.connect("clicked", lambda w = None, d = None: self.__createNode('matlab', w, d))
        newNodeTools.insert(adderNodeItem, -1)

        self.vbox.pack_start(self.tools, False, False, 0)

        vsep = Gtk.VSeparator()
        self.vbox.pack_start(vsep, False, False, 0)

        logger.debug('HUD populated')