コード例 #1
0
ファイル: metadata.py プロジェクト: reklaklislaw/bookmaker
    def build_search_box(self):
        self.search_bar_box = ca.new_widget('HBox',
                                             {'size_request': (-1, -1),
                                              'show': True})

        self.search_bar = ca.new_widget('Entry',
                                            {'size_request': (self.window.width/2, 50),
                                             'show': True})
        Gtk.rc_parse_string("""style "search-bar-font" { font_name="Sans 20" } class "GtkEntry"  style "search-bar-font" """)

        self.search_button = ca.new_widget('Button',
                                               {'label':'Search',
                                                'size_request': (-1, -1),
                                                'show': True})
        self.search_button.connect('clicked', self.submit_query)

        self.init_search_source()
        self.init_search_api()

        self.results_vbox = ca.new_widget('VBox',
                                              {'size_request': (int(3*(self.window.width/2)),-1),
                                               'show': True})

        self.search_bar_box.pack_start(self.search_bar, False, False, 0)
        self.search_bar_box.pack_start(self.search_button, False, False, 0)
        self.search_bar_box.pack_start(self.search_source, False, False, 0)
        self.search_bar_box.pack_start(self.search_source_api, False, False, 0)
        self.search_vbox.pack_start(self.search_bar_box, False, False, 0)
        self.search_vbox.pack_start(self.results_vbox, True, False, 0)
        self.main_layout.put(self.search_vbox, 0, 0)
コード例 #2
0
    def attach (self):

        config_home = Common.utils.XDG.CONFIG_HOME

        state_filename = os.path.join (config_home, "gst-debug-viewer", "state")

        self.state = AppState (state_filename)
        self.state_section = self.state.sections["state"]

        self.load_plugins ()

        self.windows = []
        
        # we override expander size because of:
        # https://bugzilla.gnome.org/show_bug.cgi?id=615985
        rcstring = """
        style "no-expander-treeview-style" {
            GtkTreeView::expander_size = 1
            #GtkTreeView::vertical-separator = 0
            GtkWidget::focus-line-width = 0
        }
        
        widget "*.log_view" style "no-expander-treeview-style"
        """
        Gtk.rc_parse_string (rcstring)

        self.open_window ()
コード例 #3
0
ファイル: terminator.py プロジェクト: Burnfaker/terminator
    def reconfigure(self):
        """Update configuration for the whole application"""

        if self.config['handle_size'] in range(0, 6):
            Gtk.rc_parse_string("""
                style "terminator-paned-style" {
                    GtkPaned::handle_size = %s 
                }
                class "GtkPaned" style "terminator-paned-style" 
                """ % self.config['handle_size'])
            Gtk.rc_reset_styles(Gtk.Settings.get_default())

        # Cause all the terminals to reconfigure
        for terminal in self.terminals:
            terminal.reconfigure()

        # Reparse our keybindings
        self.keybindings.configure(self.config['keybindings'])

        # Update tab position if appropriate
        maker = Factory()
        for window in self.windows:
            child = window.get_child()
            if maker.isinstance(child, 'Notebook'):
                child.configure()
コード例 #4
0
    def reconfigure(self):
        """Update configuration for the whole application"""

        if self.config['handle_size'] in range(0, 6):
            Gtk.rc_parse_string("""
                style "terminator-paned-style" {
                    GtkPaned::handle_size = %s 
                }
                class "GtkPaned" style "terminator-paned-style" 
                """ % self.config['handle_size'])
            Gtk.rc_reset_styles(Gtk.Settings.get_default())

        # Cause all the terminals to reconfigure
        for terminal in self.terminals:
            terminal.reconfigure()

        # Reparse our keybindings
        self.keybindings.configure(self.config['keybindings'])

        # Update tab position if appropriate
        maker = Factory()
        for window in self.windows:
            child = window.get_child()
            if maker.isinstance(child, 'Notebook'):
                child.configure()
コード例 #5
0
ファイル: ThemeWidgets.py プロジェクト: fdanesse/TamTamMini
    def __init__(self, image_name,
        adjustment=None, slider_border=0,
        insensitive_name=None, trough_color="#3D403A",
        snap=False):

        image_name = imagefile(image_name)

        Gtk.VScale.__init__(self)

        self.set_adjustment(adjustment)
        
        if snap:
            self.snap = 1 / snap

        else:
            self.snap = False

        #colormap = self.get_colormap()
        #self.troughcolor = colormap.alloc_color(
        #    trough_color, True, True)

        img = Gtk.Image()
        img.set_from_file(image_name)
        self.sliderPixbuf = img.get_pixbuf()

        if insensitive_name == None:
            self.insensitivePixbuf = None
            
        else:
            img = Gtk.Image()
            img.set_from_file(insensitive_name)
            self.insensitivePixbuf = img.get_pixbuf()

        name = image_name + "ImageVScale"
        self.set_name(name)

        rc_str = """
style "scale_style" {
    GtkRange::slider_width = %d
    GtkScale::slider_length = %d
}
widget "*%s*" style "scale_style"
        """ % (self.sliderPixbuf.get_width(),
        self.sliderPixbuf.get_height(), name)
        Gtk.rc_parse_string(rc_str)

        self.pixbufWidth = self.sliderPixbuf.get_width()
        self.pixbufHeight = self.sliderPixbuf.get_height()
        self.sliderBorder = slider_border
        self.sliderBorderMUL2 = self.sliderBorder * 2

        self.set_draw_value(False)

        #self.connect("expose-event", self.expose)
        self.connect("size-allocate", self.size_allocate)
        self.connect("button-release-event", self.button_release)
        adjustment.connect("value-changed", self.value_changed)
コード例 #6
0
ファイル: menu.py プロジェクト: Andresteve07/foobnix
 def __init__(self):
     rc_st = '''
         style "menubar-style" {
             GtkMenuBar::shadow_type = none
             GtkMenuBar::internal-padding = 0
             }
         class "GtkMenuBar" style "menubar-style"
     '''
     Gtk.rc_parse_string(rc_st)
     Gtk.MenuBar.__init__(self)
コード例 #7
0
ファイル: menu.py プロジェクト: toastercup/foobnix
 def __init__(self):
     rc_st = '''
         style "menubar-style" {
             GtkMenuBar::shadow_type = none
             GtkMenuBar::internal-padding = 0
             }
         class "GtkMenuBar" style "menubar-style"
     '''
     Gtk.rc_parse_string(rc_st)
     Gtk.MenuBar.__init__(self)
コード例 #8
0
ファイル: applet.py プロジェクト: david-xie/mate-applets
def force_no_focus_padding(widget):
    Gtk.rc_parse_string('\n'
                        '   style "timer-applet-button-style"\n'
                        '   {\n'
                        '      GtkWidget::focus-line-width=0\n'
                        '      GtkWidget::focus-padding=0\n'
                        '   }\n'
                        '\n'
                        '   widget "*.timer-applet-button" style "timer-applet-button-style"\n'
                        '\n')
    widget.set_name('timer-applet-button')
コード例 #9
0
    def __init__(self):
        #UI from Glade Interface Designer
        gladefile = "NBUReader.glade"
        self.builder = Gtk.Builder()
        self.builder.add_from_file(gladefile)
        self.builder.connect_signals(self)

        #filechooser
        self.importFile = self.builder.get_object('importFile')

        #status combo
        self.msgStatus = self.builder.get_object("msgStatusCombo")
        self.msgStatusModel = self.msgStatus.get_model()

        #messages treeview
        self.dataTreeView = self.builder.get_object("dataTreeView")
        self.dataTreeViewModel = self.builder.get_object("messages")

        #ToDo:Icons are not working
        #ToDo: Select some other colors
        Gtk.rc_parse_string("""
			style "tab-close-button-style" {
				GtkTreeView::odd-row-color = "#00CBFF"
				GtkTreeView::even-row-color = "#ABABAB"
				GtkTreeView::allow-rules = 1
			}
			widget "*custom_treeview*" style "custom-treestyle"
		""")
        self.dataTreeView.set_name("custom_treeview")

        #status bar
        self.statusbar = self.builder.get_object("statusbar")

        #inital values for widgets
        self.selectedNumbers = []
        #self.populate_numbers_combo([])
        self.msgStatus.set_active(0)
        self.statusbar.push(1, "0 messages showing out of 0 messages")

        self.dialogWindow = self.builder.get_object("selectContactDialog")
        self.dialogWindow.treeView = self.builder.get_object("SCD-contactsTV")
        self.dialogWindow.treeViewSelection = self.builder.get_object(
            "SCD-contactTVselection")
        self.dialogWindow.iterValue = None

        self.numbersList = self.builder.get_object('numbersList')

        self.window = self.builder.get_object("mainWindow")
        self.window.show_all()
コード例 #10
0
	def __init__(self):		
		#UI from Glade Interface Designer
		gladefile ="NBUReader.glade"
		self.builder = Gtk.Builder()
		self.builder.add_from_file(gladefile)
		self.builder.connect_signals(self)

		#filechooser
		self.importFile = self.builder.get_object('importFile')
		
		#status combo
		self.msgStatus = self.builder.get_object("msgStatusCombo")
		self.msgStatusModel = self.msgStatus.get_model()

		#messages treeview
		self.dataTreeView = self.builder.get_object("dataTreeView")
		self.dataTreeViewModel = self.builder.get_object("messages")
		
		#ToDo:Icons are not working
		#ToDo: Select some other colors
		Gtk.rc_parse_string("""
			style "tab-close-button-style" {
				GtkTreeView::odd-row-color = "#00CBFF"
				GtkTreeView::even-row-color = "#ABABAB"
				GtkTreeView::allow-rules = 1
			}
			widget "*custom_treeview*" style "custom-treestyle"
		""")
		self.dataTreeView.set_name("custom_treeview")

		#status bar
		self.statusbar = self.builder.get_object("statusbar")

		#inital values for widgets
		self.selectedNumbers = []
		#self.populate_numbers_combo([])
		self.msgStatus.set_active(0)
		self.statusbar.push(1, "0 messages showing out of 0 messages")    	

		self.dialogWindow = self.builder.get_object("selectContactDialog")
		self.dialogWindow.treeView = self.builder.get_object("SCD-contactsTV")
		self.dialogWindow.treeViewSelection = self.builder.get_object("SCD-contactTVselection")
		self.dialogWindow.iterValue = None

		self.numbersList = self.builder.get_object('numbersList')

		self.window = self.builder.get_object("mainWindow")
		self.window.show_all()
コード例 #11
0
    def __init__(self):
        rc_st = '''
        style "toolbar-style" {
            GtkToolbar::shadow_type = none
            }
        class "GtkToolbar" style "toolbar-style"
        '''
        Gtk.rc_parse_string(rc_st)

        Gtk.Toolbar.__init__(self)

        self.show()
        self.set_style(Gtk.ToolbarStyle.ICONS)
        self.set_show_arrow(False)

        self.i = 0
コード例 #12
0
ファイル: controls.py プロジェクト: mexicarne/exaile
        return settings.get_option(
            'plugin/minimode/progress_button_title_format',
            _('$title ($current_time / $total_time)'))

    def on_option_set(self, event, settings, option):
        """
            Updates the internal format on setting change
        """
        if option == 'gui/progress_bar_text_format':
            GLib.idle_add(self.set_property, 'format', self.get_option_value())


Gtk.rc_parse_string('''
    style "progress-button" {
        GtkToggleButton::default-border = {0, 0, 0, 0}
        GtkToggleButton::default-outside-border = {0, 0, 0, 0}
        GtkToggleButton::inner-border = {0, 0, 0, 0}
    }
    widget "*.progressbutton" style "progress-button"
''')


class ProgressButtonControl(PlaylistButtonControl):
    name = 'progress_button'
    title = _('Progress button')
    description = _('Playback progress and access ' 'to the current playlist')
    # Required to make overrides work
    __gsignals__ = {}

    def __init__(self):
        PlaylistButtonControl.__init__(self)
コード例 #13
0
                self.append_page(tab_page, label)
                tab_page.show()
                label.show()
                tab_page.setup(url, title=tab_history[0]['title'])

            else:
                browser = Browser()
                browser.connect('new-tab', self.__new_tab_cb)
                browser.connect('open-pdf', self.__open_pdf_in_new_tab_cb)
                self._append_tab(browser)
                browser.set_history(tab_history)


Gtk.rc_parse_string('''
    style "browse-tab-close" {
        xthickness = 0
        ythickness = 0
    }
    widget "*browse-tab-close" style "browse-tab-close"''')


class TabPage(Gtk.ScrolledWindow):
    __gtype_name__ = 'BrowseTabPage'

    def __init__(self, browser):
        GObject.GObject.__init__(self)

        self._browser = browser

        self.add(browser)
        browser.show()
コード例 #14
0
ファイル: statusbar.py プロジェクト: plarus/meld
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from gi.repository import GObject
from gi.repository import Gtk
from gi.repository import GtkSource
from gi.repository import Pango

from meld.conf import _
from meld.ui.bufferselectors import EncodingSelector
from meld.ui.bufferselectors import SourceLangSelector

Gtk.rc_parse_string("""
    style "meld-statusbar-style" {
        GtkStatusbar::shadow-type = GTK_SHADOW_NONE
    }
    class "MeldStatusBar" style "meld-statusbar-style"
    """)


class MeldStatusMenuButton(Gtk.MenuButton):
    """Compact menu button with arrow indicator for use in a status bar

    Implementation based on gedit-status-menu-button.c
    Copyright (C) 2008 - Jesse van den Kieboom
    """

    __gtype_name__ = "MeldStatusMenuButton"

    style = b"""
    * {
コード例 #15
0
ファイル: controls.py プロジェクト: exaile/exaile
            _('$title ($current_time / $total_time)'),
        )

    def on_option_set(self, event, settings, option):
        """
            Updates the internal format on setting change
        """
        if option == 'gui/progress_bar_text_format':
            GLib.idle_add(self.set_property, 'format', self.get_option_value())


Gtk.rc_parse_string(
    '''
    style "progress-button" {
        GtkToggleButton::default-border = {0, 0, 0, 0}
        GtkToggleButton::default-outside-border = {0, 0, 0, 0}
        GtkToggleButton::inner-border = {0, 0, 0, 0}
    }
    widget "*.progressbutton" style "progress-button"
'''
)


class ProgressButtonControl(PlaylistButtonControl):
    name = 'progress_button'
    title = _('Progress button')
    description = _('Playback progress and access ' 'to the current playlist')
    # Required to make overrides work
    __gsignals__ = {}

    def __init__(self):
        PlaylistButtonControl.__init__(self)
コード例 #16
0
ファイル: statusbar.py プロジェクト: Psykar/meld
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from gi.repository import GObject
from gi.repository import Gtk
from gi.repository import Pango


Gtk.rc_parse_string(
    """
    style "meld-statusbar-style" {
        GtkStatusbar::shadow-type = GTK_SHADOW_NONE
    }
    class "MeldStatusBar" style "meld-statusbar-style"
    """)


class MeldStatusBar(Gtk.Statusbar):
    __gtype_name__ = "MeldStatusBar"

    def __init__(self):
        GObject.GObject.__init__(self)
        self.props.spacing = 6

        hbox = self.get_message_area()
        label = hbox.get_children()[0]
        hbox.props.spacing = 6
コード例 #17
0
ファイル: dialog.py プロジェクト: misanthropos/revelation
from . import config, datahandler, entry, io, ui, util

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import GObject, Gtk, Gio, Gdk
import gettext, urllib.parse

_ = gettext.gettext

EVENT_FILTER = None
UNIQUE_DIALOGS = {}

Gtk.rc_parse_string("""
    style "hig" {
        GtkDialog::content-area-border  = 0
        GtkDialog::action-area-border   = 0
    }

    class "GtkDialog" style "hig"
""")

##### EXCEPTIONS #####


class CancelError(Exception):
    "Exception for dialog cancellations"
    pass


##### BASE DIALOGS #####

コード例 #18
0
    def __init__(self, notebook, page=None, fullscreen=False, geometry=None):
        '''Constructor
		@param notebook: the L{Notebook} to show in this window
		@param page: a C{Path} object to open
		@param fullscreen: if C{True} the window is shown fullscreen,
		if C{None} the previous state is restored
		@param geometry: the window geometry as string in format
		"C{WxH+X+Y}", if C{None} the previous state is restored
		'''
        Window.__init__(self)
        self.notebook = notebook
        self.page = None  # will be set later by open_page
        self.navigation = NavigationModel(self)
        self.hideonclose = False

        self.preferences = ConfigManager.preferences['GtkInterface']
        self.preferences.define(
            toggle_on_ctrlspace=Boolean(False),
            remove_links_on_delete=Boolean(True),
            always_use_last_cursor_pos=Boolean(True),
        )
        self.preferences.connect('changed', self.do_preferences_changed)

        self.maximized = False
        self.isfullscreen = False
        self.connect_after('window-state-event',
                           self.__class__.on_window_state_event)

        # Hidden setting to force the gtk bell off. Otherwise it
        # can bell every time you reach the begin or end of the text
        # buffer. Especially specific gtk version on windows.
        # See bug lp:546920
        self.preferences.setdefault('gtk_bell', False)
        if not self.preferences['gtk_bell']:
            Gtk.rc_parse_string('gtk-error-bell = 0')

        self._block_toggle_panes = False
        self._sidepane_autoclose = False
        self._switch_focus_accelgroup = None

        # Catching this signal prevents the window to actually be destroyed
        # when the user tries to close it. The action for close should either
        # hide or destroy the window.
        def do_delete_event(*a):
            logger.debug('Action: close (delete-event)')
            self.close()
            return True  # Do not destroy - let close() handle it

        self.connect('delete-event', do_delete_event)

        # setup uistate
        self.uistate = notebook.state['MainWindow']
        self.uistate.setdefault('windowpos', None, check=value_is_coord)
        self.uistate.setdefault('windowsize', (600, 450), check=value_is_coord)
        self.uistate.setdefault('windowmaximized', False)
        self.uistate.setdefault('active_tabs', None, tuple)
        self.uistate.setdefault('show_toolbar', True)
        self.uistate.setdefault('show_statusbar', True)
        self.uistate.setdefault('readonly', False)

        self.history = History(notebook, notebook.state)

        # init uimanager
        self.uimanager = Gtk.UIManager()
        self.uimanager.add_ui_from_string('''
		<ui>
			<menubar name="menubar">
			</menubar>
			<toolbar name="toolbar">
			</toolbar>
		</ui>
		''')

        # setup menubar and toolbar
        self.add_accel_group(self.uimanager.get_accel_group())
        self.menubar = self.uimanager.get_widget('/menubar')
        self.toolbar = self.uimanager.get_widget('/toolbar')
        self.toolbar.connect('popup-context-menu', self.do_toolbar_popup)
        self.add_bar(self.menubar)
        self.add_bar(self.toolbar)

        self.pageview = PageView(self.notebook, self.navigation)
        self.connect_object('readonly-changed', PageView.set_readonly,
                            self.pageview)
        self.pageview.connect_after('textstyle-changed',
                                    self.on_textview_textstyle_changed)
        self.pageview.textview.connect_after('toggle-overwrite',
                                             self.on_textview_toggle_overwrite)
        self.pageview.textview.connect('link-enter', self.on_link_enter)
        self.pageview.textview.connect('link-leave', self.on_link_leave)

        self.add(self.pageview)

        # create statusbar
        self.statusbar = Gtk.Statusbar()
        self.statusbar.push(0, '<page>')
        self.add_bar(self.statusbar, start=False)
        self.statusbar.set_property('margin', 0)
        self.statusbar.set_property('spacing', 0)

        def statusbar_element(string, size):
            frame = Gtk.Frame()
            frame.set_shadow_type(Gtk.ShadowType.NONE)
            self.statusbar.pack_end(frame, False, True, 0)
            label = Gtk.Label(label=string)
            label.set_size_request(size, 10)
            label.set_alignment(0.1, 0.5)
            frame.add(label)
            return label

        # specify statusbar elements right-to-left
        self.statusbar_insert_label = statusbar_element('INS', 60)
        self.statusbar_style_label = statusbar_element('<style>', 110)

        # and build the widget for backlinks
        self.statusbar_backlinks_button = \
         BackLinksMenuButton(self.notebook, self.open_page, status_bar_style=True)
        frame = Gtk.Frame()
        frame.set_shadow_type(Gtk.ShadowType.NONE)
        self.statusbar.pack_end(Gtk.Separator(), False, True, 0)
        self.statusbar.pack_end(frame, False, True, 0)
        self.statusbar.pack_end(Gtk.Separator(), False, True, 0)
        frame.add(self.statusbar_backlinks_button)

        self.move_bottom_minimized_tabs_to_statusbar(self.statusbar)

        self.do_preferences_changed()

        self._geometry_set = False
        self._set_fullscreen = False
        if geometry:
            try:
                self.parse_geometry(geometry)
                self._geometry_set = True
            except:
                logger.exception('Parsing geometry string failed:')
        elif fullscreen:
            self._set_fullscreen = True

        # Init mouse settings
        self.preferences.setdefault('mouse_nav_button_back', 8)
        self.preferences.setdefault('mouse_nav_button_forw', 9)

        # Finish uimanager
        self._uiactions = UIActions(self, self.notebook, self.page,
                                    self.navigation)
        group = get_gtk_actiongroup(self._uiactions)
        self.uimanager.insert_action_group(group, 0)

        group = get_gtk_actiongroup(self.pageview)
        self.uimanager.insert_action_group(group, 0)

        group = get_gtk_actiongroup(self)
        # don't use mnemonics on macOS to allow alt-<letter> shortcuts
        global MENU_ACTIONS
        if sys.platform == "darwin":
            MENU_ACTIONS = tuple(
                (t[0], t[1], t[2].replace('_', '')) for t in MENU_ACTIONS)
        group.add_actions(MENU_ACTIONS)
        self.uimanager.insert_action_group(group, 0)

        group.get_action('open_page_back').set_sensitive(False)
        group.get_action('open_page_forward').set_sensitive(False)

        fname = 'menubar.xml'
        self.uimanager.add_ui_from_string(data_file(fname).read())
        self.pageview.emit(
            'ui-init')  # Needs to trigger after default menus are build

        # Do this last, else menu items show up in wrong place
        self._customtools = CustomToolManagerUI(self.uimanager, self.pageview)
        self._insertedobjects = InsertedObjectUI(self.uimanager, self.pageview)
        # XXX: would like to do this in PageView itself, but need access to uimanager

        # Setup notebook signals
        notebook.connect('page-info-changed', self.do_page_info_changed)

        def move_away(o, path):
            # Try several options to get awaay
            actions = [
                self.open_page_back, self.open_page_parent, self.open_page_home
            ]
            while (path == self.page or self.page.ischild(path)) and actions:
                action = actions.pop(0)
                action()

        notebook.connect('deleted-page', move_away)  # after action

        def follow(o, path, newpath):
            if path == self.page:
                self.open_page(newpath)
            elif self.page.ischild(path):
                newpath = newpath + self.page.relname(path)
                self.open_page(newpath)
            else:
                pass

        notebook.connect('moved-page', follow)  # after action

        # init page
        page = page or self.history.get_current()
        if page:
            page = notebook.get_page(page)
            self.open_page(page)
        else:
            self.open_page_home()

        self.pageview.grab_focus()
コード例 #19
0
ファイル: listing.py プロジェクト: rubenrua/Galicaster
from galicaster.utils.i18n import _

logger = context.get_logger()

rcstring = """
style "big-scroll" {
    GtkRange::stepper-size = 20
    GtkRange::slider-width = 25
}

class "GtkRange" style "big-scroll"

"""

Gtk.rc_parse_string(rcstring)
#Gtk.rc_reset_styles(self.main_window.get_settings())


class ListingClassUI(ManagerUI):
    """
    Create Recording Listing in a VBOX with TreeView from an MP list
    """
    __gtype_name__ = 'Listing'


    def __init__(self):
        ManagerUI.__init__(self, 3)

        self.menu = Gtk.Menu()
        self.fill_menu()
コード例 #20
0
ファイル: mainwindow.py プロジェクト: pdecat/zim-desktop-wiki
    def __init__(self, notebook, page=None, fullscreen=False, geometry=None):
        '''Constructor
		@param notebook: the L{Notebook} to show in this window
		@param page: a C{Path} object to open
		@param fullscreen: if C{True} the window is shown fullscreen,
		if C{None} the previous state is restored
		@param geometry: the window geometry as string in format
		"C{WxH+X+Y}", if C{None} the previous state is restored
		'''
        Window.__init__(self)
        self.notebook = notebook
        self.page = None  # will be set later by open_page
        self.navigation = NavigationModel(self)
        self.hideonclose = False

        self.preferences = ConfigManager.preferences['GtkInterface']
        self.preferences.define(
            toggle_on_ctrlspace=Boolean(False),
            always_use_last_cursor_pos=Boolean(True),
        )
        self.preferences.connect('changed', self.do_preferences_changed)

        self.maximized = False
        self.isfullscreen = False
        self._init_fullscreen_headerbar()
        self.connect_after('window-state-event',
                           self.__class__.on_window_state_event)

        # Hidden setting to force the gtk bell off. Otherwise it
        # can bell every time you reach the begin or end of the text
        # buffer. Especially specific gtk version on windows.
        # See bug lp:546920
        self.preferences.setdefault('gtk_bell', False)
        if not self.preferences['gtk_bell']:
            Gtk.rc_parse_string('gtk-error-bell = 0')

        self._block_toggle_panes = False
        self._sidepane_autoclose = False
        self._switch_focus_accelgroup = None

        # Catching this signal prevents the window to actually be destroyed
        # when the user tries to close it. The action for close should either
        # hide or destroy the window.
        def do_delete_event(*a):
            logger.debug('Action: close (delete-event)')
            self.close()
            return True  # Do not destroy - let close() handle it

        self.connect('delete-event', do_delete_event)

        # setup uistate
        self.uistate = notebook.state['MainWindow']
        self.uistate.setdefault('windowpos', None, check=value_is_coord)
        self.uistate.setdefault('windowsize', (600, 450), check=value_is_coord)
        self.uistate.setdefault('windowmaximized', False)
        self.uistate.setdefault('active_tabs', None, tuple)
        self.uistate.setdefault('readonly', False)

        self.history = History(notebook, notebook.state)

        # init uimanager
        self.uimanager = Gtk.UIManager()
        self.uimanager.add_ui_from_string('''
		<ui>
			<menubar name="menubar">
			</menubar>
		</ui>
		''')

        # setup menubar
        self.add_accel_group(self.uimanager.get_accel_group())
        self.menubar = self.uimanager.get_widget('/menubar')
        self.add_bar(self.menubar, position=TOP)

        self.pageview = NotebookView(self.notebook, self.navigation)
        self.connect_object('readonly-changed', NotebookView.set_readonly,
                            self.pageview)

        self.add(self.pageview)

        self.do_preferences_changed()

        self._geometry_set = False
        self._set_fullscreen = False
        if geometry:
            try:
                self.parse_geometry(geometry)
                self._geometry_set = True
            except:
                logger.exception('Parsing geometry string failed:')
        elif fullscreen:
            self._set_fullscreen = True

        # Init mouse settings
        self.preferences.setdefault('mouse_nav_button_back', 8)
        self.preferences.setdefault('mouse_nav_button_forw', 9)

        # Finish uimanager
        self._uiactions = UIActions(self, self.notebook, self.page,
                                    self.navigation)
        self.__zim_extension_objects__.append(
            self._uiactions)  # HACK to make actions discoverable
        group = get_gtk_actiongroup(self._uiactions)
        self.uimanager.insert_action_group(group, 0)

        group = get_gtk_actiongroup(self.pageview)
        self.uimanager.insert_action_group(group, 0)

        group = get_gtk_actiongroup(self)
        group.add_actions(MENU_ACTIONS)
        self.uimanager.insert_action_group(group, 0)

        self.open_page_back.set_sensitive(False)
        self.open_page_forward.set_sensitive(False)

        fname = 'menubar.xml'
        self.uimanager.add_ui_from_string(data_file(fname).read())

        # header Bar
        self._headerbar = Gtk.HeaderBar()
        self._headerbar.set_show_close_button(True)
        self.set_titlebar(self._headerbar)

        self._populate_headerbars()

        # Do this last, else menu items show up in wrong place
        self._customtools = CustomToolManagerUI(self.uimanager, self.pageview)
        self._insertedobjects = InsertedObjectUI(self.uimanager, self.pageview)
        # XXX: would like to do this in PageView itself, but need access to uimanager

        # Setup notebook signals
        notebook.connect('page-info-changed', self.do_page_info_changed)

        def move_away(o, path):
            # Try several options to get awaay
            actions = [
                self.open_page_back, self.open_page_parent, self.open_page_home
            ]
            while (path == self.page or self.page.ischild(path)) and actions:
                action = actions.pop(0)
                action()

        notebook.connect('deleted-page', move_away)  # after action

        def follow(o, path, newpath):
            if path == self.page:
                self.open_page(newpath)
            elif self.page.ischild(path):
                newpath = newpath + self.page.relname(path)
                self.open_page(newpath)
            else:
                pass

        notebook.connect('moved-page', follow)  # after action

        # init page
        page = page or self.history.get_current()
        if page:
            page = notebook.get_page(page)
            self.open_page(page)
        else:
            self.open_page_home()

        PluginManager.register_new_extendable(self.pageview)
        initialize_actiongroup(self, 'win')

        self.pageview.grab_focus()
コード例 #21
0
                browser.connect('new-tab', self.__new_tab_cb)
                browser.connect('open-pdf', self.__open_pdf_in_new_tab_cb)
                browser.connect('web-view-ready', self.__web_view_ready_cb)
                browser.connect('create-web-view', self.__create_web_view_cb)
                self._append_tab(browser)
                browser.set_history(tab_history)

    def is_current_page_pdf(self):
        index = self.get_current_page()
        current_page = self.get_nth_page(index)
        return isinstance(current_page, PDFTabPage)


Gtk.rc_parse_string('''
    style "browse-tab-close" {
        xthickness = 0
        ythickness = 0
    }
    widget "*browse-tab-close" style "browse-tab-close"''')


class TabPage(Gtk.ScrolledWindow):
    __gtype_name__ = 'BrowseTabPage'

    def __init__(self, browser):
        GObject.GObject.__init__(self)

        self._browser = browser

        self.add(browser)
        browser.show()
コード例 #22
0
    def __init__(self):
        component.Component.__init__(self, 'FilterTreeView', interval=2)
        self.config = ConfigManager('gtk3ui.conf')

        self.tracker_icons = component.get('TrackerIcons')

        self.sidebar = component.get('SideBar')
        self.treeview = Gtk.TreeView()
        self.sidebar.add_tab(self.treeview, 'filters', 'Filters')

        # set filter to all when hidden:
        self.sidebar.notebook.connect('hide', self._on_hide)

        # Create the treestore
        # cat, value, label, count, pixmap, visible
        self.treestore = Gtk.TreeStore(str, str, str, int, Pixbuf, bool)

        # Create the column and cells
        column = Gtk.TreeViewColumn('Filters')
        column.set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE)
        # icon cell
        self.cell_pix = Gtk.CellRendererPixbuf()
        column.pack_start(self.cell_pix, expand=False)
        column.add_attribute(self.cell_pix, 'pixbuf', 4)
        # label cell
        cell_label = Gtk.CellRendererText()
        cell_label.set_property('ellipsize', EllipsizeMode.END)
        column.pack_start(cell_label, expand=True)
        column.set_cell_data_func(cell_label, self.render_cell_data, None)
        # count cell
        self.cell_count = Gtk.CellRendererText()
        self.cell_count.set_property('xalign', 1.0)
        self.cell_count.set_padding(3, 0)
        column.pack_start(self.cell_count, expand=False)

        self.treeview.append_column(column)

        # Style
        self.treeview.set_show_expanders(True)
        self.treeview.set_headers_visible(False)
        self.treeview.set_level_indentation(-21)
        # Force theme to use expander-size so we don't cut out entries due to indentation hack.
        Gtk.rc_parse_string(
            """style "treeview-style" {GtkTreeView::expander-size = 7}
                            class "GtkTreeView" style "treeview-style" """)

        self.treeview.set_model(self.treestore)
        self.treeview.get_selection().connect('changed',
                                              self.on_selection_changed)
        self.create_model_filter()

        self.treeview.connect('button-press-event', self.on_button_press_event)

        # colors using current theme.
        style_ctx = component.get('MainWindow').window.get_style_context()
        self.colour_background = style_ctx.get_background_color(
            Gtk.StateFlags.NORMAL)
        self.colour_foreground = style_ctx.get_color(Gtk.StateFlags.NORMAL)

        # filtertree menu
        builder = Gtk.Builder()
        builder.add_from_file(
            resource_filename(__package__,
                              os.path.join('glade', 'filtertree_menu.ui')))
        self.menu = builder.get_object('filtertree_menu')
        builder.connect_signals(self)

        self.default_menu_items = self.menu.get_children()

        # add Cat nodes:
        self.cat_nodes = {}
        self.filters = {}
コード例 #23
0
import cgi
import html

logger = context.get_logger()

rcstring = """
style "big-scroll" {
    GtkRange::stepper-size = 20
    GtkRange::slider-width = 25
}

class "GtkRange" style "big-scroll"

"""

Gtk.rc_parse_string(rcstring)
#Gtk.rc_reset_styles(self.main_window.get_settings())


class ListingClassUI(ManagerUI):
    """
    Create Recording Listing in a VBOX with TreeView from an MP list
    """
    __gtype_name__ = 'Listing'


    def __init__(self):
        ManagerUI.__init__(self, 3)

        self.menu = Gtk.Menu()
        self.fill_menu()
コード例 #24
0
    def __init__(self):
        component.Component.__init__(self, "FilterTreeView", interval=2)
        self.window = component.get("MainWindow")
        glade = self.window.main_glade
        self.hpaned = glade.get_object("hpaned")
        self.scrolled = glade.get_object("scrolledwindow_sidebar")
        self.sidebar = component.get("SideBar")
        self.config = ConfigManager("gtkui.conf")
        self.tracker_icons = component.get("TrackerIcons")

        self.label_view = Gtk.TreeView()
        self.sidebar.add_tab(self.label_view, "filters", "Filters")

        #set filter to all when hidden:
        self.sidebar.notebook.connect("hide", self._on_hide)

        #menu
        glade_menu = Gtk.Builder()
        glade_menu.add_from_file(pkg_resources.resource_filename("deluge.ui.gtkui",
            "builder/filtertree_menu.ui"))
        self.menu = glade_menu.get_object("filtertree_menu")
        glade_menu.connect_signals({
            "select_all": self.on_select_all,
            "pause_all": self.on_pause_all,
            "resume_all": self.on_resume_all
        })

        self.default_menu_items = self.menu.get_children()

        # Create the liststore
        #cat, value, label, count, pixmap, visible
        self.treestore = Gtk.TreeStore(str, str, str, int, GdkPixbuf.Pixbuf, bool)

        # Create the column
        column = Gtk.TreeViewColumn("Filters")
        column.set_sizing(Gtk.TreeViewColumnSizing.FIXED)
        render = Gtk.CellRendererPixbuf()
        self.renderpix = render
        column.pack_start(render, False)
        column.add_attribute(render, 'pixbuf', 4)
        render = Gtk.CellRendererText()
        column.pack_start(render, False)
        column.set_cell_data_func(render, self.render_cell_data,None)

        self.label_view.append_column(column)

        #style:
        self.label_view.set_show_expanders(True)
        self.label_view.set_headers_visible(False)
        # Force the theme to use an expander-size of 15 so that we don't cut out
        # entries due to our indentation hack.
        Gtk.rc_parse_string('style "treeview-style" { GtkTreeView::expander-size = 15 } class "GtkTreeView" style "treeview-style"')

        self.label_view.set_model(self.treestore)
        self.label_view.get_selection().connect("changed", self.on_selection_changed)
        self.create_model_filter()

        #init.....
        self.label_view.connect("button-press-event", self.on_button_press_event)

        #colors using current theme.
        style_ctx = self.window.window.get_style_context()
        self.colour_background = style_ctx.get_background_color(Gtk.StateFlags.NORMAL)
        self.colour_foreground = style_ctx.get_color(Gtk.StateFlags.NORMAL)