class Plugin(OomoxExportPlugin):
name = 'spotify'
display_name = 'Oomoxify'
export_text = translate("Apply Spotif_y Theme…")
export_dialog = SpotifyExportDialog
theme_model_extra = [
{
'type': 'separator',
'display_name': translate('Spotify')
},
{
'key': 'SPOTIFY_PROTO_BG',
'type': 'color',
'fallback_key': 'HDR_BG',
'display_name': translate('Background'),
},
{
'key': 'SPOTIFY_PROTO_FG',
'type': 'color',
'fallback_key': 'HDR_FG',
'display_name': translate('Foreground'),
},
{
'key': 'SPOTIFY_PROTO_SEL',
'type': 'color',
'fallback_key': 'SEL_BG',
'display_name': translate('Accent Color'),
},
]
def __init__(self, transient_for, colorscheme, theme_name, **kwargs):
super().__init__(transient_for=transient_for,
colorscheme=colorscheme,
theme_name=theme_name,
override_options={
OPTION_EXPORT_CINNAMON_THEME: {
'default':
False,
'display_name':
translate("Generate theme for _Cinnamon"),
},
OPTION_EXPORT_GNOME_SHELL_THEME: {
'default':
False,
'display_name':
translate("Generate theme for GNOME _Shell"),
},
OPTION_EXPORT_XFWM_THEME: {
'default':
False,
'display_name':
translate("Generate theme for _Xfwm"),
},
},
**kwargs)
class Plugin(OomoxIconsPlugin):
name = 'papirus_icons'
display_name = 'Papirus'
export_dialog = PapirusIconsExportDialog
preview_svg_dir = os.path.join(PLUGIN_DIR, "icon_previews/")
theme_model_icons = [
{
'key': 'ICONS_LIGHT_FOLDER',
'type': 'color',
'fallback_key': 'SEL_BG',
'display_name': translate('Light Base (Folders)'),
},
{
'key': 'ICONS_MEDIUM',
'type': 'color',
'fallback_key': 'BTN_BG',
'display_name': translate('Medium Base'),
},
{
'key': 'ICONS_DARK',
'type': 'color',
'fallback_key': 'HDR_BG',
'display_name': translate('Dark Stroke'),
},
{
'key': 'ICONS_SYMBOLIC_ACTION',
'type': 'color',
'fallback_function': lambda colors: mix_theme_colors(
colors['MENU_FG'], colors['BTN_FG'],
0.66
),
'display_name': translate('Actions Icons'),
},
{
'key': 'ICONS_SYMBOLIC_PANEL',
'type': 'color',
'fallback_key': 'FG',
'display_name': translate('Panel Icons'),
},
]
def preview_transform_function(self, svg_template, colorscheme):
return svg_template.replace(
"%LIGHT%", colorscheme["ICONS_LIGHT_FOLDER"] or FALLBACK_COLOR
).replace(
"%MEDIUM%", colorscheme["ICONS_MEDIUM"] or FALLBACK_COLOR
).replace(
"%DARK%", colorscheme["ICONS_DARK"] or FALLBACK_COLOR
).replace(
"%SYMBOLIC_ACTION%", colorscheme["ICONS_SYMBOLIC_ACTION"] or FALLBACK_COLOR
).replace(
"%SYMBOLIC_PANEL%", colorscheme["ICONS_SYMBOLIC_PANEL"] or FALLBACK_COLOR
)
def generate_terminal_palette(
cls,
template_path,
image_path,
result_callback,
):
quality = get_first_theme_option('_PIL_PALETTE_QUALITY',
{}).get('fallback_value')
use_whole_palette = bool(
get_first_theme_option('_PIL_PALETTE_STRICT',
{}).get('fallback_value'))
inverse_palette = bool(
get_first_theme_option('_PIL_PALETTE_INVERSE',
{}).get('fallback_value'))
_id = template_path + image_path + str(quality) + str(
use_whole_palette) + str(inverse_palette)
def _result_callback(generated_palette):
cls._terminal_palette_cache[_id] = generated_palette
palette = {}
palette.update(cls._terminal_palette_cache[_id])
result_callback(palette)
if not cls._terminal_palette_cache.get(_id):
_app = OomoxApplicationWindow.get_instance()
_app.disable(translate('Generating terminal palette…'))
_app.schedule_task(cls._generate_terminal_palette, template_path,
image_path, quality, use_whole_palette,
inverse_palette, _result_callback)
_app.enable()
else:
_result_callback(cls._terminal_palette_cache[_id])
def __init__(self, *args, **kwargs):
super().__init__(*args,
headline=translate("Terminal Colorscheme"),
height=440,
**kwargs)
self.label.set_text(
translate('Paste this colorscheme to your ~/.Xresources:'))
self.scrolled_window.show_all()
try:
term_colorscheme = generate_xrdb_theme_from_oomox(self.colorscheme)
xresources_theme = generate_xresources(term_colorscheme)
except Exception as exc:
self.set_text(exc)
self.show_error()
else:
self.set_text(xresources_theme)
def _generate_terminal_palette( # noqa
cls,
template_path,
image_path,
quality,
use_whole_palette,
inverse_palette,
result_callback,
) -> None:
start_time = time()
_id = cls._generate_palette_id(image_path, quality, use_whole_palette)
hex_palette = cls._palette_cache.get(_id)
if hex_palette:
cls._generate_terminal_palette_callback(hex_palette, template_path,
inverse_palette,
result_callback)
else:
_app = OomoxApplicationWindow.get_instance()
_app.disable(translate('Extracting palette from image…'))
_app.schedule_task(
cls._generate_terminal_palette_task,
template_path,
image_path,
quality,
use_whole_palette,
inverse_palette,
start_time,
result_callback,
)
_app.enable()
def __init__(self, *args, **kwargs):
default_icons_path = os.path.join(os.environ['HOME'], '.icons')
if os.environ.get('XDG_CURRENT_DESKTOP', '').lower() in (
'kde',
'lxqt',
):
default_icons_path = os.path.join(
os.environ.get(
'XDG_DATA_HOME',
os.path.join(os.environ['HOME'], '.local/share')),
'icons',
)
super().__init__(*args,
export_options={
OPTION_DEFAULT_PATH: {
'default': default_icons_path,
'display_name': translate("Export _path: "),
},
},
**kwargs)
self.option_widgets[OPTION_DEFAULT_PATH].set_text(
os.path.join(
self.export_config[OPTION_DEFAULT_PATH],
self.theme_name,
))
class Plugin(OomoxIconsPlugin):
name = 'gnome_colors'
display_name = 'Gnome-Colors'
export_dialog = GnomeColorsIconsExportDialog
preview_svg_dir = os.path.join(PLUGIN_DIR, "icon_previews/")
theme_model_icons = [
{
'key': 'ICONS_LIGHT_FOLDER',
'type': 'color',
'fallback_key': 'SEL_BG',
'display_name': translate('Light Base (Folders)'),
},
{
'key': 'ICONS_LIGHT',
'fallback_key': 'SEL_BG',
'type': 'color',
'display_name': translate('Light Base'),
},
{
'key': 'ICONS_MEDIUM',
'type': 'color',
'fallback_key': 'BTN_BG',
'display_name': translate('Medium Base'),
},
{
'key': 'ICONS_DARK',
'type': 'color',
'fallback_key': 'HDR_BG',
'display_name': translate('Dark Stroke'),
},
]
def preview_transform_function(self, svg_template, colorscheme):
return svg_template.replace(
"LightFolderBase", colorscheme["ICONS_LIGHT_FOLDER"] or FALLBACK_COLOR
).replace(
"LightBase", colorscheme["ICONS_LIGHT"] or FALLBACK_COLOR
).replace(
"MediumBase", colorscheme["ICONS_MEDIUM"] or FALLBACK_COLOR
).replace(
"DarkStroke", colorscheme["ICONS_DARK"] or FALLBACK_COLOR
)
def __init__(self, transient_for, colorscheme, theme_name):
super().__init__(transient_for=transient_for,
headline=translate("Spotify Options"),
colorscheme=colorscheme,
theme_name=theme_name)
self.label.hide()
self.export_config = ExportConfig(config_name='spotify',
default_config={
OPTION_SPOTIFY_PATH:
"/usr/share/spotify/Apps",
OPTION_FONT_NAME:
"sans-serif",
OPTION_FONT_OPTIONS:
VALUE_FONT_DEFAULT,
})
export_options_headline = Gtk.Label()
export_options_headline.set_markup('<b>' + translate("Font Options") +
'</b>')
export_options_headline.set_justify(Gtk.Justification.LEFT)
export_options_headline.set_alignment(0.0, 0.0)
self.options_box.add(export_options_headline)
self._init_radios()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
spotify_path_label = Gtk.Label(label=translate('Spotify _path:'),
use_underline=True)
self.spotify_path_entry = Gtk.Entry(
text=self.export_config[OPTION_SPOTIFY_PATH])
spotify_path_label.set_mnemonic_widget(self.spotify_path_entry)
hbox.add(spotify_path_label)
hbox.add(self.spotify_path_entry)
self.options_box.add(hbox)
self.box.add(self.options_box)
self.options_box.show_all()
self.box.add(self.apply_button)
self.apply_button.show()
def _init_radios(self):
self.font_radio_default = \
Gtk.RadioButton.new_with_mnemonic_from_widget(
None,
translate("Don't change _default font")
)
self.font_radio_default.connect("toggled", self.on_font_radio_toggled,
VALUE_FONT_DEFAULT)
self.options_box.add(self.font_radio_default)
self.font_radio_normalize = \
Gtk.RadioButton.new_with_mnemonic_from_widget(
self.font_radio_default,
translate("_Normalize font weight")
)
self.font_radio_normalize.connect("toggled",
self.on_font_radio_toggled,
VALUE_FONT_NORMALIZE)
self.options_box.add(self.font_radio_normalize)
self.font_radio_custom = Gtk.RadioButton.new_with_mnemonic_from_widget(
self.font_radio_default, translate("Use custom _font:"))
self.font_radio_custom.connect("toggled", self.on_font_radio_toggled,
VALUE_FONT_CUSTOM)
self.options_box.add(self.font_radio_custom)
self.font_name_entry = Gtk.Entry(
text=self.export_config[OPTION_FONT_NAME])
self.options_box.add(self.font_name_entry)
self.font_name_entry.set_sensitive(
self.export_config[OPTION_FONT_OPTIONS] == VALUE_FONT_CUSTOM)
if self.export_config[OPTION_FONT_OPTIONS] == VALUE_FONT_NORMALIZE:
self.font_radio_normalize.set_active(True)
if self.export_config[OPTION_FONT_OPTIONS] == VALUE_FONT_CUSTOM:
self.font_radio_custom.set_active(True)
def __init__(self, transient_for, colorscheme, theme_name, **kwargs):
default_themes_path = os.path.join(os.environ['HOME'], '.themes')
super().__init__(transient_for=transient_for,
colorscheme=colorscheme,
theme_name=theme_name,
add_options={
OPTION_DEFAULT_PATH: {
'default': default_themes_path,
'display_name': translate("Export _path: "),
},
},
**kwargs)
self.option_widgets[OPTION_DEFAULT_PATH].set_text(
os.path.join(
self.export_config[OPTION_DEFAULT_PATH],
self.theme_name,
))
class Plugin(OomoxIconsPlugin):
name = 'archdroid'
display_name = 'Archdroid'
export_dialog = ArchdroidIconsExportDialog
preview_svg_dir = os.path.join(PLUGIN_DIR, "icon_previews/")
theme_model_icons = [
{
'key': 'ICONS_ARCHDROID',
'type': 'color',
'fallback_key': 'SEL_BG',
'display_name': translate('Icons Color'),
},
]
def preview_transform_function(self, svg_template, colorscheme):
return svg_template.replace(
"%ICONS_ARCHDROID%", colorscheme["ICONS_ARCHDROID"]
or FALLBACK_COLOR)
class Plugin(OomoxThemePlugin):
name = 'arc'
display_name = 'Arc'
description = ('GTK+2, GTK+3\n'
'Cinnamon, GNOME Shell, Metacity, Openbox, Unity, Xfwm')
export_dialog = ArcThemeExportDialog
gtk_preview_dir = os.path.join(PLUGIN_DIR, "gtk_preview_css/")
preview_sizes = {
OomoxThemePlugin.PreviewImageboxesNames.CHECKBOX.name: 16,
}
enabled_keys_gtk = [
'BG',
'FG',
'HDR_BG',
'HDR_FG',
'SEL_BG',
'SEL_FG',
'TXT_BG',
'BTN_BG',
'HDR_BTN_BG',
'ACCENT_BG',
]
# enabled_keys_options = [
# 'ROUNDNESS',
# ]
theme_model_gtk = [
{
'key':
'ARC_WIDGET_BORDER_COLOR',
'fallback_function':
lambda colors: mix_theme_colors(colors['BTN_BG'], colors['BTN_FG'],
0.75),
'type':
'color',
'display_name':
translate('Border'),
'description':
translate('not supported by GTK+2 theme'),
},
]
theme_model_options = [
{
'key': 'ARC_TRANSPARENCY',
'type': 'bool',
'fallback_value': True,
'display_name': translate('Enable Theme Transparency'),
'description': translate('not supported by GTK+2 theme'),
},
# {
# 'key': 'GTK3_GENERATE_DARK',
# 'type': 'bool',
# 'fallback_value': True,
# 'display_name': translate('(GTK3) Add Dark Variant'),
# },
]
def preview_before_load_callback(self, preview_object, colorscheme):
colorscheme["TXT_FG"] = colorscheme["FG"]
colorscheme["BTN_FG"] = colorscheme["FG"]
colorscheme["HDR_BTN_FG"] = colorscheme["HDR_FG"]
colorscheme["WM_BORDER_FOCUS"] = colorscheme["HDR_BG"]
colorscheme["WM_BORDER_UNFOCUS"] = colorscheme["BTN_BG"]
colorscheme["GRADIENT"] = 0
colorscheme["ROUNDNESS"] = 0
preview_object.WM_BORDER_WIDTH = 0
_monkeypatch_update_preview_borders(preview_object)
class Plugin(OomoxThemePlugin):
name = 'materia'
display_name = 'Materia'
description = ('GTK+2, GTK+3\n'
'Cinnamon, GNOME Shell, Metacity, Unity, Xfwm')
export_dialog = MateriaThemeExportDialog
gtk_preview_dir = os.path.join(PLUGIN_DIR, "gtk_preview_css/")
preview_sizes = {
OomoxThemePlugin.PreviewImageboxesNames.CHECKBOX.name: 24,
}
enabled_keys_gtk = [
'BG',
'FG',
'HDR_BG',
'HDR_FG',
'SEL_BG',
]
enabled_keys_options = [
'ROUNDNESS',
]
theme_model_gtk = [
{
'key': 'TXT_BG',
'type': 'color',
'fallback_key': 'BG',
'display_name': translate('View'),
},
{
'key': 'BTN_BG',
'type': 'color',
'fallback_key': 'BG',
'display_name': translate('Surface (like Button, Menu, Popover)'),
},
]
theme_model_options = [
{
'key': 'MATERIA_SELECTION_OPACITY',
'type': 'float',
'fallback_value': 0.32,
'max_value': 1.0,
'display_name': translate('Selection Opacity'),
},
{
'key': 'MATERIA_PANEL_OPACITY',
'type': 'float',
'fallback_value': 0.6,
'max_value': 1.0,
'display_name': translate('DE Panel Opacity'),
},
{
'key': 'MATERIA_STYLE_COMPACT',
'type': 'bool',
'fallback_value': True,
'display_name': translate('Compact Style'),
},
]
def preview_before_load_callback(self, preview_object, colorscheme):
colorscheme["TXT_FG"] = colorscheme["FG"]
colorscheme["WM_BORDER_FOCUS"] = colorscheme["HDR_BG"]
colorscheme["WM_BORDER_UNFOCUS"] = colorscheme["BTN_BG"]
colorscheme["HDR_BTN_FG"] = colorscheme["HDR_FG"]
colorscheme["HDR_BTN_BG"] = colorscheme["HDR_BG"]
colorscheme["SEL_FG"] = colorscheme["FG"]
colorscheme["ACCENT_BG"] = colorscheme["SEL_BG"]
colorscheme["BTN_FG"] = colorscheme["FG"]
colorscheme["GRADIENT"] = 0
preview_object.WM_BORDER_WIDTH = 0
_monkeypatch_update_preview_colors(preview_object)
class Plugin(OomoxIconsPlugin):
# if not os.path.exists('/usr/share/icons/Numix/'):
# raise Exception('Numix icon theme need to be installed first')
name = 'numix_icons'
display_name = 'Numix'
export_dialog = NumixIconsExportDialog
preview_svg_dir = os.path.join(PLUGIN_DIR, "icon_previews/0/")
theme_model_icons = [
{
'key':
'ICONS_NUMIX_STYLE',
'type':
'options',
'options': [{
'value':
str(style_id),
'display_name':
translate("Style {number}").format(number=style_id),
} for style_id in range(6)],
'display_name':
translate('Numix Style'),
},
# {
# 'key': 'ICONS_NUMIX_SHAPE',
# 'type': 'options',
# 'options': [{
# 'value': 'normal',
# 'display_name': 'Normal',
# }, {
# 'value': 'circle',
# 'display_name': 'Circle',
# }, {
# 'value': 'square',
# 'display_name': 'Square',
# }],
# 'display_name': translate('Icons Shape'),
# },
{
'key': 'ICONS_LIGHT_FOLDER',
'type': 'color',
'fallback_key': 'SEL_BG',
'display_name': translate('Light Base (Folders)'),
},
# {
# 'key': 'ICONS_LIGHT',
# 'fallback_key': 'SEL_BG',
# 'type': 'color',
# 'display_name': translate('Light Base'),
# },
{
'key': 'ICONS_MEDIUM',
'type': 'color',
'fallback_key': 'BTN_BG',
'display_name': translate('Medium Base'),
},
{
'key': 'ICONS_DARK',
'type': 'color',
'fallback_key': 'HDR_BG',
'display_name': translate('Dark Stroke'),
},
]
def preview_before_load_callback(self, preview_object, colorscheme):
self.preview_svg_dir = os.path.join(PLUGIN_DIR, "icon_previews/",
colorscheme["ICONS_NUMIX_STYLE"])
preview_object.icons_plugin_name = '_update'
def preview_transform_function(self, svg_template, colorscheme):
# ).replace(
# "00ff00", colorscheme["ICONS_LIGHT"] or FALLBACK_COLOR
return svg_template.replace(
"%LIGHT%", colorscheme["ICONS_LIGHT_FOLDER"]
or FALLBACK_COLOR).replace(
"%MEDIUM%", colorscheme["ICONS_MEDIUM"]
or FALLBACK_COLOR).replace(
"%DARK%", colorscheme["ICONS_DARK"] or FALLBACK_COLOR)
class Plugin(OomoxImportPluginAsync):
name = 'import_pil'
display_name = translate('Image colors')
import_text = translate('Colors from Image')
file_extensions = (
'.jpg',
'.png',
'.gif',
)
default_theme = {
"TERMINAL_THEME_MODE": "manual",
"TERMINAL_THEME_AUTO_BGFG": False,
}
default_themes = {
"lcars": {
"TERMINAL_THEME_MODE": "manual",
"ROUNDNESS": 20,
"ICONS_STYLE": "archdroid",
}
}
translation_common = {
"NAME": "scheme",
"TERMINAL_COLOR0": "color0",
"TERMINAL_COLOR1": "color1",
"TERMINAL_COLOR2": "color2",
"TERMINAL_COLOR3": "color3",
"TERMINAL_COLOR4": "color4",
"TERMINAL_COLOR5": "color5",
"TERMINAL_COLOR6": "color6",
"TERMINAL_COLOR7": "color7",
"TERMINAL_COLOR8": "color8",
"TERMINAL_COLOR9": "color9",
"TERMINAL_COLOR10": "color10",
"TERMINAL_COLOR11": "color11",
"TERMINAL_COLOR12": "color12",
"TERMINAL_COLOR13": "color13",
"TERMINAL_COLOR14": "color14",
"TERMINAL_COLOR15": "color15",
"TERMINAL_BACKGROUND": "background",
"TERMINAL_FOREGROUND": "foreground",
"TERMINAL_ACCENT_COLOR": "color3",
}
theme_translations: Dict[str, Dict[str, str]] = {
"1": {
"BG": "color7",
"FG": "color0",
# "TXT_BG": "foreground",
# "TXT_FG": "background",
"TXT_BG": "color15",
"TXT_FG": "color0",
"SEL_BG": "color4",
"SEL_FG": "color15",
"HDR_BG": "color0",
"HDR_FG": "color7",
"BTN_BG": "color8",
"BTN_FG": "foreground",
"HDR_BTN_BG": "background",
"HDR_BTN_FG": "foreground",
"ICONS_LIGHT_FOLDER": "color12",
"ICONS_LIGHT": "color14",
"ICONS_MEDIUM": "color6",
"ICONS_DARK": "color4",
},
"2": {
"BG": "color7",
"FG": "color0",
"TXT_BG": "color15",
"TXT_FG": "color0",
"SEL_BG": "color1",
"SEL_FG": "foreground",
"HDR_BG": "color0",
"HDR_FG": "color7",
"BTN_BG": "color12",
"BTN_FG": "color0",
"WM_BORDER_FOCUS": "color10",
"ICONS_LIGHT_FOLDER": "color13",
"ICONS_LIGHT": "color9",
"ICONS_MEDIUM": "color1",
"ICONS_DARK": "color5",
},
"3": {
"BG": "color7",
"FG": "color0",
"TXT_BG": "color15",
"TXT_FG": "color0",
"SEL_BG": "color3",
"SEL_FG": "color0",
"HDR_BG": "color0",
"HDR_FG": "color7",
"BTN_BG": "color12",
"BTN_FG": "color0",
"WM_BORDER_FOCUS": "color3",
"ICONS_LIGHT_FOLDER": "color13",
"ICONS_LIGHT": "color9",
"ICONS_MEDIUM": "color1",
"ICONS_DARK": "color5",
},
"4": {
"BG": "color5",
"FG": "color0",
"HDR_BG": "color1",
"HDR_FG": "foreground",
"SEL_BG": "color4",
"SEL_FG": "foreground",
"TXT_BG": "color6",
"TXT_FG": "color1",
"BTN_BG": "color3",
"BTN_FG": "color0",
"HDR_BTN_BG": "color5",
"HDR_BTN_FG": "background",
},
"lcars": {
"BG": "background",
"FG": "foreground",
"TXT_BG": "background",
"TXT_FG": "color11",
"SEL_BG": "color1",
"SEL_FG": "background",
"HDR_BG": "background",
"HDR_FG": "color7",
"BTN_BG": "color10",
"BTN_FG": "color0",
"HDR_BTN_BG": "color12",
"HDR_BTN_FG": "background",
"WM_BORDER_FOCUS": "color10",
"ICONS_ARCHDROID": "color12",
},
}
theme_model_import = [
{
'display_name': translate('Import Colors from Image'),
'type': 'separator',
'value_filter': {
'FROM_PLUGIN': ['import_pil']
},
},
{
'key':
'_PIL_PALETTE_QUALITY',
'type':
'options',
'options': [{
'value': LOW_QUALITY,
'display_name': translate('oomox: low quality'),
}, {
'value': MEDIUM_QUALITY,
'display_name': translate('oomox: medium quality'),
}, {
'value': HIGH_QUALITY,
'display_name': translate('oomox: high quality'),
}],
# }, {
# 'value': ULTRA_QUALITY,
# 'display_name': 'ultra',
'fallback_value':
LOW_QUALITY,
'display_name':
translate('Image Analysis'),
'reload_theme':
True,
},
{
'key':
'_PIL_PALETTE_STYLE',
'type':
'options',
'options': [{
'value': template_name
} for template_name in sorted(os.listdir(TERMINAL_TEMPLATE_DIR))],
# 'fallback_value': 'monovedek_pale_gray',
'fallback_value':
'basic',
'display_name':
translate('Palette Style'),
'reload_theme':
True,
},
{
'key': '_PIL_PALETTE_STRICT',
'type': 'bool',
'fallback_value': False,
'display_name': translate('Stronger Follow Palette Template'),
'reload_theme': True,
'value_filter': {
'_PIL_PALETTE_QUALITY':
[LOW_QUALITY, MEDIUM_QUALITY, HIGH_QUALITY]
},
},
{
'key': '_PIL_PALETTE_INVERSE',
'type': 'bool',
'fallback_value': False,
'display_name': translate('Dark/Light Colors'),
'reload_theme': True,
},
{
'key':
'_PIL_THEME_TEMPLATE',
'type':
'options',
'options': [{
'value': template_name
} for template_name in sorted(theme_translations.keys())],
'fallback_value':
'1',
'display_name':
translate('GUI Theme Template'),
'reload_theme':
True,
},
{
'key': '_PIL_IMAGE_PREVIEW',
'type': 'image_path',
'fallback_value': None,
'display_name': translate('Image Thumbnail'),
},
]
theme_model_gtk = [
{
'display_name': translate('Edit Generated Theme'),
'type': 'separator',
},
]
try:
import colorz # pylint: disable=import-error,useless-suppression
theme_model_import[1]['options'] += [{
'value':
'colorz16',
'display_name':
translate('colorz lib: low quality'),
}, {
'value':
'colorz32',
'display_name':
translate('colorz lib: medium quality'),
}, {
'value':
'colorz64',
'display_name':
translate('colorz lib: high quality'),
}]
except: # noqa pylint: disable=bare-except
pass
try:
import colorthief # pylint: disable=import-error,useless-suppression
theme_model_import[1]['options'] += [{
'value':
'colorthief16',
'display_name':
translate('colorthief lib'),
}, {
'value':
'colorthief32',
'display_name':
translate('colorthief lib: doublepass'),
}]
except: # noqa pylint: disable=bare-except
pass
try:
import haishoku # pylint: disable=import-error,useless-suppression
# theme_model_import['_PIL_PALETTE_QUALITY']['options'].append({
theme_model_import[1]['options'].append({
'value':
'haishoku',
'display_name':
translate('haishoku lib'),
})
except: # noqa pylint: disable=bare-except
pass
try:
import colorthief # noqa pylint: disable=import-error,useless-suppression
import colorz # noqa pylint: disable=import-error,useless-suppression
import haishoku # noqa pylint: disable=import-error,useless-suppression
# theme_model_import['_PIL_PALETTE_QUALITY']['options'].append({
theme_model_import[1]['options'] += [{
'value':
'all_low',
'display_name':
translate('all available: low quality'),
}, {
'value':
'all_medium',
'display_name':
translate('all available: medium quality'),
}]
except: # noqa pylint: disable=bare-except
pass
_terminal_palette_cache: Dict[str, Dict[str, str]] = {}
_palette_cache: Dict[str, List[str]] = {}
@classmethod
def _get_haishoku_palette(cls, image_path) -> List[HexColor]:
from haishoku.haishoku import Haishoku # pylint: disable=import-error,useless-suppression
palette = Haishoku.getPalette(image_path)
hex_palette = [
color_hex_from_list(color) for _percentage, color in palette
]
return hex_palette
@classmethod
def _get_colorthief_palette(cls, image_path,
color_count) -> List[HexColor]:
from colorthief import ColorThief # pylint: disable=import-error,useless-suppression
color_thief = ColorThief(image_path)
palette = color_thief.get_palette(color_count=color_count)
hex_palette = [color_hex_from_list(color) for color in palette]
return hex_palette
@classmethod
def _get_colorz_lib_palette(cls, image_path,
color_count) -> List[HexColor]:
from colorz import colorz # pylint: disable=import-error,useless-suppression
with open(image_path, 'rb') as fobj:
palette = colorz(fobj, color_count, 50, 200)
hex_palette = [
color_hex_from_list(color) for pair in palette for color in pair
]
return hex_palette
@classmethod
def _get_all_available_palettes(cls, image_path: str,
use_whole_palette: bool,
quality_per_plugin: int) -> List[HexColor]:
hex_palette = []
from colorz import colorz # pylint: disable=import-error,useless-suppression
from colorthief import ColorThief # pylint: disable=import-error,useless-suppression
from haishoku.haishoku import Haishoku # pylint: disable=import-error,useless-suppression
with Pool() as pool:
oomox_future = pool.apply_async(
apply_chain,
(get_plugin_module, ('ima', os.path.join(
PLUGIN_DIR, 'ima.py'), 'get_hex_palette'),
(image_path, use_whole_palette, 48, quality_per_plugin[0])))
from functools import partial
_opener = partial(open, image_path, 'rb')
colorz_future = pool.apply_async(delayed_partial, (
colorz,
((_opener, ()), ),
(
quality_per_plugin[1],
50,
200,
),
))
colorthief_future = pool.apply_async(
call_method_from_class,
(ColorThief, (image_path, ), 'get_palette',
(quality_per_plugin[2], )))
haishoku_future = pool.apply_async(Haishoku.getPalette,
(image_path, ))
pool.close()
hex_palette += oomox_future.get()
try:
hex_palette += [
color_hex_from_list(color) for pair in colorz_future.get()
for color in pair
]
except Exception:
pass
try:
hex_palette += [
color_hex_from_list(color)
for color in colorthief_future.get()
]
except Exception:
pass
try:
hex_palette += [
color_hex_from_list(color)
for _percentage, color in haishoku_future.get()
]
except Exception:
pass
pool.join()
return hex_palette
def read_colorscheme_from_path(self, preset_path: str, callback) -> None:
get_first_theme_option(
'_PIL_IMAGE_PREVIEW')['fallback_value'] = preset_path
def _callback(image_palette):
self.read_colorscheme_from_path_callback(image_palette, callback)
self.generate_terminal_palette(
get_first_theme_option('_PIL_PALETTE_STYLE').get('fallback_value'),
preset_path,
result_callback=_callback,
)
def read_colorscheme_from_path_callback(self,
image_palette: Dict[str, HexColor],
callback) -> None:
theme_template: str = get_first_theme_option('_PIL_THEME_TEMPLATE',
{}).get('fallback_value')
oomox_theme: Dict[str, Any] = {}
oomox_theme.update(self.default_theme)
if theme_template in self.default_themes:
oomox_theme.update(self.default_themes[theme_template])
translation: Dict[str, str] = {}
translation.update(self.translation_common)
translation.update(self.theme_translations[theme_template])
for oomox_key, image_palette_key in translation.items():
if image_palette_key in image_palette:
oomox_theme[oomox_key] = image_palette[image_palette_key]
callback(oomox_theme)
@staticmethod
def _generate_palette_id(image_path, quality, use_whole_palette):
return image_path + str(quality) + str(use_whole_palette)
@classmethod
def _generate_terminal_palette( # noqa
cls,
template_path,
image_path,
quality,
use_whole_palette,
inverse_palette,
result_callback,
) -> None:
start_time = time()
_id = cls._generate_palette_id(image_path, quality, use_whole_palette)
hex_palette = cls._palette_cache.get(_id)
if hex_palette:
cls._generate_terminal_palette_callback(hex_palette, template_path,
inverse_palette,
result_callback)
else:
_app = OomoxApplicationWindow.get_instance()
_app.disable(translate('Extracting palette from image…'))
_app.schedule_task(
cls._generate_terminal_palette_task,
template_path,
image_path,
quality,
use_whole_palette,
inverse_palette,
start_time,
result_callback,
)
_app.enable()
@classmethod
def _generate_terminal_palette_task( # noqa
cls,
template_path,
image_path,
quality,
use_whole_palette,
inverse_palette,
start_time,
result_callback,
):
if str(quality).startswith('colorz'):
hex_palette = cls._get_colorz_lib_palette(
image_path, color_count=int(quality.split('colorz')[1]))
elif str(quality).startswith('colorthief'):
hex_palette = cls._get_colorthief_palette(
image_path,
color_count=int(quality.split('colorthief')[1]) + 1)
elif quality == 'haishoku':
hex_palette = cls._get_haishoku_palette(image_path)
elif str(quality).startswith('all_'):
_quality = quality.split('_')[1]
if _quality == 'low':
quality_per_plugin = [100, 16, 16]
elif _quality == 'medium':
quality_per_plugin = [200, 32, 32]
else:
raise NotImplementedError()
hex_palette = cls._get_all_available_palettes(
image_path=image_path,
use_whole_palette=use_whole_palette,
quality_per_plugin=quality_per_plugin)
else:
hex_palette = image_analyzer.get_hex_palette(
image_path,
quality=quality,
use_whole_palette=use_whole_palette)[:]
print(
f"{quality} quality, {len(hex_palette)} colors found, took {time() - start_time:.8f}s"
)
_id = cls._generate_palette_id(image_path, quality, use_whole_palette)
cls._palette_cache[_id] = hex_palette
cls._generate_terminal_palette_callback(hex_palette, template_path,
inverse_palette,
result_callback)
@classmethod
def _generate_terminal_palette_callback( # noqa pylint: disable=too-many-locals
cls,
hex_palette,
template_path,
inverse_palette,
result_callback,
):
gray_colors = get_gray_colors(hex_palette)
bright_colors = set(hex_palette)
bright_colors.difference_update(gray_colors)
bright_colors = list(bright_colors)
ACCURACY = 40 # pylint: disable=invalid-name
hex_palette += [hex_darker(c, ACCURACY) for c in gray_colors]
hex_palette += [hex_darker(c, -ACCURACY) for c in gray_colors]
reference_palette = import_xcolors(
os.path.join(TERMINAL_TEMPLATE_DIR, template_path))
result_palette = {}
if inverse_palette:
reference_palette['foreground'], reference_palette['background'] = \
reference_palette['background'], reference_palette['foreground']
is_dark_bg = is_dark(reference_palette['background'])
max_possible_lightness = 255 * 3
new_bg_color, _diff = find_closest_color(
reference_palette['background'], hex_palette)
# @TODO: use real lightness from HSV or Lab color model
lightness_delta = sum(int_list_from_hex(new_bg_color)) * (1 if is_dark_bg else -1) + \
max_possible_lightness // 4
# max_possible_lightness // 6
min_lightness = max_possible_lightness // 38
max_lightness = max_possible_lightness - min_lightness
if is_dark_bg:
min_lightness = lightness_delta
else:
max_lightness = max_possible_lightness - lightness_delta
for key, value in reference_palette.items():
if key not in [
'color0', 'color7', 'color8', 'color15', 'foreground',
'background'
]:
closest_color, _diff = find_closest_color(
value,
bright_colors,
min_lightness=min_lightness,
max_lightness=max_lightness)
else:
closest_color, _diff = find_closest_color(value, hex_palette)
result_palette[key] = closest_color
gc.collect()
result_callback(result_palette)
@classmethod
def generate_terminal_palette(
cls,
template_path,
image_path,
result_callback,
):
quality = get_first_theme_option('_PIL_PALETTE_QUALITY',
{}).get('fallback_value')
use_whole_palette = bool(
get_first_theme_option('_PIL_PALETTE_STRICT',
{}).get('fallback_value'))
inverse_palette = bool(
get_first_theme_option('_PIL_PALETTE_INVERSE',
{}).get('fallback_value'))
_id = template_path + image_path + str(quality) + str(
use_whole_palette) + str(inverse_palette)
def _result_callback(generated_palette):
cls._terminal_palette_cache[_id] = generated_palette
palette = {}
palette.update(cls._terminal_palette_cache[_id])
result_callback(palette)
if not cls._terminal_palette_cache.get(_id):
_app = OomoxApplicationWindow.get_instance()
_app.disable(translate('Generating terminal palette…'))
_app.schedule_task(cls._generate_terminal_palette, template_path,
image_path, quality, use_whole_palette,
inverse_palette, _result_callback)
_app.enable()
else:
_result_callback(cls._terminal_palette_cache[_id])
def __init__(self, *args, **kwargs):
super().__init__(*args,
height=800,
width=800,
headline=translate("Base16 Export Options…"),
**kwargs)
self.label.set_text(
translate(
"Choose export options below and copy-paste the result."))
self.export_config = ExportConfig(config_name='base16',
default_config={
ConfigKeys.last_variant: None,
ConfigKeys.last_app: None,
})
if not os.path.exists(USER_BASE16_TEMPLATES_DIR):
os.makedirs(USER_BASE16_TEMPLATES_DIR)
system_templates_dir = os.path.abspath(
os.path.join(PLUGIN_DIR, 'templates'))
templates_index_path = system_templates_dir + '.yaml'
with open(templates_index_path,
encoding=DEFAULT_ENCODING) as templates_index_file:
self.templates_homepages = yaml_load(templates_index_file.read())
# APPS
for templates_dir in (system_templates_dir, USER_BASE16_TEMPLATES_DIR):
for template_name in os.listdir(templates_dir):
template = Base16Template(
path=os.path.join(templates_dir, template_name))
self.available_apps[template.name] = template
current_app_name = self.export_config[ConfigKeys.last_app]
if not current_app_name or current_app_name not in self.available_apps:
current_app_name = self.export_config[ConfigKeys.last_app] = \
self._sorted_appnames[0]
self.current_app = self.available_apps[current_app_name]
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
apps_label = Gtk.Label(label=translate('_Application:'),
use_underline=True)
self._init_apps_dropdown()
apps_label.set_mnemonic_widget(self._apps_dropdown)
hbox.add(apps_label)
hbox.add(self._apps_dropdown)
# VARIANTS
variant_label = Gtk.Label(label=translate('_Variant:'),
use_underline=True)
self._init_variants_dropdown()
variant_label.set_mnemonic_widget(self._variants_dropdown)
hbox.add(variant_label)
hbox.add(self._variants_dropdown)
# HOMEPAGE
self._homepage_button = Gtk.Button(label=translate('Open _Homepage'),
use_underline=True)
self._homepage_button.connect('clicked', self._on_homepage_button)
hbox.add(self._homepage_button)
self.options_box.add(hbox)
self.top_area.add(self.options_box)
self.options_box.show_all()
user_templates_label = Gtk.Label()
_userdir_markup = \
f'<a href="file://{USER_BASE16_TEMPLATES_DIR}">{USER_BASE16_TEMPLATES_DIR}</a>'
user_templates_label.set_markup(
translate('User templates can be added to {userdir}').format(
userdir=_userdir_markup))
self.box.add(user_templates_label)
user_templates_label.show_all()
class Plugin(OomoxIconsPlugin):
name = 'suruplus_aspromauros_icons'
display_name = 'Suru++ Asprómauros'
export_dialog = SuruPlusIconsExportDialog
preview_svg_dir = os.path.join(PLUGIN_DIR, "icon_previews/")
theme_model_icons = [
{
'key':
'ICONS_SYMBOLIC_ACTION',
'type':
'color',
'fallback_function':
lambda colors: mix_theme_colors(colors['MENU_FG'], colors['BTN_FG'
], 0.66),
'display_name':
translate('Actions Icons'),
'value_filter': {
'SURUPLUS_GRADIENT_ENABLED': False,
},
},
{
'key': 'ICONS_SYMBOLIC_PANEL',
'type': 'color',
'fallback_key': 'FG',
'display_name': translate('Panel Icons'),
},
{
'key': 'SURUPLUS_GRADIENT_ENABLED',
'type': 'bool',
'fallback_value': False,
'reload_options': True,
'display_name': translate('Enable Gradients'),
},
{
'key': 'SURUPLUS_GRADIENT1',
'type': 'color',
'fallback_key': 'ICONS_SYMBOLIC_ACTION',
'display_name': translate('Gradient Start Color'),
'value_filter': {
'SURUPLUS_GRADIENT_ENABLED': True,
},
},
{
'key': 'SURUPLUS_GRADIENT2',
'type': 'color',
'fallback_key': 'SEL_BG',
'display_name': translate('Gradient End Color'),
'value_filter': {
'SURUPLUS_GRADIENT_ENABLED': True,
},
},
]
def preview_transform_function(self, svg_template, colorscheme):
icon_preview = svg_template.replace(
"%SYMBOLIC_ACTION%", colorscheme["ICONS_SYMBOLIC_ACTION"]
or FALLBACK_COLOR).replace(
"%SYMBOLIC_PANEL%", colorscheme["ICONS_SYMBOLIC_PANEL"]
or FALLBACK_COLOR)
if colorscheme[
'SURUPLUS_GRADIENT_ENABLED'] and 'arrongin' in svg_template:
icon_preview = icon_preview.replace(
"currentColor", "url(#arrongin)").replace(
"%GRADIENT1%", colorscheme["SURUPLUS_GRADIENT1"]
or FALLBACK_COLOR).replace(
"%GRADIENT2%", colorscheme["SURUPLUS_GRADIENT2"]
or FALLBACK_COLOR)
return icon_preview
class Plugin(PluginBase):
name = 'base16'
display_name = translate('Base16')
user_presets_display_name = translate('Base16 User-Imported')
export_text = translate('Base16-Based Templates…')
import_text = translate('From Base16 YML Format')
export_dialog = Base16ExportDialog
file_extensions = (
'.yml',
'.yaml',
)
plugin_theme_dir = os.path.abspath(os.path.join(PLUGIN_DIR, 'schemes'))
theme_model_import: 'ThemeModelSection' = [
{
'display_name': translate('Base16 Import Options'),
'type': 'separator',
'value_filter': {
'FROM_PLUGIN': name,
},
},
{
'key': 'BASE16_GENERATE_DARK',
'type': 'bool',
'fallback_value': False,
'display_name': translate('Inverse GUI Variant'),
'reload_theme': True,
},
{
'key': 'BASE16_INVERT_TERMINAL',
'type': 'bool',
'fallback_value': False,
'display_name': translate('Inverse Terminal Colors'),
'reload_theme': True,
},
{
'key': 'BASE16_MILD_TERMINAL',
'type': 'bool',
'fallback_value': False,
'display_name': translate('Mild Terminal Colors'),
'reload_theme': True,
},
{
'display_name': translate('Edit Imported Theme'),
'type': 'separator',
'value_filter': {
'FROM_PLUGIN': name,
},
},
]
theme_model_gtk = [
{
'display_name': translate('Edit Generated Theme'),
'type': 'separator',
},
]
default_theme = {
"TERMINAL_THEME_MODE": "manual",
}
translation_common = {}
translation_common.update(OOMOX_TO_BASE16_TRANSLATION)
translation_light = {
"BG": "base05",
"FG": "base00",
"HDR_BG": "base04",
"HDR_FG": "base01",
"SEL_BG": "base0D",
"SEL_FG": "base00",
"ACCENT_BG": "base0D",
"TXT_BG": "base06",
"TXT_FG": "base01",
"BTN_BG": "base03",
"BTN_FG": "base07",
"HDR_BTN_BG": "base05",
"HDR_BTN_FG": "base01",
"ICONS_LIGHT_FOLDER": "base0C",
"ICONS_LIGHT": "base0C",
"ICONS_MEDIUM": "base0D",
"ICONS_DARK": "base03",
}
translation_dark = {
"BG": "base01",
"FG": "base06",
"HDR_BG": "base00",
"HDR_FG": "base05",
"SEL_BG": "base0E",
"SEL_FG": "base00",
"ACCENT_BG": "base0E",
"TXT_BG": "base02",
"TXT_FG": "base07",
"BTN_BG": "base00",
"BTN_FG": "base05",
"HDR_BTN_BG": "base01",
"HDR_BTN_FG": "base05",
"ICONS_LIGHT_FOLDER": "base0D",
"ICONS_LIGHT": "base0D",
"ICONS_MEDIUM": "base0E",
"ICONS_DARK": "base00",
}
translation_terminal_inverse = {
"TERMINAL_BACKGROUND": "base06",
"TERMINAL_FOREGROUND": "base01",
}
translation_terminal_mild = {
"TERMINAL_COLOR8": "base01",
"TERMINAL_COLOR15": "base06",
"TERMINAL_BACKGROUND": "base07",
"TERMINAL_FOREGROUND": "base02",
}
translation_terminal_mild_inverse = {
"TERMINAL_COLOR8": "base01",
"TERMINAL_COLOR15": "base06",
"TERMINAL_BACKGROUND": "base02",
"TERMINAL_FOREGROUND": "base07",
}
def read_colorscheme_from_path(self, preset_path):
base16_theme = {}
with open(preset_path, encoding=DEFAULT_ENCODING) as preset_file:
for line in preset_file.readlines():
try:
key, value, *_rest = line.split()
key = key.rstrip(':')
value = value.strip('\'"').lower()
base16_theme[key] = value
except Exception:
pass
oomox_theme = {}
oomox_theme.update(self.default_theme)
translation = {}
translation.update(self.translation_common)
if get_first_theme_option('BASE16_GENERATE_DARK',
{}).get('fallback_value'):
translation.update(self.translation_dark)
else:
translation.update(self.translation_light)
if get_first_theme_option('BASE16_INVERT_TERMINAL',
{}).get('fallback_value'):
translation.update(self.translation_terminal_inverse)
if get_first_theme_option('BASE16_MILD_TERMINAL',
{}).get('fallback_value'):
if get_first_theme_option('BASE16_INVERT_TERMINAL',
{}).get('fallback_value'):
translation.update(self.translation_terminal_mild)
else:
translation.update(self.translation_terminal_mild_inverse)
for oomox_key, base16_key in translation.items():
if base16_key in base16_theme:
oomox_theme[oomox_key] = base16_theme[base16_key]
return oomox_theme
class Plugin(OomoxExportPlugin):
name = 'xresources'
display_name = translate('Xresources')
export_text = translate("Export _Xresources theme…")
shortcut = "<Primary>X"
export_dialog = XresourcesExportDialog