UI: initialize Overridable Static checkbox for custom properties.
[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.8")
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_property = StringProperty(
1056     name="Property Name",
1057     description="Property name edit",
1058     maxlen=1024,
1059 )
1060
1061 rna_min = FloatProperty(
1062     name="Min",
1063     default=-10000.0,
1064     precision=3,
1065 )
1066
1067 rna_max = FloatProperty(
1068     name="Max",
1069     default=10000.0,
1070     precision=3,
1071 )
1072
1073 rna_use_soft_limits = BoolProperty(
1074     name="Use Soft Limits",
1075 )
1076
1077 rna_is_overridable_static = BoolProperty(
1078     name="Is Statically Overridable",
1079     default=False,
1080 )
1081
1082
1083 class WM_OT_properties_edit(Operator):
1084     bl_idname = "wm.properties_edit"
1085     bl_label = "Edit Property"
1086     # register only because invoke_props_popup requires.
1087     bl_options = {'REGISTER', 'INTERNAL'}
1088
1089     data_path: rna_path
1090     property: rna_property
1091     value: rna_value
1092     min: rna_min
1093     max: rna_max
1094     use_soft_limits: rna_use_soft_limits
1095     is_overridable_static: rna_is_overridable_static
1096     soft_min: rna_min
1097     soft_max: rna_max
1098     description: StringProperty(
1099         name="Tooltip",
1100     )
1101
1102     def _cmp_props_get(self):
1103         # Changing these properties will refresh the UI
1104         return {
1105             "use_soft_limits": self.use_soft_limits,
1106             "soft_range": (self.soft_min, self.soft_max),
1107             "hard_range": (self.min, self.max),
1108         }
1109
1110     def execute(self, context):
1111         from rna_prop_ui import (
1112             rna_idprop_ui_prop_get,
1113             rna_idprop_ui_prop_clear,
1114             rna_idprop_ui_prop_update,
1115         )
1116
1117         data_path = self.data_path
1118         value = self.value
1119         prop = self.property
1120
1121         prop_old = getattr(self, "_last_prop", [None])[0]
1122
1123         if prop_old is None:
1124             self.report({'ERROR'}, "Direct execution not supported")
1125             return {'CANCELLED'}
1126
1127         try:
1128             value_eval = eval(value)
1129             # assert else None -> None, not "None", see [#33431]
1130             assert(type(value_eval) in {str, float, int, bool, tuple, list})
1131         except:
1132             value_eval = value
1133
1134         # First remove
1135         item = eval("context.%s" % data_path)
1136         prop_type_old = type(item[prop_old])
1137
1138         rna_idprop_ui_prop_clear(item, prop_old)
1139         exec_str = "del item[%r]" % prop_old
1140         # print(exec_str)
1141         exec(exec_str)
1142
1143         # Reassign
1144         exec_str = "item[%r] = %s" % (prop, repr(value_eval))
1145         # print(exec_str)
1146         exec(exec_str)
1147
1148         exec_str = "item.property_overridable_static_set('[\"%s\"]', %s)" % (prop, self.is_overridable_static)
1149         exec(exec_str)
1150
1151         rna_idprop_ui_prop_update(item, prop)
1152
1153         self._last_prop[:] = [prop]
1154
1155         prop_type = type(item[prop])
1156
1157         prop_ui = rna_idprop_ui_prop_get(item, prop)
1158
1159         if prop_type in {float, int}:
1160             prop_ui["min"] = prop_type(self.min)
1161             prop_ui["max"] = prop_type(self.max)
1162
1163             if self.use_soft_limits:
1164                 prop_ui["soft_min"] = prop_type(self.soft_min)
1165                 prop_ui["soft_max"] = prop_type(self.soft_max)
1166             else:
1167                 prop_ui["soft_min"] = prop_type(self.min)
1168                 prop_ui["soft_max"] = prop_type(self.max)
1169
1170         prop_ui["description"] = self.description
1171
1172         # If we have changed the type of the property, update its potential anim curves!
1173         if prop_type_old != prop_type:
1174             data_path = '["%s"]' % bpy.utils.escape_identifier(prop)
1175             done = set()
1176
1177             def _update(fcurves):
1178                 for fcu in fcurves:
1179                     if fcu not in done and fcu.data_path == data_path:
1180                         fcu.update_autoflags(item)
1181                         done.add(fcu)
1182
1183             def _update_strips(strips):
1184                 for st in strips:
1185                     if st.type == 'CLIP' and st.action:
1186                         _update(st.action.fcurves)
1187                     elif st.type == 'META':
1188                         _update_strips(st.strips)
1189
1190             adt = getattr(item, "animation_data", None)
1191             if adt is not None:
1192                 if adt.action:
1193                     _update(adt.action.fcurves)
1194                 if adt.drivers:
1195                     _update(adt.drivers)
1196                 if adt.nla_tracks:
1197                     for nt in adt.nla_tracks:
1198                         _update_strips(nt.strips)
1199
1200         # otherwise existing buttons which reference freed
1201         # memory may crash blender [#26510]
1202         # context.area.tag_redraw()
1203         for win in context.window_manager.windows:
1204             for area in win.screen.areas:
1205                 area.tag_redraw()
1206
1207         return {'FINISHED'}
1208
1209     def invoke(self, context, event):
1210         from rna_prop_ui import rna_idprop_ui_prop_get
1211
1212         data_path = self.data_path
1213
1214         if not data_path:
1215             self.report({'ERROR'}, "Data path not set")
1216             return {'CANCELLED'}
1217
1218         self._last_prop = [self.property]
1219
1220         item = eval("context.%s" % data_path)
1221
1222         # retrieve overridable static
1223         exec_str = "item.is_property_overridable_static('[\"%s\"]')" % (self.property)
1224         self.is_overridable_static = bool(eval(exec_str))
1225
1226         # setup defaults
1227         prop_ui = rna_idprop_ui_prop_get(item, self.property, False)  # don't create
1228         if prop_ui:
1229             self.min = prop_ui.get("min", -1000000000)
1230             self.max = prop_ui.get("max", 1000000000)
1231             self.description = prop_ui.get("description", "")
1232
1233             self.soft_min = prop_ui.get("soft_min", self.min)
1234             self.soft_max = prop_ui.get("soft_max", self.max)
1235             self.use_soft_limits = (
1236                 self.min != self.soft_min or
1237                 self.max != self.soft_max
1238             )
1239
1240         # store for comparison
1241         self._cmp_props = self._cmp_props_get()
1242
1243         wm = context.window_manager
1244         return wm.invoke_props_dialog(self)
1245
1246     def check(self, context):
1247         cmp_props = self._cmp_props_get()
1248         changed = False
1249         if self._cmp_props != cmp_props:
1250             if cmp_props["use_soft_limits"]:
1251                 if cmp_props["soft_range"] != self._cmp_props["soft_range"]:
1252                     self.min = min(self.min, self.soft_min)
1253                     self.max = max(self.max, self.soft_max)
1254                     changed = True
1255                 if cmp_props["hard_range"] != self._cmp_props["hard_range"]:
1256                     self.soft_min = max(self.min, self.soft_min)
1257                     self.soft_max = min(self.max, self.soft_max)
1258                     changed = True
1259             else:
1260                 if cmp_props["soft_range"] != cmp_props["hard_range"]:
1261                     self.soft_min = self.min
1262                     self.soft_max = self.max
1263                     changed = True
1264
1265             changed |= (cmp_props["use_soft_limits"] != self._cmp_props["use_soft_limits"])
1266
1267             if changed:
1268                 cmp_props = self._cmp_props_get()
1269
1270             self._cmp_props = cmp_props
1271
1272         return changed
1273
1274     def draw(self, context):
1275         layout = self.layout
1276         layout.prop(self, "property")
1277         layout.prop(self, "value")
1278         row = layout.row(align=True)
1279         row.prop(self, "min")
1280         row.prop(self, "max")
1281
1282         row = layout.row()
1283         row.prop(self, "use_soft_limits")
1284         row.prop(self, "is_overridable_static")
1285
1286         row = layout.row(align=True)
1287         row.enabled = self.use_soft_limits
1288         row.prop(self, "soft_min", text="Soft Min")
1289         row.prop(self, "soft_max", text="Soft Max")
1290         layout.prop(self, "description")
1291
1292
1293 class WM_OT_properties_add(Operator):
1294     bl_idname = "wm.properties_add"
1295     bl_label = "Add Property"
1296     bl_options = {'UNDO', 'INTERNAL'}
1297
1298     data_path: rna_path
1299
1300     def execute(self, context):
1301         from rna_prop_ui import (
1302             rna_idprop_ui_prop_get,
1303             rna_idprop_ui_prop_update,
1304         )
1305
1306         data_path = self.data_path
1307         item = eval("context.%s" % data_path)
1308
1309         def unique_name(names):
1310             prop = "prop"
1311             prop_new = prop
1312             i = 1
1313             while prop_new in names:
1314                 prop_new = prop + str(i)
1315                 i += 1
1316
1317             return prop_new
1318
1319         prop = unique_name({
1320             *item.keys(),
1321             *type(item).bl_rna.properties.keys(),
1322         })
1323
1324         item[prop] = 1.0
1325         rna_idprop_ui_prop_update(item, prop)
1326
1327         # not essential, but without this we get [#31661]
1328         prop_ui = rna_idprop_ui_prop_get(item, prop)
1329         prop_ui["soft_min"] = prop_ui["min"] = 0.0
1330         prop_ui["soft_max"] = prop_ui["max"] = 1.0
1331
1332         return {'FINISHED'}
1333
1334
1335 class WM_OT_properties_context_change(Operator):
1336     """Jump to a different tab inside the properties editor"""
1337     bl_idname = "wm.properties_context_change"
1338     bl_label = ""
1339     bl_options = {'INTERNAL'}
1340
1341     context: StringProperty(
1342         name="Context",
1343         maxlen=64,
1344     )
1345
1346     def execute(self, context):
1347         context.space_data.context = self.context
1348         return {'FINISHED'}
1349
1350
1351 class WM_OT_properties_remove(Operator):
1352     """Internal use (edit a property data_path)"""
1353     bl_idname = "wm.properties_remove"
1354     bl_label = "Remove Property"
1355     bl_options = {'UNDO', 'INTERNAL'}
1356
1357     data_path: rna_path
1358     property: rna_property
1359
1360     def execute(self, context):
1361         from rna_prop_ui import (
1362             rna_idprop_ui_prop_clear,
1363             rna_idprop_ui_prop_update,
1364         )
1365         data_path = self.data_path
1366         item = eval("context.%s" % data_path)
1367         prop = self.property
1368         rna_idprop_ui_prop_update(item, prop)
1369         del item[prop]
1370         rna_idprop_ui_prop_clear(item, prop)
1371
1372         return {'FINISHED'}
1373
1374
1375 class WM_OT_keyconfig_activate(Operator):
1376     bl_idname = "wm.keyconfig_activate"
1377     bl_label = "Activate Keyconfig"
1378
1379     filepath: StringProperty(
1380         subtype='FILE_PATH',
1381     )
1382
1383     def execute(self, context):
1384         if bpy.utils.keyconfig_set(self.filepath, report=self.report):
1385             return {'FINISHED'}
1386         else:
1387             return {'CANCELLED'}
1388
1389
1390 class WM_OT_sysinfo(Operator):
1391     """Generate system information, saved into a text file"""
1392
1393     bl_idname = "wm.sysinfo"
1394     bl_label = "Save System Info"
1395
1396     filepath: StringProperty(
1397         subtype='FILE_PATH',
1398         options={'SKIP_SAVE'},
1399     )
1400
1401     def execute(self, context):
1402         import sys_info
1403         sys_info.write_sysinfo(self.filepath)
1404         return {'FINISHED'}
1405
1406     def invoke(self, context, event):
1407         import os
1408
1409         if not self.filepath:
1410             self.filepath = os.path.join(
1411                 os.path.expanduser("~"), "system-info.txt")
1412
1413         wm = context.window_manager
1414         wm.fileselect_add(self)
1415         return {'RUNNING_MODAL'}
1416
1417
1418 class WM_OT_copy_prev_settings(Operator):
1419     """Copy settings from previous version"""
1420     bl_idname = "wm.copy_prev_settings"
1421     bl_label = "Copy Previous Settings"
1422
1423     @staticmethod
1424     def previous_version():
1425         ver = bpy.app.version
1426         ver_old = ((ver[0] * 100) + ver[1]) - 1
1427         return ver_old // 100, ver_old % 100
1428
1429     @staticmethod
1430     def _old_path():
1431         ver = bpy.app.version
1432         ver_old = ((ver[0] * 100) + ver[1]) - 1
1433         return bpy.utils.resource_path('USER', ver_old // 100, ver_old % 100)
1434
1435     @staticmethod
1436     def _new_path():
1437         return bpy.utils.resource_path('USER')
1438
1439     @classmethod
1440     def poll(cls, context):
1441         import os
1442
1443         old = cls._old_path()
1444         new = cls._new_path()
1445         if os.path.isdir(old) and not os.path.isdir(new):
1446             return True
1447
1448         old_userpref = os.path.join(old, "config", "userpref.blend")
1449         new_userpref = os.path.join(new, "config", "userpref.blend")
1450         return os.path.isfile(old_userpref) and not os.path.isfile(new_userpref)
1451
1452     def execute(self, context):
1453         import shutil
1454
1455         shutil.copytree(self._old_path(), self._new_path(), symlinks=True)
1456
1457         # reload recent-files.txt
1458         bpy.ops.wm.read_history()
1459
1460         # don't loose users work if they open the splash later.
1461         if bpy.data.is_saved is bpy.data.is_dirty is False:
1462             bpy.ops.wm.read_homefile()
1463         else:
1464             self.report({'INFO'}, "Reload Start-Up file to restore settings")
1465
1466         return {'FINISHED'}
1467
1468
1469 class WM_OT_keyconfig_test(Operator):
1470     """Test key-config for conflicts"""
1471     bl_idname = "wm.keyconfig_test"
1472     bl_label = "Test Key Configuration for Conflicts"
1473
1474     def execute(self, context):
1475         from bpy_extras import keyconfig_utils
1476
1477         wm = context.window_manager
1478         kc = wm.keyconfigs.default
1479
1480         if keyconfig_utils.keyconfig_test(kc):
1481             print("CONFLICT")
1482
1483         return {'FINISHED'}
1484
1485
1486 class WM_OT_keyconfig_import(Operator):
1487     """Import key configuration from a python script"""
1488     bl_idname = "wm.keyconfig_import"
1489     bl_label = "Import Key Configuration..."
1490
1491     filepath: StringProperty(
1492         subtype='FILE_PATH',
1493         default="keymap.py",
1494     )
1495     filter_folder: BoolProperty(
1496         name="Filter folders",
1497         default=True,
1498         options={'HIDDEN'},
1499     )
1500     filter_text: BoolProperty(
1501         name="Filter text",
1502         default=True,
1503         options={'HIDDEN'},
1504     )
1505     filter_python: BoolProperty(
1506         name="Filter python",
1507         default=True,
1508         options={'HIDDEN'},
1509     )
1510     keep_original: BoolProperty(
1511         name="Keep original",
1512         description="Keep original file after copying to configuration folder",
1513         default=True,
1514     )
1515
1516     def execute(self, context):
1517         import os
1518         from os.path import basename
1519         import shutil
1520
1521         if not self.filepath:
1522             self.report({'ERROR'}, "Filepath not set")
1523             return {'CANCELLED'}
1524
1525         config_name = basename(self.filepath)
1526
1527         path = bpy.utils.user_resource('SCRIPTS', os.path.join("presets", "keyconfig"), create=True)
1528         path = os.path.join(path, config_name)
1529
1530         try:
1531             if self.keep_original:
1532                 shutil.copy(self.filepath, path)
1533             else:
1534                 shutil.move(self.filepath, path)
1535         except Exception as ex:
1536             self.report({'ERROR'}, "Installing keymap failed: %s" % ex)
1537             return {'CANCELLED'}
1538
1539         # sneaky way to check we're actually running the code.
1540         if bpy.utils.keyconfig_set(path, report=self.report):
1541             return {'FINISHED'}
1542         else:
1543             return {'CANCELLED'}
1544
1545     def invoke(self, context, event):
1546         wm = context.window_manager
1547         wm.fileselect_add(self)
1548         return {'RUNNING_MODAL'}
1549
1550 # This operator is also used by interaction presets saving - AddPresetBase
1551
1552
1553 class WM_OT_keyconfig_export(Operator):
1554     """Export key configuration to a python script"""
1555     bl_idname = "wm.keyconfig_export"
1556     bl_label = "Export Key Configuration..."
1557
1558     all: BoolProperty(
1559         name="All Keymaps",
1560         default=False,
1561         description="Write all keymaps (not just user modified)",
1562     )
1563     filepath: StringProperty(
1564         subtype='FILE_PATH',
1565         default="keymap.py",
1566     )
1567     filter_folder: BoolProperty(
1568         name="Filter folders",
1569         default=True,
1570         options={'HIDDEN'},
1571     )
1572     filter_text: BoolProperty(
1573         name="Filter text",
1574         default=True,
1575         options={'HIDDEN'},
1576     )
1577     filter_python: BoolProperty(
1578         name="Filter python",
1579         default=True,
1580         options={'HIDDEN'},
1581     )
1582
1583     def execute(self, context):
1584         from bl_keymap_utils.io import keyconfig_export_as_data
1585
1586         if not self.filepath:
1587             raise Exception("Filepath not set")
1588
1589         if not self.filepath.endswith(".py"):
1590             self.filepath += ".py"
1591
1592         wm = context.window_manager
1593
1594         keyconfig_export_as_data(
1595             wm,
1596             wm.keyconfigs.active,
1597             self.filepath,
1598             all_keymaps=self.all,
1599         )
1600
1601         return {'FINISHED'}
1602
1603     def invoke(self, context, event):
1604         wm = context.window_manager
1605         wm.fileselect_add(self)
1606         return {'RUNNING_MODAL'}
1607
1608
1609 class WM_OT_keymap_restore(Operator):
1610     """Restore key map(s)"""
1611     bl_idname = "wm.keymap_restore"
1612     bl_label = "Restore Key Map(s)"
1613
1614     all: BoolProperty(
1615         name="All Keymaps",
1616         description="Restore all keymaps to default",
1617     )
1618
1619     def execute(self, context):
1620         wm = context.window_manager
1621
1622         if self.all:
1623             for km in wm.keyconfigs.user.keymaps:
1624                 km.restore_to_default()
1625         else:
1626             km = context.keymap
1627             km.restore_to_default()
1628
1629         return {'FINISHED'}
1630
1631
1632 class WM_OT_keyitem_restore(Operator):
1633     """Restore key map item"""
1634     bl_idname = "wm.keyitem_restore"
1635     bl_label = "Restore Key Map Item"
1636
1637     item_id: IntProperty(
1638         name="Item Identifier",
1639         description="Identifier of the item to remove",
1640     )
1641
1642     @classmethod
1643     def poll(cls, context):
1644         keymap = getattr(context, "keymap", None)
1645         return keymap
1646
1647     def execute(self, context):
1648         km = context.keymap
1649         kmi = km.keymap_items.from_id(self.item_id)
1650
1651         if (not kmi.is_user_defined) and kmi.is_user_modified:
1652             km.restore_item_to_default(kmi)
1653
1654         return {'FINISHED'}
1655
1656
1657 class WM_OT_keyitem_add(Operator):
1658     """Add key map item"""
1659     bl_idname = "wm.keyitem_add"
1660     bl_label = "Add Key Map Item"
1661
1662     def execute(self, context):
1663         km = context.keymap
1664
1665         if km.is_modal:
1666             km.keymap_items.new_modal("", 'A', 'PRESS')
1667         else:
1668             km.keymap_items.new("none", 'A', 'PRESS')
1669
1670         # clear filter and expand keymap so we can see the newly added item
1671         if context.space_data.filter_text != "":
1672             context.space_data.filter_text = ""
1673             km.show_expanded_items = True
1674             km.show_expanded_children = True
1675
1676         return {'FINISHED'}
1677
1678
1679 class WM_OT_keyitem_remove(Operator):
1680     """Remove key map item"""
1681     bl_idname = "wm.keyitem_remove"
1682     bl_label = "Remove Key Map Item"
1683
1684     item_id: IntProperty(
1685         name="Item Identifier",
1686         description="Identifier of the item to remove",
1687     )
1688
1689     @classmethod
1690     def poll(cls, context):
1691         return hasattr(context, "keymap")
1692
1693     def execute(self, context):
1694         km = context.keymap
1695         kmi = km.keymap_items.from_id(self.item_id)
1696         km.keymap_items.remove(kmi)
1697         return {'FINISHED'}
1698
1699
1700 class WM_OT_keyconfig_remove(Operator):
1701     """Remove key config"""
1702     bl_idname = "wm.keyconfig_remove"
1703     bl_label = "Remove Key Config"
1704
1705     @classmethod
1706     def poll(cls, context):
1707         wm = context.window_manager
1708         keyconf = wm.keyconfigs.active
1709         return keyconf and keyconf.is_user_defined
1710
1711     def execute(self, context):
1712         wm = context.window_manager
1713         keyconfig = wm.keyconfigs.active
1714         wm.keyconfigs.remove(keyconfig)
1715         return {'FINISHED'}
1716
1717
1718 class WM_OT_operator_cheat_sheet(Operator):
1719     """List all the Operators in a text-block, useful for scripting"""
1720     bl_idname = "wm.operator_cheat_sheet"
1721     bl_label = "Operator Cheat Sheet"
1722
1723     def execute(self, context):
1724         op_strings = []
1725         tot = 0
1726         for op_module_name in dir(bpy.ops):
1727             op_module = getattr(bpy.ops, op_module_name)
1728             for op_submodule_name in dir(op_module):
1729                 op = getattr(op_module, op_submodule_name)
1730                 text = repr(op)
1731                 if text.split("\n")[-1].startswith("bpy.ops."):
1732                     op_strings.append(text)
1733                     tot += 1
1734
1735             op_strings.append('')
1736
1737         textblock = bpy.data.texts.new("OperatorList.txt")
1738         textblock.write('# %d Operators\n\n' % tot)
1739         textblock.write('\n'.join(op_strings))
1740         self.report({'INFO'}, "See OperatorList.txt textblock")
1741         return {'FINISHED'}
1742
1743
1744 # -----------------------------------------------------------------------------
1745 # Add-on Operators
1746
1747 class WM_OT_addon_enable(Operator):
1748     """Enable an add-on"""
1749     bl_idname = "wm.addon_enable"
1750     bl_label = "Enable Add-on"
1751
1752     module: StringProperty(
1753         name="Module",
1754         description="Module name of the add-on to enable",
1755     )
1756
1757     def execute(self, context):
1758         import addon_utils
1759
1760         err_str = ""
1761
1762         def err_cb(ex):
1763             import traceback
1764             nonlocal err_str
1765             err_str = traceback.format_exc()
1766             print(err_str)
1767
1768         mod = addon_utils.enable(self.module, default_set=True, handle_error=err_cb)
1769
1770         if mod:
1771             info = addon_utils.module_bl_info(mod)
1772
1773             info_ver = info.get("blender", (0, 0, 0))
1774
1775             if info_ver > bpy.app.version:
1776                 self.report(
1777                     {'WARNING'},
1778                     "This script was written Blender "
1779                     "version %d.%d.%d and might not "
1780                     "function (correctly), "
1781                     "though it is enabled" %
1782                     info_ver
1783                 )
1784             return {'FINISHED'}
1785         else:
1786
1787             if err_str:
1788                 self.report({'ERROR'}, err_str)
1789
1790             return {'CANCELLED'}
1791
1792
1793 class WM_OT_addon_disable(Operator):
1794     """Disable an add-on"""
1795     bl_idname = "wm.addon_disable"
1796     bl_label = "Disable Add-on"
1797
1798     module: StringProperty(
1799         name="Module",
1800         description="Module name of the add-on to disable",
1801     )
1802
1803     def execute(self, context):
1804         import addon_utils
1805
1806         err_str = ""
1807
1808         def err_cb(ex):
1809             import traceback
1810             nonlocal err_str
1811             err_str = traceback.format_exc()
1812             print(err_str)
1813
1814         addon_utils.disable(self.module, default_set=True, handle_error=err_cb)
1815
1816         if err_str:
1817             self.report({'ERROR'}, err_str)
1818
1819         return {'FINISHED'}
1820
1821
1822 class WM_OT_owner_enable(Operator):
1823     """Enable workspace owner ID"""
1824     bl_idname = "wm.owner_enable"
1825     bl_label = "Enable Add-on"
1826
1827     owner_id: StringProperty(
1828         name="UI Tag",
1829     )
1830
1831     def execute(self, context):
1832         workspace = context.workspace
1833         workspace.owner_ids.new(self.owner_id)
1834         return {'FINISHED'}
1835
1836
1837 class WM_OT_owner_disable(Operator):
1838     """Enable workspace owner ID"""
1839     bl_idname = "wm.owner_disable"
1840     bl_label = "Disable UI Tag"
1841
1842     owner_id: StringProperty(
1843         name="UI Tag",
1844     )
1845
1846     def execute(self, context):
1847         workspace = context.workspace
1848         owner_id = workspace.owner_ids[self.owner_id]
1849         workspace.owner_ids.remove(owner_id)
1850         return {'FINISHED'}
1851
1852
1853 class WM_OT_theme_install(Operator):
1854     """Load and apply a Blender XML theme file"""
1855     bl_idname = "wm.theme_install"
1856     bl_label = "Install Theme..."
1857
1858     overwrite: BoolProperty(
1859         name="Overwrite",
1860         description="Remove existing theme file if exists",
1861         default=True,
1862     )
1863     filepath: StringProperty(
1864         subtype='FILE_PATH',
1865     )
1866     filter_folder: BoolProperty(
1867         name="Filter folders",
1868         default=True,
1869         options={'HIDDEN'},
1870     )
1871     filter_glob: StringProperty(
1872         default="*.xml",
1873         options={'HIDDEN'},
1874     )
1875
1876     def execute(self, context):
1877         import os
1878         import shutil
1879         import traceback
1880
1881         xmlfile = self.filepath
1882
1883         path_themes = bpy.utils.user_resource('SCRIPTS', "presets/interface_theme", create=True)
1884
1885         if not path_themes:
1886             self.report({'ERROR'}, "Failed to get themes path")
1887             return {'CANCELLED'}
1888
1889         path_dest = os.path.join(path_themes, os.path.basename(xmlfile))
1890
1891         if not self.overwrite:
1892             if os.path.exists(path_dest):
1893                 self.report({'WARNING'}, "File already installed to %r\n" % path_dest)
1894                 return {'CANCELLED'}
1895
1896         try:
1897             shutil.copyfile(xmlfile, path_dest)
1898             bpy.ops.script.execute_preset(
1899                 filepath=path_dest,
1900                 menu_idname="USERPREF_MT_interface_theme_presets",
1901             )
1902
1903         except:
1904             traceback.print_exc()
1905             return {'CANCELLED'}
1906
1907         return {'FINISHED'}
1908
1909     def invoke(self, context, event):
1910         wm = context.window_manager
1911         wm.fileselect_add(self)
1912         return {'RUNNING_MODAL'}
1913
1914
1915 class WM_OT_addon_refresh(Operator):
1916     """Scan add-on directories for new modules"""
1917     bl_idname = "wm.addon_refresh"
1918     bl_label = "Refresh"
1919
1920     def execute(self, context):
1921         import addon_utils
1922
1923         addon_utils.modules_refresh()
1924
1925         return {'FINISHED'}
1926
1927
1928 # Note: shares some logic with WM_OT_app_template_install
1929 # but not enough to de-duplicate. Fixed here may apply to both.
1930 class WM_OT_addon_install(Operator):
1931     """Install an add-on"""
1932     bl_idname = "wm.addon_install"
1933     bl_label = "Install Add-on from File..."
1934
1935     overwrite: BoolProperty(
1936         name="Overwrite",
1937         description="Remove existing add-ons with the same ID",
1938         default=True,
1939     )
1940     target: EnumProperty(
1941         name="Target Path",
1942         items=(('DEFAULT', "Default", ""),
1943                ('PREFS', "User Prefs", "")),
1944     )
1945
1946     filepath: StringProperty(
1947         subtype='FILE_PATH',
1948     )
1949     filter_folder: BoolProperty(
1950         name="Filter folders",
1951         default=True,
1952         options={'HIDDEN'},
1953     )
1954     filter_python: BoolProperty(
1955         name="Filter python",
1956         default=True,
1957         options={'HIDDEN'},
1958     )
1959     filter_glob: StringProperty(
1960         default="*.py;*.zip",
1961         options={'HIDDEN'},
1962     )
1963
1964     def execute(self, context):
1965         import addon_utils
1966         import traceback
1967         import zipfile
1968         import shutil
1969         import os
1970
1971         pyfile = self.filepath
1972
1973         if self.target == 'DEFAULT':
1974             # don't use bpy.utils.script_paths("addons") because we may not be able to write to it.
1975             path_addons = bpy.utils.user_resource('SCRIPTS', "addons", create=True)
1976         else:
1977             path_addons = context.user_preferences.filepaths.script_directory
1978             if path_addons:
1979                 path_addons = os.path.join(path_addons, "addons")
1980
1981         if not path_addons:
1982             self.report({'ERROR'}, "Failed to get add-ons path")
1983             return {'CANCELLED'}
1984
1985         if not os.path.isdir(path_addons):
1986             try:
1987                 os.makedirs(path_addons, exist_ok=True)
1988             except:
1989                 traceback.print_exc()
1990
1991         # Check if we are installing from a target path,
1992         # doing so causes 2+ addons of same name or when the same from/to
1993         # location is used, removal of the file!
1994         addon_path = ""
1995         pyfile_dir = os.path.dirname(pyfile)
1996         for addon_path in addon_utils.paths():
1997             if os.path.samefile(pyfile_dir, addon_path):
1998                 self.report({'ERROR'}, "Source file is in the add-on search path: %r" % addon_path)
1999                 return {'CANCELLED'}
2000         del addon_path
2001         del pyfile_dir
2002         # done checking for exceptional case
2003
2004         addons_old = {mod.__name__ for mod in addon_utils.modules()}
2005
2006         # check to see if the file is in compressed format (.zip)
2007         if zipfile.is_zipfile(pyfile):
2008             try:
2009                 file_to_extract = zipfile.ZipFile(pyfile, 'r')
2010             except:
2011                 traceback.print_exc()
2012                 return {'CANCELLED'}
2013
2014             if self.overwrite:
2015                 for f in file_to_extract.namelist():
2016                     module_filesystem_remove(path_addons, f)
2017             else:
2018                 for f in file_to_extract.namelist():
2019                     path_dest = os.path.join(path_addons, os.path.basename(f))
2020                     if os.path.exists(path_dest):
2021                         self.report({'WARNING'}, "File already installed to %r\n" % path_dest)
2022                         return {'CANCELLED'}
2023
2024             try:  # extract the file to "addons"
2025                 file_to_extract.extractall(path_addons)
2026             except:
2027                 traceback.print_exc()
2028                 return {'CANCELLED'}
2029
2030         else:
2031             path_dest = os.path.join(path_addons, os.path.basename(pyfile))
2032
2033             if self.overwrite:
2034                 module_filesystem_remove(path_addons, os.path.basename(pyfile))
2035             elif os.path.exists(path_dest):
2036                 self.report({'WARNING'}, "File already installed to %r\n" % path_dest)
2037                 return {'CANCELLED'}
2038
2039             # if not compressed file just copy into the addon path
2040             try:
2041                 shutil.copyfile(pyfile, path_dest)
2042             except:
2043                 traceback.print_exc()
2044                 return {'CANCELLED'}
2045
2046         addons_new = {mod.__name__ for mod in addon_utils.modules()} - addons_old
2047         addons_new.discard("modules")
2048
2049         # disable any addons we may have enabled previously and removed.
2050         # this is unlikely but do just in case. bug [#23978]
2051         for new_addon in addons_new:
2052             addon_utils.disable(new_addon, default_set=True)
2053
2054         # possible the zip contains multiple addons, we could disallow this
2055         # but for now just use the first
2056         for mod in addon_utils.modules(refresh=False):
2057             if mod.__name__ in addons_new:
2058                 info = addon_utils.module_bl_info(mod)
2059
2060                 # show the newly installed addon.
2061                 context.window_manager.addon_filter = 'All'
2062                 context.window_manager.addon_search = info["name"]
2063                 break
2064
2065         # in case a new module path was created to install this addon.
2066         bpy.utils.refresh_script_paths()
2067
2068         # print message
2069         msg = (
2070             tip_("Modules Installed (%s) from %r into %r") %
2071             (", ".join(sorted(addons_new)), pyfile, path_addons)
2072         )
2073         print(msg)
2074         self.report({'INFO'}, msg)
2075
2076         return {'FINISHED'}
2077
2078     def invoke(self, context, event):
2079         wm = context.window_manager
2080         wm.fileselect_add(self)
2081         return {'RUNNING_MODAL'}
2082
2083
2084 class WM_OT_addon_remove(Operator):
2085     """Delete the add-on from the file system"""
2086     bl_idname = "wm.addon_remove"
2087     bl_label = "Remove Add-on"
2088
2089     module: StringProperty(
2090         name="Module",
2091         description="Module name of the add-on to remove",
2092     )
2093
2094     @staticmethod
2095     def path_from_addon(module):
2096         import os
2097         import addon_utils
2098
2099         for mod in addon_utils.modules():
2100             if mod.__name__ == module:
2101                 filepath = mod.__file__
2102                 if os.path.exists(filepath):
2103                     if os.path.splitext(os.path.basename(filepath))[0] == "__init__":
2104                         return os.path.dirname(filepath), True
2105                     else:
2106                         return filepath, False
2107         return None, False
2108
2109     def execute(self, context):
2110         import addon_utils
2111         import os
2112
2113         path, isdir = WM_OT_addon_remove.path_from_addon(self.module)
2114         if path is None:
2115             self.report({'WARNING'}, "Add-on path %r could not be found" % path)
2116             return {'CANCELLED'}
2117
2118         # in case its enabled
2119         addon_utils.disable(self.module, default_set=True)
2120
2121         import shutil
2122         if isdir:
2123             shutil.rmtree(path)
2124         else:
2125             os.remove(path)
2126
2127         addon_utils.modules_refresh()
2128
2129         context.area.tag_redraw()
2130         return {'FINISHED'}
2131
2132     # lame confirmation check
2133     def draw(self, context):
2134         self.layout.label(text="Remove Add-on: %r?" % self.module)
2135         path, _isdir = WM_OT_addon_remove.path_from_addon(self.module)
2136         self.layout.label(text="Path: %r" % path)
2137
2138     def invoke(self, context, event):
2139         wm = context.window_manager
2140         return wm.invoke_props_dialog(self, width=600)
2141
2142
2143 class WM_OT_addon_expand(Operator):
2144     """Display information and preferences for this add-on"""
2145     bl_idname = "wm.addon_expand"
2146     bl_label = ""
2147     bl_options = {'INTERNAL'}
2148
2149     module: StringProperty(
2150         name="Module",
2151         description="Module name of the add-on to expand",
2152     )
2153
2154     def execute(self, context):
2155         import addon_utils
2156
2157         module_name = self.module
2158
2159         mod = addon_utils.addons_fake_modules.get(module_name)
2160         if mod is not None:
2161             info = addon_utils.module_bl_info(mod)
2162             info["show_expanded"] = not info["show_expanded"]
2163
2164         return {'FINISHED'}
2165
2166
2167 class WM_OT_addon_userpref_show(Operator):
2168     """Show add-on user preferences"""
2169     bl_idname = "wm.addon_userpref_show"
2170     bl_label = ""
2171     bl_options = {'INTERNAL'}
2172
2173     module: StringProperty(
2174         name="Module",
2175         description="Module name of the add-on to expand",
2176     )
2177
2178     def execute(self, context):
2179         import addon_utils
2180
2181         module_name = self.module
2182
2183         _modules = addon_utils.modules(refresh=False)
2184         mod = addon_utils.addons_fake_modules.get(module_name)
2185         if mod is not None:
2186             info = addon_utils.module_bl_info(mod)
2187             info["show_expanded"] = True
2188
2189             context.user_preferences.active_section = 'ADDONS'
2190             context.window_manager.addon_filter = 'All'
2191             context.window_manager.addon_search = info["name"]
2192             bpy.ops.screen.userpref_show('INVOKE_DEFAULT')
2193
2194         return {'FINISHED'}
2195
2196
2197 # Note: shares some logic with WM_OT_addon_install
2198 # but not enough to de-duplicate. Fixes here may apply to both.
2199 class WM_OT_app_template_install(Operator):
2200     """Install an application-template"""
2201     bl_idname = "wm.app_template_install"
2202     bl_label = "Install Template from File..."
2203
2204     overwrite: BoolProperty(
2205         name="Overwrite",
2206         description="Remove existing template with the same ID",
2207         default=True,
2208     )
2209
2210     filepath: StringProperty(
2211         subtype='FILE_PATH',
2212     )
2213     filter_folder: BoolProperty(
2214         name="Filter folders",
2215         default=True,
2216         options={'HIDDEN'},
2217     )
2218     filter_glob: StringProperty(
2219         default="*.zip",
2220         options={'HIDDEN'},
2221     )
2222
2223     def execute(self, context):
2224         import traceback
2225         import zipfile
2226         import os
2227
2228         filepath = self.filepath
2229
2230         path_app_templates = bpy.utils.user_resource(
2231             'SCRIPTS', os.path.join("startup", "bl_app_templates_user"),
2232             create=True,
2233         )
2234
2235         if not path_app_templates:
2236             self.report({'ERROR'}, "Failed to get add-ons path")
2237             return {'CANCELLED'}
2238
2239         if not os.path.isdir(path_app_templates):
2240             try:
2241                 os.makedirs(path_app_templates, exist_ok=True)
2242             except:
2243                 traceback.print_exc()
2244
2245         app_templates_old = set(os.listdir(path_app_templates))
2246
2247         # check to see if the file is in compressed format (.zip)
2248         if zipfile.is_zipfile(filepath):
2249             try:
2250                 file_to_extract = zipfile.ZipFile(filepath, 'r')
2251             except:
2252                 traceback.print_exc()
2253                 return {'CANCELLED'}
2254
2255             if self.overwrite:
2256                 for f in file_to_extract.namelist():
2257                     module_filesystem_remove(path_app_templates, f)
2258             else:
2259                 for f in file_to_extract.namelist():
2260                     path_dest = os.path.join(path_app_templates, os.path.basename(f))
2261                     if os.path.exists(path_dest):
2262                         self.report({'WARNING'}, "File already installed to %r\n" % path_dest)
2263                         return {'CANCELLED'}
2264
2265             try:  # extract the file to "bl_app_templates_user"
2266                 file_to_extract.extractall(path_app_templates)
2267             except:
2268                 traceback.print_exc()
2269                 return {'CANCELLED'}
2270
2271         else:
2272             # Only support installing zipfiles
2273             self.report({'WARNING'}, "Expected a zip-file %r\n" % filepath)
2274             return {'CANCELLED'}
2275
2276         app_templates_new = set(os.listdir(path_app_templates)) - app_templates_old
2277
2278         # in case a new module path was created to install this addon.
2279         bpy.utils.refresh_script_paths()
2280
2281         # print message
2282         msg = (
2283             tip_("Template Installed (%s) from %r into %r") %
2284             (", ".join(sorted(app_templates_new)), filepath, path_app_templates)
2285         )
2286         print(msg)
2287         self.report({'INFO'}, msg)
2288
2289         return {'FINISHED'}
2290
2291     def invoke(self, context, event):
2292         wm = context.window_manager
2293         wm.fileselect_add(self)
2294         return {'RUNNING_MODAL'}
2295
2296
2297 class WM_OT_tool_set_by_name(Operator):
2298     """Set the tool by name (for keymaps)"""
2299     bl_idname = "wm.tool_set_by_name"
2300     bl_label = "Set Tool By Name"
2301
2302     name: StringProperty(
2303         name="Text",
2304         description="Display name of the tool",
2305     )
2306     cycle: BoolProperty(
2307         name="Cycle",
2308         description="Cycle through tools in this group",
2309         default=False,
2310         options={'SKIP_SAVE'},
2311     )
2312
2313     space_type: rna_space_type_prop
2314
2315     if use_toolbar_release_hack:
2316         def invoke(self, context, event):
2317             # Hack :S
2318             if not self.properties.is_property_set("name"):
2319                 WM_OT_toolbar._key_held = False
2320                 return {'PASS_THROUGH'}
2321             elif (WM_OT_toolbar._key_held == event.type) and (event.value != 'RELEASE'):
2322                 return {'PASS_THROUGH'}
2323             WM_OT_toolbar._key_held = None
2324
2325             return self.execute(context)
2326
2327     def execute(self, context):
2328         from bl_ui.space_toolsystem_common import (
2329             activate_by_name,
2330             activate_by_name_or_cycle,
2331         )
2332
2333         if self.properties.is_property_set("space_type"):
2334             space_type = self.space_type
2335         else:
2336             space_type = context.space_data.type
2337
2338         fn = activate_by_name_or_cycle if self.cycle else activate_by_name
2339         if fn(context, space_type, self.name):
2340             return {'FINISHED'}
2341         else:
2342             self.report({'WARNING'}, f"Tool {self.name!r:s} not found for space {space_type!r:s}.")
2343             return {'CANCELLED'}
2344
2345
2346 class WM_OT_toolbar(Operator):
2347     bl_idname = "wm.toolbar"
2348     bl_label = "Toolbar"
2349
2350     @classmethod
2351     def poll(cls, context):
2352         return context.space_data is not None
2353
2354     if use_toolbar_release_hack:
2355         _key_held = None
2356         def invoke(self, context, event):
2357             WM_OT_toolbar._key_held = event.type
2358             return self.execute(context)
2359
2360     def execute(self, context):
2361         from bl_ui.space_toolsystem_common import ToolSelectPanelHelper
2362         from bl_keymap_utils import keymap_from_toolbar
2363
2364         space_type = context.space_data.type
2365         cls = ToolSelectPanelHelper._tool_class_from_space_type(space_type)
2366         if cls is None:
2367             return {'CANCELLED'}
2368
2369         wm = context.window_manager
2370         keymap = keymap_from_toolbar.generate(context, space_type)
2371
2372         def draw_menu(popover, context):
2373             layout = popover.layout
2374             layout.operator_context = 'INVOKE_REGION_WIN'
2375             cls.draw_cls(layout, context, detect_layout=False, scale_y=1.0)
2376
2377         wm.popover(draw_menu, ui_units_x=8, keymap=keymap)
2378         return {'FINISHED'}
2379
2380
2381 # Studio Light operations
2382 class WM_OT_studiolight_install(Operator):
2383     """Install a user defined studio light"""
2384     bl_idname = "wm.studiolight_install"
2385     bl_label = "Install Custom Studio Light"
2386
2387     files: CollectionProperty(
2388         name="File Path",
2389         type=OperatorFileListElement,
2390     )
2391     directory: StringProperty(
2392         subtype='DIR_PATH',
2393     )
2394     filter_folder: BoolProperty(
2395         name="Filter folders",
2396         default=True,
2397         options={'HIDDEN'},
2398     )
2399     filter_glob: StringProperty(
2400         default="*.png;*.jpg;*.hdr;*.exr",
2401         options={'HIDDEN'},
2402     )
2403     type: EnumProperty(
2404         items=(
2405             ('MATCAP', "MatCap", ""),
2406             ('WORLD', "World", ""),
2407             ('STUDIO', "Studio", ""),
2408         )
2409     )
2410
2411     def execute(self, context):
2412         import traceback
2413         import shutil
2414         import pathlib
2415         userpref = context.user_preferences
2416
2417         filepaths = [pathlib.Path(self.directory, e.name) for e in self.files]
2418         path_studiolights = bpy.utils.user_resource('DATAFILES')
2419
2420         if not path_studiolights:
2421             self.report({'ERROR'}, "Failed to get Studio Light path")
2422             return {'CANCELLED'}
2423
2424         path_studiolights = pathlib.Path(path_studiolights, "studiolights", self.type.lower())
2425         if not path_studiolights.exists():
2426             try:
2427                 path_studiolights.mkdir(parents=True, exist_ok=True)
2428             except:
2429                 traceback.print_exc()
2430
2431         for filepath in filepaths:
2432             shutil.copy(str(filepath), str(path_studiolights))
2433             userpref.studio_lights.load(str(path_studiolights.joinpath(filepath.name)), self.type)
2434
2435         # print message
2436         msg = (
2437             tip_("StudioLight Installed %r into %r") %
2438             (", ".join(str(x.name) for x in self.files), str(path_studiolights))
2439         )
2440         print(msg)
2441         self.report({'INFO'}, msg)
2442         return {'FINISHED'}
2443
2444     def invoke(self, context, event):
2445         wm = context.window_manager
2446         wm.fileselect_add(self)
2447         return {'RUNNING_MODAL'}
2448
2449
2450 class WM_OT_studiolight_new(Operator):
2451     """Save custom studio light from the studio light editor settings"""
2452     bl_idname = 'wm.studiolight_new'
2453     bl_label = "Save custom Studio light"
2454
2455     filename: StringProperty(
2456         name="Name",
2457         default="StudioLight",
2458     )
2459
2460     ask_overide = False
2461
2462     def execute(self, context):
2463         import pathlib
2464         userpref = context.user_preferences
2465         wm = context.window_manager
2466
2467         path_studiolights = bpy.utils.user_resource('DATAFILES')
2468
2469         if not path_studiolights:
2470             self.report({'ERROR'}, "Failed to get Studio Light path")
2471             return {'CANCELLED'}
2472
2473         path_studiolights = pathlib.Path(path_studiolights, "studiolights", "studio")
2474         if not path_studiolights.exists():
2475             try:
2476                 path_studiolights.mkdir(parents=True, exist_ok=True)
2477             except:
2478                 traceback.print_exc()
2479
2480         finalpath = str(path_studiolights.joinpath(self.filename));
2481         if pathlib.Path(finalpath + ".sl").is_file():
2482             if not self.ask_overide:
2483                 self.ask_overide = True
2484                 return wm.invoke_props_dialog(self, width=600)
2485             else:
2486                 for studio_light in userpref.studio_lights:
2487                     if studio_light.name == self.filename + ".sl":
2488                         bpy.ops.wm.studiolight_uninstall(index=studio_light.index)
2489
2490         userpref.studio_lights.new(path=finalpath)
2491
2492         # print message
2493         msg = (
2494             tip_("StudioLight Installed %r into %r") %
2495             (self.filename, str(path_studiolights))
2496         )
2497         print(msg)
2498         self.report({'INFO'}, msg)
2499         return {'FINISHED'}
2500
2501     def draw(self, context):
2502         layout = self.layout
2503         if self.ask_overide:
2504             layout.label(text="Warning, file already exists. Overwrite existing file?")
2505         else:
2506             layout.prop(self, "filename")
2507
2508     def invoke(self, context, event):
2509         wm = context.window_manager
2510         return wm.invoke_props_dialog(self, width=600)
2511
2512
2513 class WM_OT_studiolight_uninstall(Operator):
2514     """Delete Studio Light"""
2515     bl_idname = 'wm.studiolight_uninstall'
2516     bl_label = "Uninstall Studio Light"
2517     index: bpy.props.IntProperty()
2518
2519     def _remove_path(self, path):
2520         if path.exists():
2521             path.unlink()
2522
2523     def execute(self, context):
2524         import pathlib
2525         userpref = context.user_preferences
2526         for studio_light in userpref.studio_lights:
2527             if studio_light.index == self.index:
2528                 if studio_light.path:
2529                     self._remove_path(pathlib.Path(studio_light.path))
2530                 if studio_light.path_irr_cache:
2531                     self._remove_path(pathlib.Path(studio_light.path_irr_cache))
2532                 if studio_light.path_sh_cache:
2533                     self._remove_path(pathlib.Path(studio_light.path_sh_cache))
2534                 userpref.studio_lights.remove(studio_light)
2535                 return {'FINISHED'}
2536         return {'CANCELLED'}
2537
2538
2539 class WM_OT_studiolight_copy_settings(Operator):
2540     """Copy Studio Light settings to the Studio light editor"""
2541     bl_idname = 'wm.studiolight_copy_settings'
2542     bl_label = "Copy Studio Light settings"
2543     index: bpy.props.IntProperty()
2544
2545     def execute(self, context):
2546         userpref = context.user_preferences
2547         system = userpref.system
2548         for studio_light in userpref.studio_lights:
2549             if studio_light.index == self.index:
2550                 system.light_ambient = studio_light.light_ambient
2551                 for sys_light, light in zip(system.solid_lights, studio_light.solid_lights):
2552                     sys_light.use = light.use
2553                     sys_light.diffuse_color = light.diffuse_color
2554                     sys_light.specular_color = light.specular_color
2555                     sys_light.smooth = light.smooth
2556                     sys_light.direction = light.direction
2557                 return {'FINISHED'}
2558         return {'CANCELLED'}
2559
2560
2561 class WM_OT_studiolight_userpref_show(Operator):
2562     """Show light user preferences"""
2563     bl_idname = "wm.studiolight_userpref_show"
2564     bl_label = ""
2565     bl_options = {'INTERNAL'}
2566
2567     def execute(self, context):
2568         context.user_preferences.active_section = 'LIGHTS'
2569         bpy.ops.screen.userpref_show('INVOKE_DEFAULT')
2570         return {'FINISHED'}
2571
2572
2573 class WM_MT_splash(Menu):
2574     bl_label = "Splash"
2575
2576     def draw_setup(self, context):
2577         wm = context.window_manager
2578         # userpref = context.user_preferences
2579
2580         layout = self.layout
2581
2582         layout.operator_context = 'EXEC_DEFAULT'
2583
2584         layout.label(text="Quick Setup")
2585
2586         split = layout.split(factor=0.25)
2587         split.label()
2588         split = split.split(factor=2.0 / 3.0)
2589
2590         col = split.column()
2591
2592         col.label()
2593
2594         sub = col.split(factor=0.35)
2595         row = sub.row()
2596         row.alignment = 'RIGHT'
2597         row.label(text="Shortcuts")
2598         text = bpy.path.display_name(wm.keyconfigs.active.name)
2599         if not text:
2600             text = "Blender"
2601         sub.menu("USERPREF_MT_keyconfigs", text=text)
2602
2603         kc = wm.keyconfigs.active
2604         kc_prefs = kc.preferences
2605         has_select_mouse = hasattr(kc_prefs, "select_mouse")
2606         if has_select_mouse:
2607             sub = col.split(factor=0.35)
2608             row = sub.row()
2609             row.alignment = 'RIGHT'
2610             row.label(text="Select With")
2611             sub.row().prop(kc_prefs, "select_mouse", expand=True)
2612             has_select_mouse = True
2613
2614         has_spacebar_action = hasattr(kc_prefs, "spacebar_action")
2615         if has_spacebar_action:
2616             sub = col.split(factor=0.35)
2617             row = sub.row()
2618             row.alignment = 'RIGHT'
2619             row.label(text="Spacebar")
2620             sub.row().prop(kc_prefs, "spacebar_action", expand=True)
2621             has_select_mouse = True
2622
2623         col.separator()
2624
2625         sub = col.split(factor=0.35)
2626         row = sub.row()
2627         row.alignment = 'RIGHT'
2628         row.label(text="Theme")
2629         label = bpy.types.USERPREF_MT_interface_theme_presets.bl_label
2630         if label == "Presets":
2631             label = "Blender Dark"
2632         sub.menu("USERPREF_MT_interface_theme_presets", text=label)
2633
2634         # We need to make switching to a language easier first
2635         #sub = col.split(factor=0.35)
2636         #row = sub.row()
2637         #row.alignment = 'RIGHT'
2638         #row.label(text="Language:")
2639         #userpref = context.user_preferences
2640         #sub.prop(userpref.system, "language", text="")
2641
2642         # Keep height constant
2643         if not has_select_mouse:
2644             col.label()
2645         if not has_spacebar_action:
2646             col.label()
2647
2648         layout.label()
2649
2650         row = layout.row()
2651
2652         sub = row.row()
2653         if bpy.types.WM_OT_copy_prev_settings.poll(context):
2654             old_version = bpy.types.WM_OT_copy_prev_settings.previous_version()
2655             sub.operator("wm.copy_prev_settings", text="Load %d.%d Settings" % old_version)
2656             sub.operator("wm.save_userpref", text="Save New Settings")
2657         else:
2658             sub.label()
2659             sub.label()
2660             sub.operator("wm.save_userpref", text="Next")
2661
2662         layout.separator()
2663         layout.separator()
2664
2665     def draw(self, context):
2666         # Draw setup screen if no user preferences have been saved yet.
2667         import os
2668
2669         user_path = bpy.utils.resource_path('USER')
2670         userdef_path = os.path.join(user_path, "config", "userpref.blend")
2671
2672         if not os.path.isfile(userdef_path):
2673             self.draw_setup(context)
2674             return
2675
2676         # Pass
2677         layout = self.layout
2678         layout.operator_context = 'EXEC_DEFAULT'
2679         layout.emboss = 'PULLDOWN_MENU'
2680
2681         split = layout.split()
2682
2683         # Templates
2684         col1 = split.column()
2685         col1.label(text="New File")
2686
2687         bpy.types.TOPBAR_MT_file_new.draw_ex(col1, context, use_splash=True)
2688
2689         # Recent
2690         col2 = split.column()
2691         col2_title = col2.row()
2692
2693         found_recent = col2.template_recent_files()
2694
2695         if found_recent:
2696             col2_title.label(text="Recent Files")
2697         else:
2698             # Links if no recent files
2699             col2_title.label(text="Getting Started")
2700
2701             col2.operator(
2702                 "wm.url_open", text="Manual", icon='URL'
2703             ).url = "https://docs.blender.org/manual/en/dev/"
2704             col2.operator(
2705                 "wm.url_open", text="Release Notes", icon='URL',
2706             ).url = "https://www.blender.org/download/releases/%d-%d/" % bpy.app.version[:2]
2707             col2.operator(
2708                 "wm.url_open", text="Blender Website", icon='URL',
2709             ).url = "https://www.blender.org"
2710             col2.operator(
2711                 "wm.url_open", text="Credits", icon='URL',
2712             ).url = "https://www.blender.org/about/credits/"
2713
2714         layout.separator()
2715
2716         split = layout.split()
2717
2718         col1 = split.column()
2719         sub = col1.row()
2720         sub.operator_context = 'INVOKE_DEFAULT'
2721         sub.operator("wm.open_mainfile", text="Open...", icon='FILE_FOLDER')
2722         col1.operator("wm.recover_last_session", icon='RECOVER_LAST')
2723
2724         col2 = split.column()
2725         if found_recent:
2726             col2.operator(
2727                 "wm.url_open", text="Release Notes", icon='URL',
2728             ).url = "https://www.blender.org/download/releases/%d-%d/" % bpy.app.version[:2]
2729             col2.operator(
2730                 "wm.url_open", text="Development Fund", icon='URL'
2731             ).url = "https://fund.blender.org"
2732         else:
2733             col2.operator(
2734                 "wm.url_open", text="Development Fund", icon='URL'
2735             ).url = "https://fund.blender.org"
2736             col2.operator(
2737                 "wm.url_open", text="Donate", icon='URL'
2738             ).url = "https://www.blender.org/foundation/donation-payment/"
2739
2740         layout.separator()
2741         layout.separator()
2742
2743
2744 class WM_OT_drop_blend_file(Operator):
2745     bl_idname = "wm.drop_blend_file"
2746     bl_label = "Handle dropped .blend file"
2747     bl_options = {'INTERNAL'}
2748
2749     filepath: StringProperty()
2750
2751     def invoke(self, context, event):
2752         context.window_manager.popup_menu(self.draw_menu, title=bpy.path.basename(self.filepath), icon='QUESTION')
2753         return {"FINISHED"}
2754
2755     def draw_menu(self, menu, context):
2756         layout = menu.layout
2757
2758         col = layout.column()
2759         col.operator_context = 'EXEC_DEFAULT'
2760         col.operator("wm.open_mainfile", text="Open", icon='FILE_FOLDER').filepath = self.filepath
2761
2762         layout.separator()
2763         col = layout.column()
2764         col.operator_context = 'INVOKE_DEFAULT'
2765         col.operator("wm.link", text="Link...", icon='LINK_BLEND').filepath = self.filepath
2766         col.operator("wm.append", text="Append...", icon='APPEND_BLEND').filepath = self.filepath
2767
2768 classes = (
2769     WM_OT_addon_disable,
2770     WM_OT_addon_enable,
2771     WM_OT_addon_expand,
2772     WM_OT_addon_install,
2773     WM_OT_addon_refresh,
2774     WM_OT_addon_remove,
2775     WM_OT_addon_userpref_show,
2776     WM_OT_app_template_install,
2777     WM_OT_context_collection_boolean_set,
2778     WM_OT_context_cycle_array,
2779     WM_OT_context_cycle_enum,
2780     WM_OT_context_cycle_int,
2781     WM_OT_context_menu_enum,
2782     WM_OT_context_modal_mouse,
2783     WM_OT_context_pie_enum,
2784     WM_OT_context_scale_float,
2785     WM_OT_context_scale_int,
2786     WM_OT_context_set_boolean,
2787     WM_OT_context_set_enum,
2788     WM_OT_context_set_float,
2789     WM_OT_context_set_id,
2790     WM_OT_context_set_int,
2791     WM_OT_context_set_string,
2792     WM_OT_context_set_value,
2793     WM_OT_context_toggle,
2794     WM_OT_context_toggle_enum,
2795     WM_OT_copy_prev_settings,
2796     WM_OT_doc_view,
2797     WM_OT_doc_view_manual,
2798     WM_OT_drop_blend_file,
2799     WM_OT_keyconfig_activate,
2800     WM_OT_keyconfig_export,
2801     WM_OT_keyconfig_import,
2802     WM_OT_keyconfig_remove,
2803     WM_OT_keyconfig_test,
2804     WM_OT_keyitem_add,
2805     WM_OT_keyitem_remove,
2806     WM_OT_keyitem_restore,
2807     WM_OT_keymap_restore,
2808     WM_OT_operator_cheat_sheet,
2809     WM_OT_operator_pie_enum,
2810     WM_OT_path_open,
2811     WM_OT_properties_add,
2812     WM_OT_properties_context_change,
2813     WM_OT_properties_edit,
2814     WM_OT_properties_remove,
2815     WM_OT_sysinfo,
2816     WM_OT_theme_install,
2817     WM_OT_owner_disable,
2818     WM_OT_owner_enable,
2819     WM_OT_url_open,
2820     WM_OT_studiolight_install,
2821     WM_OT_studiolight_new,
2822     WM_OT_studiolight_uninstall,
2823     WM_OT_studiolight_copy_settings,
2824     WM_OT_studiolight_userpref_show,
2825     WM_OT_tool_set_by_name,
2826     WM_OT_toolbar,
2827     WM_MT_splash,
2828 )