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