ee669d172371a5c202557309a1281cc5e9d6d0e3
[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
1487         # Disable operator in case config path is overriden with environment
1488         # variable. That case has no automatic per-version configuration.
1489         userconfig_path = os.path.normpath(bpy.utils.user_resource('CONFIG'))
1490         new_userconfig_path = os.path.normpath(os.path.join(new, "config"))
1491         if userconfig_path != new_userconfig_path:
1492             return False
1493
1494         # Enable operator if new config path does not exist yet.
1495         if os.path.isdir(old) and not os.path.isdir(new):
1496             return True
1497
1498         # Enable operator also if there are no new user preference yet.
1499         old_userpref = os.path.join(old, "config", "userpref.blend")
1500         new_userpref = os.path.join(new, "config", "userpref.blend")
1501         return os.path.isfile(old_userpref) and not os.path.isfile(new_userpref)
1502
1503     def execute(self, context):
1504         import shutil
1505
1506         shutil.copytree(self._old_path(), self._new_path(), symlinks=True)
1507
1508         # reload recent-files.txt
1509         bpy.ops.wm.read_history()
1510
1511         # don't loose users work if they open the splash later.
1512         if bpy.data.is_saved is bpy.data.is_dirty is False:
1513             bpy.ops.wm.read_homefile()
1514         else:
1515             self.report({'INFO'}, "Reload Start-Up file to restore settings")
1516
1517         return {'FINISHED'}
1518
1519
1520 class WM_OT_keyconfig_test(Operator):
1521     """Test key-config for conflicts"""
1522     bl_idname = "wm.keyconfig_test"
1523     bl_label = "Test Key Configuration for Conflicts"
1524
1525     def execute(self, context):
1526         from bpy_extras import keyconfig_utils
1527
1528         wm = context.window_manager
1529         kc = wm.keyconfigs.default
1530
1531         if keyconfig_utils.keyconfig_test(kc):
1532             print("CONFLICT")
1533
1534         return {'FINISHED'}
1535
1536
1537 class WM_OT_keyconfig_import(Operator):
1538     """Import key configuration from a python script"""
1539     bl_idname = "wm.keyconfig_import"
1540     bl_label = "Import Key Configuration..."
1541
1542     filepath: StringProperty(
1543         subtype='FILE_PATH',
1544         default="keymap.py",
1545     )
1546     filter_folder: BoolProperty(
1547         name="Filter folders",
1548         default=True,
1549         options={'HIDDEN'},
1550     )
1551     filter_text: BoolProperty(
1552         name="Filter text",
1553         default=True,
1554         options={'HIDDEN'},
1555     )
1556     filter_python: BoolProperty(
1557         name="Filter python",
1558         default=True,
1559         options={'HIDDEN'},
1560     )
1561     keep_original: BoolProperty(
1562         name="Keep original",
1563         description="Keep original file after copying to configuration folder",
1564         default=True,
1565     )
1566
1567     def execute(self, context):
1568         import os
1569         from os.path import basename
1570         import shutil
1571
1572         if not self.filepath:
1573             self.report({'ERROR'}, "Filepath not set")
1574             return {'CANCELLED'}
1575
1576         config_name = basename(self.filepath)
1577
1578         path = bpy.utils.user_resource('SCRIPTS', os.path.join("presets", "keyconfig"), create=True)
1579         path = os.path.join(path, config_name)
1580
1581         try:
1582             if self.keep_original:
1583                 shutil.copy(self.filepath, path)
1584             else:
1585                 shutil.move(self.filepath, path)
1586         except Exception as ex:
1587             self.report({'ERROR'}, "Installing keymap failed: %s" % ex)
1588             return {'CANCELLED'}
1589
1590         # sneaky way to check we're actually running the code.
1591         if bpy.utils.keyconfig_set(path, report=self.report):
1592             return {'FINISHED'}
1593         else:
1594             return {'CANCELLED'}
1595
1596     def invoke(self, context, event):
1597         wm = context.window_manager
1598         wm.fileselect_add(self)
1599         return {'RUNNING_MODAL'}
1600
1601 # This operator is also used by interaction presets saving - AddPresetBase
1602
1603
1604 class WM_OT_keyconfig_export(Operator):
1605     """Export key configuration to a python script"""
1606     bl_idname = "wm.keyconfig_export"
1607     bl_label = "Export Key Configuration..."
1608
1609     all: BoolProperty(
1610         name="All Keymaps",
1611         default=False,
1612         description="Write all keymaps (not just user modified)",
1613     )
1614     filepath: StringProperty(
1615         subtype='FILE_PATH',
1616         default="keymap.py",
1617     )
1618     filter_folder: BoolProperty(
1619         name="Filter folders",
1620         default=True,
1621         options={'HIDDEN'},
1622     )
1623     filter_text: BoolProperty(
1624         name="Filter text",
1625         default=True,
1626         options={'HIDDEN'},
1627     )
1628     filter_python: BoolProperty(
1629         name="Filter python",
1630         default=True,
1631         options={'HIDDEN'},
1632     )
1633
1634     def execute(self, context):
1635         from bl_keymap_utils.io import keyconfig_export_as_data
1636
1637         if not self.filepath:
1638             raise Exception("Filepath not set")
1639
1640         if not self.filepath.endswith(".py"):
1641             self.filepath += ".py"
1642
1643         wm = context.window_manager
1644
1645         keyconfig_export_as_data(
1646             wm,
1647             wm.keyconfigs.active,
1648             self.filepath,
1649             all_keymaps=self.all,
1650         )
1651
1652         return {'FINISHED'}
1653
1654     def invoke(self, context, event):
1655         wm = context.window_manager
1656         wm.fileselect_add(self)
1657         return {'RUNNING_MODAL'}
1658
1659
1660 class WM_OT_keymap_restore(Operator):
1661     """Restore key map(s)"""
1662     bl_idname = "wm.keymap_restore"
1663     bl_label = "Restore Key Map(s)"
1664
1665     all: BoolProperty(
1666         name="All Keymaps",
1667         description="Restore all keymaps to default",
1668     )
1669
1670     def execute(self, context):
1671         wm = context.window_manager
1672
1673         if self.all:
1674             for km in wm.keyconfigs.user.keymaps:
1675                 km.restore_to_default()
1676         else:
1677             km = context.keymap
1678             km.restore_to_default()
1679
1680         return {'FINISHED'}
1681
1682
1683 class WM_OT_keyitem_restore(Operator):
1684     """Restore key map item"""
1685     bl_idname = "wm.keyitem_restore"
1686     bl_label = "Restore Key Map Item"
1687
1688     item_id: IntProperty(
1689         name="Item Identifier",
1690         description="Identifier of the item to remove",
1691     )
1692
1693     @classmethod
1694     def poll(cls, context):
1695         keymap = getattr(context, "keymap", None)
1696         return keymap
1697
1698     def execute(self, context):
1699         km = context.keymap
1700         kmi = km.keymap_items.from_id(self.item_id)
1701
1702         if (not kmi.is_user_defined) and kmi.is_user_modified:
1703             km.restore_item_to_default(kmi)
1704
1705         return {'FINISHED'}
1706
1707
1708 class WM_OT_keyitem_add(Operator):
1709     """Add key map item"""
1710     bl_idname = "wm.keyitem_add"
1711     bl_label = "Add Key Map Item"
1712
1713     def execute(self, context):
1714         km = context.keymap
1715
1716         if km.is_modal:
1717             km.keymap_items.new_modal("", 'A', 'PRESS')
1718         else:
1719             km.keymap_items.new("none", 'A', 'PRESS')
1720
1721         # clear filter and expand keymap so we can see the newly added item
1722         if context.space_data.filter_text != "":
1723             context.space_data.filter_text = ""
1724             km.show_expanded_items = True
1725             km.show_expanded_children = True
1726
1727         return {'FINISHED'}
1728
1729
1730 class WM_OT_keyitem_remove(Operator):
1731     """Remove key map item"""
1732     bl_idname = "wm.keyitem_remove"
1733     bl_label = "Remove Key Map Item"
1734
1735     item_id: IntProperty(
1736         name="Item Identifier",
1737         description="Identifier of the item to remove",
1738     )
1739
1740     @classmethod
1741     def poll(cls, context):
1742         return hasattr(context, "keymap")
1743
1744     def execute(self, context):
1745         km = context.keymap
1746         kmi = km.keymap_items.from_id(self.item_id)
1747         km.keymap_items.remove(kmi)
1748         return {'FINISHED'}
1749
1750
1751 class WM_OT_keyconfig_remove(Operator):
1752     """Remove key config"""
1753     bl_idname = "wm.keyconfig_remove"
1754     bl_label = "Remove Key Config"
1755
1756     @classmethod
1757     def poll(cls, context):
1758         wm = context.window_manager
1759         keyconf = wm.keyconfigs.active
1760         return keyconf and keyconf.is_user_defined
1761
1762     def execute(self, context):
1763         wm = context.window_manager
1764         keyconfig = wm.keyconfigs.active
1765         wm.keyconfigs.remove(keyconfig)
1766         return {'FINISHED'}
1767
1768
1769 class WM_OT_operator_cheat_sheet(Operator):
1770     """List all the Operators in a text-block, useful for scripting"""
1771     bl_idname = "wm.operator_cheat_sheet"
1772     bl_label = "Operator Cheat Sheet"
1773
1774     def execute(self, context):
1775         op_strings = []
1776         tot = 0
1777         for op_module_name in dir(bpy.ops):
1778             op_module = getattr(bpy.ops, op_module_name)
1779             for op_submodule_name in dir(op_module):
1780                 op = getattr(op_module, op_submodule_name)
1781                 text = repr(op)
1782                 if text.split("\n")[-1].startswith("bpy.ops."):
1783                     op_strings.append(text)
1784                     tot += 1
1785
1786             op_strings.append('')
1787
1788         textblock = bpy.data.texts.new("OperatorList.txt")
1789         textblock.write('# %d Operators\n\n' % tot)
1790         textblock.write('\n'.join(op_strings))
1791         self.report({'INFO'}, "See OperatorList.txt textblock")
1792         return {'FINISHED'}
1793
1794
1795 # -----------------------------------------------------------------------------
1796 # Add-on Operators
1797
1798 class WM_OT_addon_enable(Operator):
1799     """Enable an add-on"""
1800     bl_idname = "wm.addon_enable"
1801     bl_label = "Enable Add-on"
1802
1803     module: StringProperty(
1804         name="Module",
1805         description="Module name of the add-on to enable",
1806     )
1807
1808     def execute(self, context):
1809         import addon_utils
1810
1811         err_str = ""
1812
1813         def err_cb(ex):
1814             import traceback
1815             nonlocal err_str
1816             err_str = traceback.format_exc()
1817             print(err_str)
1818
1819         mod = addon_utils.enable(self.module, default_set=True, handle_error=err_cb)
1820
1821         if mod:
1822             info = addon_utils.module_bl_info(mod)
1823
1824             info_ver = info.get("blender", (0, 0, 0))
1825
1826             if info_ver > bpy.app.version:
1827                 self.report(
1828                     {'WARNING'},
1829                     "This script was written Blender "
1830                     "version %d.%d.%d and might not "
1831                     "function (correctly), "
1832                     "though it is enabled" %
1833                     info_ver
1834                 )
1835             return {'FINISHED'}
1836         else:
1837
1838             if err_str:
1839                 self.report({'ERROR'}, err_str)
1840
1841             return {'CANCELLED'}
1842
1843
1844 class WM_OT_addon_disable(Operator):
1845     """Disable an add-on"""
1846     bl_idname = "wm.addon_disable"
1847     bl_label = "Disable Add-on"
1848
1849     module: StringProperty(
1850         name="Module",
1851         description="Module name of the add-on to disable",
1852     )
1853
1854     def execute(self, context):
1855         import addon_utils
1856
1857         err_str = ""
1858
1859         def err_cb(ex):
1860             import traceback
1861             nonlocal err_str
1862             err_str = traceback.format_exc()
1863             print(err_str)
1864
1865         addon_utils.disable(self.module, default_set=True, handle_error=err_cb)
1866
1867         if err_str:
1868             self.report({'ERROR'}, err_str)
1869
1870         return {'FINISHED'}
1871
1872
1873 class WM_OT_owner_enable(Operator):
1874     """Enable workspace owner ID"""
1875     bl_idname = "wm.owner_enable"
1876     bl_label = "Enable Add-on"
1877
1878     owner_id: StringProperty(
1879         name="UI Tag",
1880     )
1881
1882     def execute(self, context):
1883         workspace = context.workspace
1884         workspace.owner_ids.new(self.owner_id)
1885         return {'FINISHED'}
1886
1887
1888 class WM_OT_owner_disable(Operator):
1889     """Enable workspace owner ID"""
1890     bl_idname = "wm.owner_disable"
1891     bl_label = "Disable UI Tag"
1892
1893     owner_id: StringProperty(
1894         name="UI Tag",
1895     )
1896
1897     def execute(self, context):
1898         workspace = context.workspace
1899         owner_id = workspace.owner_ids[self.owner_id]
1900         workspace.owner_ids.remove(owner_id)
1901         return {'FINISHED'}
1902
1903
1904 class WM_OT_theme_install(Operator):
1905     """Load and apply a Blender XML theme file"""
1906     bl_idname = "wm.theme_install"
1907     bl_label = "Install Theme..."
1908
1909     overwrite: BoolProperty(
1910         name="Overwrite",
1911         description="Remove existing theme file if exists",
1912         default=True,
1913     )
1914     filepath: StringProperty(
1915         subtype='FILE_PATH',
1916     )
1917     filter_folder: BoolProperty(
1918         name="Filter folders",
1919         default=True,
1920         options={'HIDDEN'},
1921     )
1922     filter_glob: StringProperty(
1923         default="*.xml",
1924         options={'HIDDEN'},
1925     )
1926
1927     def execute(self, context):
1928         import os
1929         import shutil
1930         import traceback
1931
1932         xmlfile = self.filepath
1933
1934         path_themes = bpy.utils.user_resource('SCRIPTS', "presets/interface_theme", create=True)
1935
1936         if not path_themes:
1937             self.report({'ERROR'}, "Failed to get themes path")
1938             return {'CANCELLED'}
1939
1940         path_dest = os.path.join(path_themes, os.path.basename(xmlfile))
1941
1942         if not self.overwrite:
1943             if os.path.exists(path_dest):
1944                 self.report({'WARNING'}, "File already installed to %r\n" % path_dest)
1945                 return {'CANCELLED'}
1946
1947         try:
1948             shutil.copyfile(xmlfile, path_dest)
1949             bpy.ops.script.execute_preset(
1950                 filepath=path_dest,
1951                 menu_idname="USERPREF_MT_interface_theme_presets",
1952             )
1953
1954         except:
1955             traceback.print_exc()
1956             return {'CANCELLED'}
1957
1958         return {'FINISHED'}
1959
1960     def invoke(self, context, event):
1961         wm = context.window_manager
1962         wm.fileselect_add(self)
1963         return {'RUNNING_MODAL'}
1964
1965
1966 class WM_OT_addon_refresh(Operator):
1967     """Scan add-on directories for new modules"""
1968     bl_idname = "wm.addon_refresh"
1969     bl_label = "Refresh"
1970
1971     def execute(self, context):
1972         import addon_utils
1973
1974         addon_utils.modules_refresh()
1975
1976         return {'FINISHED'}
1977
1978
1979 # Note: shares some logic with WM_OT_app_template_install
1980 # but not enough to de-duplicate. Fixed here may apply to both.
1981 class WM_OT_addon_install(Operator):
1982     """Install an add-on"""
1983     bl_idname = "wm.addon_install"
1984     bl_label = "Install Add-on from File..."
1985
1986     overwrite: BoolProperty(
1987         name="Overwrite",
1988         description="Remove existing add-ons with the same ID",
1989         default=True,
1990     )
1991     target: EnumProperty(
1992         name="Target Path",
1993         items=(('DEFAULT', "Default", ""),
1994                ('PREFS', "User Prefs", "")),
1995     )
1996
1997     filepath: StringProperty(
1998         subtype='FILE_PATH',
1999     )
2000     filter_folder: BoolProperty(
2001         name="Filter folders",
2002         default=True,
2003         options={'HIDDEN'},
2004     )
2005     filter_python: BoolProperty(
2006         name="Filter python",
2007         default=True,
2008         options={'HIDDEN'},
2009     )
2010     filter_glob: StringProperty(
2011         default="*.py;*.zip",
2012         options={'HIDDEN'},
2013     )
2014
2015     def execute(self, context):
2016         import addon_utils
2017         import traceback
2018         import zipfile
2019         import shutil
2020         import os
2021
2022         pyfile = self.filepath
2023
2024         if self.target == 'DEFAULT':
2025             # don't use bpy.utils.script_paths("addons") because we may not be able to write to it.
2026             path_addons = bpy.utils.user_resource('SCRIPTS', "addons", create=True)
2027         else:
2028             path_addons = context.preferences.filepaths.script_directory
2029             if path_addons:
2030                 path_addons = os.path.join(path_addons, "addons")
2031
2032         if not path_addons:
2033             self.report({'ERROR'}, "Failed to get add-ons path")
2034             return {'CANCELLED'}
2035
2036         if not os.path.isdir(path_addons):
2037             try:
2038                 os.makedirs(path_addons, exist_ok=True)
2039             except:
2040                 traceback.print_exc()
2041
2042         # Check if we are installing from a target path,
2043         # doing so causes 2+ addons of same name or when the same from/to
2044         # location is used, removal of the file!
2045         addon_path = ""
2046         pyfile_dir = os.path.dirname(pyfile)
2047         for addon_path in addon_utils.paths():
2048             if os.path.samefile(pyfile_dir, addon_path):
2049                 self.report({'ERROR'}, "Source file is in the add-on search path: %r" % addon_path)
2050                 return {'CANCELLED'}
2051         del addon_path
2052         del pyfile_dir
2053         # done checking for exceptional case
2054
2055         addons_old = {mod.__name__ for mod in addon_utils.modules()}
2056
2057         # check to see if the file is in compressed format (.zip)
2058         if zipfile.is_zipfile(pyfile):
2059             try:
2060                 file_to_extract = zipfile.ZipFile(pyfile, 'r')
2061             except:
2062                 traceback.print_exc()
2063                 return {'CANCELLED'}
2064
2065             if self.overwrite:
2066                 for f in file_to_extract.namelist():
2067                     module_filesystem_remove(path_addons, f)
2068             else:
2069                 for f in file_to_extract.namelist():
2070                     path_dest = os.path.join(path_addons, os.path.basename(f))
2071                     if os.path.exists(path_dest):
2072                         self.report({'WARNING'}, "File already installed to %r\n" % path_dest)
2073                         return {'CANCELLED'}
2074
2075             try:  # extract the file to "addons"
2076                 file_to_extract.extractall(path_addons)
2077             except:
2078                 traceback.print_exc()
2079                 return {'CANCELLED'}
2080
2081         else:
2082             path_dest = os.path.join(path_addons, os.path.basename(pyfile))
2083
2084             if self.overwrite:
2085                 module_filesystem_remove(path_addons, os.path.basename(pyfile))
2086             elif os.path.exists(path_dest):
2087                 self.report({'WARNING'}, "File already installed to %r\n" % path_dest)
2088                 return {'CANCELLED'}
2089
2090             # if not compressed file just copy into the addon path
2091             try:
2092                 shutil.copyfile(pyfile, path_dest)
2093             except:
2094                 traceback.print_exc()
2095                 return {'CANCELLED'}
2096
2097         addons_new = {mod.__name__ for mod in addon_utils.modules()} - addons_old
2098         addons_new.discard("modules")
2099
2100         # disable any addons we may have enabled previously and removed.
2101         # this is unlikely but do just in case. bug [#23978]
2102         for new_addon in addons_new:
2103             addon_utils.disable(new_addon, default_set=True)
2104
2105         # possible the zip contains multiple addons, we could disallow this
2106         # but for now just use the first
2107         for mod in addon_utils.modules(refresh=False):
2108             if mod.__name__ in addons_new:
2109                 info = addon_utils.module_bl_info(mod)
2110
2111                 # show the newly installed addon.
2112                 context.window_manager.addon_filter = 'All'
2113                 context.window_manager.addon_search = info["name"]
2114                 break
2115
2116         # in case a new module path was created to install this addon.
2117         bpy.utils.refresh_script_paths()
2118
2119         # print message
2120         msg = (
2121             tip_("Modules Installed (%s) from %r into %r") %
2122             (", ".join(sorted(addons_new)), pyfile, path_addons)
2123         )
2124         print(msg)
2125         self.report({'INFO'}, msg)
2126
2127         return {'FINISHED'}
2128
2129     def invoke(self, context, event):
2130         wm = context.window_manager
2131         wm.fileselect_add(self)
2132         return {'RUNNING_MODAL'}
2133
2134
2135 class WM_OT_addon_remove(Operator):
2136     """Delete the add-on from the file system"""
2137     bl_idname = "wm.addon_remove"
2138     bl_label = "Remove Add-on"
2139
2140     module: StringProperty(
2141         name="Module",
2142         description="Module name of the add-on to remove",
2143     )
2144
2145     @staticmethod
2146     def path_from_addon(module):
2147         import os
2148         import addon_utils
2149
2150         for mod in addon_utils.modules():
2151             if mod.__name__ == module:
2152                 filepath = mod.__file__
2153                 if os.path.exists(filepath):
2154                     if os.path.splitext(os.path.basename(filepath))[0] == "__init__":
2155                         return os.path.dirname(filepath), True
2156                     else:
2157                         return filepath, False
2158         return None, False
2159
2160     def execute(self, context):
2161         import addon_utils
2162         import os
2163
2164         path, isdir = WM_OT_addon_remove.path_from_addon(self.module)
2165         if path is None:
2166             self.report({'WARNING'}, "Add-on path %r could not be found" % path)
2167             return {'CANCELLED'}
2168
2169         # in case its enabled
2170         addon_utils.disable(self.module, default_set=True)
2171
2172         import shutil
2173         if isdir:
2174             if os.path.islink(path):
2175                 os.remove(path)
2176             else:
2177                 shutil.rmtree(path)
2178         else:
2179             os.remove(path)
2180
2181         addon_utils.modules_refresh()
2182
2183         context.area.tag_redraw()
2184         return {'FINISHED'}
2185
2186     # lame confirmation check
2187     def draw(self, context):
2188         self.layout.label(text="Remove Add-on: %r?" % self.module)
2189         path, _isdir = WM_OT_addon_remove.path_from_addon(self.module)
2190         self.layout.label(text="Path: %r" % path)
2191
2192     def invoke(self, context, event):
2193         wm = context.window_manager
2194         return wm.invoke_props_dialog(self, width=600)
2195
2196
2197 class WM_OT_addon_expand(Operator):
2198     """Display information and preferences for this add-on"""
2199     bl_idname = "wm.addon_expand"
2200     bl_label = ""
2201     bl_options = {'INTERNAL'}
2202
2203     module: StringProperty(
2204         name="Module",
2205         description="Module name of the add-on to expand",
2206     )
2207
2208     def execute(self, context):
2209         import addon_utils
2210
2211         module_name = self.module
2212
2213         mod = addon_utils.addons_fake_modules.get(module_name)
2214         if mod is not None:
2215             info = addon_utils.module_bl_info(mod)
2216             info["show_expanded"] = not info["show_expanded"]
2217
2218         return {'FINISHED'}
2219
2220
2221 class WM_OT_addon_userpref_show(Operator):
2222     """Show add-on preferences"""
2223     bl_idname = "wm.addon_userpref_show"
2224     bl_label = ""
2225     bl_options = {'INTERNAL'}
2226
2227     module: StringProperty(
2228         name="Module",
2229         description="Module name of the add-on to expand",
2230     )
2231
2232     def execute(self, context):
2233         import addon_utils
2234
2235         module_name = self.module
2236
2237         _modules = addon_utils.modules(refresh=False)
2238         mod = addon_utils.addons_fake_modules.get(module_name)
2239         if mod is not None:
2240             info = addon_utils.module_bl_info(mod)
2241             info["show_expanded"] = True
2242
2243             context.preferences.active_section = 'ADDONS'
2244             context.window_manager.addon_filter = 'All'
2245             context.window_manager.addon_search = info["name"]
2246             bpy.ops.screen.userpref_show('INVOKE_DEFAULT')
2247
2248         return {'FINISHED'}
2249
2250
2251 # Note: shares some logic with WM_OT_addon_install
2252 # but not enough to de-duplicate. Fixes here may apply to both.
2253 class WM_OT_app_template_install(Operator):
2254     """Install an application-template"""
2255     bl_idname = "wm.app_template_install"
2256     bl_label = "Install Template from File..."
2257
2258     overwrite: BoolProperty(
2259         name="Overwrite",
2260         description="Remove existing template with the same ID",
2261         default=True,
2262     )
2263
2264     filepath: StringProperty(
2265         subtype='FILE_PATH',
2266     )
2267     filter_folder: BoolProperty(
2268         name="Filter folders",
2269         default=True,
2270         options={'HIDDEN'},
2271     )
2272     filter_glob: StringProperty(
2273         default="*.zip",
2274         options={'HIDDEN'},
2275     )
2276
2277     def execute(self, context):
2278         import traceback
2279         import zipfile
2280         import os
2281
2282         filepath = self.filepath
2283
2284         path_app_templates = bpy.utils.user_resource(
2285             'SCRIPTS', os.path.join("startup", "bl_app_templates_user"),
2286             create=True,
2287         )
2288
2289         if not path_app_templates:
2290             self.report({'ERROR'}, "Failed to get add-ons path")
2291             return {'CANCELLED'}
2292
2293         if not os.path.isdir(path_app_templates):
2294             try:
2295                 os.makedirs(path_app_templates, exist_ok=True)
2296             except:
2297                 traceback.print_exc()
2298
2299         app_templates_old = set(os.listdir(path_app_templates))
2300
2301         # check to see if the file is in compressed format (.zip)
2302         if zipfile.is_zipfile(filepath):
2303             try:
2304                 file_to_extract = zipfile.ZipFile(filepath, 'r')
2305             except:
2306                 traceback.print_exc()
2307                 return {'CANCELLED'}
2308
2309             if self.overwrite:
2310                 for f in file_to_extract.namelist():
2311                     module_filesystem_remove(path_app_templates, f)
2312             else:
2313                 for f in file_to_extract.namelist():
2314                     path_dest = os.path.join(path_app_templates, os.path.basename(f))
2315                     if os.path.exists(path_dest):
2316                         self.report({'WARNING'}, "File already installed to %r\n" % path_dest)
2317                         return {'CANCELLED'}
2318
2319             try:  # extract the file to "bl_app_templates_user"
2320                 file_to_extract.extractall(path_app_templates)
2321             except:
2322                 traceback.print_exc()
2323                 return {'CANCELLED'}
2324
2325         else:
2326             # Only support installing zipfiles
2327             self.report({'WARNING'}, "Expected a zip-file %r\n" % filepath)
2328             return {'CANCELLED'}
2329
2330         app_templates_new = set(os.listdir(path_app_templates)) - app_templates_old
2331
2332         # in case a new module path was created to install this addon.
2333         bpy.utils.refresh_script_paths()
2334
2335         # print message
2336         msg = (
2337             tip_("Template Installed (%s) from %r into %r") %
2338             (", ".join(sorted(app_templates_new)), filepath, path_app_templates)
2339         )
2340         print(msg)
2341         self.report({'INFO'}, msg)
2342
2343         return {'FINISHED'}
2344
2345     def invoke(self, context, event):
2346         wm = context.window_manager
2347         wm.fileselect_add(self)
2348         return {'RUNNING_MODAL'}
2349
2350
2351 class WM_OT_tool_set_by_name(Operator):
2352     """Set the tool by name (for keymaps)"""
2353     bl_idname = "wm.tool_set_by_name"
2354     bl_label = "Set Tool By Name"
2355
2356     name: StringProperty(
2357         name="Text",
2358         description="Display name of the tool",
2359     )
2360     cycle: BoolProperty(
2361         name="Cycle",
2362         description="Cycle through tools in this group",
2363         default=False,
2364         options={'SKIP_SAVE'},
2365     )
2366
2367     space_type: rna_space_type_prop
2368
2369     if use_toolbar_release_hack:
2370         def invoke(self, context, event):
2371             # Hack :S
2372             if not self.properties.is_property_set("name"):
2373                 WM_OT_toolbar._key_held = False
2374                 return {'PASS_THROUGH'}
2375             elif (WM_OT_toolbar._key_held == event.type) and (event.value != 'RELEASE'):
2376                 return {'PASS_THROUGH'}
2377             WM_OT_toolbar._key_held = None
2378
2379             return self.execute(context)
2380
2381     def execute(self, context):
2382         from bl_ui.space_toolsystem_common import (
2383             activate_by_name,
2384             activate_by_name_or_cycle,
2385         )
2386
2387         if self.properties.is_property_set("space_type"):
2388             space_type = self.space_type
2389         else:
2390             space_type = context.space_data.type
2391
2392         fn = activate_by_name_or_cycle if self.cycle else activate_by_name
2393         if fn(context, space_type, self.name):
2394             return {'FINISHED'}
2395         else:
2396             self.report({'WARNING'}, f"Tool {self.name!r:s} not found for space {space_type!r:s}.")
2397             return {'CANCELLED'}
2398
2399
2400 class WM_OT_toolbar(Operator):
2401     bl_idname = "wm.toolbar"
2402     bl_label = "Toolbar"
2403
2404     @classmethod
2405     def poll(cls, context):
2406         return context.space_data is not None
2407
2408     if use_toolbar_release_hack:
2409         _key_held = None
2410
2411         def invoke(self, context, event):
2412             WM_OT_toolbar._key_held = event.type
2413             return self.execute(context)
2414
2415     def execute(self, context):
2416         from bl_ui.space_toolsystem_common import ToolSelectPanelHelper
2417         from bl_keymap_utils import keymap_from_toolbar
2418
2419         space_type = context.space_data.type
2420         cls = ToolSelectPanelHelper._tool_class_from_space_type(space_type)
2421         if cls is None:
2422             return {'CANCELLED'}
2423
2424         wm = context.window_manager
2425         keymap = keymap_from_toolbar.generate(context, space_type)
2426
2427         def draw_menu(popover, context):
2428             layout = popover.layout
2429             layout.operator_context = 'INVOKE_REGION_WIN'
2430             cls.draw_cls(layout, context, detect_layout=False, scale_y=1.0)
2431
2432         wm.popover(draw_menu, ui_units_x=8, keymap=keymap)
2433         return {'FINISHED'}
2434
2435
2436 # Studio Light operations
2437 class WM_OT_studiolight_install(Operator):
2438     """Install a user defined studio light"""
2439     bl_idname = "wm.studiolight_install"
2440     bl_label = "Install Custom Studio Light"
2441
2442     files: CollectionProperty(
2443         name="File Path",
2444         type=OperatorFileListElement,
2445     )
2446     directory: StringProperty(
2447         subtype='DIR_PATH',
2448     )
2449     filter_folder: BoolProperty(
2450         name="Filter folders",
2451         default=True,
2452         options={'HIDDEN'},
2453     )
2454     filter_glob: StringProperty(
2455         default="*.png;*.jpg;*.hdr;*.exr",
2456         options={'HIDDEN'},
2457     )
2458     type: EnumProperty(
2459         items=(
2460             ('MATCAP', "MatCap", ""),
2461             ('WORLD', "World", ""),
2462             ('STUDIO', "Studio", ""),
2463         )
2464     )
2465
2466     def execute(self, context):
2467         import os
2468         import shutil
2469         prefs = context.preferences
2470
2471         filepaths = [os.path.join(self.directory, e.name) for e in self.files]
2472         path_studiolights = bpy.utils.user_resource('DATAFILES', "studiolights", create=True)
2473         if not path_studiolights:
2474             self.report({'ERROR'}, "Failed to create Studio Light path")
2475             return {'CANCELLED'}
2476
2477         for filepath in filepaths:
2478             shutil.copy(filepath, path_studiolights)
2479             prefs.studio_lights.load(os.path.join(path_studiolights, filepath), self.type)
2480
2481         # print message
2482         msg = (
2483             tip_("StudioLight Installed %r into %r") %
2484             (", ".join(e.name for e in self.files), path_studiolights)
2485         )
2486         print(msg)
2487         self.report({'INFO'}, msg)
2488         return {'FINISHED'}
2489
2490     def invoke(self, context, event):
2491         wm = context.window_manager
2492
2493         if self.type == 'STUDIO':
2494             self.filter_glob = "*.sl"
2495
2496         wm.fileselect_add(self)
2497         return {'RUNNING_MODAL'}
2498
2499
2500 class WM_OT_studiolight_new(Operator):
2501     """Save custom studio light from the studio light editor settings"""
2502     bl_idname = 'wm.studiolight_new'
2503     bl_label = "Save custom Studio light"
2504
2505     filename: StringProperty(
2506         name="Name",
2507         default="StudioLight",
2508     )
2509
2510     ask_overide = False
2511
2512     def execute(self, context):
2513         import os
2514         prefs = context.preferences
2515         wm = context.window_manager
2516         filename = bpy.path.ensure_ext(self.filename, ".sl")
2517
2518         path_studiolights = bpy.utils.user_resource('DATAFILES', os.path.join("studiolights", "studio"), create=True)
2519         if not path_studiolights:
2520             self.report({'ERROR'}, "Failed to get Studio Light path")
2521             return {'CANCELLED'}
2522
2523         filepath_final = os.path.join(path_studiolights, filename)
2524         if os.path.isfile(filepath_final):
2525             if not self.ask_overide:
2526                 self.ask_overide = True
2527                 return wm.invoke_props_dialog(self, width=600)
2528             else:
2529                 for studio_light in prefs.studio_lights:
2530                     if studio_light.name == filename:
2531                         bpy.ops.wm.studiolight_uninstall(index=studio_light.index)
2532
2533         prefs.studio_lights.new(path=filepath_final)
2534
2535         # print message
2536         msg = (
2537             tip_("StudioLight Installed %r into %r") %
2538             (self.filename, str(path_studiolights))
2539         )
2540         print(msg)
2541         self.report({'INFO'}, msg)
2542         return {'FINISHED'}
2543
2544     def draw(self, context):
2545         layout = self.layout
2546         if self.ask_overide:
2547             layout.label(text="Warning, file already exists. Overwrite existing file?")
2548         else:
2549             layout.prop(self, "filename")
2550
2551     def invoke(self, context, event):
2552         wm = context.window_manager
2553         return wm.invoke_props_dialog(self, width=600)
2554
2555
2556 class WM_OT_studiolight_uninstall(Operator):
2557     """Delete Studio Light"""
2558     bl_idname = 'wm.studiolight_uninstall'
2559     bl_label = "Uninstall Studio Light"
2560     index: bpy.props.IntProperty()
2561
2562     def execute(self, context):
2563         import os
2564         prefs = context.preferences
2565         for studio_light in prefs.studio_lights:
2566             if studio_light.index == self.index:
2567                 for filepath in (
2568                         studio_light.path,
2569                         studio_light.path_irr_cache,
2570                         studio_light.path_sh_cache,
2571                 ):
2572                     if filepath and os.path.exists(filepath):
2573                         os.unlink(filepath)
2574                 prefs.studio_lights.remove(studio_light)
2575                 return {'FINISHED'}
2576         return {'CANCELLED'}
2577
2578
2579 class WM_OT_studiolight_copy_settings(Operator):
2580     """Copy Studio Light settings to the Studio light editor"""
2581     bl_idname = 'wm.studiolight_copy_settings'
2582     bl_label = "Copy Studio Light settings"
2583     index: bpy.props.IntProperty()
2584
2585     def execute(self, context):
2586         prefs = context.preferences
2587         system = prefs.system
2588         for studio_light in prefs.studio_lights:
2589             if studio_light.index == self.index:
2590                 system.light_ambient = studio_light.light_ambient
2591                 for sys_light, light in zip(system.solid_lights, studio_light.solid_lights):
2592                     sys_light.use = light.use
2593                     sys_light.diffuse_color = light.diffuse_color
2594                     sys_light.specular_color = light.specular_color
2595                     sys_light.smooth = light.smooth
2596                     sys_light.direction = light.direction
2597                 return {'FINISHED'}
2598         return {'CANCELLED'}
2599
2600
2601 class WM_OT_studiolight_userpref_show(Operator):
2602     """Show light preferences"""
2603     bl_idname = "wm.studiolight_userpref_show"
2604     bl_label = ""
2605     bl_options = {'INTERNAL'}
2606
2607     def execute(self, context):
2608         context.preferences.active_section = 'LIGHTS'
2609         bpy.ops.screen.userpref_show('INVOKE_DEFAULT')
2610         return {'FINISHED'}
2611
2612
2613 class WM_MT_splash(Menu):
2614     bl_label = "Splash"
2615
2616     def draw_setup(self, context):
2617         wm = context.window_manager
2618         # prefs = context.preferences
2619
2620         layout = self.layout
2621
2622         layout.operator_context = 'EXEC_DEFAULT'
2623
2624         layout.label(text="Quick Setup")
2625
2626         split = layout.split(factor=0.25)
2627         split.label()
2628         split = split.split(factor=2.0 / 3.0)
2629
2630         col = split.column()
2631
2632         col.label()
2633
2634         sub = col.split(factor=0.35)
2635         row = sub.row()
2636         row.alignment = 'RIGHT'
2637         row.label(text="Shortcuts")
2638         text = bpy.path.display_name(wm.keyconfigs.active.name)
2639         if not text:
2640             text = "Blender"
2641         sub.menu("USERPREF_MT_keyconfigs", text=text)
2642
2643         kc = wm.keyconfigs.active
2644         kc_prefs = kc.preferences
2645         has_select_mouse = hasattr(kc_prefs, "select_mouse")
2646         if has_select_mouse:
2647             sub = col.split(factor=0.35)
2648             row = sub.row()
2649             row.alignment = 'RIGHT'
2650             row.label(text="Select With")
2651             sub.row().prop(kc_prefs, "select_mouse", expand=True)
2652             has_select_mouse = True
2653
2654         has_spacebar_action = hasattr(kc_prefs, "spacebar_action")
2655         if has_spacebar_action:
2656             sub = col.split(factor=0.35)
2657             row = sub.row()
2658             row.alignment = 'RIGHT'
2659             row.label(text="Spacebar")
2660             sub.row().prop(kc_prefs, "spacebar_action", expand=True)
2661             has_select_mouse = True
2662
2663         col.separator()
2664
2665         sub = col.split(factor=0.35)
2666         row = sub.row()
2667         row.alignment = 'RIGHT'
2668         row.label(text="Theme")
2669         label = bpy.types.USERPREF_MT_interface_theme_presets.bl_label
2670         if label == "Presets":
2671             label = "Blender Dark"
2672         sub.menu("USERPREF_MT_interface_theme_presets", text=label)
2673
2674         # We need to make switching to a language easier first
2675         #sub = col.split(factor=0.35)
2676         #row = sub.row()
2677         #row.alignment = 'RIGHT'
2678         # row.label(text="Language:")
2679         #prefs = context.preferences
2680         #sub.prop(prefs.system, "language", text="")
2681
2682         # Keep height constant
2683         if not has_select_mouse:
2684             col.label()
2685         if not has_spacebar_action:
2686             col.label()
2687
2688         layout.label()
2689
2690         row = layout.row()
2691
2692         sub = row.row()
2693         if bpy.types.WM_OT_copy_prev_settings.poll(context):
2694             old_version = bpy.types.WM_OT_copy_prev_settings.previous_version()
2695             sub.operator("wm.copy_prev_settings", text="Load %d.%d Settings" % old_version)
2696             sub.operator("wm.save_userpref", text="Save New Settings")
2697         else:
2698             sub.label()
2699             sub.label()
2700             sub.operator("wm.save_userpref", text="Next")
2701
2702         layout.separator()
2703         layout.separator()
2704
2705     def draw(self, context):
2706         # Draw setup screen if no preferences have been saved yet.
2707         import os
2708
2709         userconfig_path = bpy.utils.user_resource('CONFIG');
2710         userdef_path = os.path.join(userconfig_path, "userpref.blend")
2711
2712         if not os.path.isfile(userdef_path):
2713             self.draw_setup(context)
2714             return
2715
2716         # Pass
2717         layout = self.layout
2718         layout.operator_context = 'EXEC_DEFAULT'
2719         layout.emboss = 'PULLDOWN_MENU'
2720
2721         split = layout.split()
2722
2723         # Templates
2724         col1 = split.column()
2725         col1.label(text="New File")
2726
2727         bpy.types.TOPBAR_MT_file_new.draw_ex(col1, context, use_splash=True)
2728
2729         # Recent
2730         col2 = split.column()
2731         col2_title = col2.row()
2732
2733         found_recent = col2.template_recent_files()
2734
2735         if found_recent:
2736             col2_title.label(text="Recent Files")
2737         else:
2738             # Links if no recent files
2739             col2_title.label(text="Getting Started")
2740
2741             col2.operator(
2742                 "wm.url_open", text="Manual", icon='URL'
2743             ).url = "https://docs.blender.org/manual/en/dev/"
2744             col2.operator(
2745                 "wm.url_open", text="Release Notes", icon='URL',
2746             ).url = "https://www.blender.org/download/releases/%d-%d/" % bpy.app.version[:2]
2747             col2.operator(
2748                 "wm.url_open", text="Blender Website", icon='URL',
2749             ).url = "https://www.blender.org"
2750             col2.operator(
2751                 "wm.url_open", text="Credits", icon='URL',
2752             ).url = "https://www.blender.org/about/credits/"
2753
2754         layout.separator()
2755
2756         split = layout.split()
2757
2758         col1 = split.column()
2759         sub = col1.row()
2760         sub.operator_context = 'INVOKE_DEFAULT'
2761         sub.operator("wm.open_mainfile", text="Open...", icon='FILE_FOLDER')
2762         col1.operator("wm.recover_last_session", icon='RECOVER_LAST')
2763
2764         col2 = split.column()
2765         if found_recent:
2766             col2.operator(
2767                 "wm.url_open", text="Release Notes", icon='URL',
2768             ).url = "https://www.blender.org/download/releases/%d-%d/" % bpy.app.version[:2]
2769             col2.operator(
2770                 "wm.url_open", text="Development Fund", icon='URL'
2771             ).url = "https://fund.blender.org"
2772         else:
2773             col2.operator(
2774                 "wm.url_open", text="Development Fund", icon='URL'
2775             ).url = "https://fund.blender.org"
2776             col2.operator(
2777                 "wm.url_open", text="Donate", icon='URL'
2778             ).url = "https://www.blender.org/foundation/donation-payment/"
2779
2780         layout.separator()
2781         layout.separator()
2782
2783
2784 class WM_OT_drop_blend_file(Operator):
2785     bl_idname = "wm.drop_blend_file"
2786     bl_label = "Handle dropped .blend file"
2787     bl_options = {'INTERNAL'}
2788
2789     filepath: StringProperty()
2790
2791     def invoke(self, context, event):
2792         context.window_manager.popup_menu(self.draw_menu, title=bpy.path.basename(self.filepath), icon='QUESTION')
2793         return {"FINISHED"}
2794
2795     def draw_menu(self, menu, context):
2796         layout = menu.layout
2797
2798         col = layout.column()
2799         col.operator_context = 'EXEC_DEFAULT'
2800         col.operator("wm.open_mainfile", text="Open", icon='FILE_FOLDER').filepath = self.filepath
2801
2802         layout.separator()
2803         col = layout.column()
2804         col.operator_context = 'INVOKE_DEFAULT'
2805         col.operator("wm.link", text="Link...", icon='LINK_BLEND').filepath = self.filepath
2806         col.operator("wm.append", text="Append...", icon='APPEND_BLEND').filepath = self.filepath
2807
2808
2809 classes = (
2810     WM_OT_addon_disable,
2811     WM_OT_addon_enable,
2812     WM_OT_addon_expand,
2813     WM_OT_addon_install,
2814     WM_OT_addon_refresh,
2815     WM_OT_addon_remove,
2816     WM_OT_addon_userpref_show,
2817     WM_OT_app_template_install,
2818     WM_OT_context_collection_boolean_set,
2819     WM_OT_context_cycle_array,
2820     WM_OT_context_cycle_enum,
2821     WM_OT_context_cycle_int,
2822     WM_OT_context_menu_enum,
2823     WM_OT_context_modal_mouse,
2824     WM_OT_context_pie_enum,
2825     WM_OT_context_scale_float,
2826     WM_OT_context_scale_int,
2827     WM_OT_context_set_boolean,
2828     WM_OT_context_set_enum,
2829     WM_OT_context_set_float,
2830     WM_OT_context_set_id,
2831     WM_OT_context_set_int,
2832     WM_OT_context_set_string,
2833     WM_OT_context_set_value,
2834     WM_OT_context_toggle,
2835     WM_OT_context_toggle_enum,
2836     WM_OT_copy_prev_settings,
2837     WM_OT_doc_view,
2838     WM_OT_doc_view_manual,
2839     WM_OT_drop_blend_file,
2840     WM_OT_keyconfig_activate,
2841     WM_OT_keyconfig_export,
2842     WM_OT_keyconfig_import,
2843     WM_OT_keyconfig_remove,
2844     WM_OT_keyconfig_test,
2845     WM_OT_keyitem_add,
2846     WM_OT_keyitem_remove,
2847     WM_OT_keyitem_restore,
2848     WM_OT_keymap_restore,
2849     WM_OT_operator_cheat_sheet,
2850     WM_OT_operator_pie_enum,
2851     WM_OT_path_open,
2852     WM_OT_properties_add,
2853     WM_OT_properties_context_change,
2854     WM_OT_properties_edit,
2855     WM_OT_properties_remove,
2856     WM_OT_sysinfo,
2857     WM_OT_theme_install,
2858     WM_OT_owner_disable,
2859     WM_OT_owner_enable,
2860     WM_OT_url_open,
2861     WM_OT_studiolight_install,
2862     WM_OT_studiolight_new,
2863     WM_OT_studiolight_uninstall,
2864     WM_OT_studiolight_copy_settings,
2865     WM_OT_studiolight_userpref_show,
2866     WM_OT_tool_set_by_name,
2867     WM_OT_toolbar,
2868     WM_MT_splash,
2869 )