formatting edits, no functional changes.
[blender.git] / release / scripts / startup / bl_operators / wm.py
1 # ##### BEGIN GPL LICENSE BLOCK #####
2 #
3 #  This program is free software; you can redistribute it and/or
4 #  modify it under the terms of the GNU General Public License
5 #  as published by the Free Software Foundation; either version 2
6 #  of the License, or (at your option) any later version.
7 #
8 #  This program is distributed in the hope that it will be useful,
9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 #  GNU General Public License for more details.
12 #
13 #  You should have received a copy of the GNU General Public License
14 #  along with this program; if not, write to the Free Software Foundation,
15 #  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16 #
17 # ##### END GPL LICENSE BLOCK #####
18
19 # <pep8 compliant>
20
21 import bpy
22 from bpy.types import Menu, Operator
23 from bpy.props import (StringProperty,
24                        BoolProperty,
25                        IntProperty,
26                        FloatProperty,
27                        EnumProperty,
28                        )
29
30 from rna_prop_ui import rna_idprop_ui_prop_get, rna_idprop_ui_prop_clear
31
32
33 class MESH_OT_delete_edgeloop(Operator):
34     '''Delete an edge loop by merging the faces on each side to a single face loop'''
35     bl_idname = "mesh.delete_edgeloop"
36     bl_label = "Delete Edge Loop"
37
38     def execute(self, context):
39         if 'FINISHED' in bpy.ops.transform.edge_slide(value=1.0):
40             bpy.ops.mesh.select_more()
41             bpy.ops.mesh.remove_doubles()
42             return {'FINISHED'}
43
44         return {'CANCELLED'}
45
46 rna_path_prop = StringProperty(
47         name="Context Attributes",
48         description="rna context string",
49         maxlen=1024,
50         )
51
52 rna_reverse_prop = BoolProperty(
53         name="Reverse",
54         description="Cycle backwards",
55         default=False,
56         )
57
58 rna_relative_prop = BoolProperty(
59         name="Relative",
60         description="Apply relative to the current value (delta)",
61         default=False,
62         )
63
64
65 def context_path_validate(context, data_path):
66     import sys
67     try:
68         value = eval("context.%s" % data_path) if data_path else Ellipsis
69     except AttributeError:
70         if "'NoneType'" in str(sys.exc_info()[1]):
71             # One of the items in the rna path is None, just ignore this
72             value = Ellipsis
73         else:
74             # We have a real error in the rna path, dont ignore that
75             raise
76
77     return value
78
79
80 def execute_context_assign(self, context):
81     if context_path_validate(context, self.data_path) is Ellipsis:
82         return {'PASS_THROUGH'}
83
84     if getattr(self, "relative", False):
85         exec("context.%s+=self.value" % self.data_path)
86     else:
87         exec("context.%s=self.value" % self.data_path)
88
89     return {'FINISHED'}
90
91
92 class BRUSH_OT_active_index_set(Operator):
93     '''Set active sculpt/paint brush from it's number'''
94     bl_idname = "brush.active_index_set"
95     bl_label = "Set Brush Number"
96
97     mode = StringProperty(
98             name="mode",
99             description="Paint mode to set brush for",
100             maxlen=1024,
101             )
102     index = IntProperty(
103             name="number",
104             description="Brush number",
105             )
106
107     _attr_dict = {"sculpt": "use_paint_sculpt",
108                   "vertex_paint": "use_paint_vertex",
109                   "weight_paint": "use_paint_weight",
110                   "image_paint": "use_paint_image",
111                   }
112
113     def execute(self, context):
114         attr = self._attr_dict.get(self.mode)
115         if attr is None:
116             return {'CANCELLED'}
117
118         for i, brush in enumerate((cur for cur in bpy.data.brushes if getattr(cur, attr))):
119             if i == self.index:
120                 getattr(context.tool_settings, self.mode).brush = brush
121                 return {'FINISHED'}
122
123         return {'CANCELLED'}
124
125
126 class WM_OT_context_set_boolean(Operator):
127     '''Set a context value.'''
128     bl_idname = "wm.context_set_boolean"
129     bl_label = "Context Set Boolean"
130     bl_options = {'UNDO', 'INTERNAL'}
131
132     data_path = rna_path_prop
133     value = BoolProperty(
134             name="Value",
135             description="Assignment value",
136             default=True,
137             )
138
139     execute = execute_context_assign
140
141
142 class WM_OT_context_set_int(Operator):  # same as enum
143     '''Set a context value.'''
144     bl_idname = "wm.context_set_int"
145     bl_label = "Context Set"
146     bl_options = {'UNDO', 'INTERNAL'}
147
148     data_path = rna_path_prop
149     value = IntProperty(
150             name="Value",
151             description="Assign value",
152             default=0,
153             )
154     relative = rna_relative_prop
155
156     execute = execute_context_assign
157
158
159 class WM_OT_context_scale_int(Operator):
160     '''Scale an int context value.'''
161     bl_idname = "wm.context_scale_int"
162     bl_label = "Context Set"
163     bl_options = {'UNDO', 'INTERNAL'}
164
165     data_path = rna_path_prop
166     value = FloatProperty(
167             name="Value",
168             description="Assign value",
169             default=1.0,
170             )
171     always_step = BoolProperty(
172             name="Always Step",
173             description="Always adjust the value by a minimum of 1 when 'value' is not 1.0.",
174             default=True,
175             )
176
177     def execute(self, context):
178         if context_path_validate(context, self.data_path) is Ellipsis:
179             return {'PASS_THROUGH'}
180
181         value = self.value
182         data_path = self.data_path
183
184         if value == 1.0:  # nothing to do
185             return {'CANCELLED'}
186
187         if getattr(self, "always_step", False):
188             if value > 1.0:
189                 add = "1"
190                 func = "max"
191             else:
192                 add = "-1"
193                 func = "min"
194             exec("context.%s = %s(round(context.%s * value), context.%s + %s)" %
195                  (data_path, func, data_path, data_path, add))
196         else:
197             exec("context.%s *= value" % self.data_path)
198
199         return {'FINISHED'}
200
201
202 class WM_OT_context_set_float(Operator):  # same as enum
203     '''Set a context value.'''
204     bl_idname = "wm.context_set_float"
205     bl_label = "Context Set Float"
206     bl_options = {'UNDO', 'INTERNAL'}
207
208     data_path = rna_path_prop
209     value = FloatProperty(
210             name="Value",
211             description="Assignment value",
212             default=0.0,
213             )
214     relative = rna_relative_prop
215
216     execute = execute_context_assign
217
218
219 class WM_OT_context_set_string(Operator):  # same as enum
220     '''Set a context value.'''
221     bl_idname = "wm.context_set_string"
222     bl_label = "Context Set String"
223     bl_options = {'UNDO', 'INTERNAL'}
224
225     data_path = rna_path_prop
226     value = StringProperty(
227             name="Value",
228             description="Assign value",
229             maxlen=1024,
230             )
231
232     execute = execute_context_assign
233
234
235 class WM_OT_context_set_enum(Operator):
236     '''Set a context value.'''
237     bl_idname = "wm.context_set_enum"
238     bl_label = "Context Set Enum"
239     bl_options = {'UNDO', 'INTERNAL'}
240
241     data_path = rna_path_prop
242     value = StringProperty(
243             name="Value",
244             description="Assignment value (as a string)",
245             maxlen=1024,
246             )
247
248     execute = execute_context_assign
249
250
251 class WM_OT_context_set_value(Operator):
252     '''Set a context value.'''
253     bl_idname = "wm.context_set_value"
254     bl_label = "Context Set Value"
255     bl_options = {'UNDO', 'INTERNAL'}
256
257     data_path = rna_path_prop
258     value = StringProperty(
259             name="Value",
260             description="Assignment value (as a string)",
261             maxlen=1024,
262             )
263
264     def execute(self, context):
265         if context_path_validate(context, self.data_path) is Ellipsis:
266             return {'PASS_THROUGH'}
267         exec("context.%s=%s" % (self.data_path, self.value))
268         return {'FINISHED'}
269
270
271 class WM_OT_context_toggle(Operator):
272     '''Toggle a context value.'''
273     bl_idname = "wm.context_toggle"
274     bl_label = "Context Toggle"
275     bl_options = {'UNDO', 'INTERNAL'}
276
277     data_path = rna_path_prop
278
279     def execute(self, context):
280
281         if context_path_validate(context, self.data_path) is Ellipsis:
282             return {'PASS_THROUGH'}
283
284         exec("context.%s=not (context.%s)" %
285             (self.data_path, self.data_path))
286
287         return {'FINISHED'}
288
289
290 class WM_OT_context_toggle_enum(Operator):
291     '''Toggle a context value.'''
292     bl_idname = "wm.context_toggle_enum"
293     bl_label = "Context Toggle Values"
294     bl_options = {'UNDO', 'INTERNAL'}
295
296     data_path = rna_path_prop
297     value_1 = StringProperty(
298             name="Value",
299             description="Toggle enum",
300             maxlen=1024,
301             )
302     value_2 = StringProperty(
303             name="Value",
304             description="Toggle enum",
305             maxlen=1024,
306             )
307
308     def execute(self, context):
309
310         if context_path_validate(context, self.data_path) is Ellipsis:
311             return {'PASS_THROUGH'}
312
313         exec("context.%s = ['%s', '%s'][context.%s!='%s']" %
314              (self.data_path, self.value_1,
315               self.value_2, self.data_path,
316               self.value_2,
317               ))
318
319         return {'FINISHED'}
320
321
322 class WM_OT_context_cycle_int(Operator):
323     '''Set a context value. Useful for cycling active material, '''
324     '''vertex keys, groups' etc.'''
325     bl_idname = "wm.context_cycle_int"
326     bl_label = "Context Int Cycle"
327     bl_options = {'UNDO', 'INTERNAL'}
328
329     data_path = rna_path_prop
330     reverse = rna_reverse_prop
331
332     def execute(self, context):
333         data_path = self.data_path
334         value = context_path_validate(context, data_path)
335         if value is Ellipsis:
336             return {'PASS_THROUGH'}
337
338         if self.reverse:
339             value -= 1
340         else:
341             value += 1
342
343         exec("context.%s=value" % data_path)
344
345         if value != eval("context.%s" % data_path):
346             # relies on rna clamping int's out of the range
347             if self.reverse:
348                 value = (1 << 31) - 1
349             else:
350                 value = -1 << 31
351
352             exec("context.%s=value" % data_path)
353
354         return {'FINISHED'}
355
356
357 class WM_OT_context_cycle_enum(Operator):
358     '''Toggle a context value.'''
359     bl_idname = "wm.context_cycle_enum"
360     bl_label = "Context Enum Cycle"
361     bl_options = {'UNDO', 'INTERNAL'}
362
363     data_path = rna_path_prop
364     reverse = rna_reverse_prop
365
366     def execute(self, context):
367
368         value = context_path_validate(context, self.data_path)
369         if value is Ellipsis:
370             return {'PASS_THROUGH'}
371
372         orig_value = value
373
374         # Have to get rna enum values
375         rna_struct_str, rna_prop_str = self.data_path.rsplit('.', 1)
376         i = rna_prop_str.find('[')
377
378         # just incse we get "context.foo.bar[0]"
379         if i != -1:
380             rna_prop_str = rna_prop_str[0:i]
381
382         rna_struct = eval("context.%s.rna_type" % rna_struct_str)
383
384         rna_prop = rna_struct.properties[rna_prop_str]
385
386         if type(rna_prop) != bpy.types.EnumProperty:
387             raise Exception("expected an enum property")
388
389         enums = rna_struct.properties[rna_prop_str].enum_items.keys()
390         orig_index = enums.index(orig_value)
391
392         # Have the info we need, advance to the next item
393         if self.reverse:
394             if orig_index == 0:
395                 advance_enum = enums[-1]
396             else:
397                 advance_enum = enums[orig_index - 1]
398         else:
399             if orig_index == len(enums) - 1:
400                 advance_enum = enums[0]
401             else:
402                 advance_enum = enums[orig_index + 1]
403
404         # set the new value
405         exec("context.%s=advance_enum" % self.data_path)
406         return {'FINISHED'}
407
408
409 class WM_OT_context_cycle_array(Operator):
410     '''Set a context array value.
411     Useful for cycling the active mesh edit mode.'''
412     bl_idname = "wm.context_cycle_array"
413     bl_label = "Context Array Cycle"
414     bl_options = {'UNDO', 'INTERNAL'}
415
416     data_path = rna_path_prop
417     reverse = rna_reverse_prop
418
419     def execute(self, context):
420         data_path = self.data_path
421         value = context_path_validate(context, data_path)
422         if value is Ellipsis:
423             return {'PASS_THROUGH'}
424
425         def cycle(array):
426             if self.reverse:
427                 array.insert(0, array.pop())
428             else:
429                 array.append(array.pop(0))
430             return array
431
432         exec("context.%s=cycle(context.%s[:])" % (data_path, data_path))
433
434         return {'FINISHED'}
435
436
437 class WM_MT_context_menu_enum(Menu):
438     bl_label = ""
439     data_path = ""  # BAD DESIGN, set from operator below.
440
441     def draw(self, context):
442         data_path = self.data_path
443         value = context_path_validate(bpy.context, data_path)
444         if value is Ellipsis:
445             return {'PASS_THROUGH'}
446         base_path, prop_string = data_path.rsplit(".", 1)
447         value_base = context_path_validate(context, base_path)
448
449         values = [(i.name, i.identifier) for i in value_base.bl_rna.properties[prop_string].enum_items]
450
451         for name, identifier in values:
452             prop = self.layout.operator("wm.context_set_enum", text=name)
453             prop.data_path = data_path
454             prop.value = identifier
455
456
457 class WM_OT_context_menu_enum(Operator):
458     bl_idname = "wm.context_menu_enum"
459     bl_label = "Context Enum Menu"
460     bl_options = {'UNDO', 'INTERNAL'}
461     data_path = rna_path_prop
462
463     def execute(self, context):
464         data_path = self.data_path
465         WM_MT_context_menu_enum.data_path = data_path
466         bpy.ops.wm.call_menu(name="WM_MT_context_menu_enum")
467         return {'PASS_THROUGH'}
468
469
470 class WM_OT_context_set_id(Operator):
471     '''Toggle a context value.'''
472     bl_idname = "wm.context_set_id"
473     bl_label = "Set Library ID"
474     bl_options = {'UNDO', 'INTERNAL'}
475
476     data_path = rna_path_prop
477     value = StringProperty(
478             name="Value",
479             description="Assign value",
480             maxlen=1024,
481             )
482
483     def execute(self, context):
484         value = self.value
485         data_path = self.data_path
486
487         # match the pointer type from the target property to bpy.data.*
488         # so we lookup the correct list.
489         data_path_base, data_path_prop = data_path.rsplit(".", 1)
490         data_prop_rna = eval("context.%s" % data_path_base).rna_type.properties[data_path_prop]
491         data_prop_rna_type = data_prop_rna.fixed_type
492
493         id_iter = None
494
495         for prop in bpy.data.rna_type.properties:
496             if prop.rna_type.identifier == "CollectionProperty":
497                 if prop.fixed_type == data_prop_rna_type:
498                     id_iter = prop.identifier
499                     break
500
501         if id_iter:
502             value_id = getattr(bpy.data, id_iter).get(value)
503             exec("context.%s=value_id" % data_path)
504
505         return {'FINISHED'}
506
507
508 doc_id = StringProperty(
509         name="Doc ID",
510         description="",
511         maxlen=1024,
512         options={'HIDDEN'},
513         )
514
515 doc_new = StringProperty(
516         name="Edit Description",
517         description="",
518         maxlen=1024,
519         )
520
521 data_path_iter = StringProperty(
522         description="The data path relative to the context, must point to an iterable.")
523
524 data_path_item = StringProperty(
525         description="The data path from each iterable to the value (int or float)")
526
527
528 class WM_OT_context_collection_boolean_set(Operator):
529     '''Set boolean values for a collection of items'''
530     bl_idname = "wm.context_collection_boolean_set"
531     bl_label = "Context Collection Boolean Set"
532     bl_options = {'UNDO', 'REGISTER', 'INTERNAL'}
533
534     data_path_iter = data_path_iter
535     data_path_item = data_path_item
536
537     type = EnumProperty(
538             name="Type",
539             items=(('TOGGLE', "Toggle", ""),
540                    ('ENABLE', "Enable", ""),
541                    ('DISABLE', "Disable", ""),
542                    ),
543             )
544
545     def execute(self, context):
546         data_path_iter = self.data_path_iter
547         data_path_item = self.data_path_item
548
549         items = list(getattr(context, data_path_iter))
550         items_ok = []
551         is_set = False
552         for item in items:
553             try:
554                 value_orig = eval("item." + data_path_item)
555             except:
556                 continue
557
558             if value_orig == True:
559                 is_set = True
560             elif value_orig == False:
561                 pass
562             else:
563                 self.report({'WARNING'}, "Non boolean value found: %s[ ].%s" %
564                             (data_path_iter, data_path_item))
565                 return {'CANCELLED'}
566
567             items_ok.append(item)
568
569         if self.type == 'ENABLE':
570             is_set = True
571         elif self.type == 'DISABLE':
572             is_set = False
573         else:
574             is_set = not is_set
575
576         exec_str = "item.%s = %s" % (data_path_item, is_set)
577         for item in items_ok:
578             exec(exec_str)
579
580         return {'FINISHED'}
581
582
583 class WM_OT_context_modal_mouse(Operator):
584     '''Adjust arbitrary values with mouse input'''
585     bl_idname = "wm.context_modal_mouse"
586     bl_label = "Context Modal Mouse"
587     bl_options = {'GRAB_POINTER', 'BLOCKING', 'INTERNAL'}
588
589     data_path_iter = data_path_iter
590     data_path_item = data_path_item
591
592     input_scale = FloatProperty(
593             description="Scale the mouse movement by this value before applying the delta",
594             default=0.01,
595             )
596     invert = BoolProperty(
597             description="Invert the mouse input",
598             default=False,
599             )
600     initial_x = IntProperty(options={'HIDDEN'})
601
602     def _values_store(self, context):
603         data_path_iter = self.data_path_iter
604         data_path_item = self.data_path_item
605
606         self._values = values = {}
607
608         for item in getattr(context, data_path_iter):
609             try:
610                 value_orig = eval("item." + data_path_item)
611             except:
612                 continue
613
614             # check this can be set, maybe this is library data.
615             try:
616                 exec("item.%s = %s" % (data_path_item, value_orig))
617             except:
618                 continue
619
620             values[item] = value_orig
621
622     def _values_delta(self, delta):
623         delta *= self.input_scale
624         if self.invert:
625             delta = - delta
626
627         data_path_item = self.data_path_item
628         for item, value_orig in self._values.items():
629             if type(value_orig) == int:
630                 exec("item.%s = int(%d)" % (data_path_item, round(value_orig + delta)))
631             else:
632                 exec("item.%s = %f" % (data_path_item, value_orig + delta))
633
634     def _values_restore(self):
635         data_path_item = self.data_path_item
636         for item, value_orig in self._values.items():
637             exec("item.%s = %s" % (data_path_item, value_orig))
638
639         self._values.clear()
640
641     def _values_clear(self):
642         self._values.clear()
643
644     def modal(self, context, event):
645         event_type = event.type
646
647         if event_type == 'MOUSEMOVE':
648             delta = event.mouse_x - self.initial_x
649             self._values_delta(delta)
650
651         elif 'LEFTMOUSE' == event_type:
652             self._values_clear()
653             return {'FINISHED'}
654
655         elif event_type in {'RIGHTMOUSE', 'ESC'}:
656             self._values_restore()
657             return {'FINISHED'}
658
659         return {'RUNNING_MODAL'}
660
661     def invoke(self, context, event):
662         self._values_store(context)
663
664         if not self._values:
665             self.report({'WARNING'}, "Nothing to operate on: %s[ ].%s" %
666                     (self.data_path_iter, self.data_path_item))
667
668             return {'CANCELLED'}
669         else:
670             self.initial_x = event.mouse_x
671
672             context.window_manager.modal_handler_add(self)
673             return {'RUNNING_MODAL'}
674
675
676 class WM_OT_url_open(Operator):
677     "Open a website in the Webbrowser"
678     bl_idname = "wm.url_open"
679     bl_label = ""
680
681     url = StringProperty(
682             name="URL",
683             description="URL to open",
684             )
685
686     def execute(self, context):
687         import webbrowser
688         _webbrowser_bug_fix()
689         webbrowser.open(self.url)
690         return {'FINISHED'}
691
692
693 class WM_OT_path_open(Operator):
694     "Open a path in a file browser"
695     bl_idname = "wm.path_open"
696     bl_label = ""
697
698     filepath = StringProperty(
699             name="File Path",
700             maxlen=1024,
701             subtype='FILE_PATH',
702             )
703
704     def execute(self, context):
705         import sys
706         import os
707         import subprocess
708
709         filepath = bpy.path.abspath(self.filepath)
710         filepath = os.path.normpath(filepath)
711
712         if not os.path.exists(filepath):
713             self.report({'ERROR'}, "File '%s' not found" % filepath)
714             return {'CANCELLED'}
715
716         if sys.platform[:3] == "win":
717             subprocess.Popen(['start', filepath], shell=True)
718         elif sys.platform == 'darwin':
719             subprocess.Popen(['open', filepath])
720         else:
721             try:
722                 subprocess.Popen(['xdg-open', filepath])
723             except OSError:
724                 # xdg-open *should* be supported by recent Gnome, KDE, Xfce
725                 pass
726
727         return {'FINISHED'}
728
729
730 class WM_OT_doc_view(Operator):
731     '''Load online reference docs'''
732     bl_idname = "wm.doc_view"
733     bl_label = "View Documentation"
734
735     doc_id = doc_id
736     if bpy.app.version_cycle == "release":
737         _prefix = ("http://www.blender.org/documentation/blender_python_api_%s%s_release" %
738                    ("_".join(str(v) for v in bpy.app.version[:2]), bpy.app.version_char))
739     else:
740         _prefix = ("http://www.blender.org/documentation/blender_python_api_%s" %
741                    "_".join(str(v) for v in bpy.app.version))
742
743     def _nested_class_string(self, class_string):
744         ls = []
745         class_obj = getattr(bpy.types, class_string, None).bl_rna
746         while class_obj:
747             ls.insert(0, class_obj)
748             class_obj = class_obj.nested
749         return '.'.join(class_obj.identifier for class_obj in ls)
750
751     def execute(self, context):
752         id_split = self.doc_id.split('.')
753         if len(id_split) == 1:  # rna, class
754             url = '%s/bpy.types.%s.html' % (self._prefix, id_split[0])
755         elif len(id_split) == 2:  # rna, class.prop
756             class_name, class_prop = id_split
757
758             if hasattr(bpy.types, class_name.upper() + '_OT_' + class_prop):
759                 url = ("%s/bpy.ops.%s.html#bpy.ops.%s.%s" %
760                        (self._prefix, class_name, class_name, class_prop))
761             else:
762
763                 # detect if this is a inherited member and use that name instead
764                 rna_parent = getattr(bpy.types, class_name).bl_rna
765                 rna_prop = rna_parent.properties[class_prop]
766                 rna_parent = rna_parent.base
767                 while rna_parent and rna_prop == rna_parent.properties.get(class_prop):
768                     class_name = rna_parent.identifier
769                     rna_parent = rna_parent.base
770
771                 # It so happens that epydoc nests these, not sphinx
772                 # class_name_full = self._nested_class_string(class_name)
773                 url = ("%s/bpy.types.%s.html#bpy.types.%s.%s" %
774                        (self._prefix, class_name, class_name, class_prop))
775
776         else:
777             return {'PASS_THROUGH'}
778
779         import webbrowser
780         _webbrowser_bug_fix()
781         webbrowser.open(url)
782
783         return {'FINISHED'}
784
785
786 class WM_OT_doc_edit(Operator):
787     '''Load online reference docs'''
788     bl_idname = "wm.doc_edit"
789     bl_label = "Edit Documentation"
790
791     doc_id = doc_id
792     doc_new = doc_new
793
794     _url = "http://www.mindrones.com/blender/svn/xmlrpc.php"
795
796     def _send_xmlrpc(self, data_dict):
797         print("sending data:", data_dict)
798
799         import xmlrpc.client
800         user = 'blenderuser'
801         pwd = 'blender>user'
802
803         docblog = xmlrpc.client.ServerProxy(self._url)
804         docblog.metaWeblog.newPost(1, user, pwd, data_dict, 1)
805
806     def execute(self, context):
807
808         doc_id = self.doc_id
809         doc_new = self.doc_new
810
811         class_name, class_prop = doc_id.split('.')
812
813         if not doc_new:
814             self.report({'ERROR'}, "No input given for '%s'" % doc_id)
815             return {'CANCELLED'}
816
817         # check if this is an operator
818         op_name = class_name.upper() + '_OT_' + class_prop
819         op_class = getattr(bpy.types, op_name, None)
820
821         # Upload this to the web server
822         upload = {}
823
824         if op_class:
825             rna = op_class.bl_rna
826             doc_orig = rna.description
827             if doc_orig == doc_new:
828                 return {'RUNNING_MODAL'}
829
830             print("op - old:'%s' -> new:'%s'" % (doc_orig, doc_new))
831             upload["title"] = 'OPERATOR %s:%s' % (doc_id, doc_orig)
832         else:
833             rna = getattr(bpy.types, class_name).bl_rna
834             doc_orig = rna.properties[class_prop].description
835             if doc_orig == doc_new:
836                 return {'RUNNING_MODAL'}
837
838             print("rna - old:'%s' -> new:'%s'" % (doc_orig, doc_new))
839             upload["title"] = 'RNA %s:%s' % (doc_id, doc_orig)
840
841         upload["description"] = doc_new
842
843         self._send_xmlrpc(upload)
844
845         return {'FINISHED'}
846
847     def draw(self, context):
848         layout = self.layout
849         layout.label(text="Descriptor ID: '%s'" % self.doc_id)
850         layout.prop(self, "doc_new", text="")
851
852     def invoke(self, context, event):
853         wm = context.window_manager
854         return wm.invoke_props_dialog(self, width=600)
855
856
857 rna_path = StringProperty(
858         name="Property Edit",
859         description="Property data_path edit",
860         maxlen=1024,
861         options={'HIDDEN'},
862         )
863
864 rna_value = StringProperty(
865         name="Property Value",
866         description="Property value edit",
867         maxlen=1024,
868         )
869
870 rna_property = StringProperty(
871         name="Property Name",
872         description="Property name edit",
873         maxlen=1024,
874         )
875
876 rna_min = FloatProperty(
877         name="Min",
878         default=0.0,
879         precision=3,
880         )
881
882 rna_max = FloatProperty(
883         name="Max",
884         default=1.0,
885         precision=3,
886         )
887
888
889 class WM_OT_properties_edit(Operator):
890     '''Internal use (edit a property data_path)'''
891     bl_idname = "wm.properties_edit"
892     bl_label = "Edit Property"
893     bl_options = {'REGISTER'}  # only because invoke_props_popup requires.
894
895     data_path = rna_path
896     property = rna_property
897     value = rna_value
898     min = rna_min
899     max = rna_max
900     description = StringProperty(
901             name="Tip",
902             )
903
904     def execute(self, context):
905         data_path = self.data_path
906         value = self.value
907         prop = self.property
908
909         prop_old = getattr(self, "_last_prop", [None])[0]
910
911         if prop_old is None:
912             self.report({'ERROR'}, "Direct execution not supported")
913             return {'CANCELLED'}
914
915         try:
916             value_eval = eval(value)
917         except:
918             value_eval = value
919
920         # First remove
921         item = eval("context.%s" % data_path)
922
923         rna_idprop_ui_prop_clear(item, prop_old)
924         exec_str = "del item['%s']" % prop_old
925         # print(exec_str)
926         exec(exec_str)
927
928         # Reassign
929         exec_str = "item['%s'] = %s" % (prop, repr(value_eval))
930         # print(exec_str)
931         exec(exec_str)
932         self._last_prop[:] = [prop]
933
934         prop_type = type(item[prop])
935
936         prop_ui = rna_idprop_ui_prop_get(item, prop)
937
938         if prop_type in {float, int}:
939
940             prop_ui['soft_min'] = prop_ui['min'] = prop_type(self.min)
941             prop_ui['soft_max'] = prop_ui['max'] = prop_type(self.max)
942
943         prop_ui['description'] = self.description
944
945         # otherwise existing buttons which reference freed
946         # memory may crash blender [#26510]
947         # context.area.tag_redraw()
948         for win in context.window_manager.windows:
949             for area in win.screen.areas:
950                 area.tag_redraw()
951
952         return {'FINISHED'}
953
954     def invoke(self, context, event):
955
956         if not self.data_path:
957             self.report({'ERROR'}, "Data path not set")
958             return {'CANCELLED'}
959
960         self._last_prop = [self.property]
961
962         item = eval("context.%s" % self.data_path)
963
964         # setup defaults
965         prop_ui = rna_idprop_ui_prop_get(item, self.property, False)  # dont create
966         if prop_ui:
967             self.min = prop_ui.get("min", -1000000000)
968             self.max = prop_ui.get("max", 1000000000)
969             self.description = prop_ui.get("description", "")
970
971         wm = context.window_manager
972         return wm.invoke_props_dialog(self)
973
974
975 class WM_OT_properties_add(Operator):
976     '''Internal use (edit a property data_path)'''
977     bl_idname = "wm.properties_add"
978     bl_label = "Add Property"
979
980     data_path = rna_path
981
982     def execute(self, context):
983         item = eval("context.%s" % self.data_path)
984
985         def unique_name(names):
986             prop = 'prop'
987             prop_new = prop
988             i = 1
989             while prop_new in names:
990                 prop_new = prop + str(i)
991                 i += 1
992
993             return prop_new
994
995         property = unique_name(item.keys())
996
997         item[property] = 1.0
998         return {'FINISHED'}
999
1000
1001 class WM_OT_properties_context_change(Operator):
1002     "Change the context tab in a Properties Window"
1003     bl_idname = "wm.properties_context_change"
1004     bl_label = ""
1005
1006     context = StringProperty(
1007             name="Context",
1008             maxlen=32,
1009             )
1010
1011     def execute(self, context):
1012         context.space_data.context = (self.context)
1013         return {'FINISHED'}
1014
1015
1016 class WM_OT_properties_remove(Operator):
1017     '''Internal use (edit a property data_path)'''
1018     bl_idname = "wm.properties_remove"
1019     bl_label = "Remove Property"
1020
1021     data_path = rna_path
1022     property = rna_property
1023
1024     def execute(self, context):
1025         item = eval("context.%s" % self.data_path)
1026         del item[self.property]
1027         return {'FINISHED'}
1028
1029
1030 class WM_OT_keyconfig_activate(Operator):
1031     bl_idname = "wm.keyconfig_activate"
1032     bl_label = "Activate Keyconfig"
1033
1034     filepath = StringProperty(
1035             name="File Path",
1036             maxlen=1024,
1037             )
1038
1039     def execute(self, context):
1040         bpy.utils.keyconfig_set(self.filepath)
1041         return {'FINISHED'}
1042
1043
1044 class WM_OT_appconfig_default(Operator):
1045     bl_idname = "wm.appconfig_default"
1046     bl_label = "Default Application Configuration"
1047
1048     def execute(self, context):
1049         import os
1050
1051         context.window_manager.keyconfigs.active = context.window_manager.keyconfigs.default
1052
1053         filepath = os.path.join(bpy.utils.preset_paths("interaction")[0], "blender.py")
1054
1055         if os.path.exists(filepath):
1056             bpy.ops.script.execute_preset(filepath=filepath, menu_idname="USERPREF_MT_interaction_presets")
1057
1058         return {'FINISHED'}
1059
1060
1061 class WM_OT_appconfig_activate(Operator):
1062     bl_idname = "wm.appconfig_activate"
1063     bl_label = "Activate Application Configuration"
1064
1065     filepath = StringProperty(
1066             name="File Path",
1067             maxlen=1024,
1068             )
1069
1070     def execute(self, context):
1071         import os
1072         bpy.utils.keyconfig_set(self.filepath)
1073
1074         filepath = self.filepath.replace("keyconfig", "interaction")
1075
1076         if os.path.exists(filepath):
1077             bpy.ops.script.execute_preset(filepath=filepath, menu_idname="USERPREF_MT_interaction_presets")
1078
1079         return {'FINISHED'}
1080
1081
1082 class WM_OT_sysinfo(Operator):
1083     '''Generate System Info'''
1084     bl_idname = "wm.sysinfo"
1085     bl_label = "System Info"
1086
1087     def execute(self, context):
1088         import sys_info
1089         sys_info.write_sysinfo(self)
1090         return {'FINISHED'}
1091
1092
1093 class WM_OT_copy_prev_settings(Operator):
1094     '''Copy settings from previous version'''
1095     bl_idname = "wm.copy_prev_settings"
1096     bl_label = "Copy Previous Settings"
1097
1098     def execute(self, context):
1099         import os
1100         import shutil
1101         ver = bpy.app.version
1102         ver_old = ((ver[0] * 100) + ver[1]) - 1
1103         path_src = bpy.utils.resource_path('USER', ver_old // 100, ver_old % 100)
1104         path_dst = bpy.utils.resource_path('USER')
1105
1106         if os.path.isdir(path_dst):
1107             self.report({'ERROR'}, "Target path %r exists" % path_dst)
1108         elif not os.path.isdir(path_src):
1109             self.report({'ERROR'}, "Source path %r exists" % path_src)
1110         else:
1111             shutil.copytree(path_src, path_dst)
1112
1113             # in 2.57 and earlier windows installers, system scripts were copied
1114             # into the configuration directory, don't want to copy those
1115             system_script = os.path.join(path_dst, 'scripts/modules/bpy_types.py')
1116             if os.path.isfile(system_script):
1117                 shutil.rmtree(os.path.join(path_dst, 'scripts'))
1118                 shutil.rmtree(os.path.join(path_dst, 'plugins'))
1119
1120             # dont loose users work if they open the splash later.
1121             if bpy.data.is_saved is bpy.data.is_dirty is False:
1122                 bpy.ops.wm.read_homefile()
1123             else:
1124                 self.report({'INFO'}, "Reload Start-Up file to restore settings.")
1125             return {'FINISHED'}
1126
1127         return {'CANCELLED'}
1128
1129
1130 def _webbrowser_bug_fix():
1131     # test for X11
1132     import os
1133
1134     if os.environ.get("DISPLAY"):
1135
1136         # BSD licenced code copied from python, temp fix for bug
1137         # http://bugs.python.org/issue11432, XXX == added code
1138         def _invoke(self, args, remote, autoraise):
1139             # XXX, added imports
1140             import io
1141             import subprocess
1142             import time
1143
1144             raise_opt = []
1145             if remote and self.raise_opts:
1146                 # use autoraise argument only for remote invocation
1147                 autoraise = int(autoraise)
1148                 opt = self.raise_opts[autoraise]
1149                 if opt:
1150                     raise_opt = [opt]
1151
1152             cmdline = [self.name] + raise_opt + args
1153
1154             if remote or self.background:
1155                 inout = io.open(os.devnull, "r+")
1156             else:
1157                 # for TTY browsers, we need stdin/out
1158                 inout = None
1159             # if possible, put browser in separate process group, so
1160             # keyboard interrupts don't affect browser as well as Python
1161             setsid = getattr(os, 'setsid', None)
1162             if not setsid:
1163                 setsid = getattr(os, 'setpgrp', None)
1164
1165             p = subprocess.Popen(cmdline, close_fds=True,  # XXX, stdin=inout,
1166                                  stdout=(self.redirect_stdout and inout or None),
1167                                  stderr=inout, preexec_fn=setsid)
1168             if remote:
1169                 # wait five secons. If the subprocess is not finished, the
1170                 # remote invocation has (hopefully) started a new instance.
1171                 time.sleep(1)
1172                 rc = p.poll()
1173                 if rc is None:
1174                     time.sleep(4)
1175                     rc = p.poll()
1176                     if rc is None:
1177                         return True
1178                 # if remote call failed, open() will try direct invocation
1179                 return not rc
1180             elif self.background:
1181                 if p.poll() is None:
1182                     return True
1183                 else:
1184                     return False
1185             else:
1186                 return not p.wait()
1187
1188         import webbrowser
1189         webbrowser.UnixBrowser._invoke = _invoke