def show_screenshot(self, widget, event): ''' Creates and displays a dialog with the screenshot image ''' height = Gdk.Screen().get_default().get_height() width = Gdk.Screen().get_default().get_width() pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size( SCREENSHOT_PATH, width * 0.5, height * 0.5) image = Gtk.Image.new_from_pixbuf(pixbuf) dialog = KanoDialog( _("Screenshot"), # noqa: F821 widget=image) dialog.run()
def css_style(style): css = Gtk.CssProvider() css.load_from_data(css_style_dark if style == 1 else css_style_light) screen = Gdk.Screen() style_context = Gtk.StyleContext() style_context.add_provider_for_screen( screen.get_default(), css, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
def __init__(self): Gtk.Window.__init__(self, title="ArFedora Terminal") self.resize(800, 400) scrolledwindow = Gtk.ScrolledWindow() self.add(scrolledwindow) self.terminal = Vte.Terminal() self.terminal.connect("eof", self.quit_) self.terminal.set_color_background( Gdk.RGBA(red=0.180392, green=0.203922, blue=0.211765, alpha=1.000000)) self.terminal.set_color_foreground( Gdk.RGBA(red=0.988235, green=0.913725, blue=0.309804, alpha=1.000000)) self.terminal.set_allow_hyperlink(True) vadjustment = self.terminal.get_vadjustment() scrolledwindow.set_vadjustment(vadjustment) user_info = pwd.getpwuid(os.geteuid()) self.terminal.spawn_sync(Vte.PtyFlags.DEFAULT, user_info.pw_dir, [user_info.pw_shell], [], GLib.SpawnFlags.DO_NOT_REAP_CHILD, None, None) self.terminal.connect("button-release-event", self.on_button_event) self.menu = Gtk.Menu() self.menu.set_screen(Gdk.Screen().get_default()) copytextmenuitem = Gtk.MenuItem("Copy") pastetextmenuitem = Gtk.MenuItem("Paste") fontsizemenuitem = Gtk.MenuItem("Font") cursorshapemenuitem = Gtk.MenuItem("Cursor Shape") cursorcolormenuitem = Gtk.MenuItem("Cursor Color") backgroundmenuitem = Gtk.MenuItem("Backgound Color") foregroundmenuitem = Gtk.MenuItem("Foreground Color") copytextmenuitem.connect("activate", self.copy_text) pastetextmenuitem.connect("activate", self.paste_text) fontsizemenuitem.connect("activate", self.font_change) cursorshapemenuitem.connect("activate", self.cursor_shape) cursorcolormenuitem.connect("activate", self.on_cursor_menuitem_activated) backgroundmenuitem.connect("activate", self.on_background_menuitem_activated) foregroundmenuitem.connect("activate", self.on_foreground_menuitem_activated) self.menu.append(copytextmenuitem) self.menu.append(pastetextmenuitem) self.menu.append(fontsizemenuitem) self.menu.append(cursorshapemenuitem) self.menu.append(cursorcolormenuitem) self.menu.append(backgroundmenuitem) self.menu.append(foregroundmenuitem) scrolledwindow.add(self.terminal)
def usar_estilo(self): css_provider = Gtk.CssProvider() css_provider.load_from_path('static/imagens/estilo_calculadora.css') screen = Gdk.Screen() style_context = Gtk.StyleContext() style_context.add_provider_for_screen( screen.get_default(), css_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
def temp1(): global xx, yy, ad xx += .4 root.move(yy, xx) if xx >= gdk.Screen().height() / 2 - 150: glib.timeout_add(1.8, temp3) return False return True
def style_application(self, *args): style = "/home/michael/iq-option/style/class.css" css_provider = Gtk.CssProvider() css_provider.load_from_path(style) screen = Gdk.Screen() style_context = Gtk.StyleContext() style_context.add_provider_for_screen( screen.get_default(), css_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
def on_report_chosen(widget, format, path): self.report_chooser = None reports.simple(self.facts, start, end, format, path) if format == ("html"): webbrowser.open_new("file://%s" % path) else: try: gtk.show_uri(gdk.Screen(), "file://%s" % os.path.split(path)[0], 0) except: pass # bug 626656 - no use in capturing this one i think
def _set_custom_css(file): css_provider = Gtk.CssProvider.new() css_provider.load_from_path(path=file) screen = Gdk.Screen() style_context = Gtk.StyleContext.new() style_context.add_provider_for_screen( screen=screen.get_default(), provider=css_provider, priority=Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION, )
def __init__(self): # Dynamic Resolution Scaling self.monitor = Gdk.Screen() self.monitor.connect("size-changed", self.resize) # Newer versions of pygtk have this method try: self.monitor.connect("monitors-changed", self.resize) except: pass # Launch Banner self.config = self.configure() self.execute(self.config)
def launch_url (url, ext=""): if os.name == 'nt': os.startfile(url) elif os.name == 'posix': try: Gtk.show_uri(Gdk.Screen(),url,0) except GObject.GError as err: #print dir(err) label = _('Unable to open URL') for reg, msg in [('mailto:',_('Unable to launch mail reader.')), ('http:',_('Unable to open website.')), ('file:',_('Unable to open file.'))]: if re.match(reg,url.lower()): label = msg dialog_extras.show_message( label=label, sublabel=err.message, expander=[_('_Details'), _("There was an error launching the url: %s"%url)] )
def animation(): global xx, yy, kk yy = gdk.Screen().width() / 2 - 150 def temp1(): global xx, yy, ad xx += .4 root.move(yy, xx) if xx >= gdk.Screen().height() / 2 - 150: glib.timeout_add(1.8, temp3) return False return True def temp3(): global store1 store1 += .4 root.set_size_request(store1, 0) if store1 >= 300: glib.timeout_add(1.8, temp2) return False return True def temp2(): global kk, image2, image, ebox, vbox, plab, elab, store1 kk += .4 root.set_size_request(store1, kk) if kk >= 20: image.show() if kk >= 140: plab.show() if kk >= 170: elab.show() if kk >= 210: image2.show() if kk >= 300: root.show_all() return False return True glib.timeout_add(1.8, temp1)
def on_darkmode_toggled(self, source_object): """Callback for when the menubutton Dark is toggled. """ settings = Gtk.Settings().get_default() dark = source_object.get_active() if settings.props.gtk_theme_name == "Adwaita": if dark: settings.props.gtk_application_prefer_dark_theme = True else: settings.props.gtk_application_prefer_dark_theme = False else: # Non-standard theme, use fallback style provider style_context = self.get_style_context() screen = Gdk.Screen().get_default() if dark: style_context.add_provider_for_screen( screen, self.dark_fallback_provider, Gtk.STYLE_PROVIDER_PRIORITY_USER) else: style_context.remove_provider_for_screen( screen, self.dark_fallback_provider) for buf in self.buffers: buf.update_buffer_default_color() buf.emit("notifyLevelChanged") STATE.set_dark(dark)
def __init__(self): h = Gdk.Screen().height() w = Gdk.Screen.width() Gtk.Window.__init__(self, title="Gitmarks") self.props.resizable = True self.props.default_width = w / 3 self.props.default_height = h self.status_bar = Gtk.Statusbar.new() self.tree_view = None self.item_list = None gm_dispatcher = dispatcher.Dispatcher() ofh = OpenFileHandler(self, self.status_bar, gm_dispatcher) handlers = [ofh] gm_dispatcher.load_handlers(handlers) self.vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=3) self.hbox = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL) self.add(self.vbox) hb_factory = widgets.HeaderBar(gm_dispatcher) header_bar = hb_factory.make_headerbar("Gitmarks") self.profile_label = hb_factory.get_profile_label() self.set_titlebar(header_bar) self.vbox.pack_start(self.hbox, True, True, 0) self.vbox.pack_end(self.status_bar, False, True, 0) self.connect("delete-event", Gtk.main_quit) self.gio_settings = settings.GitmarksSettings().create_gio_settings( GLib.get_current_dir()) if self.init_settings() is None: sys.exit(0)
def __init__(self): Gtk.Window.__init__(self, title="Vte Bash Prompt Generator") self.maximize() self.clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD) self.current = "" mainscrolledwindow = Gtk.ScrolledWindow() self.mainbox = Gtk.HBox(spacing=10) mainscrolledwindow.add(self.mainbox) self.tbox = Gtk.VBox(spacing=10) #################################### self.bg_color = Gdk.RGBA(red=0.180392, green=0.203922, blue=0.211765, alpha=1.000000) self.fontsize = [] self.cursorshape = [0] self.cursorcolor = Gdk.RGBA(red=1.000000, green=1.000000, blue=1.000000, alpha=1.000000) #self.foreground = Gdk.RGBA(red=1.000000, green=1.000000, blue=1.000000, alpha=1.000000) #################################### self.add(mainscrolledwindow) fbox1 = Gtk.HBox() flowbox1 = Gtk.FlowBox() flowbox1.props.homogeneous = True flowbox1.set_valign(Gtk.Align.START) flowbox1.set_max_children_per_line(1) flowbox1.set_selection_mode(Gtk.SelectionMode.NONE) fbox1.pack_start(flowbox1, False, False, 0) self.mainbox.pack_start(fbox1, False, False, 0) self.mainbox.pack_start(self.tbox, True, True, 0) fbox2 = Gtk.HBox() flowbox2 = Gtk.FlowBox() flowbox2.props.homogeneous = True flowbox2.set_valign(Gtk.Align.START) flowbox2.set_max_children_per_line(1) flowbox2.set_selection_mode(Gtk.SelectionMode.NONE) fbox2.pack_start(flowbox2, False, False, 0) self.mainbox.pack_start(fbox2, False, False, 0) flowbox3 = Gtk.FlowBox() flowbox3.props.homogeneous = True flowbox3.set_valign(Gtk.Align.START) flowbox3.set_max_children_per_line(1) flowbox3.set_selection_mode(Gtk.SelectionMode.NONE) fbox1.pack_start(flowbox3, False, False, 0) flowbox4 = Gtk.FlowBox() flowbox4.props.homogeneous = True flowbox4.set_valign(Gtk.Align.START) flowbox4.set_max_children_per_line(1) flowbox4.set_selection_mode(Gtk.SelectionMode.NONE) fbox2.pack_start(flowbox4, False, False, 0) for k, v in COLORS.items(): b = Gtk.Button(k) b.connect("clicked", self.color_bg__button_clicked, v) flowbox1.add(b) for k, v in BG_COLORS.items(): b = Gtk.Button("bg {}".format(k)) b.connect("clicked", self.color_bg__button_clicked, v) flowbox2.add(b) for k, v in OPTIONS1.items(): b = Gtk.Button(k) b.connect("clicked", self.color_bg__button_clicked, v) flowbox3.add(b) for k, v in OPTIONS2.items(): b = Gtk.Button(k) b.connect("clicked", self.color_bg__button_clicked, v) flowbox4.add(b) self.entry = Gtk.Entry() self.entry.props.placeholder_text = "Enter PS1..." self.entry_buffer = self.entry.get_buffer() self.tbox.pack_start(self.entry, False, False, 0) self.entry.connect("notify::text", self.on_entry_text_changed) self.entry.props.margin = 10 self.entry.set_icon_from_icon_name(Gtk.EntryIconPosition(0), "edit-copy") self.entry.set_icon_from_icon_name(Gtk.EntryIconPosition(1), "edit-clear") #self.entry.set_icon_from_gicon(Gtk.EntryIconPosition(1),Gio.ThemedIcon(name="applications-multimedia")) self.entry.set_icon_tooltip_markup(Gtk.EntryIconPosition(0), "Copy") self.entry.connect("icon-press", self.on_copy_pressed) self.menu = Gtk.Menu() self.menu.set_screen(Gdk.Screen().get_default()) fontsizemenuitem = Gtk.MenuItem("Font") cursorshapemenuitem = Gtk.MenuItem("Cursor Shape") cursorcolormenuitem = Gtk.MenuItem("Cursor Color") backgroundmenuitem = Gtk.MenuItem("Backgound Color") #foregroundmenuitem = Gtk.MenuItem("Foreground Color") fontsizemenuitem.connect("activate", self.font_change) cursorshapemenuitem.connect("activate", self.cursor_shape) cursorcolormenuitem.connect("activate", self.on_cursor_menuitem_activated) backgroundmenuitem.connect("activate", self.on_background_menuitem_activated) #foregroundmenuitem.connect("activate", self.on_foreground_menuitem_activated) self.menu.append(fontsizemenuitem) self.menu.append(cursorshapemenuitem) self.menu.append(cursorcolormenuitem) self.menu.append(backgroundmenuitem) #self.menu.append(foregroundmenuitem) self.terminal_gui()
def __init__(self, settings, paths, index): """Create the necessary objects and settings. Args: settings: Settings from configfiles to use. paths: Paths received from the parser. index: Current position in paths. """ Gtk.Window.__init__(self) self.connect('destroy', Gtk.main_quit) # Own stuff general = settings["GENERAL"] self.directory = os.path.expanduser("~/.vimiv") self.paths = paths self.index = index self.set_icon_name("vimiv") # Sceen and window size screen = Gdk.Screen() self.screensize = [screen.width(), screen.height()] try: winsize = general["geometry"].split("x") self.winsize = (int(winsize[0]), int(winsize[1])) self.resize(self.winsize[0], self.winsize[1]) except: self.winsize = (800, 600) self.resize(self.winsize[0], self.winsize[1]) # Generate Window structure # Grid in which everything gets packed self.main_grid = Gtk.Grid() # Other classes self.keyhandler = KeyHandler(self, settings) self.commandline = CommandLine(self, settings) self.tags = TagHandler(self) self.mark = Mark(self, settings) self.fileextras = FileExtras(self) self.statusbar = Statusbar(self, settings) self.completions = VimivComplete(self) self.slideshow = Slideshow(self, settings) self.image = Image(self, settings) self.library = Library(self, settings) self.thumbnail = Thumbnail(self, settings) self.manipulate = Manipulate(self, settings) self.window = Window(self, settings) self.information = Information() Commands(self, settings) # Pack library, statusbar and manipulate self.main_grid.attach(self.library.grid, 0, 0, 1, 1) self.main_grid.attach(self.image.scrolled_win, 1, 0, 1, 1) self.main_grid.attach(self.manipulate.scrolled_win, 0, 1, 2, 1) self.main_grid.attach(self.statusbar.bar, 0, 2, 2, 1) # Overlay contains grid mainly and adds commandline as floating self.overlay = Gtk.Overlay() self.overlay.add(self.main_grid) self.overlay.add_overlay(self.commandline.grid) self.add(self.overlay)
def on_email(about, mail): Gtk.show_uri(Gdk.Screen(), "mailto:%s" % mail, 0L)
def on_url(about, link): Gtk.show_uri(Gdk.Screen(), link, 0L)
from gi.repository import GtkSource from sugar3 import env from sugar3.graphics import style from sugar3.graphics.icon import Icon from sugar3.graphics.alert import Alert from sugar3.graphics.alert import TimeoutAlert from sugar3.graphics.palette import Palette from sugar3.graphics.palette import ToolInvoker from sugar3.graphics.toolbutton import ToolButton from sugar3.graphics.toolbarbox import ToolbarBox from sugar3.graphics.palettemenu import PaletteMenuBox from sugar3.graphics.palettemenu import PaletteMenuItem from sugar3.graphics.toggletoolbutton import ToggleToolButton screen = Gdk.Screen().get_default() WIDTH = (screen.get_width() / 6) * 5 HEIGHT = (screen.get_height() / 6) * 5 DEFAULT_FONTS = ['Sans', 'Serif', 'Monospace'] USER_FONTS_FILE_PATH = env.get_profile_path('fonts') GLOBAL_FONTS_FILE_PATH = '/etc/sugar_fonts' class FileChooserOpen(Gtk.Window): __gsignals__ = {'open-file': (GObject.SIGNAL_RUN_FIRST, None, [str])} def __init__(self, activity, folder=None): Gtk.Window.__init__(self)
def __init__(self, application): """ Initialises the main window """ super().__init__(application=application) self.api = API() self.store = DataStore() self.city = None self.city_tz = "UTC" self.currentWeather = None self.forecastWeather = [] self.chartData = [] self.historyWeather = [] self.historyChartData = [] self.LH = 0 self.LW = 0 # Background image self.overlay = Gtk.Overlay() self.add(self.overlay) self.bg = Gtk.Image() scrollable_wrapper = Gtk.ScrolledWindow() scrollable_wrapper.add(self.bg) scrollable_wrapper.set_size_request(DEFAULT_SCREEN_WIDTH, DEFAULT_SCREEN_HEIGHT) self.overlay.add(scrollable_wrapper) # Header header = Gtk.HeaderBar() header.set_show_close_button(True) header.props.title = "Halo" self.set_titlebar(header) refresh_btn = Gtk.Button(label=None, image=Gtk.Image( icon_name='view-refresh-symbolic', icon_size=Gtk.IconSize.BUTTON)) refresh_btn.connect("clicked", self.refresh) # Dropdown menu menubar = Gtk.MenuBar() ac_grp = Gtk.AccelGroup() self.add_accel_group(ac_grp) menu = Gtk.ImageMenuItem() menu.set_image( Gtk.Image(icon_name='view-more-symbolic', icon_size=Gtk.IconSize.MENU)) menu.set_always_show_image(True) menu_dropdown = Gtk.Menu() menu_refresh = Gtk.MenuItem("Refresh", ac_grp) menu_preference = Gtk.MenuItem("Preference") menu_city_change = Gtk.MenuItem("Change City") menu_about = Gtk.MenuItem("About") menu_exit = Gtk.MenuItem("Exit") menu_refresh.add_accelerator("activate", ac_grp, ord('R'), Gdk.ModifierType.CONTROL_MASK, Gtk.AccelFlags.VISIBLE) menu_city_change.add_accelerator("activate", ac_grp, ord('C'), 0, Gtk.AccelFlags.VISIBLE) menu_refresh.connect('activate', self.refresh) menu_preference.connect('activate', self.show_preference) menu_city_change.connect('activate', self.switch_city) menu_about.connect('activate', self.show_about) menu_exit.connect('activate', lambda w: application.quit()) menu_dropdown.append(menu_refresh) menu_dropdown.append(menu_preference) menu_dropdown.append(menu_city_change) menu_dropdown.append(menu_about) menu_dropdown.append(Gtk.SeparatorMenuItem()) menu_dropdown.append(menu_exit) menu.set_submenu(menu_dropdown) menubar.append(menu) header.pack_end(menubar) header.pack_end(refresh_btn) # Weather Panel tm = Gtk.Box(spacing=0) left = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10) right = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=5) top = Gtk.Box(spacing=10) view = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10) left.set_homogeneous(False) right.set_homogeneous(False) self.icon = Gtk.Image() self.place = Gtk.Label() self.status = Gtk.Label() self.temperature = Gtk.Label() self.time = Gtk.Label() self.t_follow = Gtk.Label() self.date = Gtk.Label() self.time.set_alignment(0, 1) self.t_follow.set_alignment(0, 1) self.date.set_alignment(0, 0) self.icon.set_alignment(1, 0) self.status.set_alignment(1, 0) self.place.set_alignment(1, 0) self.temperature.set_alignment(1, 0) self.time.set_name("time") self.t_follow.set_name("t_follow") self.date.set_name("date") self.status.set_name("status") self.place.set_name("place") self.temperature.set_name("temperature") view.set_name("box") tm.pack_start(self.time, False, False, 2) tm.pack_start(self.t_follow, False, False, 2) left.pack_start(tm, False, False, 0) left.pack_start(self.date, False, False, 0) right.pack_start(self.icon, False, False, 0) right.pack_start(self.status, False, False, 0) right.pack_start(self.place, False, False, 0) right.pack_start(self.temperature, False, False, 10) top.pack_start(left, True, True, 20) top.pack_start(right, True, True, 20) # Summary and Trend View switcher = Gtk.StackSwitcher() stack_area = Gtk.Stack() self.forecastArea = SummaryView() self.historyArea = SummaryView(True) stack_area.add_titled(self.historyArea.get_view(), "history", "History") stack_area.add_titled(self.forecastArea.get_view(), "forecast", "Forecast") stack_area.set_transition_type( Gtk.StackTransitionType.SLIDE_LEFT_RIGHT) stack_area.set_transition_duration(150) stack_area.set_homogeneous(True) switcher.set_name("toggle") switcher.set_opacity(0.92) switcher.set_stack(stack_area) sw_b = Gtk.Box(spacing=10) sw_b.pack_start(switcher, False, False, 25) view.pack_start(top, True, True, 10) view.pack_start(sw_b, False, False, 0) view.pack_start(stack_area, False, False, 0) self.overlay.add_overlay(view) # Styling screen = Gdk.Screen().get_default() css_provider = Gtk.CssProvider() css_provider.load_from_path(BASE + '/style.css') context = Gtk.StyleContext() context.add_provider_for_screen(screen, css_provider, Gtk.STYLE_PROVIDER_PRIORITY_USER) self.set_default_size(DataStore.get_width(), DataStore.get_height()) self.set_position(Gtk.WindowPosition.CENTER) self.connect( 'size-allocate', lambda w, rect: GObject.idle_add( self.win_resize, rect, priority=GLib.PRIORITY_HIGH)) self.set_icon_from_file(BASE + "/assets/halo.svg") self.show_all() GObject.timeout_add_seconds(2, self.update_time) GObject.idle_add(self.refresh) stack_area.set_visible_child_name("forecast")
def __init__(self, handle): super(RulerActivity, self).__init__(handle) self.button_dict = {} self.callback_dict = {} self._ready = False font = 'helvetica 12' font_bold = 'helvetica bold 12' # # We need a canvas # self._canvas = MyCanvas() self.set_canvas(self._canvas) self._canvas.show() screen = Gdk.Screen() width = screen.width() height = screen.height() - GRID_CELL_SIZE dpi, self.known_dpi = calc_dpi() self._canvas.set_dpi(dpi) # Create instances of our graphics self._r = show_rulers.ScreenOfRulers(font, font_bold, width, height) self._gcm = show_grids.ScreenGrid_cm(font, font_bold, width, height) self._gmm = show_grids.ScreenGrid_mm(font, font_bold, width, height) self._a90 = show_angles.Angles90(font, font_bold, width, height) self._a360 = show_angles.Angles360(font, font_bold, width, height) self._c = show_checkers.ScreenOfCircles(font, font_bold, width, height) # start with a ruler self._current = self._r self._canvas.add_a_ruler(self._current) # other settings self._grids_mode = "cm" self._angles_mode = "90" # # We need some toolbars # self.max_participants = 1 toolbar_box = ToolbarBox() # Buttons added to the Activity toolbar activity_button = ActivityToolbarButton(self) toolbar_box.toolbar.insert(activity_button, 0) activity_button.show() self.rulers = radio_factory('ruler', toolbar_box.toolbar, self._rulers_cb, tooltip=_('Ruler'), group=None) self.grids = radio_factory('grid-a', toolbar_box.toolbar, self._grids_cb, tooltip=_('Grid'), group=self.rulers) self.angles = radio_factory('angles-90', toolbar_box.toolbar, self._angles_cb, tooltip=_('Angles'), group=self.rulers) self.checker = radio_factory('checker', toolbar_box.toolbar, self._checker_cb, tooltip=_('Checker'), group=self.rulers) self.wrapper = Gtk.ToolItem() self.wrapper2 = Gtk.ToolItem() self.wrapper3 = Gtk.ToolItem() self.custom_unit_entry = Gtk.Entry() self.txt1 = Gtk.Label() self.txt1.set_text(_('1 custom unit equals ')) self.txt2 = Gtk.Label() # TRANS: mm is for Milli Meters self.txt2.set_text(_(' mm.')) self.wrapper.add(self.txt1) self.wrapper2.add(self.custom_unit_entry) self.wrapper3.add(self.txt2) self.wrapper.show_all() self.wrapper2.show_all() self.wrapper3.show_all() separator = Gtk.SeparatorToolItem() separator.props.draw = True separator.set_expand(False) separator.show() toolbar_box.toolbar.insert(separator, -1) custom_units_toolbox = ToolbarBox() custom_units_toolbox.toolbar.insert(self.wrapper, -1) custom_units_toolbox.toolbar.insert(self.wrapper2, -1) custom_units_toolbox.toolbar.insert(self.wrapper3, -1) custom_units_toolbox.show() self.custom_units_button = ToolbarButton(icon_name='view-source', page=custom_units_toolbox) toolbar_box.toolbar.insert(self.custom_units_button, -1) self.custom_unit_entry.connect('changed', self.custom_unit_change_cb) self.custom_units_button.show() if not self.known_dpi: separator = Gtk.SeparatorToolItem() separator.show() toolbar_box.toolbar.insert(separator, -1) dpi = self._canvas.get_dpi() self._dpi_spin_adj = Gtk.Adjustment(dpi, 72, 200, 2, 32, 0) self._dpi_spin = Gtk.SpinButton(self._dpi_spin_adj, 0, 0) self._dpi_spin_id = self._dpi_spin.connect('value-changed', self._dpi_spin_cb) self._dpi_spin.set_numeric(True) self._dpi_spin.show() self.tool_item_dpi = Gtk.ToolItem() self.tool_item_dpi.add(self._dpi_spin) toolbar_box.toolbar.insert(self.tool_item_dpi, -1) self.tool_item_dpi.show() separator = Gtk.SeparatorToolItem() separator.props.draw = False separator.set_expand(True) separator.show() toolbar_box.toolbar.insert(separator, -1) # The ever-present Stop Button stop_button = StopButton(self) stop_button.props.accelerator = '<Ctrl>Q' toolbar_box.toolbar.insert(stop_button, -1) stop_button.show() self.set_toolbar_box(toolbar_box) toolbar_box.show() self.show_all() # Restore state if previously saved self._ready = True if 'ruler' in self.metadata and \ self.metadata['ruler'] in self.button_dict: _logger.debug('restoring %s', self.metadata['ruler']) self.button_dict[self.metadata['ruler']].set_active(True) self.callback_dict[self.metadata['ruler']] else: self._rulers_cb() self.rulers.set_active(True) if 'custom_unit' in self.metadata: self.custom_unit_entry.set_text(self.metadata['custom_unit']) else: # set the default self.custom_unit_entry.set_text("25.4")
def init(self): self.all_category = {} self.switchcategory = {} self.sw = Gtk.ScrolledWindow() self.maincontainer = Gtk.VBox() self.grid = Gtk.Grid() self.stack = Gtk.Stack() self.stack.set_hexpand(True) self.stack.set_vexpand(True) self.listbox_ = Gtk.ListBox() self.grid.attach(self.listbox_, 0, 0, 1, 1) self.grid.attach(self.stack, 1, 0, 1, 1) self.maincontainer.add(self.grid) self.sw.add(self.maincontainer) self.add(self.sw) self.loading_all_plugins() self.listbox_.connect("row-activated", self.on_activated_row) try: gi.require_version('Vte', '2.91') from gi.repository import Vte tscrolledwindow = Gtk.ScrolledWindow() self.terminal = Vte.Terminal() #self.terminal.set_color_background(Gdk.RGBA(red=0.180392, green=0.203922, blue=0.211765, alpha=1.000000)) self.terminal.set_color_foreground( Gdk.RGBA(red=0.988235, green=0.913725, blue=0.309804, alpha=1.000000)) vadjustment = self.terminal.get_vadjustment() tscrolledwindow.set_vadjustment(vadjustment) _pty = Vte.Pty.new_sync(Vte.PtyFlags(0), None) _pty.child_setup() self.terminal.set_pty(_pty) self.terminal.connect("button-release-event", self.on_button_event) self.menu = Gtk.Menu() self.menu.set_screen(Gdk.Screen().get_default()) self.copytextmenuitem = Gtk.MenuItem.new_with_label("Copy") cursorcolormenuitem = Gtk.MenuItem.new_with_label("Cursor Color") backgroundmenuitem = Gtk.MenuItem.new_with_label("Backgound Color") foregroundmenuitem = Gtk.MenuItem.new_with_label( "Foreground Color") self.copytextmenuitem.connect("activate", self.copy_text) cursorcolormenuitem.connect("activate", self.on_cursor_menuitem_activated) backgroundmenuitem.connect("activate", self.on_background_menuitem_activated) foregroundmenuitem.connect("activate", self.on_foreground_menuitem_activated) self.menu.append(self.copytextmenuitem) self.menu.append(cursorcolormenuitem) self.menu.append(backgroundmenuitem) self.menu.append(foregroundmenuitem) self.vte_format = Vte.Format(1) tscrolledwindow.add(self.terminal) self.maincontainer.pack_end(tscrolledwindow, True, True, 0) except Exception as e: print(e) self.show_all()
log = logging.getLogger(__name__) def create_non_gtk_widgets(): sv = GtkSource.View() sv.destroy() # Can we do this during install? def create_user_dirs(): log.info('Ensuring data directories exist.') # TODO: Loading screen for starting db, creating user dirs etc? if __name__ == '__main__': create_user_dirs() log.info('Bootstrapping gtk resources.') create_non_gtk_widgets() css_provider = Gtk.CssProvider() css_provider.load_from_path('ui/style.css') Gtk.StyleContext().add_provider_for_screen( Gdk.Screen().get_default(), css_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) MainWindow() log.info('Starting application.') Gtk.main()
def __init__(self, message="UNCLASSIFIED", fgcolor="#FFFFFF", bgcolor="#007A33", font="liberation-sans", size="small", weight="bold", x=0, y=0, esc=True, opacity=0.75, sys_info=False): """Set up and display the main window Keyword arguments: message -- The classification level to display fgcolor -- Foreground color of the text to display bgcolor -- Background color of the banner the text is against font -- Font type to use for the displayed text size -- Size of font to use for text weight -- Bold or normal hres -- Horizontal Screen Resolution (int) [ requires vres ] vres -- Vertical Screen Resolution (int) [ requires hres ] opacity -- Opacity of window (float) [0 .. 1, default 0.75] """ self.hres = x self.vres = y self.css = """window label { background-color: %s; } """ % bgcolor # Dynamic Resolution Scaling self.monitor = Gdk.Screen() self.monitor.connect("size-changed", self.resize) # Newer versions of pygtk have this method try: self.monitor.connect("monitors-changed", self.resize) except: pass # Create Main Window self.window = Gtk.Window() self.window.set_position(Gtk.WindowPosition.CENTER) self.window.connect("hide", self.restore) self.window.connect("key-press-event", self.keypress) self.window.set_property('skip-taskbar-hint', True) self.window.set_property('skip-pager-hint', True) self.window.set_property('destroy-with-parent', True) self.window.stick() self.window.set_decorated(False) self.window.set_keep_above(True) self.window.set_app_paintable(True) # Set the default window size self.window.set_default_size(int(self.hres), 5) # Create Main Horizontal Box to Populate self.hbox = Gtk.HBox() # Create the Center Vertical Box self.vbox_center = Gtk.VBox() self.center_label = Gtk.Label( "<span font_family='%s' weight='%s' foreground='%s' size='%s'>%s</span>" % (font, weight, fgcolor, size, message)) self.center_label.set_use_markup(True) self.center_label.set_justify(Gtk.Justification.CENTER) self.vbox_center.pack_start(self.center_label, True, True, 0) # Create the Right-Justified Vertical Box to Populate for hostname self.vbox_right = Gtk.VBox() self.host_label = Gtk.Label( "<span font_family='%s' weight='%s' foreground='%s' size='%s'>%s</span>" % (font, weight, fgcolor, size, get_host())) self.host_label.set_use_markup(True) self.host_label.set_justify(Gtk.Justification.RIGHT) self.host_label.set_width_chars(20) # Create the Left-Justified Vertical Box to Populate for user self.vbox_left = Gtk.VBox() self.user_label = Gtk.Label( "<span font_family='%s' weight='%s' foreground='%s' size='%s'>%s</span>" % (font, weight, fgcolor, size, get_user())) self.user_label.set_use_markup(True) self.user_label.set_justify(Gtk.Justification.LEFT) self.user_label.set_width_chars(20) # Create the Right-Justified Vertical Box to Populate for ESC message self.vbox_esc_right = Gtk.VBox() self.esc_label = Gtk.Label(label="<span font_family='liberation-sans' weight='normal' foreground='%s' size='xx-small'> (ESC to hide temporarily) </span>" % (fgcolor)) self.esc_label.set_use_markup(True) self.esc_label.set_justify(Gtk.Justification.RIGHT) self.esc_label.set_width_chars(20) # Empty Label for formatting purposes self.vbox_empty = Gtk.VBox() self.empty_label = Gtk.Label( label="<span font_family='liberation-sans' weight='normal'> </span>") self.empty_label.set_use_markup(True) self.empty_label.set_width_chars(20) if not esc: if not sys_info: self.hbox.pack_start(self.vbox_center, True, True, 0) else: self.vbox_right.pack_start(self.host_label, True, True, 0) self.vbox_left.pack_start(self.user_label, True, True, 0) self.hbox.pack_start(self.vbox_right, False, True, 20) self.hbox.pack_start(self.vbox_center, True, True, 0) self.hbox.pack_start(self.vbox_left, False, True, 20) else: if esc and not sys_info: self.empty_label.set_justify(Gtk.Justification.LEFT) self.vbox_empty.pack_start(self.empty_label, True, True, 0) self.vbox_esc_right.pack_start(self.esc_label, True, True, 0) self.hbox.pack_start(self.vbox_esc_right, False, True, 0) self.hbox.pack_start(self.vbox_center, True, True, 0) self.hbox.pack_start(self.vbox_empty, False, True, 0) if sys_info: self.vbox_right.pack_start(self.host_label, True, True, 0) self.vbox_left.pack_start(self.user_label, True, True, 0) self.hbox.pack_start(self.vbox_right, False, True, 20) self.hbox.pack_start(self.vbox_center, True, True, 0) self.hbox.pack_start(self.vbox_left, False, True, 20) self.window.add(self.hbox) self.window.show_all() self.width, self.height = self.window.get_size() # load style from file provider = Gtk.CssProvider() provider.load_from_data(self.css.encode()) self.apply_css(self.window, provider) try: self.window.set_opacity(opacity) except: pass