Python scrolled_window.ScrolledWindow类代码示例

class TwoButtonTemplate(Gtk.Box):
    def __init__(self, title, description, left_btn_text, right_btn_text, buttons_shown):
        Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL)

        self.title = Heading(title, description)
        self.title.container.set_margin_bottom(0)

        self.sw = ScrolledWindow()
        self.sw.apply_styling_to_widget(wide=False)

        self.left_button = KanoButton(left_btn_text, color='orange')
        self.right_button = KanoButton(right_btn_text, color='green')

        kano_button_box = Gtk.ButtonBox()
        kano_button_box.set_layout(Gtk.ButtonBoxStyle.CENTER)
        kano_button_box.set_spacing(20)

        if buttons_shown == 2:
            kano_button_box.pack_start(self.left_button, False, False, 0)

        kano_button_box.pack_start(self.right_button, False, False, 0)

        self.pack_start(self.title.container, False, False, 0)
        self.pack_start(self.sw, True, True, 0)
        self.pack_end(kano_button_box, False, False, 0)

    def get_right_button(self):
        return self.right_button

    def get_left_button(self):
        return self.left_button

    def __init__(self):
        ScrolledWindow.__init__(self, hexpand=True, vexpand=True)
        self.set_size_request(500, 300)

        self.contents = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.add_with_viewport(self.contents)

        self.devices = []
        self.dev_view = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.contents.pack_start(self.dev_view, False, False, 0)

    def setup_application_widgets(self):
        screen = Gdk.Screen.get_default()
        width = screen.get_width()
        height = screen.get_height()

        self.terminal = TerminalUi()
        fg_color = Gdk.Color.parse("#ffffff")[1]
        bg_color = Gdk.Color.parse("#262626")[1]
        self.terminal.set_colors(fg_color, bg_color, [])
        self.terminal.set_margin_top(10)
        self.terminal.set_margin_left(10)
        self.terminal.set_margin_right(10)

        self.spellbook = Spellbook()

        self.story = Storybook(
            width / 2 - 40,
            height - self.spellbook.HEIGHT - 2 * 44 - 10
        )
        self.story.set_margin_top(10)
        self.story.set_margin_left(10)
        self.story.set_margin_right(10)

        story_sw = ScrolledWindow()
        story_sw.apply_styling_to_screen()
        story_sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        story_sw.add(self.story)

        left_background = Gtk.EventBox()
        left_background.get_style_context().add_class("story_background")
        right_background = Gtk.EventBox()
        right_background.get_style_context().add_class("terminal_background")

        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.add(vbox)

        hbox = Gtk.Box()

        vbox.pack_start(hbox, False, False, 0)
        vbox.pack_start(self.spellbook, False, False, 0)
        hbox.pack_start(left_background, False, False, 0)
        hbox.pack_start(right_background, False, False, 0)

        left_background.add(story_sw)
        right_background.add(self.terminal)

        # Allow for margin on bottom and top bar.
        self.terminal.set_size_request(
            width / 2 - 20, height - self.spellbook.HEIGHT - 2 * 44 - 20
        )
        story_sw.set_size_request(
            width / 2 - 20, height - self.spellbook.HEIGHT - 2 * 44 - 10
        )

        self.run_server()

    def __init__(self):
        Gtk.Grid.__init__(self)

        self.get_style_context().add_class('password')
        self.set_row_spacing(10)

        title = Heading(_('Select Account'),
                        _('Log in to which account?'))
        self.attach(title.container, 0, 0, 2, 1)

        self.scrolled_window = ScrolledWindow()
        self.scrolled_window.set_size_request(self.WIDTH, self.HEIGHT)
        self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.box.set_spacing(10)
        self.box.set_margin_left(10)
        self.box.set_margin_right(10)
        self.scrolled_window.add(self.box)
        self.attach(self.scrolled_window, 0, 1, 2, 1)

        self.last_username = get_last_user()
        self._populate()

        self.add_account_btn = OrangeButton(_('Add Account'))
        self.add_account_btn.connect('clicked', self._btn_add_account_pressed)
        self.attach(self.add_account_btn, 0, 2, 1, 1)

        self.shutdown_btn = OrangeButton(_('Shutdown'))
        self.shutdown_btn.connect('clicked', self._btn_shutdown_pressed)
        self.attach(self.shutdown_btn, 1, 2, 1, 1)

    def __add_scrolled_window(self):
        text = Gtk.TextView()
        text.get_buffer().set_text(self.scrolled_text)
        text.set_wrap_mode(Gtk.WrapMode.WORD)
        text.set_editable(False)

        scrolledwindow = ScrolledWindow()
        scrolledwindow.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        scrolledwindow.add_with_viewport(text)
        scrolledwindow.set_size_request(400, 200)
        scrolledwindow.apply_styling_to_widget(wide=False)

        return scrolledwindow

class ScrolledWindowTemplate(Gtk.Box):

    def __init__(
        self,
        title,
        description,
        button_text,
        orange_button_text=None
    ):

        Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL)

        self.sw = ScrolledWindow()
        self.sw.apply_styling_to_widget(wide=False)

        self.title = Heading(title, description)
        self.kano_button = KanoButton(button_text)
        self.kano_button.pack_and_align()

        self.pack_start(self.title.container, False, False, 0)
        self.pack_start(self.sw, True, True, 0)

        if orange_button_text:
            box_align = Gtk.Alignment(xscale=0, xalign=0.5)
            button_box = Gtk.ButtonBox(
                orientation=Gtk.Orientation.HORIZONTAL, spacing=40
            )

            label = Gtk.Label("")
            self.orange_button = OrangeButton(orange_button_text)
            button_box.pack_start(label, False, False, 0)
            button_box.pack_start(self.kano_button.align, False, False, 0)
            button_box.pack_start(self.orange_button, False, False, 0)

            box_align.add(button_box)
            self.pack_start(box_align, False, False, 0)
        else:
            self.pack_start(self.kano_button.align, False, False, 0)

    def get_scrolled_window(self):
        return self.sw

    def __init__(self, category, avatar_parser):
        logger.debug(
            "Initialising pop up menu with category {}".format(category))

        self.top_bar_height = 50

        # Size of the selected icon
        self.button_width = 42
        self.button_height = 42

        self._category = category
        self._parser = avatar_parser
        if self._category == self._parser.char_label:
            self._signal_name = 'character_selected'
        else:
            self._signal_name = 'pop_up_item_selected'
        self._border_path = self._parser.get_selected_border(self._category)
        self._hover_path = self._parser.get_hover_border(self._category)

        obj_names = self._parser.list_avail_objs(self._category)
        SelectMenu.__init__(self, obj_names, self._signal_name)

        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.add(vbox)

        # Grid which the buttons are packed into
        self._grid = Gtk.Grid()

        # pack the grid into a sw of a specified height
        sw = ScrolledWindow()
        sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        sw.apply_styling_to_widget()
        sw.add(self._grid)
        sw.set_size_request(152, 294)

        # Labels the category
        top_bar = self._create_top_bar()
        vbox.pack_start(top_bar, False, False, 0)
        vbox.pack_start(sw, False, False, 10)

        self._pack_items()
        self.show_all()

def activate(_win):
    project_list = ProjectList()

    scrolledwindow = ScrolledWindow()
    scrolledwindow.apply_styling_to_widget()
    scrolledwindow.add_with_viewport(project_list.background)
    scrolledwindow.set_size_request(734, 404)

    _box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
    _box.pack_start(scrolledwindow, False, False, 0)

    _win.pack_in_main_content(_box)
    _win.show_all()

        def __init__(self, screen_number=None, screen_name=None,
                     socket_id=0, onescreen=False):
            # Check for internet, if screen is 12 means no internet
            if screen_number == 12 or screen_name == 'no-internet':
                common.has_internet = False
            else:
                common.has_internet = is_internet()

            # Set combobox styling to the screen
            # Is done here so we don't attach the styling multiple times when
            # switching screens
            apply_styling_to_screen(self.CSS_PATH)
            apply_common_to_screen()
            KanoComboBox.apply_styling_to_screen()
            ScrolledWindow.apply_styling_to_screen(wide=True)

            # Set window
            base_class.__init__(self, _("Settings"), self.width,
                                self.height, socket_id)

            self.set_decorated(True)
            self.top_bar = TopBar(_("Settings"))
            self.top_bar.set_close_callback(self.close_window)
            self.prev_handler = None
            self.set_icon_name('kano-settings')

            if self._base_name == "Window":
                self.set_titlebar(self.top_bar)

            self._onescreen = onescreen

            self.connect('delete-event', Gtk.main_quit)
            # In case we are called from kano-world-launcher, terminate splash
            os.system('kano-stop-splash')
            # Init to Home Screen
            HomeScreen(self, screen_number=screen_number, screen_name=screen_name)

    def _generate_grid(self):
        row_count = int(math.ceil(
            float(len(self._DISPLAYED_SCREENS)) / self._col_count)
        )

        table = Gtk.Table(row_count, self._col_count, homogeneous=True,
                          hexpand=True, vexpand=True)
        table.props.margin = 0

        for idx, screen in enumerate(self._DISPLAYED_SCREENS):
            row = idx / 2
            col = idx % 2

            screen.create_menu_button(self._change_screen_cb)

            if row % 2:
                style_class = 'appgrid_grey'
            else:
                style_class = 'appgrid_white'

            screen.menu_button.button.get_style_context().add_class(style_class)

            screen.refresh_menu_button()

            table.attach(screen.menu_button.button,
                         col, col + 1, row, row + 1,
                         Gtk.AttachOptions.FILL | Gtk.AttachOptions.EXPAND,
                         Gtk.AttachOptions.FILL, 0, 0)


        scrolled_window = ScrolledWindow(wide_scrollbar=True, vexpand=True,
                                         hexpand=True)
        scrolled_window.get_style_context().add_class('app-grid')
        scrolled_window.add_with_viewport(table)

        return scrolled_window

    def _create_main_box(self, network_list):
        '''Show the screen with the different WiFi networks
        '''

        heading = Heading(
            _("Connect to WiFi"),
            _("Choose a network"),
            self._win.is_plug(),
            back_btn=False
        )

        # This box is to pack everything in the window
        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)

        # For now, pack the network into a scrolled window
        sw = ScrolledWindow()
        sw.apply_styling_to_widget()
        sw.set_size_request(-1, 215)
        sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)

        self._network_box = self._create_network_box(network_list)
        sw.add(self._network_box)

        # Pack the scrolled window into an event box to give the illusion of a
        # border
        sw_border = self._add_border_to_widget(sw)
        sw_border.set_margin_right(30)
        sw_border.set_margin_left(30)
        sw_border.set_margin_bottom(20)
        sw_border.set_margin_top(10)

        # Then pack all the elements into the vbox
        vbox.pack_start(heading.container, False, False, 0)
        vbox.pack_start(sw_border, False, False, 0)

        # Pack in the refresh connect buttons
        button_box = self._create_refresh_connect_buttons()
        vbox.pack_end(button_box, False, False, 30)

        return vbox

    def __setup_application_widgets(self):
        screen = Gdk.Screen.get_default()

        self.__spellbook = Spellbook(is_caps_lock_on=self.__is_caps_lock_on)

        width = screen.get_width()
        height = screen.get_height()
        terminal_width, terminal_height = width / 2 - 20, height - self.__spellbook.HEIGHT - 2 * 44 - 20
        story_width, story_height = width / 2 - 20, height - self.__spellbook.HEIGHT - 2 * 44 - 10
        self.__terminal = TerminalUi(terminal_width, terminal_height)
        self.__story = Storybook(story_width, story_height)

        self.hbox = Gtk.Box()

        story_sw = ScrolledWindow()
        story_sw.apply_styling_to_screen()
        story_sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        story_sw.add(self.__story)
        story_sw.set_size_request(story_width, story_height)

        left_background = Gtk.EventBox()
        left_background.get_style_context().add_class("story_background")
        left_background.add(story_sw)

        right_background = Gtk.EventBox()
        right_background.get_style_context().add_class("terminal_background")

        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.add(vbox)

        vbox.pack_start(self.hbox, False, False, 0)
        vbox.pack_start(self.__spellbook, False, False, 0)
        self.hbox.pack_start(left_background, False, False, 0)
        self.hbox.pack_start(right_background, False, False, 0)

        right_background.add(self.__terminal)

    def __init__(self, main_win, apps_obj):
        Gtk.EventBox.__init__(self, hexpand=True, vexpand=True)
        style = self.get_style_context()
        style.add_class('app-grid')

        self._win = main_win
        self._apps = apps_obj
        self._num_apps = 0

        self._sw = ScrolledWindow(hexpand=True, vexpand=True,
                                  wide_scrollbar=True)

        self._sw.props.margin_top = 7
        self._sw.props.margin_bottom = 0
        self._sw.props.margin_left = 0
        self._sw.props.margin_right = 0
        self._sw.props.border_width = 0
        self._sw.set_shadow_type(Gtk.ShadowType.NONE)

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

        self._sw.add_with_viewport(self._box)
        self.add(self._sw)

def show_results(msg_upgraded, msg_added, msg_removed, debian_err_packages,
                 appstate_after_nonclean, python_ok, python_err):

    # Create Gtk textiew with markdown
    text_view = Gtk.TextView()
    text_view.set_margin_top(10)
    text_view.set_margin_bottom(20)
    text_view.set_margin_left(20)
    text_view.set_margin_right(20)
    text_buffer = text_view.get_buffer()
    bold_tag = text_buffer.create_tag("bold", weight=Pango.Weight.BOLD)

    scrolled_window = ScrolledWindow()
    scrolled_window.apply_styling_to_widget()
    scrolled_window.add_with_viewport(text_view)
    scrolled_window.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
    scrolled_window.set_size_request(400, 200)

    result_dialog = kano_dialog.KanoDialog("Update result", "",
                                           widget=scrolled_window,
                                           global_style=True)
    result_dialog.dialog.set_icon_name("kano-updater")
    result_dialog.dialog.set_title("Kano Updater")

    if msg_upgraded:
        text = "\nApps upgraded:\n"
        add_text_to_end(text_buffer, text, bold_tag)
        add_text_to_end(text_buffer, msg_upgraded)

    if msg_added:
        text = "\nApps added:\n"
        add_text_to_end(text_buffer, text, bold_tag)
        add_text_to_end(text_buffer, msg_added)

    if msg_removed:
        text = "\nApps removed:\n"
        add_text_to_end(text_buffer, text, bold_tag)
        add_text_to_end(text_buffer, msg_removed)

    if debian_err_packages:
        text = "\nApps with errors:\n"
        add_text_to_end(text_buffer, text, bold_tag)
        msg_error = "{}\n".format('\n'.join(debian_err_packages))
        add_text_to_end(text_buffer, msg_error)

    if appstate_after_nonclean:
        text = "\nApps with non-clean state:\n"
        add_text_to_end(text_buffer, text, bold_tag)

        non_clean_list = '\n'.join(appstate_after_nonclean.iterkeys())
        msg_non_clean_list = non_clean_list + "\n"
        add_text_to_end(text_buffer, msg_non_clean_list)

    if python_ok:
        text = "\nPython modules upgraded:\n"
        add_text_to_end(text_buffer, text, bold_tag)

        python_modules = "{}\n".format('\n'.join(python_ok))
        add_text_to_end(text_buffer, python_modules)

    if python_err:
        text = "\nPython modules with error:\n"
        add_text_to_end(text_buffer, text, bold_tag)

        err_list = '\n'.join(python_err)
        msg_python_err = err_list + "\n"
        add_text_to_end(text_buffer, msg_python_err)

    if not (msg_upgraded or msg_added or msg_removed or debian_err_packages or
            appstate_after_nonclean or python_ok or python_err):
        add_text_to_end(text_buffer, "No updates needed this time.", bold_tag)

    result_dialog.run()
    while Gtk.events_pending():
        Gtk.main_iteration()

class AppGrid(Gtk.EventBox):
    def __init__(self, main_win, apps_obj):
        Gtk.EventBox.__init__(self, hexpand=True, vexpand=True)
        style = self.get_style_context()
        style.add_class('app-grid')

        self._win = main_win
        self._apps = apps_obj
        self._num_apps = 0

        self._sw = ScrolledWindow(hexpand=True, vexpand=True,
                                  wide_scrollbar=True)

        self._sw.props.margin_top = 7
        self._sw.props.margin_bottom = 0
        self._sw.props.margin_left = 0
        self._sw.props.margin_right = 0
        self._sw.props.border_width = 0
        self._sw.set_shadow_type(Gtk.ShadowType.NONE)

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

        self._sw.add_with_viewport(self._box)
        self.add(self._sw)

    def new_entry(self, app, sort_by="title", reverse=False):
        if "colour" not in app:
            if (self._num_apps % 2) == 0:
                app["colour"] = "#f2914a"
            else:
                app["colour"] = "#f5a269"
            self._num_apps += 1

        entry = AppGridEntry(app, self._win, self._apps)
        self._box.pack_start(entry, False, False, 0)

        pos = 0
        for child in self._box:
            child_app_data = child.get_app_data()

            # keep the special "want-more" entry at the bottom of the list
            if "slug" in child_app_data and \
               child_app_data["slug"] == "want-more":
                break

            if reverse:
                if app[sort_by] > child_app_data[sort_by]:
                    break
            else:
                if app[sort_by] < child_app_data[sort_by]:
                    break

            pos += 1

        self._box.reorder_child(entry, pos)

        entry.show_all()
        return entry

    def get_num(self):
        return self._num_apps