σ dςτdc @`sαdZddlmZmZmZmZddlTddlZddlm Z ddlm Z ie dƒd6e d ƒd 6Z d Zd Zd ZdgZiZdd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zd„Zdddeddddeeedd„ Zdefd„Z defed„Z!d„Z"d„Z#d„Z$d „Z%d!„Z&d"„Z'd#„Z(d$„Z)d%„Z*ed&„Z+ddd'„Z,ie d 6e!d(6Z-d)e.fd*„ƒYZ/dS(+uCreation and management of plug-in actions - procedures and constraints. Most functions take a setting group containing actions as its first argument. Many functions define events invoked on the setting group containing actions. These events include: * `'before-add-action'` - invoked when: * calling `add()` before adding an action, * calling `clear()` before resetting actions (due to initial actions being added back). Arguments: action dictionary to be added * `'after-add-action'` - invoked when: * calling `add()` after adding an action, * calling `setting.Group.load()` or `setting.Persistor.load()` after loading an action (loading an action counts as adding). * calling `clear()` after resetting actions (due to initial actions being added back). Arguments: * created action, * original action dictionary (same as in `'before-add-action'`). When this event is triggered in `setting.Group.load()` or `setting.Persistor.load()`, this argument is `None` as there is no way to obtain the original dictionary. * `'before-reorder-action'` - invoked when calling `reorder()` before reordering an action. Arguments: action, position before reordering * `'after-reorder-action'` - invoked when calling `reorder()` after reordering an action. Arguments: action, position before reordering, new position * `'before-remove-action'` - invoked when calling `remove()` before removing an action. Arguments: action to be removed * `'after-remove-action'` - invoked when calling `remove()` after removing an action. Arguments: name of the removed action * `'before-clear-actions'` - invoked when calling `clear()` before clearing actions. * `'after-clear-actions'` - invoked when calling `clear()` after clearing actions. i(tabsolute_importtdivisiontprint_functiontunicode_literals(t*N(t pygimplib(t placeholdersu Backgroundu backgroundu Foregroundu foregroundudefault_proceduresudefault_constraintsu procedureunamecC`sgtjjd|didd6dd6ƒ}|t|­tu after-loadN(tpgtsettingtGrouptNonet!_ACTIONS_AND_INITIAL_ACTION_DICTSt_create_initial_actionst connect_eventt_set_up_action_after_loading(Rtinitial_actionstactions((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pytcreateTsN    cC`s1|dk r-x|D]}t||ƒqWndS(N(Rtadd(RRt action_dict((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyR³s  cC`s2x+|D]#}t|ƒ|jd|dƒqWdS(Nuafter-add-action(t_set_up_action_post_creationt invoke_eventR(Rtaction((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyRΉs  cC`sΊt|tƒrt|ƒ}n6tjj|ƒr?t|ƒ}ntdj|ƒƒ‚t|ƒt|ƒ}|j d|ƒt ||ƒt |}|j |gƒ|j d||ƒ|S(u  Add an action to the `actions` setting group. `action_dict_or_function` can be one of the following: * a dictionary - see `create()` for required and accepted fields. * a PDB procedure. Objects of other types passed to `action_dict_or_function` raise `TypeError`. The same action can be added multiple times. Each action will be assigned a unique name and display name (e.g. `'rename'` and `'Rename'` for the first action, `'rename_2'` and `'Rename (2)'` for the second action, and so on). u;"{}" is not a valid object - pass a dict or a PDB procedureubefore-add-actionuafter-add-action( t isinstancetdictRtpdbutilstis_pdb_proceduret!get_action_dict_for_pdb_proceduret TypeErrortformatt_check_required_fieldsRt_uniquify_name_and_display_namet_create_action_by_typeR(Rtaction_dict_or_functionRtorig_action_dictR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyRΏs     cC`s9x2tD]*}||krtdj|ƒƒ‚qqWdS(Numissing required field: "{}"(t_REQUIRED_ACTION_FIELDSt ValueErrorR%(t action_kwargstrequired_field((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyR&κs  cC`sO|d|dRN(Rtadditional_tagsRHR?RA((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyt_create_procedure—s    cK`s‘ddg}|dk r%||7}n|dk r@t|ƒ}nt|d|d||}|jidd6dd6|d 6td ƒd 6gƒ|S( Nuactionu constraintRHRAubooleanutypeualso_apply_to_parent_foldersunameu default_valueuAlso apply to parent foldersu display_name(RR>RNRRB(RRORHtalso_apply_to_parent_foldersR?RAt constraint((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyt_create_constraintͺs"     cC`sI|djdt|dƒ|djdƒrEt|ƒt|ƒndS(Nuenabledu after-set-guiu display_nameuoriginugimp_pdb(Rt!_set_display_name_for_enabled_guitis_itemt8_connect_events_to_sync_array_and_array_length_argumentst1_hide_gui_for_run_mode_and_array_length_arguments(R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyRΙs   cC`s |jddd|jjƒdS(Ntgui_typeucheck_button_labelt gui_element(tset_guitguitelement(tsetting_enabledtsetting_display_name((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyRTΤs cC`sYd„}d„}x@t|ƒD]2\}}|jd||ƒ|jd||ƒqWdS(NcS`s|j|jdƒdS(Ni(t set_valueR9(t array_settingtinsertion_indexR9tarray_length_setting((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyt_increment_array_lengthάscS`s|j|jdƒdS(Ni(R_R9(R`RaRb((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyt_decrement_array_lengthΰsuafter-add-elementubefore-delete-element(t$_get_array_length_and_array_settingsR(RRcRdtlength_settingR`((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyRVΪs   cC`sxtt|dƒdƒ}|dk rG|jdkrG|jjtƒnx*t|ƒD]\}}|jjtƒqTWdS(Nu argumentsurun-mode(tnexttiterRR:R[t set_visibleR Re(Rtfirst_argumentRftunused_((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyRWλs cC`sbg}d}xO|dD]C}t|tjjƒrT|dk rT|j||fƒn|}qW|S(Nu arguments(RRRRt ArraySettingtappend(Rtarray_length_and_array_settingstprevious_settingR((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyReτs! c C`sΊd„}itjj|jƒd6tjj|jƒd6dd6gd6tjj|jƒd6td6}g}xGt|jƒD]6\}\}}}tjj|ƒ}ytjj|} Wn$t k rέt |d|ƒ‚nXtj j ||d |ƒƒ} |j | ƒt| tƒr;t| ƒ} | | d<|| dxs N(RgRtR(RR‡((R‡s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyR…rscC`sj|jdƒ|jg|D]}|j^qƒ|rY|tkrYt|t|ƒqYn|jdƒdS(u’Removes all added actions. If `add_initial_actions` is `True`, add back actions specified as `initial_actions` in `create()` after removing all actions. ubefore-clear-actionsuafter-clear-actionsN(RRŠRRR(RR R((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyR }s  # c#`s‘ttƒ‰ˆdk r<ˆˆkr<tdjˆƒƒ‚n‡‡fd†}xL|D]D}||ƒsmqUn|dkr|VqU||krU||VqUqUWdS(u‡ Walk (iterate over) a setting group containing actions. The value of `action_type` determines what types of actions to iterate over. If `action_type` is `None`, iterate over all actions. For allowed action types, see `create()`. Invalid values for `action_type` raise `ValueError`. If `setting_name` is `None`, iterate over each setting group representing the entire action. If `setting_name` is not `None`, iterate over each setting or subgroup inside each action. For example, `'enabled'` yields the `'enabled'` setting for each action. For the list of possible names of settings and subgroups, see `create()`. uinvalid action type "{}"c`s7ˆdkr&t‡fd†ˆDƒƒSˆˆjkSdS(Nc3`s|]}|ˆjkVqdS(N(RA(R‹R@(R(s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pys ¦s(RtanyRA(R(t action_typet action_types(Rs?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pythas_matching_type€s N(R>R=RR,R%(RRt setting_nameRR((RRŽs?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyR7Žs     u constraintRxcB`seZd„ZRS(cC`s||_||_dS(N(tprocedure_nametunsupported_param_type(tselfR‘R’((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyt__init__½s (t__name__t __module__R”(((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyRx»s(0t__doc__t __future__RRRRtfuture.builtinsRzt export_layersRRRRBt BUILTIN_TAGStDEFAULT_PROCEDURES_GROUPtDEFAULT_CONSTRAINTS_GROUPR<R+RRRRRRR&R'R/R0R(R1R RNRPRSRRTRVRWReR#R†RŠR…R R7R=t ExceptionRx(((s?/home/josie/.config/GIMP/2.10/plug-ins/export_layers/actions.pyt:sl"     _   +      c    C   ' # -*- coding: utf-8 -*- """Background and foreground layer insertion and manipulation.""" from __future__ import absolute_import, division, print_function, unicode_literals from future.builtins import * import gimp from gimp import pdb import gimpenums from export_layers import exceptions from export_layers import pygimplib as pg def insert_background_layer(batcher, tag): return _insert_tagged_layer(batcher, tag, 'after') def insert_foreground_layer(batcher, tag): return _insert_tagged_layer(batcher, tag, 'before') def _insert_tagged_layer(batcher, tag, insert_mode): tagged_items = [ item for item in batcher.item_tree.iter(with_folders=True, filtered=False) if tag in item.tags] merged_tagged_layer = None orig_merged_tagged_layer = None def _cleanup_tagged_layers(batcher): if orig_merged_tagged_layer is not None and pdb.gimp_item_is_valid(orig_merged_tagged_layer): pdb.gimp_item_delete(orig_merged_tagged_layer) batcher.invoker.remove(cleanup_tagged_layers_action_id, ['cleanup_contents']) # We use`Invoker.add` instead of `batcher.add_procedure` since the latter # would add the function only at the start of processing and we already are in # the middle of processing here. cleanup_tagged_layers_action_id = batcher.invoker.add( _cleanup_tagged_layers, ['cleanup_contents']) while True: image = batcher.current_image current_parent = batcher.current_raw_item.parent position = pdb.gimp_image_get_item_position(image, batcher.current_raw_item) if insert_mode == 'after': position += 1 if not tagged_items: yield continue if orig_merged_tagged_layer is None: merged_tagged_layer = _insert_merged_tagged_layer( batcher, image, tagged_items, tag, current_parent, position) orig_merged_tagged_layer = pdb.gimp_layer_copy(merged_tagged_layer, True) _remove_locks_from_layer(orig_merged_tagged_layer) else: merged_tagged_layer = pdb.gimp_layer_copy(orig_merged_tagged_layer, True) _remove_locks_from_layer(merged_tagged_layer) pdb.gimp_image_insert_layer(image, merged_tagged_layer, current_parent, position) yield def _insert_merged_tagged_layer(batcher, image, tagged_items, tag, parent, position): first_tagged_layer_position = position for i, item in enumerate(tagged_items): layer_copy = pg.pdbutils.copy_and_paste_layer( item.raw, image, parent, first_tagged_layer_position + i, True, True, True) layer_copy.visible = True batcher.invoker.invoke( ['before_process_item_contents'], [batcher, batcher.current_item, layer_copy]) if parent is None: children = image.layers else: children = parent.children if len(tagged_items) == 1: merged_tagged_layer = children[first_tagged_layer_position] else: second_to_last_tagged_layer_position = first_tagged_layer_position + len(tagged_items) - 2 for i in range(second_to_last_tagged_layer_position, first_tagged_layer_position - 1, -1): merged_tagged_layer = pdb.gimp_image_merge_down( image, children[i], gimpenums.EXPAND_AS_NECESSARY) return merged_tagged_layer def _remove_locks_from_layer(layer): pdb.gimp_item_set_lock_content(layer, False) if not isinstance(layer, gimp.GroupLayer): if gimp.version >= (2, 10): pdb.gimp_item_set_lock_position(layer, False) pdb.gimp_layer_set_lock_alpha(layer, False) def merge_background(batcher, merge_type=gimpenums.EXPAND_AS_NECESSARY): _merge_tagged_layer( batcher, merge_type, get_background_layer, 'current_item') def merge_foreground(batcher, merge_type=gimpenums.EXPAND_AS_NECESSARY): _merge_tagged_layer( batcher, merge_type, get_foreground_layer, 'tagged_layer') def _merge_tagged_layer(batcher, merge_type, get_tagged_layer_func, layer_to_merge_down_str): tagged_layer = get_tagged_layer_func(batcher) if tagged_layer is not None: name = batcher.current_raw_item.name visible = pdb.gimp_item_get_visible(batcher.current_raw_item) orig_tags = _get_tags(batcher.current_raw_item) if layer_to_merge_down_str == 'current_item': layer_to_merge_down = batcher.current_raw_item elif layer_to_merge_down_str == 'tagged_layer': layer_to_merge_down = tagged_layer else: raise ValueError('invalid value for "layer_to_merge_down_str"') pdb.gimp_item_set_visible(batcher.current_raw_item, True) merged_layer = pdb.gimp_image_merge_down( batcher.current_image, layer_to_merge_down, merge_type) merged_layer.name = name batcher.current_raw_item = merged_layer pdb.gimp_item_set_visible(batcher.current_raw_item, visible) _set_tags(batcher.current_raw_item, orig_tags) # We do not expect layer groups as folders to be merged since the plug-in # manipulates regular layers only (a layer group is merged into a single # layer during processing). Therefore, folder tags are ignored. _set_tags(batcher.current_raw_item, set(), pg.itemtree.TYPE_FOLDER) def get_background_layer(batcher): return _get_adjacent_layer( batcher, lambda position, num_layers: position < num_layers - 1, 1, 'insert_background_layers', _('There are no background layers.')) def get_foreground_layer(batcher): return _get_adjacent_layer( batcher, lambda position, num_layers: position > 0, -1, 'insert_foreground_layers', _('There are no foreground layers.')) def _get_adjacent_layer( batcher, position_cond_func, adjacent_position_increment, insert_tagged_layers_procedure_name, skip_message): raw_item = batcher.current_raw_item if raw_item.parent is None: children = batcher.current_image.layers else: children = raw_item.parent.children adjacent_layer = None num_layers = len(children) if num_layers > 1: position = pdb.gimp_image_get_item_position(batcher.current_image, batcher.current_raw_item) if position_cond_func(position, num_layers): next_layer = children[position + adjacent_position_increment] tags = [ procedure['arguments/tag'].value for procedure in _get_previous_enabled_procedures( batcher, batcher.current_procedure, insert_tagged_layers_procedure_name)] if _has_tag(next_layer, tags, None) or _has_tag(next_layer, tags, pg.itemtree.TYPE_FOLDER): adjacent_layer = next_layer if adjacent_layer is not None: # This is necessary for some procedures relying on the active layer, e.g. # `plug-in-autocrop-layer`. batcher.current_image.active_layer = adjacent_layer return adjacent_layer else: raise exceptions.SkipAction(skip_message) def _get_previous_enabled_procedures(batcher, current_action, action_orig_name_to_match): # HACK: This avoids a circular import. To resolve this, one possible way is to # refactor `actions` to turn actions into classes. from export_layers import actions previous_enabled_procedures = [] for procedure in actions.walk(batcher.procedures): if procedure == current_action: return previous_enabled_procedures if procedure['enabled'].value and procedure['orig_name'].value == action_orig_name_to_match: previous_enabled_procedures.append(procedure) return previous_enabled_procedures def _has_tag(layer, tags, item_type=None): return any(tag in _get_tags(layer, item_type) for tag in tags) def _get_tags(layer, item_type=None): return pg.itemtree.get_tags_from_raw_item(layer, pg.config.SOURCE_NAME, item_type) def _set_tags(layer, tags, item_type=None): return pg.itemtree.set_tags_for_raw_item(layer, tags, pg.config.SOURCE_NAME, item_type)