Python ScrolledWindow.apply_styling_to_widget方法代码示例

# 需要导入模块: from kano.gtk3.scrolled_window import ScrolledWindow [as 别名]
# 或者: from kano.gtk3.scrolled_window.ScrolledWindow import apply_styling_to_widget [as 别名]
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

# 需要导入模块: from kano.gtk3.scrolled_window import ScrolledWindow [as 别名]
# 或者: from kano.gtk3.scrolled_window.ScrolledWindow import apply_styling_to_widget [as 别名]
    def __init__(self, parser):

        # for some reason, this is not being obeyed
        self.item_width = 55
        self.item_height = 50

        self._signal_name = 'category_item_selected'
        self._parser = parser

        # Initialise self._items
        self._items = {}

        # Save the order of the categories so we can use it outside
        self.categories = self._parser.list_available_categories()
        SelectMenu.__init__(self, self.categories, self._signal_name)

        # Add the scrollbar for the category menu
        sw = ScrolledWindow()
        sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        # Set the scrollbar to the left
        sw.set_placement(Gtk.CornerType.TOP_RIGHT)
        sw.apply_styling_to_widget()
        sw.set_size_request(-1, 364)
        self.add(sw)

        self._vertbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        sw.add(self._vertbox)

        # The menu is one item by 7 items
        self.set_size_request(self.item_width, 7 * self.item_height)
        self._pack_buttons()

# 需要导入模块: from kano.gtk3.scrolled_window import ScrolledWindow [as 别名]
# 或者: from kano.gtk3.scrolled_window.ScrolledWindow import apply_styling_to_widget [as 别名]
    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

# 需要导入模块: from kano.gtk3.scrolled_window import ScrolledWindow [as 别名]
# 或者: from kano.gtk3.scrolled_window.ScrolledWindow import apply_styling_to_widget [as 别名]
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()

# 需要导入模块: from kano.gtk3.scrolled_window import ScrolledWindow [as 别名]
# 或者: from kano.gtk3.scrolled_window.ScrolledWindow import apply_styling_to_widget [as 别名]
    def __init__(self, border_width=2):
        Gtk.EventBox.__init__(self)

        # Very hacky way to get a border (gg GTK): create a grey event box
        # which is a little bigger than the white event box containing the
        # widget
        apply_styling_to_screen(
            os.path.join(common_css_dir, 'multiline_entry.css')
        )
        self.get_style_context().add_class('gray-box')
        widget_box = Gtk.EventBox()
        widget_box.get_style_context().add_class('white-box')
        widget_box.set_margin_left(border_width)    # gray border width (px)
        widget_box.set_margin_right(border_width)
        widget_box.set_margin_top(border_width)
        widget_box.set_margin_bottom(border_width)
        self.add(widget_box)

        # putting the TextView into a ScrolledWindow so it doesn't resize
        # horiz & vert
        scrolled_window = ScrolledWindow()
        scrolled_window.set_vexpand(True)
        scrolled_window.set_hexpand(True)
        scrolled_window.set_policy(
            Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC
        )
        scrolled_window.apply_styling_to_widget()
        widget_box.add(scrolled_window)

        # creating the actual TextView
        self.text_view = Gtk.TextView()
        # break on words, then chars
        self.text_view.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
        # the white border inside the thin gray border
        self.text_view.set_margin_left(10)
        self.text_view.set_margin_right(10)
        self.text_view.set_margin_top(10)
        self.text_view.set_margin_bottom(10)
        scrolled_window.add(self.text_view)

        # placeholder text logic
        self.placeholder_text = None
        self.placeholder_text_set = False
        self.restore_buffer_handler_id = None
        self.clear_buffer_handler_id = None

        self.text_view.set_buffer(KanoTextBuffer())
        text_buffer = self.text_view.get_buffer()
        text_buffer.connect('changed', self._on_changed)

# 需要导入模块: from kano.gtk3.scrolled_window import ScrolledWindow [as 别名]
# 或者: from kano.gtk3.scrolled_window.ScrolledWindow import apply_styling_to_widget [as 别名]
    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()

# 需要导入模块: from kano.gtk3.scrolled_window import ScrolledWindow [as 别名]
# 或者: from kano.gtk3.scrolled_window.ScrolledWindow import apply_styling_to_widget [as 别名]
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

# 需要导入模块: from kano.gtk3.scrolled_window import ScrolledWindow [as 别名]
# 或者: from kano.gtk3.scrolled_window.ScrolledWindow import apply_styling_to_widget [as 别名]
    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

# 需要导入模块: from kano.gtk3.scrolled_window import ScrolledWindow [as 别名]
# 或者: from kano.gtk3.scrolled_window.ScrolledWindow import apply_styling_to_widget [as 别名]
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()

# 需要导入模块: from kano.gtk3.scrolled_window import ScrolledWindow [as 别名]
# 或者: from kano.gtk3.scrolled_window.ScrolledWindow import apply_styling_to_widget [as 别名]
    def contact_window(self):
        '''
        Contact Us window
        Contains text view and a Send button
        '''
        # delete the directory containing all the info we'll send, and recreate
        delete_tmp_dir()
        create_tmp_dir()

        ApplicationWindow.__init__(
            self,
            _('Contact Us'),  # noqa: F821
            self.WIDTH,
            0.35
        )

        screen = Gdk.Screen.get_default()
        specific_provider = Gtk.CssProvider()
        specific_provider.load_from_path(Media.media_dir() + 'css/style.css')
        style_context = Gtk.StyleContext()
        style_context.add_provider_for_screen(screen, specific_provider,
                                              Gtk.STYLE_PROVIDER_PRIORITY_USER)

        # Make sure this window has no icon in the task bar
        # so it plays nice with kdesk-blur
        self.set_property('skip-taskbar-hint', True)

        self._grid = Gtk.Grid()

        # Create top bar
        self._top_bar = TopBar(
            title=_("Contact Us"),  # noqa: F821
            window_width=self.WIDTH,
            has_buttons=False
        )
        self._top_bar.set_close_callback(Gtk.main_quit)
        self.set_decorated(True)
        self.set_titlebar(self._top_bar)

        # Create Text view
        self._text = Gtk.TextView()
        self._text.set_editable(True)
        self._text.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
        self._text.set_size_request(self.WIDTH, -1)

        self._textbuffer = self._text.get_buffer()
        self._textbuffer.set_text(
            _("Type your feedback here!")  # noqa: F821
        )
        self._clear_buffer_handler_id = self._textbuffer.connect(
            "insert-text", self.clear_buffer
        )

        scrolledwindow = ScrolledWindow()
        scrolledwindow.set_vexpand(True)
        scrolledwindow.set_policy(Gtk.PolicyType.NEVER,
                                  Gtk.PolicyType.AUTOMATIC)
        scrolledwindow.apply_styling_to_widget()
        scrolledwindow.add(self._text)
        scrolledwindow.set_margin_left(2)
        scrolledwindow.set_margin_right(2)
        scrolledwindow.set_margin_top(2)
        scrolledwindow.set_margin_bottom(2)

        # Very hacky way to get a border: create a grey event box
        # which is a little bigger than the widget below
        border = Gtk.EventBox()
        border.get_style_context().add_class("grey")
        border.add(scrolledwindow)
        self._grid.attach(border, 0, 0, 1, 1)
        border.set_margin_left(20)
        border.set_margin_right(20)
        border.set_margin_top(10)
        border.set_margin_bottom(20)

        # Create send button
        self._send_button = KanoButton(
            _("SEND")  # noqa: F821
        )
        self._send_button.set_sensitive(False)
        self._send_button.connect("button_press_event", self.send_feedback)
        self._send_button.pack_and_align()
        self._send_button.align.set_padding(10, 10, 0, 0)

        bottom_background = Gtk.EventBox()
        bottom_background.get_style_context().add_class("grey")
        bottom_background.add(self._send_button.align)

        self._grid.attach(bottom_background, 0, 1, 1, 1)

        self._grid.set_row_spacing(0)
        self.set_main_widget(self._grid)

        # kano-profile stat collection
        try:
            from kano_profile.badges import \
                increment_app_state_variable_with_dialog
            increment_app_state_variable_with_dialog(
                'kano-feedback', 'starts', 1
            )
#.........这里部分代码省略.........

# 需要导入模块: from kano.gtk3.scrolled_window import ScrolledWindow [as 别名]
# 或者: from kano.gtk3.scrolled_window.ScrolledWindow import apply_styling_to_widget [as 别名]
    def report_window(self):
        '''
        Report window
        Contains 2 text views and Take Screenshot, Add Image and Send buttons
        '''
        ApplicationWindow.__init__(
            self,
            _('Report a Problem'),  # noqa: F821
            self.WIDTH,
            0.35
        )

        screen = Gdk.Screen.get_default()
        specific_provider = Gtk.CssProvider()
        specific_provider.load_from_path(Media.media_dir() + 'css/style.css')
        style_context = Gtk.StyleContext()
        style_context.add_provider_for_screen(screen, specific_provider,
                                              Gtk.STYLE_PROVIDER_PRIORITY_USER)

        self.set_icon_name("feedback")
        self._grid = Gtk.Grid()

        # Create top bar
        self._top_bar = TopBar(
            title=_("Report a Problem"),  # noqa: F821
            window_width=self.WIDTH,
            has_buttons=False
        )
        self._top_bar.set_close_callback(Gtk.main_quit)
        self.set_decorated(True)
        self.set_titlebar(self._top_bar)

        self.entry = Gtk.Entry()
        self.entry.props.placeholder_text = \
            _("Add subject (optional)")  # noqa: F821
        self.entry.set_margin_left(20)
        self.entry.set_margin_right(20)
        self.entry.set_margin_top(20)
        self.entry.set_margin_bottom(10)
        self._grid.attach(self.entry, 0, 0, 1, 1)

        # Create Text view
        self._text = Gtk.TextView()
        self._text.set_editable(True)
        self._text.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
        self._text.set_size_request(self.WIDTH, -1)

        self._textbuffer = self._text.get_buffer()
        self._textbuffer.set_text(
            _("Type your problem here!")  # noqa: F821
        )

        self._clear_buffer_handler_id = self._textbuffer.connect(
            "insert-text", self.clear_buffer
        )

        scrolledwindow = ScrolledWindow()
        scrolledwindow.set_vexpand(True)
        scrolledwindow.set_policy(
            Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC
        )
        scrolledwindow.apply_styling_to_widget()
        scrolledwindow.add(self._text)
        scrolledwindow.set_margin_left(2)
        scrolledwindow.set_margin_right(2)
        scrolledwindow.set_margin_top(2)
        scrolledwindow.set_margin_bottom(2)

        # Very hacky way to get a border: create a grey event box
        # which is a little bigger than the widget below
        border = Gtk.EventBox()
        border.get_style_context().add_class("grey")
        border.add(scrolledwindow)
        self._grid.attach(border, 0, 1, 1, 1)
        border.set_margin_left(20)
        border.set_margin_right(20)
        border.set_margin_top(10)
        border.set_margin_bottom(20)

        # Create take screenshot button
        self._screenshot_button = KanoButton(
            _("TAKE SCREENSHOT"),  # noqa: F821
            "blue"
        )
        self._screenshot_button.set_sensitive(True)
        self._screenshot_button.connect("button_press_event",
                                        self.screenshot_clicked)

        # Create attach screenshot button
        self._attach_button = KanoButton(
            _("ADD IMAGE"),  # noqa: F821
            "blue"
        )
        self._attach_button.set_sensitive(True)
        self._attach_button.connect("button_press_event", self.attach_clicked)

        # Create send button
        self._send_button = KanoButton(
            _("SEND")  # noqa: F821
        )
#.........这里部分代码省略.........