def run(): logger.debug('user_datapath: %r', userdatapath) logger.debug('user_confpath: %r', userconfpath) # User-configured locale (if enabled by user) set_user_configured_locale(userconfpath) # Locale setting from lib.gettext_setup import init_gettext init_gettext(localepath) # mypaintlib import is performed first in gui.application now. from gui import application app_state_dirs = application.StateDirs( app_data=datapath, app_icons=iconspath, user_data=userdatapath, user_config=userconfpath, ) app = application.Application( filenames=args, state_dirs=app_state_dirs, version=version, fullscreen=options.fullscreen, ) # Gtk must not be imported before init_gettext # has been run - else locales will not be set # up properly (e.g: left-to-right interfaces for right-to-left scripts) # Note that this is not the first import of Gtk in the __program__; # it is imported indirectly via the import of gui.application from lib.gibindings import Gtk settings = Gtk.Settings.get_default() dark = app.preferences.get("ui.dark_theme_variant", True) settings.set_property("gtk-application-prefer-dark-theme", dark) if debug and options.run_and_quit: from lib.gibindings import GLib GLib.timeout_add(1000, lambda *a: Gtk.main_quit()) else: from gui import gtkexcepthook func = app.filehandler.confirm_destructive_action gtkexcepthook.quit_confirmation_func = func # temporary workaround for gtk3 Ctrl-C bug: # https://bugzilla.gnome.org/show_bug.cgi?id=622084 import signal signal.signal(signal.SIGINT, signal.SIG_DFL) Gtk.main()
def _queue_color_change(self, new_col, cm): self._queued_data = new_col, cm if not self._timeout_id: self._timeout_id = GLib.timeout_add( interval=16.66, # 60 fps cap function=self._change_color, )
def _queue_movement(self, zone, args): self._move_item = (zone, args) if not self._move_timeout_id: self._move_timeout_id = GLib.timeout_add( interval=16.66, # 60 fps cap function=self._do_move, )
def _restart_outside_popup_timeout(self): if not self.outside_popup_timeout: return self._stop_outside_popup_timeout() self._outside_popup_timeout_id = GLib.timeout_add( int(1000 * self.outside_popup_timeout), self._outside_popup_timeout_cb, )
def _restart_autoleave_timeout(self): if not self.autoleave_timeout: return self._stop_autoleave_timeout() self._autoleave_timeout_id = GLib.timeout_add( int(1000 * self.autoleave_timeout), self._autoleave_timeout_cb, )
def _queue_frame_change(self, model, new_frame): """Queue a frame change (that may trigger a redraw)""" self._queued_frame = (model, new_frame) if not self._change_timeout_id: self._change_timeout_id = GLib.timeout_add( interval=33.33, # 30 fps cap function=self._set_queued_frame, )
def map_cb(self, *junk): logger.info('Event statistics enabled.') self.app.doc.tdw.connect("event", self.event_cb) self.app.drawWindow.connect("event", self.event_cb) self._timer_id = GLib.timeout_add(1000, self.second_timer_cb, priority=GLib.PRIORITY_HIGH)
def status_callback(handler): """ Set up and run fill info/cancellation dialog :param handler: handler for fill info/cancellation :return: False if the fill is cancelled, None otherwise """ app = gui.application.get_app() # Prevent escape release (always) triggering mode stack popping app.kbm.enabled = False # Create new dialog for each occurrence, hopefully # occurrences are rare enough for it not to matter very much. status_dialog = Gtk.MessageDialog(parent=app.drawWindow, buttons=Gtk.ButtonsType.CANCEL) curr_stage = [None] # Status update ticker callback - also handles dialog destruction def status_update(): if handler.running(): # Only update the header when the stage has changed if curr_stage[0] != handler.stage: curr_stage[0] = handler.stage status_dialog.set_property("text", handler.stage_string) status_dialog.set_property("secondary-text", handler.progress_string) return True else: # Destroy dialog when fill is done, whether cancelled or not status_dialog.response(Gtk.ResponseType.OK) return False # Update the status message 20 times/s GLib.timeout_add(50, status_update) result = status_dialog.run() if result != Gtk.ResponseType.OK: handler.cancel() status_dialog.hide() handler.wait() status_dialog.destroy() app.kbm.enabled = True return result == Gtk.ResponseType.OK
def _popup_leave_notify_cb(self, widget, event): if not self.active: return # allow to leave the window for a short time if self._outside_popup_timeout_id: GLib.source_remove(self._outside_popup_timeout_id) self._outside_popup_timeout_id = None self._outside_popup_timeout_id = GLib.timeout_add( int(1000 * self.outside_popup_timeout), self._outside_popup_timeout_cb, )
def _start_autohide_timeout(self): """Start a timer to hide the UI after a brief period of inactivity""" if not self._autohide_timeout: logger.debug("Starting autohide timeout (%d milliseconds)", self.AUTOHIDE_TIMEOUT) else: self._cancel_autohide_timeout() srcid = GLib.timeout_add( self.AUTOHIDE_TIMEOUT, self._autohide_timeout_cb, ) self._autohide_timeout = srcid
def _start_autoreveal_timeout(self, widget): """Start a timer to reveal the widget after a brief period of edge contact """ if not self._autoreveal_timeout: logger.debug("Starting autoreveal timeout (%d milliseconds)", self.AUTOHIDE_REVEAL_TIMEOUT) else: self._cancel_autoreveal_timeout() srcid = GLib.timeout_add( self.AUTOHIDE_REVEAL_TIMEOUT, self._autoreveal_timeout_cb, widget, ) self._autoreveal_timeout.append(srcid)
def _restart_hover_expand_timer(self, path, x, y): self._stop_hover_expand_timer() root = self._docmodel.layer_stack layer = root.deepget(path) if not isinstance(layer, lib.layer.LayerStack): return if self.row_expanded(Gtk.TreePath(path)): return self._hover_expand_timer_id = GLib.timeout_add( int(self.DRAG_HOVER_EXPAND_TIME * 1000), self._hover_expand_timer_cb, path, x, y, )
def _toplevel_configure_cb(self, toplevel, event): """Record the toplevel window's position ("configure-event" callback) """ # Avoid saving fullscreen positions. The timeout is a bit of hack, but # it's necessary because the state change event and the configure event # when fullscreening don't have a sensible order. w, h = event.width, event.height srcid = self._save_toplevel_pos_timeout if srcid: GLib.source_remove(srcid) srcid = GLib.timeout_add( 250, self._save_toplevel_pos_timeout_cb, w, h, ) self._save_toplevel_pos_timeout = srcid
def __restart_anim_if_needed(self): """Restart if not currently running, without changing the alpha. """ if self.__anim_srcid is None: delay = int(1000 // self.fade_fps) self.__anim_srcid = GLib.timeout_add(delay, self.anim_cb)