python类ScrolledWindow()的实例源码

def __init__(self):
        Gtk.ScrolledWindow.__init__(self)
        self.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        self._on_focus_in_blocked = False
        self.m_min_width = 500
        self.m_min_height = 300
        self.set_size_request(self.m_min_width, self.m_min_height)
        self.m_linkbuttons = []
        self.g_searchentry = None

def __init__(self, model, parent):
        Gtk.VBox.__init__(self)
        self.m_model = model
        self.m_parent = parent
        sc = Gtk.ScrolledWindow()
        sc.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        self.pack_start(sc, True, True, 0)
        self.g_column_box = Gtk.HBox()
        self.g_column_box.set_spacing(gu.hig.SPACE_LARGE)
        self.g_column_box.set_border_width(gu.hig.SPACE_SMALL)
        # We pack column into this box
        sc.add_with_viewport(self.g_column_box)
        self.show_all()
        if model:
            self.update_from_model()

def show_path_info(self, w):
        if not self.g_path_info_dlg:
            self.g_path_info_dlg = Gtk.Dialog(_("_File locations").replace("_", ""), self,
                buttons=(Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT))
            sc = Gtk.ScrolledWindow()
            sc.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.NEVER)
            self.g_path_info_dlg.vbox.pack_start(sc, True, True, 0)
            #
            vbox = gu.hig_dlg_vbox()
            sc.add_with_viewport(vbox)

            box1, box2 = gu.hig_category_vbox(_("_File locations").replace("_", ""))
            vbox.pack_start(box1, True, True, 0)
            sizegroup = Gtk.SizeGroup(Gtk.SizeGroupMode.HORIZONTAL)
            # statistics.sqlite
            # win32 solfegerc
            # win32 langenviron.txt
            box2.pack_start(gu.hig_label_widget(_("Solfege application data:"), Gtk.Label(label=filesystem.app_data()), sizegroup), False, False, 0)
            box2.pack_start(gu.hig_label_widget(_("Solfege user data:"), Gtk.Label(label=filesystem.user_data()), sizegroup), False, False, 0)
            box2.pack_start(gu.hig_label_widget(_("Solfege config file:"), Gtk.Label(label=filesystem.rcfile()), sizegroup), False, False, 0)
            box2.pack_start(gu.hig_label_widget(_("Solfege installation directory:"), Gtk.Label(label=os.getcwdu()), sizegroup), False, False, 0)
            box2.pack_start(gu.hig_label_widget(_("User manual in HTML format:"), Gtk.Label(label=os.path.join(os.getcwdu(), "help")), sizegroup), False, False, 0)
            box2.pack_start(gu.hig_label_widget("gtk:", Gtk.Label(label=str(Gtk)), sizegroup), False, False, 0)
            box2.pack_start(gu.hig_label_widget("pyalsa:", Gtk.Label(label=str(alsaseq)), sizegroup), False, False, 0)
            box2.pack_start(gu.hig_label_widget("PYTHONHOME", Gtk.Label(os.environ.get('PYTHONHOME', 'Not defined')), sizegroup), False, False, 0)
            self.g_path_info_dlg.show_all()

            def f(*w):
                self.g_path_info_dlg.hide()
                return True
            self.g_path_info_dlg.connect('response', f)
            self.g_path_info_dlg.connect('delete-event', f)
            sc.set_size_request(min(vbox.size_request().width + gu.hig.SPACE_LARGE * 2,
                                    Gdk.Screen.width() * 0.9),
                                vbox.size_request().height)

def __init__(self, main, title='Search results'):
        super(SearchDialog,self).__init__(title, main.window, Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT, (Gtk.STOCK_OK,Gtk.ResponseType.ACCEPT))

        # the cancel button
        self.butt_cancel = self.action_area.get_children()[0]
        self.butt_cancel.connect("clicked", lambda x: self.destroy())

        # Positions
        self.resize(400, 400)
        self.set_position(Gtk.WindowPosition.CENTER)
        ui.gtk3.common.set_bokken_icon(self)

        # Log TextView
        #################################################################
        self.output_text = Gtk.TextView(buffer=None)
        self.output_text.set_wrap_mode(Gtk.WrapMode.NONE)
        self.output_text.set_editable(False)
        self.output_buffer = self.output_text.get_buffer()

        self.scrolled_window = Gtk.ScrolledWindow()
        self.scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.ALWAYS)
        self.scrolled_window.is_visible = True

        # Add Textview to Scrolled Window
        self.scrolled_window.add_with_viewport(self.output_text)

        #self.vbox.pack_start(self.output_text, True, True, 0)
        self.vbox.pack_start(self.scrolled_window, True, True, 0)
        self.show_all()

def __init__(self, title='Add comment'):
        super(CommentsDialog,self).__init__(title, None, Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT, (Gtk.STOCK_CANCEL, Gtk.ResponseType.REJECT, Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT))

        # the cancel button
        self.butt_cancel = self.action_area.get_children()[1]
        self.butt_cancel.connect("clicked", lambda x: self.destroy())

        # Positions
        self.resize(400, 200)
        self.set_position(Gtk.WindowPosition.CENTER)
        ui.gtk3.common.set_bokken_icon(self)

        # Log TextView
        #################################################################
        self.input_text = Gtk.TextView(buffer=None)
        self.input_text.set_wrap_mode(Gtk.WrapMode.NONE)
        self.input_text.set_left_margin(10)
        self.input_buffer = self.input_text.get_buffer()

        self.scrolled_window = Gtk.ScrolledWindow()
        self.scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        self.scrolled_window.is_visible = True

        # Add Textview to Scrolled Window
        self.scrolled_window.add_with_viewport(self.input_text)

        #self.vbox.pack_start(self.input_text, True, True, 0)
        self.vbox.pack_start(self.scrolled_window, True, True, 0)
        self.show_all()

def create_tree(self):
        # Scrolled Window
        self.sw = Gtk.ScrolledWindow()
        self.sw.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
        self.sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)

        self.store = Gtk.ListStore(str, str)
        self.tree = Gtk.TreeView(self.store)

        self.sw.add(self.tree)

        self.tree.set_rules_hint(True)

        # Connect right click popup search menu
        self.popup_handler = self.tree.connect('button-press-event', self.popup_menu)

        # Create the column
        bblocks = Gtk.TreeViewColumn()
        bblocks.set_title("Basic Blocks")

        cell = Gtk.CellRendererText()
        bblocks.pack_start(cell, True)
        bblocks.add_attribute(cell, "text", 0)

        self.treestore = Gtk.TreeStore(str)

        # Add column to tree
        self.tree.append_column(bblocks)
        self.tree.set_model(self.treestore)
        self.tree.expand_all()

def __init__(self, parent=None,
                 title='', description='', long_description=''):
        Gtk.Window.__init__(self, title=title)
        self.set_parent(parent)
        self.set_transient_for(parent)
        self.set_destroy_with_parent(False)
        self.set_default_size(600, 500)
        self.vbox = Gtk.VBox(spacing=0)
        self.add(self.vbox)
        self.text_buffer = Gtk.TextBuffer()
        self.text_buffer.insert_at_cursor(description)
        self.text_buffer.insert_at_cursor(
            '\n\n'
            + '############################################################'
            + '\n')
        self.text_buffer.insert_at_cursor(
            'Complete file implementing the input method follows here:\n')
        self.text_buffer.insert_at_cursor(
            '############################################################'
            + '\n')
        self.text_buffer.insert_at_cursor(long_description)
        self.text_view = Gtk.TextView()
        self.text_view.set_buffer(self.text_buffer)
        self.text_view.set_editable(False)
        self.text_view.set_cursor_visible(False)
        self.text_view.set_justification(Gtk.Justification.LEFT)
        self.text_view.set_wrap_mode(Gtk.WrapMode.WORD)
        self.scrolledwindow = Gtk.ScrolledWindow()
        self.scrolledwindow.set_hexpand(True)
        self.scrolledwindow.set_vexpand(True)
        self.scrolledwindow.add(self.text_view)
        self.vbox.pack_start(self.scrolledwindow, True, True, 0)
        self.close_button = Gtk.Button(stock=Gtk.STOCK_CLOSE)
        self.close_button.connect("clicked", self.on_close_button_clicked)
        self.hbox = Gtk.HBox(spacing=0)
        self.hbox.pack_end(self.close_button, False, False, 0)
        self.vbox.pack_start(self.hbox, False, False, 5)

def __init__(self, **kwargs):
        super().__init__(
            default_width=800,
            default_height=400,
            **kwargs
        )
        self.add_dialog = None


        action = Gio.SimpleAction.new('add-application', None)
        self.add_action(action)
        action.connect('activate', self.on_add_application)


        header = Gtk.HeaderBar(show_close_button=True, title=_('DRI Configuration'))
        add_btn = Gtk.Button.new_from_icon_name('list-add-symbolic', Gtk.IconSize.BUTTON)
        add_btn.props.action_name = 'win.add-application'
        header.pack_start(add_btn)
        header.show_all()
        self.set_titlebar(header)

        box = Gtk.Box(Gtk.Orientation.HORIZONTAL)
        sidebar = Gtk.StackSidebar()
        sw = Gtk.ScrolledWindow(child=sidebar, hscrollbar_policy=Gtk.PolicyType.NEVER)
        box.pack_start(sw, False, True, 0)

        stack = Gtk.Stack()
        # Just a basic mockup
        conf = dri.DRIConfig('/etc/drirc')
        device = conf.devices[0]
        for app in device.apps:
            # TODO: Group these by device
            pane = ApplicationPane(app, visible=True)
            stack.add_titled(pane, app.name, app.name)
        sidebar.props.stack = stack

        sw = Gtk.ScrolledWindow(child=stack)
        box.pack_start(sw, True, True, 0)
        box.show_all()
        self.add(box)

def on_menuitem_feedback_activate(self, widget):
        window_feedback = Gtk.Window()
        window_feedback.set_title("Feedback Form")
        window_feedback.set_default_size(640, 640)
        window_feedback.set_position(Gtk.WindowPosition.CENTER)
        feedback_browser = WebKit.WebView()
        feedback_browser.connect("console-message", self._javascript_console_message) # Suppress .js output
        feedback_scroller = Gtk.ScrolledWindow()
        feedback_scroller.add(feedback_browser)
        window_feedback.add(feedback_scroller)
        feedback_browser.open("https://jamiemcgowan.typeform.com/to/ng5Lhc")
        window_feedback.show_all()

def setup_viewer(self):
        self.viewer_grid = Gtk.Grid()

        scroll_window = Gtk.ScrolledWindow()
        scroll_window.set_vexpand(True)
        scroll_window.set_hexpand(True)
        self.viewer_grid.attach(scroll_window, 0, 0, 1, 1)

        self.courses_grid = courseGrid(self.course_manager.user['display_years'])
        scroll_window.add(self.courses_grid)

        self.columns = {}
        for year in range(1,self.course_manager.user['display_years']+1):
            for pos, quarter in enumerate(["fall", "winter", "spring", "summer"]):
                column_id = self.column_template.format(year, quarter)
                column = self.courses_grid.year_map[year].quarter_map[pos]

                # For drag and drop
                column.drag_dest_set_target_list(None)
                column.drag_dest_add_text_targets()

                column.connect('button-press-event', self.box_clicked)
                column.connect("drag-data-received", self.on_drag_data_received)
                self.columns[column_id] = column.box

        self.interface_switcher.insert_page(self.viewer_grid, None, 0)

def create_synonyms_flowbox(self):

        label_Synonyms=Gtk.Label()
        label_Synonyms.set_markup("<u><b>Synonyms</b></u>")
        self.vbox_left2.pack_start(label_Synonyms,False,True,0)
        self.scrolled=Gtk.ScrolledWindow()
        self.scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        self.flowbox=Gtk.FlowBox()
        self.flowbox.set_valign(Gtk.Align.START)
        self.flowbox.set_max_children_per_line(7)
        self.flowbox.set_selection_mode(Gtk.SelectionMode.NONE)

        self.toggle_button_list=[]
        for i in range(100):
            x=Gtk.ToggleButton(label=str(i))
            self.toggle_button_list.append(x)

        for i in range(100):
            self.toggle_button_list[i].connect('clicked',self.toggle_button_clicked)

        for i in self.toggle_button_list:
            self.flowbox.add(i)

        self.scrolled.add(self.flowbox)
        self.add(self.scrolled)
        self.vbox_left2.pack_start(self.scrolled,True,True,0)                           

#########signal callback functions######################

def __init__(self, item):
        super().__init__()

        self.set_name('LinksButton')
        self.set_label('%i links' % len(item.links))
        self.set_halign(Gtk.Align.START)
        self.set_valign(Gtk.Align.END)
        self.set_margin_left(5)
        self.set_margin_bottom(5)
        self.connect('activate-link', self._on_activate_link)

        style_context = self.get_style_context()
        style_context.remove_class('text-button')
        style_context.remove_class('button')

        self._weakref = weakref.ref(item)

        self._box = Gtk.Box()
        self._box.set_orientation(Gtk.Orientation.VERTICAL)

        height_request = 300
        if len(self.item.links) <= 5: height_request = 150
        scrolled_window = Gtk.ScrolledWindow()
        scrolled_window.set_policy(
            Gtk.PolicyType.NEVER,
            Gtk.PolicyType.AUTOMATIC
        )
        scrolled_window.set_size_request(300, height_request)
        scrolled_window.add(self._box)
        scrolled_window.show_all()

        self._popover = Gtk.Popover()
        self._popover.set_relative_to(self)
        self._popover.add(scrolled_window)

        self.populate()

def __init__(self, name: str, title: str, subtitle: str, width: int, height: int, header_buttons: dict, is_parent: bool):
        """Initialize Window class"""
        super(Window, self).__init__(title=title)
        self._name = name
        self._title = title
        self._subtitle = subtitle
        self._width = width
        self._height = height
        if header_buttons:
            self._header = HeaderBar(self._title, self._subtitle, header_buttons)
            self.set_titlebar(self._header.render)
        else:
            self._header = None
        self._is_parent = is_parent

        # self.set_resizable(False)
        self.set_size_request(self._width, self._height)
        self.set_position(Gtk.WindowPosition.CENTER)
        self.set_border_width(10)
        self.set_name(self._name)

        self._scrolled = Gtk.ScrolledWindow()
        self._scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        self._box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
        self._box.set_homogeneous(False)
        self.add(self._scrolled)
        self._scrolled.add(self._box)

        if self._is_parent:
            self.connect("delete-event", Gtk.main_quit)

def createScrollbar(Treeview):
    Scrollbar = Gtk.ScrolledWindow()
    Scrollbar.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
    Scrollbar.set_vexpand(True)
    Scrollbar.add(Treeview)
    return Scrollbar


# creating subFrame in Vulkan Tab

def __init__(self,url):
        self.code = None
        Gtk.Dialog.__init__(self)
        self.set_position(Gtk.WindowPosition.CENTER_ALWAYS)
        self.set_title(comun.APP)
        self.set_icon_from_file(comun.ICON)
        #
        vbox = Gtk.VBox(spacing = 5)
        self.get_content_area().add(vbox)
        hbox1 = Gtk.HBox()
        vbox.pack_start(hbox1,True,True,0)
        #
        self.scrolledwindow1 = Gtk.ScrolledWindow()
        self.scrolledwindow1.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        self.scrolledwindow1.set_shadow_type(Gtk.ShadowType.IN)
        hbox1.pack_start(self.scrolledwindow1,True,True,0)
        #
        self.viewer = WebKit.WebView()
        self.scrolledwindow1.add(self.viewer)
        self.scrolledwindow1.set_size_request(600,420)
        self.viewer.connect('navigation-policy-decision-requested', self.on_navigation_requested)
        self.viewer.open(url)
        #       
        self.show_all()

    ####################################################################
    #########################BROWSER####################################
    ####################################################################

def __init__(self):
        Gtk.ScrolledWindow.__init__(self)
        self.view = Gtk.DrawingArea()
        self.view.set_hexpand(True)
        self.view.set_vexpand(True)
        self.view.set_events(Gdk.EventMask.BUTTON_PRESS_MASK
                             | Gdk.EventMask.KEY_PRESS_MASK
                             | Gdk.EventType.MOTION_NOTIFY
                             | Gdk.EventMask.POINTER_MOTION_MASK)
        self.view.connect('draw', self.draw)
        self.view.connect('button-press-event', self.press)
        self.view.connect('motion-notify-event', self.motion)
        self.add(self.view)

def build_scrollable_popover(pos, width, height):

    popover = Gtk.Popover()
    popover.set_position(pos)
    scrolled_window = Gtk.ScrolledWindow()
    scrolled_window.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
    scrolled_window.set_size_request(width, height)
    popover.add(scrolled_window)
    return popover

def __init__(self, mainapp):
        self._mainapp = mainapp
        self.config = mainapp.config
        self.draw = mainapp.draw

        self.default_size = self.config["misc"]["dsize"]
        self.last_size = (-1, -1)
        self.tag_image_bytedata = None

        # window setup
        self.overlay = Gtk.Overlay()
        self.image = Gtk.Image()
        self.scrolled = Gtk.ScrolledWindow()
        self.scrolled.add(self.image)

        self.overlay.add(self.scrolled)
        self.overlay.add_overlay(self.draw.area)

        self.va = self.scrolled.get_vadjustment()
        self.ha = self.scrolled.get_hadjustment()

        self.rebuild_window()
        # fix this
        if not self.config["image"]["show"]:
            self.overlay.remove(self.scrolled)

    # Base window properties

def __setup_ui(self, win):
        btn_setting = Gtk.Button("Settings")
        btn_setting.set_margin_right(self.HORIZONTAL_MARGIN)
        btn_reload = Gtk.Button("Reload")
        btn_box = Gtk.HBox()
        btn_box.add(btn_setting)
        btn_box.add(btn_reload)
        self._listbox = Gtk.TreeView(self._list_store)
        self._listbox.set_headers_visible(False)
        self._listbox.connect("row-activated", self.__row_activated)
        self._scrollable = Gtk.ScrolledWindow()
        self._scrollable.add(self._listbox)
        self.__fill_listbox()
        self._frame = Gtk.Frame()
        self._frame.add(self._scrollable)
        self._frame.set_border_width(1)
        self._frame.set_margin_bottom(self.VERTICAL_MARGIN)
        vbox = Gtk.VBox()
        vbox.pack_start(self._frame, 1, 1, 1)
        vbox.pack_end(btn_box, 0, 0, 0)
        vbox.set_margin_top(self.VERTICAL_MARGIN)
        vbox.set_margin_bottom(self.VERTICAL_MARGIN)
        vbox.set_margin_left(self.VERTICAL_MARGIN)
        vbox.set_margin_right(self.VERTICAL_MARGIN)
        win.add(vbox)
        return btn_reload, btn_setting