-
Notifications
You must be signed in to change notification settings - Fork 385
/
compatibility.py
541 lines (467 loc) · 20.3 KB
/
compatibility.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
# -*- coding: utf-8 -*-
# This file is part of MyPaint.
# Copyright (C) 2019 by the MyPaint Development Team
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
from logging import getLogger
from lib.gibindings import Gtk
from . import compatconfig as config
from .compatconfig import C1X, C2X, COMPAT_SETTINGS, DEFAULT_COMPAT
import lib.eotf
from lib.layer.data import BackgroundLayer
from lib.meta import Compatibility, PREREL, MYPAINT_VERSION
from lib.modes import MODE_STRINGS, set_default_mode
from lib.mypaintlib import CombineNormal, CombineSpectralWGM
from lib.mypaintlib import combine_mode_get_info
from lib.gettext import C_
logger = getLogger(__name__)
FILE_WARNINGS = {
Compatibility.INCOMPATIBLE: 'ui.file_compat_warning_severe',
Compatibility.PARTIALLY: 'ui.file_compat_warning_mild',
}
_FILE_OPEN_OPTIONS = [
('', C_("File Load Compat Options", "Based on file")),
(C1X, C_("Prefs Dialog|Compatibility", "1.x")),
(C2X, C_("Prefs Dialog|Compatibility", "2.x")),
]
FILE_WARNING_MSGS = {
Compatibility.INCOMPATIBLE: C_(
"file compatibility warning",
# TRANSLATORS: This is probably a rare warning, and it will not
# TRANSLATORS: really be shown at all before the release of 3.0
u"“{filename}” was saved with <b>MyPaint {new_version}</b>."
" It may be <b>incompatible</b> with <b>MyPaint {current_version}</b>."
"\n\n"
"Editing this file with this version of MyPaint is not guaranteed"
" to work, and may even result in crashes."
"\n\n"
"It is <b>strongly recommended</b> to upgrade to <b>MyPaint"
" {new_version}</b> or newer if you want to edit this file!"),
Compatibility.PARTIALLY: C_(
"file compatibility warning",
u"“{filename}” was saved with <b>MyPaint {new_version}</b>. "
"It may not be fully compatible with <b>Mypaint {current_version}</b>."
"\n\n"
"Saving it with this version of MyPaint may result in data"
" that is only supported by the newer version being lost."
"\n\n"
"To be safe you should upgrade to MyPaint {new_version} or newer."),
}
OPEN_ANYWAY = C_(
"file compatibility question",
"Do you want to open this file anyway?"
)
_PIGMENT_OP = combine_mode_get_info(CombineSpectralWGM)['name']
def has_pigment_layers(elem):
"""Check if the layer stack xml contains a pigment layer
Has to be done before any layers are loaded, since the
correct eotf value needs to set before loading the tiles.
"""
# Ignore the composite op of the background.
# We only need to check for the namespaced attribute, as
# any file containing the non-namespaced counterpart was
# created prior (version-wise) to pigment layers.
bg_attr = BackgroundLayer.ORA_BGTILE_ATTR
if elem.get(bg_attr, None):
return False
op = elem.attrib.get('composite-op', None)
return op == _PIGMENT_OP or any([has_pigment_layers(c) for c in elem])
def incompatible_ora_cb(app):
def cb(comp_type, prerel, filename, target_version):
""" Internal: callback that may show a confirmation/warning dialog
Unless disabled in settings, when a potentially
incompatible ora is opened, a warning dialog is
shown, allowing users to cancel the loading.
"""
if comp_type == Compatibility.FULLY:
return True
logger.warning(
"Loaded file “{filename}” may be {compat_desc}!\n"
"App version: {version}, File version: {file_version}".format(
filename=filename,
compat_desc=Compatibility.DESC[comp_type],
version=lib.meta.MYPAINT_VERSION,
file_version=target_version
))
if prerel and comp_type > Compatibility.INCOMPATIBLE and PREREL != '':
logger.info("Warning dialog skipped in prereleases.")
return True
return incompatible_ora_warning_dialog(
comp_type, prerel, filename, target_version, app)
return cb
def incompatible_ora_warning_dialog(
comp_type, prerel, filename, target_version, app):
# Skip the dialog if the user has disabled the warning
# for this level of incompatibility
warn = app.preferences.get(FILE_WARNINGS[comp_type], True)
if not warn:
return True
# Toggle allowing users to disable future warnings directly
# in the dialog, this is configurable in the settings too.
# The checkbutton code is pretty much copied from the filehandling
# save-to-scrap checkbutton; a lot of duplication.
skip_warning_text = C_(
"Version compat warning toggle",
u"Don't show this warning again"
)
skip_warning_button = Gtk.CheckButton.new()
skip_warning_button.set_label(skip_warning_text)
skip_warning_button.set_hexpand(False)
skip_warning_button.set_vexpand(False)
skip_warning_button.set_halign(Gtk.Align.END)
skip_warning_button.set_margin_top(12)
skip_warning_button.set_margin_bottom(12)
skip_warning_button.set_margin_start(12)
skip_warning_button.set_margin_end(12)
skip_warning_button.set_can_focus(False)
def skip_warning_toggled(checkbut):
app.preferences[FILE_WARNINGS[comp_type]] = not checkbut.get_active()
app.preferences_window.compat_preferences.update_ui()
skip_warning_button.connect("toggled", skip_warning_toggled)
def_msg = "Invalid key, report this! key={key}".format(key=comp_type)
msg_markup = FILE_WARNING_MSGS.get(comp_type, def_msg).format(
filename=filename,
new_version=target_version,
current_version=MYPAINT_VERSION
) + "\n\n" + OPEN_ANYWAY
d = Gtk.MessageDialog(
transient_for=app.drawWindow,
buttons=Gtk.ButtonsType.NONE,
modal=True,
message_type=Gtk.MessageType.WARNING,
)
d.set_markup(msg_markup)
vbox = d.get_content_area()
vbox.set_spacing(0)
vbox.set_margin_top(12)
vbox.pack_start(skip_warning_button, False, True, 0)
d.add_button(Gtk.STOCK_NO, Gtk.ResponseType.REJECT)
d.add_button(Gtk.STOCK_YES, Gtk.ResponseType.ACCEPT)
d.set_default_response(Gtk.ResponseType.REJECT)
# Without this, the check button takes initial focus
def show_checkbut(*args):
skip_warning_button.show()
skip_warning_button.set_can_focus(True)
d.connect("show", show_checkbut)
response = d.run()
d.destroy()
return response == Gtk.ResponseType.ACCEPT
class CompatFileBehavior(config.CompatFileBehaviorConfig):
""" Holds data and functions related to per-file choice of compat mode
"""
_CFBC = config.CompatFileBehaviorConfig
_OPTIONS = [
_CFBC.ALWAYS_1X,
_CFBC.ALWAYS_2X,
_CFBC.UNLESS_PIGMENT_LAYER_1X,
]
_LABELS = {
_CFBC.ALWAYS_1X: (
C_(
"Prefs Dialog|Compatibility",
# TRANSLATORS: One of the options for the
# TRANSLATORS: "When Not Specified in File"
# TRANSLATORS: compatibility setting.
"Always open in 1.x mode"
)
),
_CFBC.ALWAYS_2X: (
C_(
"Prefs Dialog|Compatibility",
# TRANSLATORS: One of the options for the
# TRANSLATORS: "When Not Specified in File"
# TRANSLATORS: compatibility setting.
"Always open in 2.x mode"
)
),
_CFBC.UNLESS_PIGMENT_LAYER_1X: (
C_(
"Prefs Dialog|Compatibility",
# TRANSLATORS: One of the options for the
# TRANSLATORS: "When Not Specified in File"
# TRANSLATORS: compatibility setting.
"Open in 1.x mode unless file contains pigment layers"
)
),
}
def __init__(self, combobox, prefs):
self.combo = combobox
self.prefs = prefs
options_store = Gtk.ListStore()
options_store.set_column_types((str, str))
for option in self._OPTIONS:
options_store.append((option, self._LABELS[option]))
combobox.set_model(options_store)
cell = Gtk.CellRendererText()
combobox.pack_start(cell, True)
combobox.add_attribute(cell, 'text', 1)
self.update_ui()
combobox.connect('changed', self.changed_cb)
def update_ui(self):
self.combo.set_active_id(self.prefs[self.SETTING])
def changed_cb(self, combo):
active_id = self.combo.get_active_id()
self.prefs[self.SETTING] = active_id
@staticmethod
def get_compat_mode(setting, root_elem, default):
""" Get the compat mode to use for a file
The decision is based on the given file behavior setting
and the layer stack xml.
"""
# If more options are added, rewrite to use separate classes.
if setting == CompatFileBehavior.ALWAYS_1X:
return C1X
elif setting == CompatFileBehavior.ALWAYS_2X:
return C2X
elif setting == CompatFileBehavior.UNLESS_PIGMENT_LAYER_1X:
if has_pigment_layers(root_elem):
logger.info("Pigment layer found!")
return C2X
else:
return C1X
else:
msg = "Unknown file compat setting: {setting}, using default mode."
logger.warning(msg.format(setting=setting))
return default
class CompatibilityPreferences:
""" A single instance should be a part of the preference window
This class handles preferences related to the compatibility modes
and their settings.
"""
def __init__(self, app, builder):
self.app = app
self._builder = builder
# Widget references
getobj = builder.get_object
# Default compat mode choice radio buttons
self.default_radio_1_x = getobj('compat_1_x_radiobutton')
self.default_radio_2_x = getobj('compat_2_x_radiobutton')
# For each mode, choice for whether pigment is on or off by default
self.pigment_switch_1_x = getobj('pigment_setting_switch_1_x')
self.pigment_switch_2_x = getobj('pigment_setting_switch_2_x')
# For each mode, choice of which layer type is the default
self.pigment_radio_1_x = getobj('def_new_layer_pigment_1_x')
self.pigment_radio_2_x = getobj('def_new_layer_pigment_2_x')
self.normal_radio_1_x = getobj('def_new_layer_normal_1_x')
self.normal_radio_2_x = getobj('def_new_layer_normal_2_x')
def file_warning_cb(level):
def cb(checkbut):
app.preferences[FILE_WARNINGS[level]] = checkbut.get_active()
return cb
self.file_warning_mild = getobj('file_compat_warning_mild')
self.file_warning_mild.connect(
"toggled", file_warning_cb(Compatibility.PARTIALLY))
self.file_warning_severe = getobj('file_compat_warning_severe')
self.file_warning_severe.connect(
"toggled", file_warning_cb(Compatibility.INCOMPATIBLE))
self.compat_file_behavior = CompatFileBehavior(
getobj('compat_file_behavior_combobox'), self.app.preferences)
# Initialize widgets and callbacks
self.setup_layer_type_strings()
self.setup_widget_callbacks()
def setup_widget_callbacks(self):
""" Hook up callbacks for switches and radiobuttons
"""
# Convenience wrapper - here it is enough to act when toggling on,
# so ignore callbacks triggered by radio buttons being toggled off.
def ignore_detoggle(cb_func):
def cb(btn, *args):
if btn.get_active():
cb_func(btn, *args)
return cb
# Connect default layer type toggles
layer_type_cb = ignore_detoggle(self.set_compat_layer_type_cb)
self.normal_radio_1_x.connect('toggled', layer_type_cb, C1X, False)
self.pigment_radio_1_x.connect('toggled', layer_type_cb, C1X, True)
self.normal_radio_2_x.connect('toggled', layer_type_cb, C2X, False)
self.pigment_radio_2_x.connect('toggled', layer_type_cb, C2X, True)
def_compat_cb = ignore_detoggle(self.set_default_compat_mode_cb)
self.default_radio_1_x.connect('toggled', def_compat_cb, C1X)
self.default_radio_2_x.connect('toggled', def_compat_cb, C2X)
pigment_switch_cb = self.default_pigment_changed_cb
self.pigment_switch_1_x.connect('state-set', pigment_switch_cb, C1X)
self.pigment_switch_2_x.connect('state-set', pigment_switch_cb, C2X)
def setup_layer_type_strings(self):
""" Replace the placeholder labels and add tooltips
"""
def string_setup(widget, label, tooltip):
widget.set_label(label)
widget.set_tooltip_text(tooltip)
normal_label, normal_tooltip = MODE_STRINGS[CombineNormal]
string_setup(self.normal_radio_1_x, normal_label, normal_tooltip)
string_setup(self.normal_radio_2_x, normal_label, normal_tooltip)
pigment_label, pigment_tooltip = MODE_STRINGS[CombineSpectralWGM]
string_setup(self.pigment_radio_1_x, pigment_label, pigment_tooltip)
string_setup(self.pigment_radio_2_x, pigment_label, pigment_tooltip)
def update_ui(self):
prefs = self.app.preferences
# File warnings update (can be changed from confirmation dialogs)
self.file_warning_mild.set_active(
prefs.get(FILE_WARNINGS[Compatibility.PARTIALLY], True))
self.file_warning_severe.set_active(
prefs.get(FILE_WARNINGS[Compatibility.INCOMPATIBLE], True))
# Even in a radio button group with 2 widgets, using set_active(False)
# will not toggle the other button on, hence this ugly pattern.
if prefs.get(DEFAULT_COMPAT, C2X) == C1X:
self.default_radio_1_x.set_active(True)
else:
self.default_radio_2_x.set_active(True)
mode_settings = prefs[COMPAT_SETTINGS]
# 1.x
self.pigment_switch_1_x.set_active(
mode_settings[C1X][config.PIGMENT_BY_DEFAULT])
if mode_settings[C1X][config.PIGMENT_LAYER_BY_DEFAULT]:
self.pigment_radio_1_x.set_active(True)
else:
self.normal_radio_1_x.set_active(True)
# 2.x
self.pigment_switch_2_x.set_active(
mode_settings[C2X][config.PIGMENT_BY_DEFAULT])
if mode_settings[C2X][config.PIGMENT_LAYER_BY_DEFAULT]:
self.pigment_radio_2_x.set_active(True)
else:
self.normal_radio_2_x.set_active(True)
def _update_prefs(self, mode, setting, value):
prefs = self.app.preferences
prefs[COMPAT_SETTINGS][mode].update({setting: value})
# Widget callbacks
def set_default_compat_mode_cb(self, radiobutton, compat_mode):
self.app.preferences[DEFAULT_COMPAT] = compat_mode
def set_compat_layer_type_cb(self, btn, mode, use_pigment):
self._update_prefs(mode, config.PIGMENT_LAYER_BY_DEFAULT, use_pigment)
update_default_layer_type(self.app)
def default_pigment_changed_cb(self, switch, use_pigment, mode):
self._update_prefs(mode, config.PIGMENT_BY_DEFAULT, use_pigment)
update_default_pigment_setting(self.app)
def ora_compat_handler(app):
def handler(eotf_value, root_stack_elem):
default = app.preferences[DEFAULT_COMPAT]
if eotf_value is not None:
try:
eotf_value = float(eotf_value)
compat = C1X if eotf_value == 1.0 else C2X
except ValueError:
msg = "Invalid eotf: {eotf}, using default compat mode!"
logger.warning(msg.format(eotf=eotf_value))
eotf_value = None
compat = default
else:
logger.info("No eotf value specified in openraster file")
# Depending on user settings, decide whether to
# use the default value for the eotf, or the legacy value of 1.0
setting = app.preferences[CompatFileBehavior.SETTING]
compat = CompatFileBehavior.get_compat_mode(
setting, root_stack_elem, default)
set_compat_mode(app, compat, custom_eotf=eotf_value)
return handler
def set_compat_mode(app, compat_mode, custom_eotf=None, update=True):
"""Set compatibility mode
Set compatibility mode and update associated settings;
default pigment brush setting and default layer type.
If the "update" keyword is set to False, the settings
are not updated.
If the compatibility mode is changed, the scratchpad is
saved and reloaded under the new mode settings.
"""
if compat_mode not in {C1X, C2X}:
compat_mode = C2X
msg = "Unknown compatibility mode: '{mode}'! Using 2.x instead."
logger.warning(msg.format(mode=compat_mode))
changed = compat_mode != app.compat_mode
app.compat_mode = compat_mode
# Save scratchpad (with current eotf)
if update and changed:
app.drawWindow.save_current_scratchpad_cb(None)
# Change eotf and set new compat mode
if compat_mode == C1X:
logger.info("Setting mode to 1.x (legacy)")
lib.eotf.set_eotf(1.0)
else:
logger.info("Setting mode to 2.x (standard)")
lib.eotf.set_eotf(custom_eotf or lib.eotf.base_eotf())
if update and changed:
# Reload scratchpad (with new eotf)
app.drawWindow.revert_current_scratchpad_cb(None)
for f in app.brush.observers:
f({'color_h', 'color_s', 'color_v'})
update_default_layer_type(app)
update_default_pigment_setting(app)
def update_default_layer_type(app):
"""Update default layer type from settings
"""
prefs = app.preferences
mode_settings = prefs[COMPAT_SETTINGS][app.compat_mode]
if mode_settings[config.PIGMENT_LAYER_BY_DEFAULT]:
logger.info("Setting default layer type to Pigment")
set_default_mode(CombineSpectralWGM)
else:
logger.info("Setting default layer type to Normal")
set_default_mode(CombineNormal)
def update_default_pigment_setting(app):
"""Update default pigment brush setting value
"""
prefs = app.preferences
mode_settings = prefs[COMPAT_SETTINGS][app.compat_mode]
app.brushmanager.set_pigment_by_default(
mode_settings[config.PIGMENT_BY_DEFAULT]
)
class CompatSelector:
""" A dropdown menu with file loading compatibility options
If a file was accidentally set to use the wrong mode, these
options are used to force opening in a particular mode.
"""
def __init__(self, app):
self.app = app
combo = Gtk.ComboBox()
store = Gtk.ListStore()
store.set_column_types((str, str))
for k, v in _FILE_OPEN_OPTIONS:
store.append((k, v))
combo.set_model(store)
combo.set_active(0)
cell = Gtk.CellRendererText()
combo.pack_start(cell, True)
combo.add_attribute(cell, 'text', 1)
combo_label = Gtk.Label(
# TRANSLATORS: This is a label for a dropdown menu in the
# TRANSLATORS: file chooser dialog when loading .ora files.
label=C_("File Load Compat Options", "Compatibility mode:")
)
hbox = Gtk.HBox()
hbox.set_spacing(6)
hbox.pack_start(combo_label, False, False, 0)
hbox.pack_start(combo, False, False, 0)
hbox.show_all()
hbox.set_visible(False)
self._compat_override = None
self._combo = combo
combo.connect('changed', self._combo_changed_cb)
self._widget = hbox
def _combo_changed_cb(self, combo):
idx = combo.get_active()
if idx >= 0:
self._compat_override = _FILE_OPEN_OPTIONS[idx][0]
else:
self._compat_override = None
def file_selection_changed_cb(self, chooser):
""" Show/hide widget and enable/disable override
"""
fn = chooser.get_filename()
applicable = fn is not None and fn.endswith('.ora')
self.widget.set_visible(applicable)
if not applicable:
self._compat_override = None
else:
self._combo_changed_cb(self._combo)
@property
def widget(self):
return self._widget
@property
def compat_function(self):
""" Returns an overriding compatibility handler or None
"""
if self._compat_override:
return lambda *a: set_compat_mode(self.app, self._compat_override)