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