def __init__(self, filename):
self._filename = filename
builder = Gtk.Builder()
builder.set_translation_domain(self._TRANSLATION_DOMAIN)
builder.add_from_file(filename)
self._builder = builder
self._cache = {}
def _test():
win = Gtk.Window()
win.set_title("accelmap.py")
win.connect("destroy", Gtk.main_quit)
builder = Gtk.Builder()
import gui.factoryaction # noqa F401: for side effects only
builder.add_from_file("gui/resources.xml")
uimgr = builder.get_object("app_ui_manager")
editor = AccelMapEditor()
editor.ui_manager = uimgr
win.add(editor)
win.set_default_size(400, 300)
win.show_all()
Gtk.main()
def __init__(self, app, **kwargs):
"""Initialize for the main app and its working doc."""
super(Presenter, self).__init__(**kwargs)
self._app = weakref.proxy(app)
builder_xml = os.path.splitext(__file__)[0] + ".glade"
builder = Gtk.Builder()
builder.set_translation_domain("mypaint")
builder.add_from_file(builder_xml)
self._dialog = builder.get_object("recovery_dialog")
self._treeview = builder.get_object("recovery_treeview")
self._liststore = builder.get_object("recovery_liststore")
self._recover_button = builder.get_object("recover_autosave_button")
self._delete_button = builder.get_object("delete_autosave_button")
at_start_checkbutton = builder.get_object("at_startup_checkbutton")
at_start_checkbutton.set_active(self.check_at_startup)
builder.connect_signals(self)
def __init__(self):
app = None
if __name__ != '__main__':
from gui.application import get_app
app = get_app()
self._brush = app.brush
bm = app.brushmanager
bm.brush_selected += self.brush_selected_cb
else:
self._brush = lib.brush.BrushInfo()
self._brush.load_defaults()
SubWindow.__init__(self, app, key_input=True)
# Tracking vars for updating the treestore in response to
# brush setting changes and loading new brushes.
self._treestore = None
self._setting_treepath = {} # {cname: Gtk.TreePath}, path for setting
self._group_treepath = {} # {groupid: Gtk.TreePath}, path for group
self._setting_group = {} # {cname: groupid}, group containing setting
# Adjusters: may be shared with those of the app
self._base_adj = {} #: setting cname => base value adj
self._input_y_adj = {} #: input name => scale y range (+-) adj
self._input_xmin_adj = {} #: input name => scale x min adj
self._input_xmax_adj = {} #: input name => scale x min adj
self._disable_input_adj_changed_cb = False
self._init_adjustments()
self.set_title(
C_(
"brush settings editor: subwindow title",
"Brush Settings Editor",
))
self._scales = []
self._setting = None
self._builder = Gtk.Builder()
self._builder.set_translation_domain("mypaint")
self._build_ui()
self._base_value_scale = self._builder.get_object("base_value_scale")
self.connect_after("show", self._post_show_cb)
self.connect('button-press-event', self._clear_focus)
editor = self._builder.get_object("brush_editor")
self.add(editor)
self._brush.observers.append(self.brush_modified_cb)
self._live_update_idle_cb_id = None
self._updating_metadata_ui = False
self.set_default_size(1000, 800)
def _test():
"""Interactive module test function"""
import os
import sys
vbox = Gtk.VBox()
builder = Gtk.Builder()
# Handlers can find out about their template values by parsing their
# name (using the GtkBuildable interface). Alternatively, you can set
# up private attributes in the instantiation loop.
def _test_button_clicked_cb(widget):
id_ = Gtk.Buildable.get_name(widget)
if isinstance(id_, bytes):
id_ = id_.decode("utf-8")
print("Clicked: id=%r" % (id_, ))
print(" i=%r" % (widget._i, ))
# Unicode is supported in IDs and template values.
# The XML template may be plain ASCII since escape() is used when
# filling it.
object_ids = [u"button_{id}"]
words = [u"à", u"chacun", u"son", u"goût"]
for i in words:
params = {"id": i, "label": i.upper()}
objs = add_objects_from_template_string(builder, _TEST_TEMPLATE,
object_ids, params)
for w in objs:
w.connect("clicked", _test_button_clicked_cb)
vbox.pack_start(w, True, True, 0)
w._i = i
# The label should never be instantiated by this code. In fact, only
# the four buttons should.
for obj in builder.get_objects():
assert isinstance(obj, Gtk.Button)
# Remainder of the demo code
window = Gtk.Window()
window.add(vbox)
window.set_title(os.path.basename(sys.argv[0]))
window.connect("destroy", lambda *a: Gtk.main_quit())
window.set_size_request(250, 200)
window.show_all()
Gtk.main()
def __init__(self):
import gui.application
app = gui.application.get_app()
assert app is not None
super(PreferencesWindow, self).__init__(
app=app,
title=_('Preferences'),
transient_for=app.drawWindow,
destroy_with_parent=True,
)
self.add_buttons(
Gtk.STOCK_REVERT_TO_SAVED, RESPONSE_REVERT,
Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT,
)
self.connect('response', self.on_response)
self.in_update_ui = False
# Set up widgets
builder = Gtk.Builder()
builder.set_translation_domain("mypaint")
ui_dir = os.path.dirname(os.path.abspath(__file__))
xml_path = os.path.join(ui_dir, 'preferenceswindow.glade')
builder.add_from_file(xml_path)
self._builder = builder
getobj = builder.get_object
self.compat_preferences = CompatibilityPreferences(app, builder)
# Populate locale/language combo box
locale_combo = getobj("locale_combobox")
setup_locale_combobox(locale_combo)
# Notebook
nb = getobj("prefs_notebook")
self.nb = nb
self.vbox.pack_start(nb, True, True, 0)
# Curve init
curve = getobj("mapping_curve")
curve.changed_cb = self.pressure_curve_changed_cb
curve.magnetic = False
self._pressure_curve = curve
# Button mappings editor
assert "input.button_mapping" in app.preferences
reg = gui.mode.ModeRegistry
actions_possible = [n for n in reg.get_action_names()
if issubclass(reg.get_mode_class(n),
gui.mode.DragMode)]
actions_possible += gui.mode.BUTTON_BINDING_ACTIONS
bm_ed = getobj("button_mapping_editor")
bm_ed.set_bindings(app.preferences["input.button_mapping"])
bm_ed.set_actions(actions_possible)
bm_ed.bindings_observers.append(self.button_mapping_edited_cb)
# Autosave controls
autosave_interval_spinbut = getobj("autosave_interval_spinbutton")
self._autosave_interval_spinbutton = autosave_interval_spinbut
# Signal hookup now everything is in the right initial state
self._builder.connect_signals(self)
def __init__(self):
import gui.application
app = gui.application.get_app()
assert app is not None
super(PreferencesWindow, self).__init__(
app=app,
title=_('Preferences'),
transient_for=app.drawWindow,
destroy_with_parent=True,
)
self.add_buttons(
Gtk.STOCK_REVERT_TO_SAVED,
RESPONSE_REVERT,
Gtk.STOCK_OK,
Gtk.ResponseType.ACCEPT,
)
self.connect('response', self.on_response)
self.in_update_ui = False
# Set up widgets
builder = Gtk.Builder()
builder.set_translation_domain("mypaint")
ui_dir = os.path.dirname(os.path.abspath(__file__))
xml_path = os.path.join(ui_dir, 'preferenceswindow.glade')
builder.add_from_file(xml_path)
self._builder = builder
getobj = builder.get_object
self.compat_preferences = CompatibilityPreferences(app, builder)
# Populate locale/language combo box
locale_combo = getobj("locale_combobox")
setup_locale_combobox(locale_combo)
# Notebook
nb = getobj("prefs_notebook")
self.nb = nb
self.vbox.pack_start(nb, True, True, 0)
# Curve init
curve = getobj("mapping_curve")
curve.changed_cb = self.pressure_curve_changed_cb
curve.magnetic = False
self._pressure_curve = curve
# Button mappings editor
assert "input.button_mapping" in app.preferences
reg = gui.mode.ModeRegistry
actions_possible = [
n for n in reg.get_action_names()
if issubclass(reg.get_mode_class(n), gui.mode.DragMode)
]
actions_possible += gui.mode.BUTTON_BINDING_ACTIONS
bm_ed = getobj("button_mapping_editor")
bm_ed.set_bindings(app.preferences["input.button_mapping"])
bm_ed.set_actions(actions_possible)
bm_ed.bindings_observers.append(self.button_mapping_edited_cb)
# Autosave controls
autosave_interval_spinbut = getobj("autosave_interval_spinbutton")
self._autosave_interval_spinbutton = autosave_interval_spinbut
# Dynamic brush cursor crosshair settings
p = app.preferences
dyn_ch_checkbut = getobj("show_crosshair_checkbutton")
dyn_ch_enabled = p.get("cursor.dynamic_crosshair", False)
dyn_ch_checkbut.set_active(dyn_ch_enabled)
self._dynamic_crosshair_checkbut = dyn_ch_checkbut
dyn_ch_spinner = getobj("dynamic_crosshair_threshold_spinbutton")
dyn_ch_threshold = p.get("cursor.dynamic_crosshair_threshold", 8)
max_cursor = max(Gdk.Display.get_default().get_maximal_cursor_size())
adj = Gtk.Adjustment(value=dyn_ch_threshold,
lower=(1 +
p.get("cursor.freehand.min_size", 4) // 2),
upper=max_cursor,
step_increment=1,
page_increment=2)
dyn_ch_spinner.set_adjustment(adj)
dyn_ch_spinner.set_sensitive(dyn_ch_enabled)
self._dyn_crosshair_threshold = dyn_ch_spinner
self._dyn_crosshair_label = getobj("dynamic_crosshair_threshold_label")
# Signal hookup now everything is in the right initial state
self._builder.connect_signals(self)
def __init__(self, filenames, state_dirs, version, fullscreen=False):
"""Construct, but do not run.
:param list filenames: The list of files to load (unicode required)
:param StateDirs state_dirs: static special paths.
:param unicode version: Version string for the about dialog.
:param bool fullscreen: Go fullscreen after starting.
Only the first filename listed will be loaded. If no files are
listed, the autosave recovery dialog may be shown when the
application starts up.
"""
assert Application._INSTANCE is None
super(Application, self).__init__()
Application._INSTANCE = self
self.state_dirs = state_dirs #: Static special paths: see StateDirs
self.version = version #: version string for the app.
# Create the user's config directory and any needed R/W data
# storage areas.
for basedir in [state_dirs.user_config, state_dirs.user_data]:
if not os.path.isdir(basedir):
os.makedirs(basedir)
logger.info('Created basedir %r', basedir)
for datasubdir in [u'backgrounds', u'brushes', u'scratchpads']:
datadir = os.path.join(state_dirs.user_data, datasubdir)
if not os.path.isdir(datadir):
os.mkdir(datadir)
logger.info('Created data subdir %r', datadir)
_init_icons(state_dirs.app_icons)
# Core actions and menu structure
ui_dir = os.path.dirname(os.path.abspath(__file__))
resources_xml = join(ui_dir, "resources.xml")
self.builder = Gtk.Builder()
self.builder.set_translation_domain("mypaint")
self.builder.add_from_file(resources_xml)
self.ui_manager = self.builder.get_object("app_ui_manager")
signal_callback_objs = [self]
Gdk.set_program_class('MyPaint')
self.pixmaps = PixbufDirectory(join(state_dirs.app_data, u'pixmaps'))
self.cursor_color_picker = Gdk.Cursor.new_from_pixbuf(
Gdk.Display.get_default(),
self.pixmaps.cursor_color_picker,
3,
15,
)
self.cursor_color_picker_h = Gdk.Cursor.new_from_pixbuf(
Gdk.Display.get_default(),
self.pixmaps.cursor_color_picker_h,
3,
15,
)
self.cursor_color_picker_c = Gdk.Cursor.new_from_pixbuf(
Gdk.Display.get_default(),
self.pixmaps.cursor_color_picker_c,
3,
15,
)
self.cursor_color_picker_y = Gdk.Cursor.new_from_pixbuf(
Gdk.Display.get_default(),
self.pixmaps.cursor_color_picker_y,
3,
15,
)
self.cursors = gui.cursor.CustomCursorMaker(self)
# App-level settings
self._preferences = lib.observable.ObservableDict()
self.load_settings()
# Set up compatibility mode (most of it)
self.compat_mode = None
self.reset_compat_mode(update=False)
compat.update_default_layer_type(self)
# Unmanaged main brush.
# Always the same instance (we can attach settings_observers).
# This brush is where temporary changes (color, size...) happen.
self.brush = brush.BrushInfo()
self.brush.load_defaults()
# Global pressure mapping function, ignored unless set
self.pressure_mapping = None
# Fake inputs to send when using a mouse. Adjustable
# via slider and/or hotkeys
self.fakepressure = 0.5
self.fakerotation = 0.5
# Keyboard manager
self.kbm = keyboard.KeyboardManager(self)
# File I/O
self.filehandler = filehandling.FileHandler(self)
# Picking grabs
self.context_grab = gui.picker.ContextPickingGrabPresenter()
self.context_grab.app = self
self.color_grab = gui.picker.ColorPickingGrabPresenter()
self.color_grab.app = self
# Load the main interface
mypaint_main_xml = join(ui_dir, "mypaint.glade")
self.builder.add_from_file(mypaint_main_xml)
# Main drawing window
self.drawWindow = self.builder.get_object("drawwindow")
signal_callback_objs.append(self.drawWindow)
# Workspace widget. Manages layout of toolwindows, and autohide in
# fullscreen.
wkspace = self.builder.get_object("app_workspace")
wkspace.build_from_layout(self.preferences["workspace.layout"])
wkspace.floating_window_created += self._floating_window_created_cb
fs_autohide_action = self.builder.get_object("FullscreenAutohide")
fs_autohide_action.set_active(wkspace.autohide_enabled)
self.workspace = wkspace
# Working document: viewer widget
app_canvas = self.builder.get_object("app_canvas")
# Working document: model and controller
cache_size = self.preferences.get('ui.rendered_tile_cache_size',
lib.cache.DEFAULT_CACHE_SIZE)
default_stack_size = lib.document.DEFAULT_UNDO_STACK_SIZE
undo_stack_size = self.preferences.setdefault(
'command.max_undo_stack_size', default_stack_size)
undo_stack_size = validation.validate(
undo_stack_size, default_stack_size, int, lambda a: a > 0,
"The undo stack size ({value}) must be a positive integer!")
model = lib.document.Document(self.brush,
cache_size=cache_size,
max_undo_stack_size=undo_stack_size)
self.doc = document.Document(self, app_canvas, model)
app_canvas.set_model(model)
signal_callback_objs.append(self.doc)
signal_callback_objs.append(self.doc.modes)
self.scratchpad_filename = ""
scratchpad_model = lib.document.Document(
self.brush,
painting_only=True,
cache_size=lib.cache.DEFAULT_CACHE_SIZE / 4)
scratchpad_tdw = tileddrawwidget.TiledDrawWidget()
scratchpad_tdw.scroll_on_allocate = False
scratchpad_tdw.set_model(scratchpad_model)
self.scratchpad_doc = document.Document(self, scratchpad_tdw,
scratchpad_model)
self.brushmanager = brushmanager.BrushManager(
lib.config.mypaint_brushdir,
join(self.state_dirs.user_data, 'brushes'),
self,
)
signal_callback_objs.append(self.filehandler)
self.brushmodifier = brushmodifier.BrushModifier(self)
signal_callback_objs.append(self.brushmodifier)
self.blendmodemanager = blendmodehandler.BlendModeManager(self)
signal_callback_objs.append(self.blendmodemanager)
self.blendmodemanager.register(self.brushmodifier.bm)
self.line_mode_settings = linemode.LineModeSettings(self)
# Button press mapping
self.button_mapping = ButtonMapping()
# Monitors pluggings and uses of input device, configures them,
# and switches between device-specific brushes.
self.device_monitor = gui.device.Monitor(self)
if not self.preferences.get("scratchpad.last_opened_scratchpad", None):
self.preferences["scratchpad.last_opened_scratchpad"] \
= self.filehandler.get_scratchpad_autosave()
self.scratchpad_filename \
= self.preferences["scratchpad.last_opened_scratchpad"]
self.brush_color_manager = BrushColorManager(self)
self.brush_color_manager.set_picker_cursor(self.cursor_color_picker)
self.brush_color_manager.set_data_path(self.datapath)
#: Mapping of setting cname to a GtkAdjustment which controls the base
#: value of that setting for the app's current brush.
self.brush_adjustment = {}
self.init_brush_adjustments()
# Extend with some fake inputs that act kind of like brush settings
self.fake_adjustment = {}
# Connect signals defined in resources.xml
callback_finder = CallbackFinder(signal_callback_objs)
self.builder.connect_signals(callback_finder)
self.kbm.start_listening()
self.filehandler.doc = self.doc
self.filehandler.filename = None
Gtk.AccelMap.load(join(self.user_confpath, 'accelmap.conf'))
# Load the default background image
self.doc.reset_background()
# Non-dockable subwindows
# Loading is deferred as late as possible
self._subwindow_classes = {
# action-name: action-class
"BackgroundWindow": backgroundwindow.BackgroundWindow,
"BrushEditorWindow": brusheditor.BrushEditorWindow,
"PreferencesWindow": preferenceswindow.PreferencesWindow,
"InputTestWindow": inputtestwindow.InputTestWindow,
"BrushIconEditorWindow": brushiconeditor.BrushIconEditorWindow,
}
self._subwindows = {}
# Statusbar init
statusbar = self.builder.get_object("app_statusbar")
self.statusbar = statusbar
context_id = statusbar.get_context_id("transient-message")
self._transient_msg_context_id = context_id
self._transient_msg_remove_timeout_id = None
# Profiling & debug stuff
self.profiler = gui.profiling.Profiler()
# Show main UI.
self.drawWindow.show_all()
GLib.idle_add(self._at_application_start, filenames, fullscreen)
