Fix operators from W menu for the API changes
[blender.git] / release / scripts / startup / bl_operators / wm.py
1 # ##### BEGIN GPL LICENSE BLOCK #####
2 #
3 #  This program is free software; you can redistribute it and/or
4 #  modify it under the terms of the GNU General Public License
5 #  as published by the Free Software Foundation; either version 2
6 #  of the License, or (at your option) any later version.
7 #
8 #  This program is distributed in the hope that it will be useful,
9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 #  GNU General Public License for more details.
12 #
13 #  You should have received a copy of the GNU General Public License
14 #  along with this program; if not, write to the Free Software Foundation,
15 #  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16 #
17 # ##### END GPL LICENSE BLOCK #####
18
19 # <pep8 compliant>
20
21 import bpy
22 from bpy.types import (
23     Operator,
24     OperatorFileListElement
25 )
26 from bpy.props import (
27     BoolProperty,
28     EnumProperty,
29     FloatProperty,
30     IntProperty,
31     StringProperty,
32     CollectionProperty,
33 )
34
35 from bpy.app.translations import pgettext_tip as tip_
36
37
38 rna_path_prop = StringProperty(
39     name="Context Attributes",
40     description="RNA context string",
41     maxlen=1024,
42 )
43
44 rna_reverse_prop = BoolProperty(
45     name="Reverse",
46     description="Cycle backwards",
47     default=False,
48 )
49
50 rna_wrap_prop = BoolProperty(
51     name="Wrap",
52     description="Wrap back to the first/last values",
53     default=False,
54 )
55
56 rna_relative_prop = BoolProperty(
57     name="Relative",
58     description="Apply relative to the current value (delta)",
59     default=False,
60 )
61
62 rna_space_type_prop = EnumProperty(
63     name="Type",
64     items=tuple(
65         (e.identifier, e.name, "", e. value)
66         for e in bpy.types.Space.bl_rna.properties["type"].enum_items
67     ),
68     default='EMPTY',
69 )
70
71
72 def context_path_validate(context, data_path):
73     try:
74         value = eval("context.%s" % data_path) if data_path else Ellipsis
75     except AttributeError as ex:
76         if str(ex).startswith("'NoneType'"):
77             # One of the items in the rna path is None, just ignore this
78             value = Ellipsis
79         else:
80             # We have a real error in the rna path, don't ignore that
81             raise
82
83     return value
84
85
86 def operator_value_is_undo(value):
87     if value in {None, Ellipsis}:
88         return False
89
90     # typical properties or objects
91     id_data = getattr(value, "id_data", Ellipsis)
92
93     if id_data is None:
94         return False
95     elif id_data is Ellipsis:
96         # handle mathutils types
97         id_data = getattr(getattr(value, "owner", None), "id_data", None)
98
99         if id_data is None:
100             return False
101
102     # return True if its a non window ID type
103     return (isinstance(id_data, bpy.types.ID) and
104             (not isinstance(id_data, (bpy.types.WindowManager,
105                                       bpy.types.Screen,
106                                       bpy.types.Brush,
107                                       ))))
108
109
110 def operator_path_is_undo(context, data_path):
111     # note that if we have data paths that use strings this could fail
112     # luckily we don't do this!
113     #
114     # When we can't find the data owner assume no undo is needed.
115     data_path_head = data_path.rpartition(".")[0]
116
117     if not data_path_head:
118         return False
119
120     value = context_path_validate(context, data_path_head)
121
122     return operator_value_is_undo(value)
123
124
125 def operator_path_undo_return(context, data_path):
126     return {'FINISHED'} if operator_path_is_undo(context, data_path) else {'CANCELLED'}
127
128
129 def operator_value_undo_return(value):
130     return {'FINISHED'} if operator_value_is_undo(value) else {'CANCELLED'}
131
132
133 def execute_context_assign(self, context):
134     data_path = self.data_path
135     if context_path_validate(context, data_path) is Ellipsis:
136         return {'PASS_THROUGH'}
137
138     if getattr(self, "relative", False):
139         exec("context.%s += self.value" % data_path)
140     else:
141         exec("context.%s = self.value" % data_path)
142
143     return operator_path_undo_return(context, data_path)
144
145
146 def module_filesystem_remove(path_base, module_name):
147     import os
148     module_name = os.path.splitext(module_name)[0]
149     for f in os.listdir(path_base):
150         f_base = os.path.splitext(f)[0]
151         if f_base == module_name:
152             f_full = os.path.join(path_base, f)
153
154             if os.path.isdir(f_full):
155                 os.rmdir(f_full)
156             else:
157                 os.remove(f_full)
158
159
160 class BRUSH_OT_active_index_set(Operator):
161     """Set active sculpt/paint brush from it's number"""
162     bl_idname = "brush.active_index_set"
163     bl_label = "Set Brush Number"
164
165     mode: StringProperty(
166         name="Mode",
167         description="Paint mode to set brush for",
168         maxlen=1024,
169     )
170     index: IntProperty(
171         name="Number",
172         description="Brush number",
173     )
174
175     _attr_dict = {
176         "sculpt": "use_paint_sculpt",
177         "vertex_paint": "use_paint_vertex",
178         "weight_paint": "use_paint_weight",
179         "image_paint": "use_paint_image",
180     }
181
182     def execute(self, context):
183         attr = self._attr_dict.get(self.mode)
184         if attr is None:
185             return {'CANCELLED'}
186
187         toolsettings = context.tool_settings
188         for i, brush in enumerate((cur for cur in bpy.data.brushes if getattr(cur, attr))):
189             if i == self.index:
190                 getattr(toolsettings, self.mode).brush = brush
191                 return {'FINISHED'}
192
193         return {'CANCELLED'}
194
195
196 class WM_OT_context_set_boolean(Operator):
197     """Set a context value"""
198     bl_idname = "wm.context_set_boolean"
199     bl_label = "Context Set Boolean"
200     bl_options = {'UNDO', 'INTERNAL'}
201
202     data_path: rna_path_prop
203     value: BoolProperty(
204         name="Value",
205         description="Assignment value",
206         default=True,
207     )
208
209     execute = execute_context_assign
210
211
212 class WM_OT_context_set_int(Operator):  # same as enum
213     """Set a context value"""
214     bl_idname = "wm.context_set_int"
215     bl_label = "Context Set"
216     bl_options = {'UNDO', 'INTERNAL'}
217
218     data_path: rna_path_prop
219     value: IntProperty(
220         name="Value",
221         description="Assign value",
222         default=0,
223     )
224     relative: rna_relative_prop
225
226     execute = execute_context_assign
227
228
229 class WM_OT_context_scale_float(Operator):
230     """Scale a float context value"""
231     bl_idname = "wm.context_scale_float"
232     bl_label = "Context Scale Float"
233     bl_options = {'UNDO', 'INTERNAL'}
234
235     data_path: rna_path_prop
236     value: FloatProperty(
237         name="Value",
238         description="Assign value",
239         default=1.0,
240     )
241
242     def execute(self, context):
243         data_path = self.data_path
244         if context_path_validate(context, data_path) is Ellipsis:
245             return {'PASS_THROUGH'}
246
247         value = self.value
248
249         if value == 1.0:  # nothing to do
250             return {'CANCELLED'}
251
252         exec("context.%s *= value" % data_path)
253
254         return operator_path_undo_return(context, data_path)
255
256
257 class WM_OT_context_scale_int(Operator):
258     """Scale an int context value"""
259     bl_idname = "wm.context_scale_int"
260     bl_label = "Context Scale Int"
261     bl_options = {'UNDO', 'INTERNAL'}
262
263     data_path: rna_path_prop
264     value: FloatProperty(
265         name="Value",
266         description="Assign value",
267         default=1.0,
268     )
269     always_step: BoolProperty(
270         name="Always Step",
271         description="Always adjust the value by a minimum of 1 when 'value' is not 1.0",
272         default=True,
273     )
274
275     def execute(self, context):
276         data_path = self.data_path
277         if context_path_validate(context, data_path) is Ellipsis:
278             return {'PASS_THROUGH'}
279
280         value = self.value
281
282         if value == 1.0:  # nothing to do
283             return {'CANCELLED'}
284
285         if getattr(self, "always_step", False):
286             if value > 1.0:
287                 add = "1"
288                 func = "max"
289             else:
290                 add = "-1"
291                 func = "min"
292             exec("context.%s = %s(round(context.%s * value), context.%s + %s)" %
293                  (data_path, func, data_path, data_path, add))
294         else:
295             exec("context.%s *= value" % data_path)
296
297         return operator_path_undo_return(context, data_path)
298
299
300 class WM_OT_context_set_float(Operator):  # same as enum
301     """Set a context value"""
302     bl_idname = "wm.context_set_float"
303     bl_label = "Context Set Float"
304     bl_options = {'UNDO', 'INTERNAL'}
305
306     data_path: rna_path_prop
307     value: FloatProperty(
308         name="Value",
309         description="Assignment value",
310         default=0.0,
311     )
312     relative: rna_relative_prop
313
314     execute = execute_context_assign
315
316
317 class WM_OT_context_set_string(Operator):  # same as enum
318     """Set a context value"""
319     bl_idname = "wm.context_set_string"
320     bl_label = "Context Set String"
321     bl_options = {'UNDO', 'INTERNAL'}
322
323     data_path: rna_path_prop
324     value: StringProperty(
325         name="Value",
326         description="Assign value",
327         maxlen=1024,
328     )
329
330     execute = execute_context_assign
331
332
333 class WM_OT_context_set_enum(Operator):
334     """Set a context value"""
335     bl_idname = "wm.context_set_enum"
336     bl_label = "Context Set Enum"
337     bl_options = {'UNDO', 'INTERNAL'}
338
339     data_path: rna_path_prop
340     value: StringProperty(
341         name="Value",
342         description="Assignment value (as a string)",
343         maxlen=1024,
344     )
345
346     execute = execute_context_assign
347
348
349 class WM_OT_context_set_value(Operator):
350     """Set a context value"""
351     bl_idname = "wm.context_set_value"
352     bl_label = "Context Set Value"
353     bl_options = {'UNDO', 'INTERNAL'}
354
355     data_path: rna_path_prop
356     value: StringProperty(
357         name="Value",
358         description="Assignment value (as a string)",
359         maxlen=1024,
360     )
361
362     def execute(self, context):
363         data_path = self.data_path
364         if context_path_validate(context, data_path) is Ellipsis:
365             return {'PASS_THROUGH'}
366         exec("context.%s = %s" % (data_path, self.value))
367         return operator_path_undo_return(context, data_path)
368
369
370 class WM_OT_context_toggle(Operator):
371     """Toggle a context value"""
372     bl_idname = "wm.context_toggle"
373     bl_label = "Context Toggle"
374     bl_options = {'UNDO', 'INTERNAL'}
375
376     data_path: rna_path_prop
377
378     def execute(self, context):
379         data_path = self.data_path
380
381         if context_path_validate(context, data_path) is Ellipsis:
382             return {'PASS_THROUGH'}
383
384         exec("context.%s = not (context.%s)" % (data_path, data_path))
385
386         return operator_path_undo_return(context, data_path)
387
388
389 class WM_OT_context_toggle_enum(Operator):
390     """Toggle a context value"""
391     bl_idname = "wm.context_toggle_enum"
392     bl_label = "Context Toggle Values"
393     bl_options = {'UNDO', 'INTERNAL'}
394
395     data_path: rna_path_prop
396     value_1: StringProperty(
397         name="Value",
398         description="Toggle enum",
399         maxlen=1024,
400     )
401     value_2: StringProperty(
402         name="Value",
403         description="Toggle enum",
404         maxlen=1024,
405     )
406
407     def execute(self, context):
408         data_path = self.data_path
409
410         if context_path_validate(context, data_path) is Ellipsis:
411             return {'PASS_THROUGH'}
412
413         # failing silently is not ideal, but we don't want errors for shortcut
414         # keys that some values that are only available in a particular context
415         try:
416             exec("context.%s = ('%s', '%s')[context.%s != '%s']" %
417                  (data_path, self.value_1,
418                   self.value_2, data_path,
419                   self.value_2,
420                   ))
421         except:
422             return {'PASS_THROUGH'}
423
424         return operator_path_undo_return(context, data_path)
425
426
427 class WM_OT_context_cycle_int(Operator):
428     """Set a context value (useful for cycling active material, """ \
429         """vertex keys, groups, etc.)"""
430     bl_idname = "wm.context_cycle_int"
431     bl_label = "Context Int Cycle"
432     bl_options = {'UNDO', 'INTERNAL'}
433
434     data_path: rna_path_prop
435     reverse: rna_reverse_prop
436     wrap: rna_wrap_prop
437
438     def execute(self, context):
439         data_path = self.data_path
440         value = context_path_validate(context, data_path)
441         if value is Ellipsis:
442             return {'PASS_THROUGH'}
443
444         if self.reverse:
445             value -= 1
446         else:
447             value += 1
448
449         exec("context.%s = value" % data_path)
450
451         if self.wrap:
452             if value != eval("context.%s" % data_path):
453                 # relies on rna clamping integers out of the range
454                 if self.reverse:
455                     value = (1 << 31) - 1
456                 else:
457                     value = -1 << 31
458
459                 exec("context.%s = value" % data_path)
460
461         return operator_path_undo_return(context, data_path)
462
463
464 class WM_OT_context_cycle_enum(Operator):
465     """Toggle a context value"""
466     bl_idname = "wm.context_cycle_enum"
467     bl_label = "Context Enum Cycle"
468     bl_options = {'UNDO', 'INTERNAL'}
469
470     data_path: rna_path_prop
471     reverse: rna_reverse_prop
472     wrap: rna_wrap_prop
473
474     def execute(self, context):
475         data_path = self.data_path
476         value = context_path_validate(context, data_path)
477         if value is Ellipsis:
478             return {'PASS_THROUGH'}
479
480         orig_value = value
481
482         # Have to get rna enum values
483         rna_struct_str, rna_prop_str = data_path.rsplit('.', 1)
484         i = rna_prop_str.find('[')
485
486         # just in case we get "context.foo.bar[0]"
487         if i != -1:
488             rna_prop_str = rna_prop_str[0:i]
489
490         rna_struct = eval("context.%s.rna_type" % rna_struct_str)
491
492         rna_prop = rna_struct.properties[rna_prop_str]
493
494         if type(rna_prop) != bpy.types.EnumProperty:
495             raise Exception("expected an enum property")
496
497         enums = rna_struct.properties[rna_prop_str].enum_items.keys()
498         orig_index = enums.index(orig_value)
499
500         # Have the info we need, advance to the next item.
501         #
502         # When wrap's disabled we may set the value to its self,
503         # this is done to ensure update callbacks run.
504         if self.reverse:
505             if orig_index == 0:
506                 advance_enum = enums[-1] if self.wrap else enums[0]
507             else:
508                 advance_enum = enums[orig_index - 1]
509         else:
510             if orig_index == len(enums) - 1:
511                 advance_enum = enums[0] if self.wrap else enums[-1]
512             else:
513                 advance_enum = enums[orig_index + 1]
514
515         # set the new value
516         exec("context.%s = advance_enum" % data_path)
517         return operator_path_undo_return(context, data_path)
518
519
520 class WM_OT_context_cycle_array(Operator):
521     """Set a context array value """ \
522         """(useful for cycling the active mesh edit mode)"""
523     bl_idname = "wm.context_cycle_array"
524     bl_label = "Context Array Cycle"
525     bl_options = {'UNDO', 'INTERNAL'}
526
527     data_path: rna_path_prop
528     reverse: rna_reverse_prop
529
530     def execute(self, context):
531         data_path = self.data_path
532         value = context_path_validate(context, data_path)
533         if value is Ellipsis:
534             return {'PASS_THROUGH'}
535
536         def cycle(array):
537             if self.reverse:
538                 array.insert(0, array.pop())
539             else:
540                 array.append(array.pop(0))
541             return array
542
543         exec("context.%s = cycle(context.%s[:])" % (data_path, data_path))
544
545         return operator_path_undo_return(context, data_path)
546
547
548 class WM_OT_context_menu_enum(Operator):
549     bl_idname = "wm.context_menu_enum"
550     bl_label = "Context Enum Menu"
551     bl_options = {'UNDO', 'INTERNAL'}
552
553     data_path: rna_path_prop
554
555     def execute(self, context):
556         data_path = self.data_path
557         value = context_path_validate(context, data_path)
558
559         if value is Ellipsis:
560             return {'PASS_THROUGH'}
561
562         base_path, prop_string = data_path.rsplit(".", 1)
563         value_base = context_path_validate(context, base_path)
564         prop = value_base.bl_rna.properties[prop_string]
565
566         def draw_cb(self, context):
567             layout = self.layout
568             layout.prop(value_base, prop_string, expand=True)
569
570         context.window_manager.popup_menu(draw_func=draw_cb, title=prop.name, icon=prop.icon)
571
572         return {'FINISHED'}
573
574
575 class WM_OT_context_pie_enum(Operator):
576     bl_idname = "wm.context_pie_enum"
577     bl_label = "Context Enum Pie"
578     bl_options = {'UNDO', 'INTERNAL'}
579
580     data_path: rna_path_prop
581
582     def invoke(self, context, event):
583         wm = context.window_manager
584         data_path = self.data_path
585         value = context_path_validate(context, data_path)
586
587         if value is Ellipsis:
588             return {'PASS_THROUGH'}
589
590         base_path, prop_string = data_path.rsplit(".", 1)
591         value_base = context_path_validate(context, base_path)
592         prop = value_base.bl_rna.properties[prop_string]
593
594         def draw_cb(self, context):
595             layout = self.layout
596             layout.prop(value_base, prop_string, expand=True)
597
598         wm.popup_menu_pie(draw_func=draw_cb, title=prop.name, icon=prop.icon, event=event)
599
600         return {'FINISHED'}
601
602
603 class WM_OT_operator_pie_enum(Operator):
604     bl_idname = "wm.operator_pie_enum"
605     bl_label = "Operator Enum Pie"
606     bl_options = {'UNDO', 'INTERNAL'}
607
608     data_path: StringProperty(
609         name="Operator",
610         description="Operator name (in python as string)",
611         maxlen=1024,
612     )
613     prop_string: StringProperty(
614         name="Property",
615         description="Property name (as a string)",
616         maxlen=1024,
617     )
618
619     def invoke(self, context, event):
620         wm = context.window_manager
621
622         data_path = self.data_path
623         prop_string = self.prop_string
624
625         # same as eval("bpy.ops." + data_path)
626         op_mod_str, ob_id_str = data_path.split(".", 1)
627         op = getattr(getattr(bpy.ops, op_mod_str), ob_id_str)
628         del op_mod_str, ob_id_str
629
630         try:
631             op_rna = op.get_rna()
632         except KeyError:
633             self.report({'ERROR'}, "Operator not found: bpy.ops.%s" % data_path)
634             return {'CANCELLED'}
635
636         def draw_cb(self, context):
637             layout = self.layout
638             pie = layout.menu_pie()
639             pie.operator_enum(data_path, prop_string)
640
641         wm.popup_menu_pie(draw_func=draw_cb, title=op_rna.bl_rna.name, event=event)
642
643         return {'FINISHED'}
644
645
646 class WM_OT_context_set_id(Operator):
647     """Set a context value to an ID data-block"""
648     bl_idname = "wm.context_set_id"
649     bl_label = "Set Library ID"
650     bl_options = {'UNDO', 'INTERNAL'}
651
652     data_path: rna_path_prop
653     value: StringProperty(
654         name="Value",
655         description="Assign value",
656         maxlen=1024,
657     )
658
659     def execute(self, context):
660         value = self.value
661         data_path = self.data_path
662
663         # match the pointer type from the target property to bpy.data.*
664         # so we lookup the correct list.
665         data_path_base, data_path_prop = data_path.rsplit(".", 1)
666         data_prop_rna = eval("context.%s" % data_path_base).rna_type.properties[data_path_prop]
667         data_prop_rna_type = data_prop_rna.fixed_type
668
669         id_iter = None
670
671         for prop in bpy.data.rna_type.properties:
672             if prop.rna_type.identifier == "CollectionProperty":
673                 if prop.fixed_type == data_prop_rna_type:
674                     id_iter = prop.identifier
675                     break
676
677         if id_iter:
678             value_id = getattr(bpy.data, id_iter).get(value)
679             exec("context.%s = value_id" % data_path)
680
681         return operator_path_undo_return(context, data_path)
682
683
684 doc_id = StringProperty(
685     name="Doc ID",
686     maxlen=1024,
687     options={'HIDDEN'},
688 )
689
690 data_path_iter = StringProperty(
691     description="The data path relative to the context, must point to an iterable")
692
693 data_path_item = StringProperty(
694     description="The data path from each iterable to the value (int or float)")
695
696
697 class WM_OT_context_collection_boolean_set(Operator):
698     """Set boolean values for a collection of items"""
699     bl_idname = "wm.context_collection_boolean_set"
700     bl_label = "Context Collection Boolean Set"
701     bl_options = {'UNDO', 'REGISTER', 'INTERNAL'}
702
703     data_path_iter: data_path_iter
704     data_path_item: data_path_item
705
706     type: EnumProperty(
707         name="Type",
708         items=(('TOGGLE', "Toggle", ""),
709                ('ENABLE', "Enable", ""),
710                ('DISABLE', "Disable", ""),
711                ),
712     )
713
714     def execute(self, context):
715         data_path_iter = self.data_path_iter
716         data_path_item = self.data_path_item
717
718         items = list(getattr(context, data_path_iter))
719         items_ok = []
720         is_set = False
721         for item in items:
722             try:
723                 value_orig = eval("item." + data_path_item)
724             except:
725                 continue
726
727             if value_orig is True:
728                 is_set = True
729             elif value_orig is False:
730                 pass
731             else:
732                 self.report({'WARNING'}, "Non boolean value found: %s[ ].%s" %
733                             (data_path_iter, data_path_item))
734                 return {'CANCELLED'}
735
736             items_ok.append(item)
737
738         # avoid undo push when nothing to do
739         if not items_ok:
740             return {'CANCELLED'}
741
742         if self.type == 'ENABLE':
743             is_set = True
744         elif self.type == 'DISABLE':
745             is_set = False
746         else:
747             is_set = not is_set
748
749         exec_str = "item.%s = %s" % (data_path_item, is_set)
750         for item in items_ok:
751             exec(exec_str)
752
753         return operator_value_undo_return(item)
754
755
756 class WM_OT_context_modal_mouse(Operator):
757     """Adjust arbitrary values with mouse input"""
758     bl_idname = "wm.context_modal_mouse"
759     bl_label = "Context Modal Mouse"
760     bl_options = {'GRAB_CURSOR', 'BLOCKING', 'UNDO', 'INTERNAL'}
761
762     data_path_iter: data_path_iter
763     data_path_item: data_path_item
764     header_text: StringProperty(
765         name="Header Text",
766         description="Text to display in header during scale",
767     )
768
769     input_scale: FloatProperty(
770         description="Scale the mouse movement by this value before applying the delta",
771         default=0.01,
772     )
773     invert: BoolProperty(
774         description="Invert the mouse input",
775         default=False,
776     )
777     initial_x: IntProperty(options={'HIDDEN'})
778
779     def _values_store(self, context):
780         data_path_iter = self.data_path_iter
781         data_path_item = self.data_path_item
782
783         self._values = values = {}
784
785         for item in getattr(context, data_path_iter):
786             try:
787                 value_orig = eval("item." + data_path_item)
788             except:
789                 continue
790
791             # check this can be set, maybe this is library data.
792             try:
793                 exec("item.%s = %s" % (data_path_item, value_orig))
794             except:
795                 continue
796
797             values[item] = value_orig
798
799     def _values_delta(self, delta):
800         delta *= self.input_scale
801         if self.invert:
802             delta = - delta
803
804         data_path_item = self.data_path_item
805         for item, value_orig in self._values.items():
806             if type(value_orig) == int:
807                 exec("item.%s = int(%d)" % (data_path_item, round(value_orig + delta)))
808             else:
809                 exec("item.%s = %f" % (data_path_item, value_orig + delta))
810
811     def _values_restore(self):
812         data_path_item = self.data_path_item
813         for item, value_orig in self._values.items():
814             exec("item.%s = %s" % (data_path_item, value_orig))
815
816         self._values.clear()
817
818     def _values_clear(self):
819         self._values.clear()
820
821     def modal(self, context, event):
822         event_type = event.type
823
824         if event_type == 'MOUSEMOVE':
825             delta = event.mouse_x - self.initial_x
826             self._values_delta(delta)
827             header_text = self.header_text
828             if header_text:
829                 if len(self._values) == 1:
830                     (item, ) = self._values.keys()
831                     header_text = header_text % eval("item.%s" % self.data_path_item)
832                 else:
833                     header_text = (self.header_text % delta) + " (delta)"
834                 context.area.header_text_set(text=header_text)
835
836         elif 'LEFTMOUSE' == event_type:
837             item = next(iter(self._values.keys()))
838             self._values_clear()
839             context.area.header_text_set()
840             return operator_value_undo_return(item)
841
842         elif event_type in {'RIGHTMOUSE', 'ESC'}:
843             self._values_restore()
844             context.area.header_text_set()
845             return {'CANCELLED'}
846
847         return {'RUNNING_MODAL'}
848
849     def invoke(self, context, event):
850         self._values_store(context)
851
852         if not self._values:
853             self.report({'WARNING'}, "Nothing to operate on: %s[ ].%s" %
854                         (self.data_path_iter, self.data_path_item))
855
856             return {'CANCELLED'}
857         else:
858             self.initial_x = event.mouse_x
859
860             context.window_manager.modal_handler_add(self)
861             return {'RUNNING_MODAL'}
862
863
864 class WM_OT_url_open(Operator):
865     """Open a website in the web-browser"""
866     bl_idname = "wm.url_open"
867     bl_label = ""
868     bl_options = {'INTERNAL'}
869
870     url: StringProperty(
871         name="URL",
872         description="URL to open",
873     )
874
875     def execute(self, context):
876         import webbrowser
877         webbrowser.open(self.url)
878         return {'FINISHED'}
879
880
881 class WM_OT_path_open(Operator):
882     """Open a path in a file browser"""
883     bl_idname = "wm.path_open"
884     bl_label = ""
885     bl_options = {'INTERNAL'}
886
887     filepath: StringProperty(
888         subtype='FILE_PATH',
889         options={'SKIP_SAVE'},
890     )
891
892     def execute(self, context):
893         import sys
894         import os
895         import subprocess
896
897         filepath = self.filepath
898
899         if not filepath:
900             self.report({'ERROR'}, "File path was not set")
901             return {'CANCELLED'}
902
903         filepath = bpy.path.abspath(filepath)
904         filepath = os.path.normpath(filepath)
905
906         if not os.path.exists(filepath):
907             self.report({'ERROR'}, "File '%s' not found" % filepath)
908             return {'CANCELLED'}
909
910         if sys.platform[:3] == "win":
911             os.startfile(filepath)
912         elif sys.platform == "darwin":
913             subprocess.check_call(["open", filepath])
914         else:
915             try:
916                 subprocess.check_call(["xdg-open", filepath])
917             except:
918                 # xdg-open *should* be supported by recent Gnome, KDE, Xfce
919                 import traceback
920                 traceback.print_exc()
921
922         return {'FINISHED'}
923
924
925 def _wm_doc_get_id(doc_id, do_url=True, url_prefix=""):
926
927     def operator_exists_pair(a, b):
928         # Not fast, this is only for docs.
929         return b in dir(getattr(bpy.ops, a))
930
931     def operator_exists_single(a):
932         a, b = a.partition("_OT_")[::2]
933         return operator_exists_pair(a.lower(), b)
934
935     id_split = doc_id.split(".")
936     url = rna = None
937
938     if len(id_split) == 1:  # rna, class
939         if do_url:
940             url = "%s/bpy.types.%s.html" % (url_prefix, id_split[0])
941         else:
942             rna = "bpy.types.%s" % id_split[0]
943
944     elif len(id_split) == 2:  # rna, class.prop
945         class_name, class_prop = id_split
946
947         # an operator (common case - just button referencing an op)
948         if operator_exists_pair(class_name, class_prop):
949             if do_url:
950                 url = (
951                     "%s/bpy.ops.%s.html#bpy.ops.%s.%s" %
952                     (url_prefix, class_name, class_name, class_prop)
953                 )
954             else:
955                 rna = "bpy.ops.%s.%s" % (class_name, class_prop)
956         elif operator_exists_single(class_name):
957             # note: ignore the prop name since we don't have a way to link into it
958             class_name, class_prop = class_name.split("_OT_", 1)
959             class_name = class_name.lower()
960             if do_url:
961                 url = (
962                     "%s/bpy.ops.%s.html#bpy.ops.%s.%s" %
963                     (url_prefix, class_name, class_name, class_prop)
964                 )
965             else:
966                 rna = "bpy.ops.%s.%s" % (class_name, class_prop)
967         else:
968             # an RNA setting, common case
969             rna_class = getattr(bpy.types, class_name)
970
971             # detect if this is a inherited member and use that name instead
972             rna_parent = rna_class.bl_rna
973             rna_prop = rna_parent.properties.get(class_prop)
974             if rna_prop:
975                 rna_parent = rna_parent.base
976                 while rna_parent and rna_prop == rna_parent.properties.get(class_prop):
977                     class_name = rna_parent.identifier
978                     rna_parent = rna_parent.base
979
980                 if do_url:
981                     url = (
982                         "%s/bpy.types.%s.html#bpy.types.%s.%s" %
983                         (url_prefix, class_name, class_name, class_prop)
984                     )
985                 else:
986                     rna = "bpy.types.%s.%s" % (class_name, class_prop)
987             else:
988                 # We assume this is custom property, only try to generate generic url/rna_id...
989                 if do_url:
990                     url = ("%s/bpy.types.bpy_struct.html#bpy.types.bpy_struct.items" % (url_prefix,))
991                 else:
992                     rna = "bpy.types.bpy_struct"
993
994     return url if do_url else rna
995
996
997 class WM_OT_doc_view_manual(Operator):
998     """Load online manual"""
999     bl_idname = "wm.doc_view_manual"
1000     bl_label = "View Manual"
1001
1002     doc_id: doc_id
1003
1004     @staticmethod
1005     def _find_reference(rna_id, url_mapping, verbose=True):
1006         if verbose:
1007             print("online manual check for: '%s'... " % rna_id)
1008         from fnmatch import fnmatchcase
1009         # XXX, for some reason all RNA ID's are stored lowercase
1010         # Adding case into all ID's isn't worth the hassle so force lowercase.
1011         rna_id = rna_id.lower()
1012         for pattern, url_suffix in url_mapping:
1013             if fnmatchcase(rna_id, pattern):
1014                 if verbose:
1015                     print("            match found: '%s' --> '%s'" % (pattern, url_suffix))
1016                 return url_suffix
1017         if verbose:
1018             print("match not found")
1019         return None
1020
1021     @staticmethod
1022     def _lookup_rna_url(rna_id, verbose=True):
1023         for prefix, url_manual_mapping in bpy.utils.manual_map():
1024             rna_ref = WM_OT_doc_view_manual._find_reference(rna_id, url_manual_mapping, verbose=verbose)
1025             if rna_ref is not None:
1026                 url = prefix + rna_ref
1027                 return url
1028
1029     def execute(self, context):
1030         rna_id = _wm_doc_get_id(self.doc_id, do_url=False)
1031         if rna_id is None:
1032             return {'PASS_THROUGH'}
1033
1034         url = self._lookup_rna_url(rna_id)
1035
1036         if url is None:
1037             self.report(
1038                 {'WARNING'},
1039                 "No reference available %r, "
1040                 "Update info in 'rna_manual_reference.py' "
1041                 "or callback to bpy.utils.manual_map()" %
1042                 self.doc_id
1043             )
1044             return {'CANCELLED'}
1045         else:
1046             import webbrowser
1047             webbrowser.open(url)
1048             return {'FINISHED'}
1049
1050
1051 class WM_OT_doc_view(Operator):
1052     """Load online reference docs"""
1053     bl_idname = "wm.doc_view"
1054     bl_label = "View Documentation"
1055
1056     doc_id: doc_id
1057     if bpy.app.version_cycle == "release":
1058         _prefix = ("https://docs.blender.org/api/blender_python_api_current")
1059     else:
1060         _prefix = ("https://docs.blender.org/api/blender_python_api_master")
1061
1062     def execute(self, context):
1063         url = _wm_doc_get_id(self.doc_id, do_url=True, url_prefix=self._prefix)
1064         if url is None:
1065             return {'PASS_THROUGH'}
1066
1067         import webbrowser
1068         webbrowser.open(url)
1069
1070         return {'FINISHED'}
1071
1072
1073 rna_path = StringProperty(
1074     name="Property Edit",
1075     description="Property data_path edit",
1076     maxlen=1024,
1077     options={'HIDDEN'},
1078 )
1079
1080 rna_value = StringProperty(
1081     name="Property Value",
1082     description="Property value edit",
1083     maxlen=1024,
1084 )
1085
1086 rna_property = StringProperty(
1087     name="Property Name",
1088     description="Property name edit",
1089     maxlen=1024,
1090 )
1091
1092 rna_min = FloatProperty(
1093     name="Min",
1094     default=-10000.0,
1095     precision=3,
1096 )
1097
1098 rna_max = FloatProperty(
1099     name="Max",
1100     default=10000.0,
1101     precision=3,
1102 )
1103
1104 rna_use_soft_limits = BoolProperty(
1105     name="Use Soft Limits",
1106 )
1107
1108 rna_is_overridable_static = BoolProperty(
1109     name="Is Statically Overridable",
1110     default=False,
1111 )
1112
1113
1114 class WM_OT_properties_edit(Operator):
1115     bl_idname = "wm.properties_edit"
1116     bl_label = "Edit Property"
1117     # register only because invoke_props_popup requires.
1118     bl_options = {'REGISTER', 'INTERNAL'}
1119
1120     data_path: rna_path
1121     property: rna_property
1122     value: rna_value
1123     min: rna_min
1124     max: rna_max
1125     use_soft_limits: rna_use_soft_limits
1126     is_overridable_static: rna_is_overridable_static
1127     soft_min: rna_min
1128     soft_max: rna_max
1129     description: StringProperty(
1130         name="Tooltip",
1131     )
1132
1133     def _cmp_props_get(self):
1134         # Changing these properties will refresh the UI
1135         return {
1136             "use_soft_limits": self.use_soft_limits,
1137             "soft_range": (self.soft_min, self.soft_max),
1138             "hard_range": (self.min, self.max),
1139         }
1140
1141     def execute(self, context):
1142         from rna_prop_ui import (
1143             rna_idprop_ui_prop_get,
1144             rna_idprop_ui_prop_clear,
1145             rna_idprop_ui_prop_update,
1146         )
1147
1148         data_path = self.data_path
1149         value = self.value
1150         prop = self.property
1151
1152         prop_old = getattr(self, "_last_prop", [None])[0]
1153
1154         if prop_old is None:
1155             self.report({'ERROR'}, "Direct execution not supported")
1156             return {'CANCELLED'}
1157
1158         try:
1159             value_eval = eval(value)
1160             # assert else None -> None, not "None", see [#33431]
1161             assert(type(value_eval) in {str, float, int, bool, tuple, list})
1162         except:
1163             value_eval = value
1164
1165         # First remove
1166         item = eval("context.%s" % data_path)
1167         prop_type_old = type(item[prop_old])
1168
1169         rna_idprop_ui_prop_clear(item, prop_old)
1170         exec_str = "del item[%r]" % prop_old
1171         # print(exec_str)
1172         exec(exec_str)
1173
1174         # Reassign
1175         exec_str = "item[%r] = %s" % (prop, repr(value_eval))
1176         # print(exec_str)
1177         exec(exec_str)
1178
1179         exec_str = "item.property_overridable_static_set('[\"%s\"]', %s)" % (prop, self.is_overridable_static)
1180         exec(exec_str)
1181
1182         rna_idprop_ui_prop_update(item, prop)
1183
1184         self._last_prop[:] = [prop]
1185
1186         prop_type = type(item[prop])
1187
1188         prop_ui = rna_idprop_ui_prop_get(item, prop)
1189
1190         if prop_type in {float, int}:
1191             prop_ui["min"] = prop_type(self.min)
1192             prop_ui["max"] = prop_type(self.max)
1193
1194             if self.use_soft_limits:
1195                 prop_ui["soft_min"] = prop_type(self.soft_min)
1196                 prop_ui["soft_max"] = prop_type(self.soft_max)
1197             else:
1198                 prop_ui["soft_min"] = prop_type(self.min)
1199                 prop_ui["soft_max"] = prop_type(self.max)
1200
1201         prop_ui["description"] = self.description
1202
1203         # If we have changed the type of the property, update its potential anim curves!
1204         if prop_type_old != prop_type:
1205             data_path = '["%s"]' % bpy.utils.escape_identifier(prop)
1206             done = set()
1207
1208             def _update(fcurves):
1209                 for fcu in fcurves:
1210                     if fcu not in done and fcu.data_path == data_path:
1211                         fcu.update_autoflags(item)
1212                         done.add(fcu)
1213
1214             def _update_strips(strips):
1215                 for st in strips:
1216                     if st.type == 'CLIP' and st.action:
1217                         _update(st.action.fcurves)
1218                     elif st.type == 'META':
1219                         _update_strips(st.strips)
1220
1221             adt = getattr(item, "animation_data", None)
1222             if adt is not None:
1223                 if adt.action:
1224                     _update(adt.action.fcurves)
1225                 if adt.drivers:
1226                     _update(adt.drivers)
1227                 if adt.nla_tracks:
1228                     for nt in adt.nla_tracks:
1229                         _update_strips(nt.strips)
1230
1231         # otherwise existing buttons which reference freed
1232         # memory may crash blender [#26510]
1233         # context.area.tag_redraw()
1234         for win in context.window_manager.windows:
1235             for area in win.screen.areas:
1236                 area.tag_redraw()
1237
1238         return {'FINISHED'}
1239
1240     def invoke(self, context, event):
1241         from rna_prop_ui import rna_idprop_ui_prop_get
1242
1243         data_path = self.data_path
1244
1245         if not data_path:
1246             self.report({'ERROR'}, "Data path not set")
1247             return {'CANCELLED'}
1248
1249         self._last_prop = [self.property]
1250
1251         item = eval("context.%s" % data_path)
1252
1253         # setup defaults
1254         prop_ui = rna_idprop_ui_prop_get(item, self.property, False)  # don't create
1255         if prop_ui:
1256             self.min = prop_ui.get("min", -1000000000)
1257             self.max = prop_ui.get("max", 1000000000)
1258             self.description = prop_ui.get("description", "")
1259
1260             self.soft_min = prop_ui.get("soft_min", self.min)
1261             self.soft_max = prop_ui.get("soft_max", self.max)
1262             self.use_soft_limits = (
1263                 self.min != self.soft_min or
1264                 self.max != self.soft_max
1265             )
1266
1267         # store for comparison
1268         self._cmp_props = self._cmp_props_get()
1269
1270         wm = context.window_manager
1271         return wm.invoke_props_dialog(self)
1272
1273     def check(self, context):
1274         cmp_props = self._cmp_props_get()
1275         changed = False
1276         if self._cmp_props != cmp_props:
1277             if cmp_props["use_soft_limits"]:
1278                 if cmp_props["soft_range"] != self._cmp_props["soft_range"]:
1279                     self.min = min(self.min, self.soft_min)
1280                     self.max = max(self.max, self.soft_max)
1281                     changed = True
1282                 if cmp_props["hard_range"] != self._cmp_props["hard_range"]:
1283                     self.soft_min = max(self.min, self.soft_min)
1284                     self.soft_max = min(self.max, self.soft_max)
1285                     changed = True
1286             else:
1287                 if cmp_props["soft_range"] != cmp_props["hard_range"]:
1288                     self.soft_min = self.min
1289                     self.soft_max = self.max
1290                     changed = True
1291
1292             changed |= (cmp_props["use_soft_limits"] != self._cmp_props["use_soft_limits"])
1293
1294             if changed:
1295                 cmp_props = self._cmp_props_get()
1296
1297             self._cmp_props = cmp_props
1298
1299         return changed
1300
1301     def draw(self, context):
1302         layout = self.layout
1303         layout.prop(self, "property")
1304         layout.prop(self, "value")
1305         row = layout.row(align=True)
1306         row.prop(self, "min")
1307         row.prop(self, "max")
1308
1309         row = layout.row()
1310         row.prop(self, "use_soft_limits")
1311         row.prop(self, "is_overridable_static")
1312
1313         row = layout.row(align=True)
1314         row.enabled = self.use_soft_limits
1315         row.prop(self, "soft_min", text="Soft Min")
1316         row.prop(self, "soft_max", text="Soft Max")
1317         layout.prop(self, "description")
1318
1319
1320 class WM_OT_properties_add(Operator):
1321     bl_idname = "wm.properties_add"
1322     bl_label = "Add Property"
1323     bl_options = {'UNDO', 'INTERNAL'}
1324
1325     data_path: rna_path
1326
1327     def execute(self, context):
1328         from rna_prop_ui import (
1329             rna_idprop_ui_prop_get,
1330             rna_idprop_ui_prop_update,
1331         )
1332
1333         data_path = self.data_path
1334         item = eval("context.%s" % data_path)
1335
1336         def unique_name(names):
1337             prop = "prop"
1338             prop_new = prop
1339             i = 1
1340             while prop_new in names:
1341                 prop_new = prop + str(i)
1342                 i += 1
1343
1344             return prop_new
1345
1346         prop = unique_name({
1347             *item.keys(),
1348             *type(item).bl_rna.properties.keys(),
1349         })
1350
1351         item[prop] = 1.0
1352         rna_idprop_ui_prop_update(item, prop)
1353
1354         # not essential, but without this we get [#31661]
1355         prop_ui = rna_idprop_ui_prop_get(item, prop)
1356         prop_ui["soft_min"] = prop_ui["min"] = 0.0
1357         prop_ui["soft_max"] = prop_ui["max"] = 1.0
1358
1359         return {'FINISHED'}
1360
1361
1362 class WM_OT_properties_context_change(Operator):
1363     """Jump to a different tab inside the properties editor"""
1364     bl_idname = "wm.properties_context_change"
1365     bl_label = ""
1366     bl_options = {'INTERNAL'}
1367
1368     context: StringProperty(
1369         name="Context",
1370         maxlen=64,
1371     )
1372
1373     def execute(self, context):
1374         context.space_data.context = self.context
1375         return {'FINISHED'}
1376
1377
1378 class WM_OT_properties_remove(Operator):
1379     """Internal use (edit a property data_path)"""
1380     bl_idname = "wm.properties_remove"
1381     bl_label = "Remove Property"
1382     bl_options = {'UNDO', 'INTERNAL'}
1383
1384     data_path: rna_path
1385     property: rna_property
1386
1387     def execute(self, context):
1388         from rna_prop_ui import (
1389             rna_idprop_ui_prop_clear,
1390             rna_idprop_ui_prop_update,
1391         )
1392         data_path = self.data_path
1393         item = eval("context.%s" % data_path)
1394         prop = self.property
1395         rna_idprop_ui_prop_update(item, prop)
1396         del item[prop]
1397         rna_idprop_ui_prop_clear(item, prop)
1398
1399         return {'FINISHED'}
1400
1401
1402 class WM_OT_keyconfig_activate(Operator):
1403     bl_idname = "wm.keyconfig_activate"
1404     bl_label = "Activate Keyconfig"
1405
1406     filepath: StringProperty(
1407         subtype='FILE_PATH',
1408     )
1409
1410     def execute(self, context):
1411         if bpy.utils.keyconfig_set(self.filepath, report=self.report):
1412             return {'FINISHED'}
1413         else:
1414             return {'CANCELLED'}
1415
1416
1417 class WM_OT_appconfig_default(Operator):
1418     bl_idname = "wm.appconfig_default"
1419     bl_label = "Default Application Configuration"
1420
1421     def execute(self, context):
1422         import os
1423
1424         context.window_manager.keyconfigs.active = context.window_manager.keyconfigs.default
1425
1426         filepath = os.path.join(bpy.utils.preset_paths("interaction")[0], "blender.py")
1427
1428         if os.path.exists(filepath):
1429             bpy.ops.script.execute_preset(
1430                 filepath=filepath,
1431                 menu_idname="USERPREF_MT_interaction_presets",
1432             )
1433
1434         return {'FINISHED'}
1435
1436
1437 class WM_OT_appconfig_activate(Operator):
1438     bl_idname = "wm.appconfig_activate"
1439     bl_label = "Activate Application Configuration"
1440
1441     filepath: StringProperty(
1442         subtype='FILE_PATH',
1443     )
1444
1445     def execute(self, context):
1446         import os
1447         bpy.utils.keyconfig_set(self.filepath)
1448
1449         filepath = self.filepath.replace("keyconfig", "interaction")
1450
1451         if os.path.exists(filepath):
1452             bpy.ops.script.execute_preset(
1453                 filepath=filepath,
1454                 menu_idname="USERPREF_MT_interaction_presets",
1455             )
1456
1457         return {'FINISHED'}
1458
1459
1460 class WM_OT_sysinfo(Operator):
1461     """Generate system information, saved into a text file"""
1462
1463     bl_idname = "wm.sysinfo"
1464     bl_label = "Save System Info"
1465
1466     filepath: StringProperty(
1467         subtype='FILE_PATH',
1468         options={'SKIP_SAVE'},
1469     )
1470
1471     def execute(self, context):
1472         import sys_info
1473         sys_info.write_sysinfo(self.filepath)
1474         return {'FINISHED'}
1475
1476     def invoke(self, context, event):
1477         import os
1478
1479         if not self.filepath:
1480             self.filepath = os.path.join(
1481                 os.path.expanduser("~"), "system-info.txt")
1482
1483         wm = context.window_manager
1484         wm.fileselect_add(self)
1485         return {'RUNNING_MODAL'}
1486
1487
1488 class WM_OT_copy_prev_settings(Operator):
1489     """Copy settings from previous version"""
1490     bl_idname = "wm.copy_prev_settings"
1491     bl_label = "Copy Previous Settings"
1492
1493     def execute(self, context):
1494         import os
1495         import shutil
1496         ver = bpy.app.version
1497         ver_old = ((ver[0] * 100) + ver[1]) - 1
1498         path_src = bpy.utils.resource_path('USER', ver_old // 100, ver_old % 100)
1499         path_dst = bpy.utils.resource_path('USER')
1500
1501         if os.path.isdir(path_dst):
1502             self.report({'ERROR'}, "Target path %r exists" % path_dst)
1503         elif not os.path.isdir(path_src):
1504             self.report({'ERROR'}, "Source path %r does not exist" % path_src)
1505         else:
1506             shutil.copytree(path_src, path_dst, symlinks=True)
1507
1508             # reload recent-files.txt
1509             bpy.ops.wm.read_history()
1510
1511             # don't loose users work if they open the splash later.
1512             if bpy.data.is_saved is bpy.data.is_dirty is False:
1513                 bpy.ops.wm.read_homefile()
1514             else:
1515                 self.report({'INFO'}, "Reload Start-Up file to restore settings")
1516
1517             return {'FINISHED'}
1518
1519         return {'CANCELLED'}
1520
1521
1522 class WM_OT_keyconfig_test(Operator):
1523     """Test key-config for conflicts"""
1524     bl_idname = "wm.keyconfig_test"
1525     bl_label = "Test Key Configuration for Conflicts"
1526
1527     def execute(self, context):
1528         from bpy_extras import keyconfig_utils
1529
1530         wm = context.window_manager
1531         kc = wm.keyconfigs.default
1532
1533         if keyconfig_utils.keyconfig_test(kc):
1534             print("CONFLICT")
1535
1536         return {'FINISHED'}
1537
1538
1539 class WM_OT_keyconfig_import(Operator):
1540     """Import key configuration from a python script"""
1541     bl_idname = "wm.keyconfig_import"
1542     bl_label = "Import Key Configuration..."
1543
1544     filepath: StringProperty(
1545         subtype='FILE_PATH',
1546         default="keymap.py",
1547     )
1548     filter_folder: BoolProperty(
1549         name="Filter folders",
1550         default=True,
1551         options={'HIDDEN'},
1552     )
1553     filter_text: BoolProperty(
1554         name="Filter text",
1555         default=True,
1556         options={'HIDDEN'},
1557     )
1558     filter_python: BoolProperty(
1559         name="Filter python",
1560         default=True,
1561         options={'HIDDEN'},
1562     )
1563     keep_original: BoolProperty(
1564         name="Keep original",
1565         description="Keep original file after copying to configuration folder",
1566         default=True,
1567     )
1568
1569     def execute(self, context):
1570         import os
1571         from os.path import basename
1572         import shutil
1573
1574         if not self.filepath:
1575             self.report({'ERROR'}, "Filepath not set")
1576             return {'CANCELLED'}
1577
1578         config_name = basename(self.filepath)
1579
1580         path = bpy.utils.user_resource('SCRIPTS', os.path.join("presets", "keyconfig"), create=True)
1581         path = os.path.join(path, config_name)
1582
1583         try:
1584             if self.keep_original:
1585                 shutil.copy(self.filepath, path)
1586             else:
1587                 shutil.move(self.filepath, path)
1588         except Exception as ex:
1589             self.report({'ERROR'}, "Installing keymap failed: %s" % ex)
1590             return {'CANCELLED'}
1591
1592         # sneaky way to check we're actually running the code.
1593         if bpy.utils.keyconfig_set(path, report=self.report):
1594             return {'FINISHED'}
1595         else:
1596             return {'CANCELLED'}
1597
1598     def invoke(self, context, event):
1599         wm = context.window_manager
1600         wm.fileselect_add(self)
1601         return {'RUNNING_MODAL'}
1602
1603 # This operator is also used by interaction presets saving - AddPresetBase
1604
1605
1606 class WM_OT_keyconfig_export(Operator):
1607     """Export key configuration to a python script"""
1608     bl_idname = "wm.keyconfig_export"
1609     bl_label = "Export Key Configuration..."
1610
1611     all: BoolProperty(
1612         name="All Keymaps",
1613         default=False,
1614         description="Write all keymaps (not just user modified)",
1615     )
1616     filepath: StringProperty(
1617         subtype='FILE_PATH',
1618         default="keymap.py",
1619     )
1620     filter_folder: BoolProperty(
1621         name="Filter folders",
1622         default=True,
1623         options={'HIDDEN'},
1624     )
1625     filter_text: BoolProperty(
1626         name="Filter text",
1627         default=True,
1628         options={'HIDDEN'},
1629     )
1630     filter_python: BoolProperty(
1631         name="Filter python",
1632         default=True,
1633         options={'HIDDEN'},
1634     )
1635
1636     def execute(self, context):
1637         from bpy_extras import keyconfig_utils
1638
1639         if not self.filepath:
1640             raise Exception("Filepath not set")
1641
1642         if not self.filepath.endswith(".py"):
1643             self.filepath += ".py"
1644
1645         wm = context.window_manager
1646
1647         keyconfig_utils.keyconfig_export_as_data(
1648             wm,
1649             wm.keyconfigs.active,
1650             self.filepath,
1651             all_keymaps=self.all,
1652         )
1653
1654         return {'FINISHED'}
1655
1656     def invoke(self, context, event):
1657         wm = context.window_manager
1658         wm.fileselect_add(self)
1659         return {'RUNNING_MODAL'}
1660
1661
1662 class WM_OT_keymap_restore(Operator):
1663     """Restore key map(s)"""
1664     bl_idname = "wm.keymap_restore"
1665     bl_label = "Restore Key Map(s)"
1666
1667     all: BoolProperty(
1668         name="All Keymaps",
1669         description="Restore all keymaps to default",
1670     )
1671
1672     def execute(self, context):
1673         wm = context.window_manager
1674
1675         if self.all:
1676             for km in wm.keyconfigs.user.keymaps:
1677                 km.restore_to_default()
1678         else:
1679             km = context.keymap
1680             km.restore_to_default()
1681
1682         return {'FINISHED'}
1683
1684
1685 class WM_OT_keyitem_restore(Operator):
1686     """Restore key map item"""
1687     bl_idname = "wm.keyitem_restore"
1688     bl_label = "Restore Key Map Item"
1689
1690     item_id: IntProperty(
1691         name="Item Identifier",
1692         description="Identifier of the item to remove",
1693     )
1694
1695     @classmethod
1696     def poll(cls, context):
1697         keymap = getattr(context, "keymap", None)
1698         return keymap
1699
1700     def execute(self, context):
1701         km = context.keymap
1702         kmi = km.keymap_items.from_id(self.item_id)
1703
1704         if (not kmi.is_user_defined) and kmi.is_user_modified:
1705             km.restore_item_to_default(kmi)
1706
1707         return {'FINISHED'}
1708
1709
1710 class WM_OT_keyitem_add(Operator):
1711     """Add key map item"""
1712     bl_idname = "wm.keyitem_add"
1713     bl_label = "Add Key Map Item"
1714
1715     def execute(self, context):
1716         km = context.keymap
1717
1718         if km.is_modal:
1719             km.keymap_items.new_modal("", 'A', 'PRESS')
1720         else:
1721             km.keymap_items.new("none", 'A', 'PRESS')
1722
1723         # clear filter and expand keymap so we can see the newly added item
1724         if context.space_data.filter_text != "":
1725             context.space_data.filter_text = ""
1726             km.show_expanded_items = True
1727             km.show_expanded_children = True
1728
1729         return {'FINISHED'}
1730
1731
1732 class WM_OT_keyitem_remove(Operator):
1733     """Remove key map item"""
1734     bl_idname = "wm.keyitem_remove"
1735     bl_label = "Remove Key Map Item"
1736
1737     item_id: IntProperty(
1738         name="Item Identifier",
1739         description="Identifier of the item to remove",
1740     )
1741
1742     @classmethod
1743     def poll(cls, context):
1744         return hasattr(context, "keymap")
1745
1746     def execute(self, context):
1747         km = context.keymap
1748         kmi = km.keymap_items.from_id(self.item_id)
1749         km.keymap_items.remove(kmi)
1750         return {'FINISHED'}
1751
1752
1753 class WM_OT_keyconfig_remove(Operator):
1754     """Remove key config"""
1755     bl_idname = "wm.keyconfig_remove"
1756     bl_label = "Remove Key Config"
1757
1758     @classmethod
1759     def poll(cls, context):
1760         wm = context.window_manager
1761         keyconf = wm.keyconfigs.active
1762         return keyconf and keyconf.is_user_defined
1763
1764     def execute(self, context):
1765         wm = context.window_manager
1766         keyconfig = wm.keyconfigs.active
1767         wm.keyconfigs.remove(keyconfig)
1768         return {'FINISHED'}
1769
1770
1771 class WM_OT_operator_cheat_sheet(Operator):
1772     """List all the Operators in a text-block, useful for scripting"""
1773     bl_idname = "wm.operator_cheat_sheet"
1774     bl_label = "Operator Cheat Sheet"
1775
1776     def execute(self, context):
1777         op_strings = []
1778         tot = 0
1779         for op_module_name in dir(bpy.ops):
1780             op_module = getattr(bpy.ops, op_module_name)
1781             for op_submodule_name in dir(op_module):
1782                 op = getattr(op_module, op_submodule_name)
1783                 text = repr(op)
1784                 if text.split("\n")[-1].startswith("bpy.ops."):
1785                     op_strings.append(text)
1786                     tot += 1
1787
1788             op_strings.append('')
1789
1790         textblock = bpy.data.texts.new("OperatorList.txt")
1791         textblock.write('# %d Operators\n\n' % tot)
1792         textblock.write('\n'.join(op_strings))
1793         self.report({'INFO'}, "See OperatorList.txt textblock")
1794         return {'FINISHED'}
1795
1796
1797 # -----------------------------------------------------------------------------
1798 # Add-on Operators
1799
1800 class WM_OT_addon_enable(Operator):
1801     """Enable an add-on"""
1802     bl_idname = "wm.addon_enable"
1803     bl_label = "Enable Add-on"
1804
1805     module: StringProperty(
1806         name="Module",
1807         description="Module name of the add-on to enable",
1808     )
1809
1810     def execute(self, context):
1811         import addon_utils
1812
1813         err_str = ""
1814
1815         def err_cb(ex):
1816             import traceback
1817             nonlocal err_str
1818             err_str = traceback.format_exc()
1819             print(err_str)
1820
1821         mod = addon_utils.enable(self.module, default_set=True, handle_error=err_cb)
1822
1823         if mod:
1824             info = addon_utils.module_bl_info(mod)
1825
1826             info_ver = info.get("blender", (0, 0, 0))
1827
1828             if info_ver > bpy.app.version:
1829                 self.report(
1830                     {'WARNING'},
1831                     "This script was written Blender "
1832                     "version %d.%d.%d and might not "
1833                     "function (correctly), "
1834                     "though it is enabled" %
1835                     info_ver
1836                 )
1837             return {'FINISHED'}
1838         else:
1839
1840             if err_str:
1841                 self.report({'ERROR'}, err_str)
1842
1843             return {'CANCELLED'}
1844
1845
1846 class WM_OT_addon_disable(Operator):
1847     """Disable an add-on"""
1848     bl_idname = "wm.addon_disable"
1849     bl_label = "Disable Add-on"
1850
1851     module: StringProperty(
1852         name="Module",
1853         description="Module name of the add-on to disable",
1854     )
1855
1856     def execute(self, context):
1857         import addon_utils
1858
1859         err_str = ""
1860
1861         def err_cb(ex):
1862             import traceback
1863             nonlocal err_str
1864             err_str = traceback.format_exc()
1865             print(err_str)
1866
1867         addon_utils.disable(self.module, default_set=True, handle_error=err_cb)
1868
1869         if err_str:
1870             self.report({'ERROR'}, err_str)
1871
1872         return {'FINISHED'}
1873
1874
1875 class WM_OT_owner_enable(Operator):
1876     """Enable workspace owner ID"""
1877     bl_idname = "wm.owner_enable"
1878     bl_label = "Enable Add-on"
1879
1880     owner_id: StringProperty(
1881         name="UI Tag",
1882     )
1883
1884     def execute(self, context):
1885         workspace = context.workspace
1886         workspace.owner_ids.new(self.owner_id)
1887         return {'FINISHED'}
1888
1889
1890 class WM_OT_owner_disable(Operator):
1891     """Enable workspace owner ID"""
1892     bl_idname = "wm.owner_disable"
1893     bl_label = "Disable UI Tag"
1894
1895     owner_id: StringProperty(
1896         name="UI Tag",
1897     )
1898
1899     def execute(self, context):
1900         workspace = context.workspace
1901         owner_id = workspace.owner_ids[self.owner_id]
1902         workspace.owner_ids.remove(owner_id)
1903         return {'FINISHED'}
1904
1905
1906 class WM_OT_theme_install(Operator):
1907     """Load and apply a Blender XML theme file"""
1908     bl_idname = "wm.theme_install"
1909     bl_label = "Install Theme..."
1910
1911     overwrite: BoolProperty(
1912         name="Overwrite",
1913         description="Remove existing theme file if exists",
1914         default=True,
1915     )
1916     filepath: StringProperty(
1917         subtype='FILE_PATH',
1918     )
1919     filter_folder: BoolProperty(
1920         name="Filter folders",
1921         default=True,
1922         options={'HIDDEN'},
1923     )
1924     filter_glob: StringProperty(
1925         default="*.xml",
1926         options={'HIDDEN'},
1927     )
1928
1929     def execute(self, context):
1930         import os
1931         import shutil
1932         import traceback
1933
1934         xmlfile = self.filepath
1935
1936         path_themes = bpy.utils.user_resource('SCRIPTS', "presets/interface_theme", create=True)
1937
1938         if not path_themes:
1939             self.report({'ERROR'}, "Failed to get themes path")
1940             return {'CANCELLED'}
1941
1942         path_dest = os.path.join(path_themes, os.path.basename(xmlfile))
1943
1944         if not self.overwrite:
1945             if os.path.exists(path_dest):
1946                 self.report({'WARNING'}, "File already installed to %r\n" % path_dest)
1947                 return {'CANCELLED'}
1948
1949         try:
1950             shutil.copyfile(xmlfile, path_dest)
1951             bpy.ops.script.execute_preset(
1952                 filepath=path_dest,
1953                 menu_idname="USERPREF_MT_interface_theme_presets",
1954             )
1955
1956         except:
1957             traceback.print_exc()
1958             return {'CANCELLED'}
1959
1960         return {'FINISHED'}
1961
1962     def invoke(self, context, event):
1963         wm = context.window_manager
1964         wm.fileselect_add(self)
1965         return {'RUNNING_MODAL'}
1966
1967
1968 class WM_OT_addon_refresh(Operator):
1969     """Scan add-on directories for new modules"""
1970     bl_idname = "wm.addon_refresh"
1971     bl_label = "Refresh"
1972
1973     def execute(self, context):
1974         import addon_utils
1975
1976         addon_utils.modules_refresh()
1977
1978         return {'FINISHED'}
1979
1980
1981 # Note: shares some logic with WM_OT_app_template_install
1982 # but not enough to de-duplicate. Fixed here may apply to both.
1983 class WM_OT_addon_install(Operator):
1984     """Install an add-on"""
1985     bl_idname = "wm.addon_install"
1986     bl_label = "Install Add-on from File..."
1987
1988     overwrite: BoolProperty(
1989         name="Overwrite",
1990         description="Remove existing add-ons with the same ID",
1991         default=True,
1992     )
1993     target: EnumProperty(
1994         name="Target Path",
1995         items=(('DEFAULT', "Default", ""),
1996                ('PREFS', "User Prefs", "")),
1997     )
1998
1999     filepath: StringProperty(
2000         subtype='FILE_PATH',
2001     )
2002     filter_folder: BoolProperty(
2003         name="Filter folders",
2004         default=True,
2005         options={'HIDDEN'},
2006     )
2007     filter_python: BoolProperty(
2008         name="Filter python",
2009         default=True,
2010         options={'HIDDEN'},
2011     )
2012     filter_glob: StringProperty(
2013         default="*.py;*.zip",
2014         options={'HIDDEN'},
2015     )
2016
2017     def execute(self, context):
2018         import addon_utils
2019         import traceback
2020         import zipfile
2021         import shutil
2022         import os
2023
2024         pyfile = self.filepath
2025
2026         if self.target == 'DEFAULT':
2027             # don't use bpy.utils.script_paths("addons") because we may not be able to write to it.
2028             path_addons = bpy.utils.user_resource('SCRIPTS', "addons", create=True)
2029         else:
2030             path_addons = context.user_preferences.filepaths.script_directory
2031             if path_addons:
2032                 path_addons = os.path.join(path_addons, "addons")
2033
2034         if not path_addons:
2035             self.report({'ERROR'}, "Failed to get add-ons path")
2036             return {'CANCELLED'}
2037
2038         if not os.path.isdir(path_addons):
2039             try:
2040                 os.makedirs(path_addons, exist_ok=True)
2041             except:
2042                 traceback.print_exc()
2043
2044         # Check if we are installing from a target path,
2045         # doing so causes 2+ addons of same name or when the same from/to
2046         # location is used, removal of the file!
2047         addon_path = ""
2048         pyfile_dir = os.path.dirname(pyfile)
2049         for addon_path in addon_utils.paths():
2050             if os.path.samefile(pyfile_dir, addon_path):
2051                 self.report({'ERROR'}, "Source file is in the add-on search path: %r" % addon_path)
2052                 return {'CANCELLED'}
2053         del addon_path
2054         del pyfile_dir
2055         # done checking for exceptional case
2056
2057         addons_old = {mod.__name__ for mod in addon_utils.modules()}
2058
2059         # check to see if the file is in compressed format (.zip)
2060         if zipfile.is_zipfile(pyfile):
2061             try:
2062                 file_to_extract = zipfile.ZipFile(pyfile, 'r')
2063             except:
2064                 traceback.print_exc()
2065                 return {'CANCELLED'}
2066
2067             if self.overwrite:
2068                 for f in file_to_extract.namelist():
2069                     module_filesystem_remove(path_addons, f)
2070             else:
2071                 for f in file_to_extract.namelist():
2072                     path_dest = os.path.join(path_addons, os.path.basename(f))
2073                     if os.path.exists(path_dest):
2074                         self.report({'WARNING'}, "File already installed to %r\n" % path_dest)
2075                         return {'CANCELLED'}
2076
2077             try:  # extract the file to "addons"
2078                 file_to_extract.extractall(path_addons)
2079             except:
2080                 traceback.print_exc()
2081                 return {'CANCELLED'}
2082
2083         else:
2084             path_dest = os.path.join(path_addons, os.path.basename(pyfile))
2085
2086             if self.overwrite:
2087                 module_filesystem_remove(path_addons, os.path.basename(pyfile))
2088             elif os.path.exists(path_dest):
2089                 self.report({'WARNING'}, "File already installed to %r\n" % path_dest)
2090                 return {'CANCELLED'}
2091
2092             # if not compressed file just copy into the addon path
2093             try:
2094                 shutil.copyfile(pyfile, path_dest)
2095             except:
2096                 traceback.print_exc()
2097                 return {'CANCELLED'}
2098
2099         addons_new = {mod.__name__ for mod in addon_utils.modules()} - addons_old
2100         addons_new.discard("modules")
2101
2102         # disable any addons we may have enabled previously and removed.
2103         # this is unlikely but do just in case. bug [#23978]
2104         for new_addon in addons_new:
2105             addon_utils.disable(new_addon, default_set=True)
2106
2107         # possible the zip contains multiple addons, we could disallow this
2108         # but for now just use the first
2109         for mod in addon_utils.modules(refresh=False):
2110             if mod.__name__ in addons_new:
2111                 info = addon_utils.module_bl_info(mod)
2112
2113                 # show the newly installed addon.
2114                 context.window_manager.addon_filter = 'All'
2115                 context.window_manager.addon_search = info["name"]
2116                 break
2117
2118         # in case a new module path was created to install this addon.
2119         bpy.utils.refresh_script_paths()
2120
2121         # print message
2122         msg = (
2123             tip_("Modules Installed (%s) from %r into %r") %
2124             (", ".join(sorted(addons_new)), pyfile, path_addons)
2125         )
2126         print(msg)
2127         self.report({'INFO'}, msg)
2128
2129         return {'FINISHED'}
2130
2131     def invoke(self, context, event):
2132         wm = context.window_manager
2133         wm.fileselect_add(self)
2134         return {'RUNNING_MODAL'}
2135
2136
2137 class WM_OT_addon_remove(Operator):
2138     """Delete the add-on from the file system"""
2139     bl_idname = "wm.addon_remove"
2140     bl_label = "Remove Add-on"
2141
2142     module: StringProperty(
2143         name="Module",
2144         description="Module name of the add-on to remove",
2145     )
2146
2147     @staticmethod
2148     def path_from_addon(module):
2149         import os
2150         import addon_utils
2151
2152         for mod in addon_utils.modules():
2153             if mod.__name__ == module:
2154                 filepath = mod.__file__
2155                 if os.path.exists(filepath):
2156                     if os.path.splitext(os.path.basename(filepath))[0] == "__init__":
2157                         return os.path.dirname(filepath), True
2158                     else:
2159                         return filepath, False
2160         return None, False
2161
2162     def execute(self, context):
2163         import addon_utils
2164         import os
2165
2166         path, isdir = WM_OT_addon_remove.path_from_addon(self.module)
2167         if path is None:
2168             self.report({'WARNING'}, "Add-on path %r could not be found" % path)
2169             return {'CANCELLED'}
2170
2171         # in case its enabled
2172         addon_utils.disable(self.module, default_set=True)
2173
2174         import shutil
2175         if isdir:
2176             shutil.rmtree(path)
2177         else:
2178             os.remove(path)
2179
2180         addon_utils.modules_refresh()
2181
2182         context.area.tag_redraw()
2183         return {'FINISHED'}
2184
2185     # lame confirmation check
2186     def draw(self, context):
2187         self.layout.label(text="Remove Add-on: %r?" % self.module)
2188         path, isdir = WM_OT_addon_remove.path_from_addon(self.module)
2189         self.layout.label(text="Path: %r" % path)
2190
2191     def invoke(self, context, event):
2192         wm = context.window_manager
2193         return wm.invoke_props_dialog(self, width=600)
2194
2195
2196 class WM_OT_addon_expand(Operator):
2197     """Display information and preferences for this add-on"""
2198     bl_idname = "wm.addon_expand"
2199     bl_label = ""
2200     bl_options = {'INTERNAL'}
2201
2202     module: StringProperty(
2203         name="Module",
2204         description="Module name of the add-on to expand",
2205     )
2206
2207     def execute(self, context):
2208         import addon_utils
2209
2210         module_name = self.module
2211
2212         mod = addon_utils.addons_fake_modules.get(module_name)
2213         if mod is not None:
2214             info = addon_utils.module_bl_info(mod)
2215             info["show_expanded"] = not info["show_expanded"]
2216
2217         return {'FINISHED'}
2218
2219
2220 class WM_OT_addon_userpref_show(Operator):
2221     """Show add-on user preferences"""
2222     bl_idname = "wm.addon_userpref_show"
2223     bl_label = ""
2224     bl_options = {'INTERNAL'}
2225
2226     module: StringProperty(
2227         name="Module",
2228         description="Module name of the add-on to expand",
2229     )
2230
2231     def execute(self, context):
2232         import addon_utils
2233
2234         module_name = self.module
2235
2236         modules = addon_utils.modules(refresh=False)
2237         mod = addon_utils.addons_fake_modules.get(module_name)
2238         if mod is not None:
2239             info = addon_utils.module_bl_info(mod)
2240             info["show_expanded"] = True
2241
2242             context.user_preferences.active_section = 'ADDONS'
2243             context.window_manager.addon_filter = 'All'
2244             context.window_manager.addon_search = info["name"]
2245             bpy.ops.screen.userpref_show('INVOKE_DEFAULT')
2246
2247         return {'FINISHED'}
2248
2249
2250 # Note: shares some logic with WM_OT_addon_install
2251 # but not enough to de-duplicate. Fixes here may apply to both.
2252 class WM_OT_app_template_install(Operator):
2253     """Install an application-template"""
2254     bl_idname = "wm.app_template_install"
2255     bl_label = "Install Template from File..."
2256
2257     overwrite: BoolProperty(
2258         name="Overwrite",
2259         description="Remove existing template with the same ID",
2260         default=True,
2261     )
2262
2263     filepath: StringProperty(
2264         subtype='FILE_PATH',
2265     )
2266     filter_folder: BoolProperty(
2267         name="Filter folders",
2268         default=True,
2269         options={'HIDDEN'},
2270     )
2271     filter_glob: StringProperty(
2272         default="*.zip",
2273         options={'HIDDEN'},
2274     )
2275
2276     def execute(self, context):
2277         import traceback
2278         import zipfile
2279         import shutil
2280         import os
2281
2282         filepath = self.filepath
2283
2284         path_app_templates = bpy.utils.user_resource(
2285             'SCRIPTS', os.path.join("startup", "bl_app_templates_user"),
2286             create=True,
2287         )
2288
2289         if not path_app_templates:
2290             self.report({'ERROR'}, "Failed to get add-ons path")
2291             return {'CANCELLED'}
2292
2293         if not os.path.isdir(path_app_templates):
2294             try:
2295                 os.makedirs(path_app_templates, exist_ok=True)
2296             except:
2297                 traceback.print_exc()
2298
2299         app_templates_old = set(os.listdir(path_app_templates))
2300
2301         # check to see if the file is in compressed format (.zip)
2302         if zipfile.is_zipfile(filepath):
2303             try:
2304                 file_to_extract = zipfile.ZipFile(filepath, 'r')
2305             except:
2306                 traceback.print_exc()
2307                 return {'CANCELLED'}
2308
2309             if self.overwrite:
2310                 for f in file_to_extract.namelist():
2311                     module_filesystem_remove(path_app_templates, f)
2312             else:
2313                 for f in file_to_extract.namelist():
2314                     path_dest = os.path.join(path_app_templates, os.path.basename(f))
2315                     if os.path.exists(path_dest):
2316                         self.report({'WARNING'}, "File already installed to %r\n" % path_dest)
2317                         return {'CANCELLED'}
2318
2319             try:  # extract the file to "bl_app_templates_user"
2320                 file_to_extract.extractall(path_app_templates)
2321             except:
2322                 traceback.print_exc()
2323                 return {'CANCELLED'}
2324
2325         else:
2326             # Only support installing zipfiles
2327             self.report({'WARNING'}, "Expected a zip-file %r\n" % filepath)
2328             return {'CANCELLED'}
2329
2330         app_templates_new = set(os.listdir(path_app_templates)) - app_templates_old
2331
2332         # in case a new module path was created to install this addon.
2333         bpy.utils.refresh_script_paths()
2334
2335         # print message
2336         msg = (
2337             tip_("Template Installed (%s) from %r into %r") %
2338             (", ".join(sorted(app_templates_new)), filepath, path_app_templates)
2339         )
2340         print(msg)
2341         self.report({'INFO'}, msg)
2342
2343         return {'FINISHED'}
2344
2345     def invoke(self, context, event):
2346         wm = context.window_manager
2347         wm.fileselect_add(self)
2348         return {'RUNNING_MODAL'}
2349
2350
2351 class WM_OT_tool_set_by_name(Operator):
2352     """Set the tool by name (for keymaps)"""
2353     bl_idname = "wm.tool_set_by_name"
2354     bl_label = "Set Tool By Name"
2355
2356     name: StringProperty(
2357         name="Text",
2358         description="Display name of the tool",
2359     )
2360     cycle: BoolProperty(
2361         name="Cycle",
2362         description="Cycle through tools in this group",
2363         default=False,
2364         options={'SKIP_SAVE'},
2365     )
2366
2367     space_type: rna_space_type_prop
2368
2369     def execute(self, context):
2370         from bl_ui.space_toolsystem_common import (
2371             activate_by_name,
2372             activate_by_name_or_cycle,
2373         )
2374
2375         if self.properties.is_property_set("space_type"):
2376             space_type = self.space_type
2377         else:
2378             space_type = context.space_data.type
2379
2380         fn = activate_by_name_or_cycle if self.cycle else activate_by_name
2381         if fn(context, space_type, self.name):
2382             return {'FINISHED'}
2383         else:
2384             self.report({'WARNING'}, f"Tool {self.name!r} not found.")
2385             return {'CANCELLED'}
2386
2387
2388 class WM_OT_toolbar(Operator):
2389     bl_idname = "wm.toolbar"
2390     bl_label = "Toolbar"
2391
2392     @classmethod
2393     def poll(cls, context):
2394         return context.space_data is not None
2395
2396     def execute(self, context):
2397         from bl_ui.space_toolsystem_common import (
2398             ToolSelectPanelHelper,
2399             keymap_from_context,
2400         )
2401         space_type = context.space_data.type
2402
2403         cls = ToolSelectPanelHelper._tool_class_from_space_type(space_type)
2404         if cls is None:
2405             self.report({'WARNING'}, f"Toolbar not found for {space_type!r}")
2406             return {'CANCELLED'}
2407
2408         wm = context.window_manager
2409         keymap = keymap_from_context(context, space_type)
2410
2411         def draw_menu(popover, context):
2412             layout = popover.layout
2413
2414             layout.operator_context = 'INVOKE_REGION_WIN'
2415             layout.operator("wm.search_menu", text="Search Commands...", icon='VIEWZOOM')
2416
2417             cls.draw_cls(layout, context, detect_layout=False, scale_y=1.0)
2418
2419         wm.popover(draw_menu, ui_units_x=8, keymap=keymap)
2420         return {'FINISHED'}
2421
2422
2423 # Studio Light operations
2424 class WM_OT_studiolight_install(Operator):
2425     """Install a user defined studio light"""
2426     bl_idname = "wm.studiolight_install"
2427     bl_label = "Install Custom Studio Light"
2428
2429     files: CollectionProperty(
2430         name="File Path",
2431         type=OperatorFileListElement,
2432     )
2433     directory: StringProperty(
2434         subtype='DIR_PATH',
2435     )
2436     filter_folder: BoolProperty(
2437         name="Filter folders",
2438         default=True,
2439         options={'HIDDEN'},
2440     )
2441     filter_glob: StringProperty(
2442         default="*.png;*.jpg;*.hdr;*.exr",
2443         options={'HIDDEN'},
2444     )
2445     orientation: EnumProperty(
2446         items=(
2447             ('MATCAP', "MatCap", ""),
2448             ('WORLD', "World", ""),
2449             ('CAMERA', "Camera", ""),
2450         )
2451     )
2452
2453     def execute(self, context):
2454         import traceback
2455         import shutil
2456         import pathlib
2457         userpref = context.user_preferences
2458
2459         filepaths = [pathlib.Path(self.directory, e.name) for e in self.files]
2460         path_studiolights = bpy.utils.user_resource('DATAFILES')
2461
2462         if not path_studiolights:
2463             self.report({'ERROR'}, "Failed to get Studio Light path")
2464             return {'CANCELLED'}
2465
2466         path_studiolights = pathlib.Path(path_studiolights, "studiolights", self.orientation.lower())
2467         if not path_studiolights.exists():
2468             try:
2469                 path_studiolights.mkdir(parents=True, exist_ok=True)
2470             except:
2471                 traceback.print_exc()
2472
2473         for filepath in filepaths:
2474             shutil.copy(str(filepath), str(path_studiolights))
2475             userpref.studio_lights.new(str(path_studiolights.joinpath(filepath.name)), self.orientation)
2476
2477         # print message
2478         msg = (
2479             tip_("StudioLight Installed %r into %r") %
2480             (", ".join(str(x.name) for x in self.files), str(path_studiolights))
2481         )
2482         print(msg)
2483         self.report({'INFO'}, msg)
2484         return {'FINISHED'}
2485
2486     def invoke(self, context, event):
2487         wm = context.window_manager
2488         wm.fileselect_add(self)
2489         return {'RUNNING_MODAL'}
2490
2491
2492 class WM_OT_studiolight_uninstall(Operator):
2493     bl_idname = 'wm.studiolight_uninstall'
2494     bl_label = "Uninstall Studio Light"
2495     index: bpy.props.IntProperty()
2496
2497     def _remove_path(self, path):
2498         if path.exists():
2499             path.unlink()
2500
2501     def execute(self, context):
2502         import pathlib
2503         userpref = context.user_preferences
2504         for studio_light in userpref.studio_lights:
2505             if studio_light.index == self.index:
2506                 if len(studio_light.path) > 0:
2507                     self._remove_path(pathlib.Path(studio_light.path))
2508                 if len(studio_light.path_irr_cache) > 0:
2509                     self._remove_path(pathlib.Path(studio_light.path_irr_cache))
2510                 if len(studio_light.path_sh_cache) > 0:
2511                     self._remove_path(pathlib.Path(studio_light.path_sh_cache))
2512                 userpref.studio_lights.remove(studio_light)
2513                 return {'FINISHED'}
2514         return {'CANCELLED'}
2515
2516
2517 class WM_OT_studiolight_userpref_show(Operator):
2518     """Show light user preferences"""
2519     bl_idname = "wm.studiolight_userpref_show"
2520     bl_label = ""
2521     bl_options = {'INTERNAL'}
2522
2523     def execute(self, context):
2524         context.user_preferences.active_section = 'LIGHTS'
2525         bpy.ops.screen.userpref_show('INVOKE_DEFAULT')
2526         return {'FINISHED'}
2527
2528
2529 classes = (
2530     BRUSH_OT_active_index_set,
2531     WM_OT_addon_disable,
2532     WM_OT_addon_enable,
2533     WM_OT_addon_expand,
2534     WM_OT_addon_install,
2535     WM_OT_addon_refresh,
2536     WM_OT_addon_remove,
2537     WM_OT_addon_userpref_show,
2538     WM_OT_app_template_install,
2539     WM_OT_appconfig_activate,
2540     WM_OT_appconfig_default,
2541     WM_OT_context_collection_boolean_set,
2542     WM_OT_context_cycle_array,
2543     WM_OT_context_cycle_enum,
2544     WM_OT_context_cycle_int,
2545     WM_OT_context_menu_enum,
2546     WM_OT_context_modal_mouse,
2547     WM_OT_context_pie_enum,
2548     WM_OT_context_scale_float,
2549     WM_OT_context_scale_int,
2550     WM_OT_context_set_boolean,
2551     WM_OT_context_set_enum,
2552     WM_OT_context_set_float,
2553     WM_OT_context_set_id,
2554     WM_OT_context_set_int,
2555     WM_OT_context_set_string,
2556     WM_OT_context_set_value,
2557     WM_OT_context_toggle,
2558     WM_OT_context_toggle_enum,
2559     WM_OT_copy_prev_settings,
2560     WM_OT_doc_view,
2561     WM_OT_doc_view_manual,
2562     WM_OT_keyconfig_activate,
2563     WM_OT_keyconfig_export,
2564     WM_OT_keyconfig_import,
2565     WM_OT_keyconfig_remove,
2566     WM_OT_keyconfig_test,
2567     WM_OT_keyitem_add,
2568     WM_OT_keyitem_remove,
2569     WM_OT_keyitem_restore,
2570     WM_OT_keymap_restore,
2571     WM_OT_operator_cheat_sheet,
2572     WM_OT_operator_pie_enum,
2573     WM_OT_path_open,
2574     WM_OT_properties_add,
2575     WM_OT_properties_context_change,
2576     WM_OT_properties_edit,
2577     WM_OT_properties_remove,
2578     WM_OT_sysinfo,
2579     WM_OT_theme_install,
2580     WM_OT_owner_disable,
2581     WM_OT_owner_enable,
2582     WM_OT_url_open,
2583     WM_OT_studiolight_install,
2584     WM_OT_studiolight_uninstall,
2585     WM_OT_studiolight_userpref_show,
2586     WM_OT_tool_set_by_name,
2587     WM_OT_toolbar,
2588 )