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