Remove extensions_framework module

This is no longer used by release or contrib add-ons.

While interesting to use declarative definitions,
this adds a layer between Blender's API's and scripts,
which needs to be maintained and updated with Blender.

4 files changed, 0 insertions, 1191 deletions

diff --git a/modules/extensions_framework/__init__.py b/modules/extensions_framework/__init__.py
deleted file mode 100644
index 5a53a632..00000000
--- a/modules/extensions_framework/__init__.py
+++ /dev/null
@@ -1,371 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# ***** BEGIN GPL LICENSE BLOCK *****
-#
-# --------------------------------------------------------------------------
-# Blender 2.5 Extensions Framework
-# --------------------------------------------------------------------------
-#
-# Authors:
-# Doug Hammond
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, see <http://www.gnu.org/licenses/>.
-#
-# ***** END GPL LICENCE BLOCK *****
-#
-import time
-
-import bpy
-
-from extensions_framework.ui import EF_OT_msg
-bpy.utils.register_class(EF_OT_msg)
-del EF_OT_msg
-
-def log(str, popup=False, module_name='EF'):
-    """Print a message to the console, prefixed with the module_name
-    and the current time. If the popup flag is True, the message will
-    be raised in the UI as a warning using the operator bpy.ops.ef.msg.
-
-    """
-    print("[%s %s] %s" %
-        (module_name, time.strftime('%Y-%b-%d %H:%M:%S'), str))
-    if popup:
-        bpy.ops.ef.msg(
-            msg_type='WARNING',
-            msg_text=str
-        )
-
-
-added_property_cache = {}
-
-def init_properties(obj, props, cache=True):
-    """Initialise custom properties in the given object or type.
-    The props list is described in the declarative_property_group
-    class definition. If the cache flag is False, this function
-    will attempt to redefine properties even if they have already been
-    added.
-
-    """
-
-    if not obj in added_property_cache.keys():
-        added_property_cache[obj] = []
-
-    for prop in props:
-        try:
-            if cache and prop['attr'] in added_property_cache[obj]:
-                continue
-
-            if prop['type'] == 'bool':
-                t = bpy.props.BoolProperty
-                a = {k: v for k,v in prop.items() if k in ["name",
-                    "description","default","options","subtype","update"]}
-            elif prop['type'] == 'bool_vector':
-                t = bpy.props.BoolVectorProperty
-                a = {k: v for k,v in prop.items() if k in ["name",
-                    "description","default","options","subtype","size",
-                    "update"]}
-            elif prop['type'] == 'collection':
-                t = bpy.props.CollectionProperty
-                a = {k: v for k,v in prop.items() if k in ["ptype","name",
-                    "description","default","options"]}
-                a['type'] = a['ptype']
-                del a['ptype']
-            elif prop['type'] == 'enum':
-                t = bpy.props.EnumProperty
-                a = {k: v for k,v in prop.items() if k in ["items","name",
-                    "description","default","options","update"]}
-            elif prop['type'] == 'float':
-                t = bpy.props.FloatProperty
-                a = {k: v for k,v in prop.items() if k in ["name",
-                    "description","default","min","max","soft_min","soft_max",
-                    "step","precision","options","subtype","unit","update"]}
-            elif prop['type'] == 'float_vector':
-                t = bpy.props.FloatVectorProperty
-                a = {k: v for k,v in prop.items() if k in ["name",
-                    "description","default","min","max","soft_min","soft_max",
-                    "step","precision","options","subtype","size","update"]}
-            elif prop['type'] == 'int':
-                t = bpy.props.IntProperty
-                a = {k: v for k,v in prop.items() if k in ["name",
-                    "description","default","min","max","soft_min","soft_max",
-                    "step","options","subtype","update"]}
-            elif prop['type'] == 'int_vector':
-                t = bpy.props.IntVectorProperty
-                a = {k: v for k,v in prop.items() if k in ["name",
-                    "description","default","min","max","soft_min","soft_max",
-                    "options","subtype","size","update"]}
-            elif prop['type'] == 'pointer':
-                t = bpy.props.PointerProperty
-                a = {k: v for k,v in prop.items() if k in ["ptype", "name",
-                    "description","options","update"]}
-                a['type'] = a['ptype']
-                del a['ptype']
-            elif prop['type'] == 'string':
-                t = bpy.props.StringProperty
-                a = {k: v for k,v in prop.items() if k in ["name",
-                    "description","default","maxlen","options","subtype",
-                    "update"]}
-            else:
-                continue
-
-            setattr(obj, prop['attr'], t(**a))
-
-            added_property_cache[obj].append(prop['attr'])
-        except KeyError:
-            # Silently skip invalid entries in props
-            continue
-
-class declarative_property_group(bpy.types.PropertyGroup):
-    """A declarative_property_group describes a set of logically
-    related properties, using a declarative style to list each
-    property type, name, values, and other relevant information.
-    The information provided for each property depends on the
-    property's type.
-
-    The properties list attribute in this class describes the
-    properties present in this group.
-
-    Some additional information about the properties in this group
-    can be specified, so that a UI can be generated to display them.
-    To that end, the controls list attribute and the visibility dict
-    attribute are present here, to be read and interpreted by a
-    property_group_renderer object.
-    See extensions_framework.ui.property_group_renderer.
-
-    """
-
-    ef_initialised = False
-
-    """This property tells extensions_framework which bpy.type(s)
-    to attach this PropertyGroup to. If left as an empty list,
-    it will not be attached to any type, but its properties will
-    still be initialised. The type(s) given in the list should be
-    a string, such as 'Scene'.
-
-    """
-    ef_attach_to = []
-
-    @classmethod
-    def initialise_properties(cls):
-        """This is a function that should be called on
-        sub-classes of declarative_property_group in order
-        to ensure that they are initialised when the addon
-        is loaded.
-        the init_properties is called without caching here,
-        as it is assumed that any addon calling this function
-        will also call ef_remove_properties when it is
-        unregistered.
-
-        """
-
-        if not cls.ef_initialised:
-            for property_group_parent in cls.ef_attach_to:
-                if property_group_parent is not None:
-                    prototype = getattr(bpy.types, property_group_parent)
-                    if not hasattr(prototype, cls.__name__):
-                        init_properties(prototype, [{
-                            'type': 'pointer',
-                            'attr': cls.__name__,
-                            'ptype': cls,
-                            'name': cls.__name__,
-                            'description': cls.__name__
-                        }], cache=False)
-
-            init_properties(cls, cls.properties, cache=False)
-            cls.ef_initialised = True
-
-        return cls
-
-    @classmethod
-    def register_initialise_properties(cls):
-        """As ef_initialise_properties, but also registers the
-        class with RNA. Note that this isn't a great idea
-        because it's non-trivial to unregister the class, unless
-        you keep track of it yourself.
-        """
-
-        bpy.utils.register_class(cls)
-        cls.initialise_properties()
-        return cls
-
-    @classmethod
-    def remove_properties(cls):
-        """This is a function that should be called on
-        sub-classes of declarative_property_group in order
-        to ensure that they are un-initialised when the addon
-        is unloaded.
-
-        """
-
-        if cls.ef_initialised:
-            prototype = getattr(bpy.types, cls.__name__)
-            for prop in cls.properties:
-                if hasattr(prototype, prop['attr']):
-                    delattr(prototype, prop['attr'])
-
-            for property_group_parent in cls.ef_attach_to:
-                if property_group_parent is not None:
-                    prototype = getattr(bpy.types, property_group_parent)
-                    if hasattr(prototype, cls.__name__):
-                        delattr(prototype, cls.__name__)
-
-            cls.ef_initialised = False
-
-        return cls
-
-
-    """This list controls the order of property layout when rendered
-    by a property_group_renderer. This can be a nested list, where each
-    list becomes a row in the panel layout. Nesting may be to any depth.
-
-    """
-    controls = []
-
-    """The visibility dict controls the visibility of properties based on
-    the value of other properties. See extensions_framework.validate
-    for test syntax.
-
-    """
-    visibility = {}
-
-    """The enabled dict controls the enabled state of properties based on
-    the value of other properties. See extensions_framework.validate
-    for test syntax.
-
-    """
-    enabled = {}
-
-    """The alert dict controls the alert state of properties based on
-    the value of other properties. See extensions_framework.validate
-    for test syntax.
-
-    """
-    alert = {}
-
-    """The properties list describes each property to be created. Each
-    item should be a dict of args to pass to a
-    bpy.props.<?>Property function, with the exception of 'type'
-    which is used and stripped by extensions_framework in order to
-    determine which Property creation function to call.
-
-    Example item:
-    {
-        'type': 'int',                              # bpy.props.IntProperty
-        'attr': 'threads',                          # bpy.types.<type>.threads
-        'name': 'Render Threads',                   # Rendered next to the UI
-        'description': 'Number of threads to use',  # Tooltip text in the UI
-        'default': 1,
-        'min': 1,
-        'soft_min': 1,
-        'max': 64,
-        'soft_max': 64
-    }
-
-    """
-    properties = []
-
-    def draw_callback(self, context):
-        """Sub-classes can override this to get a callback when
-        rendering is completed by a property_group_renderer sub-class.
-
-        """
-
-        pass
-
-    @classmethod
-    def get_exportable_properties(cls):
-        """Return a list of properties which have the 'save_in_preset' key
-        set to True, and hence should be saved into preset files.
-
-        """
-
-        out = []
-        for prop in cls.properties:
-            if 'save_in_preset' in prop.keys() and prop['save_in_preset']:
-                out.append(prop)
-        return out
-
-    def reset(self):
-        """Reset all properties in this group to the default value,
-        if specified"""
-        for prop in self.properties:
-            pk = prop.keys()
-            if 'attr' in pk and 'default' in pk and hasattr(self, prop['attr']):
-                setattr(self, prop['attr'], prop['default'])
-
-class Addon(object):
-    """A list of classes registered by this addon"""
-    static_addon_count = 0
-
-    addon_serial = 0
-    addon_classes = None
-    bl_info = None
-
-    BL_VERSION = None
-    BL_IDNAME = None
-
-    def __init__(self, bl_info=None):
-        self.addon_classes = []
-        self.bl_info = bl_info
-
-        # Keep a count in case we have to give this addon an anonymous name
-        self.addon_serial = Addon.static_addon_count
-        Addon.static_addon_count += 1
-
-        if self.bl_info:
-            self.BL_VERSION = '.'.join(['%s'%v for v in self.bl_info['version']]).lower()
-            self.BL_IDNAME = self.bl_info['name'].lower() + '-' + self.BL_VERSION
-        else:
-            # construct anonymous name
-            self.BL_VERSION = '0'
-            self.BL_IDNAME = 'Addon-%03d'%self.addon_serial
-
-    def addon_register_class(self, cls):
-        """This method is designed to be used as a decorator on RNA-registerable
-        classes defined by the addon. By using this decorator, this class will
-        keep track of classes registered by this addon so that they can be
-        unregistered later in the correct order.
-
-        """
-        self.addon_classes.append(cls)
-        return cls
-
-    def register(self):
-        """This is the register function that should be exposed in the addon's
-        __init__.
-
-        """
-        for cls in self.addon_classes:
-            bpy.utils.register_class(cls)
-            if hasattr(cls, 'ef_attach_to'): cls.initialise_properties()
-
-    def unregister(self):
-        """This is the unregister function that should be exposed in the addon's
-        __init__.
-
-        """
-        for cls in self.addon_classes[::-1]:    # unregister in reverse order
-            if hasattr(cls, 'ef_attach_to'): cls.remove_properties()
-            bpy.utils.unregister_class(cls)
-
-    def init_functions(self):
-        """Returns references to the three functions that this addon needs
-        for successful class registration management. In the addon's __init__
-        you would use like this:
-
-        addon_register_class, register, unregister = Addon().init_functions()
-
-        """
-
-        return self.register, self.unregister
diff --git a/modules/extensions_framework/ui.py b/modules/extensions_framework/ui.py
deleted file mode 100644
index 52746b43..00000000
--- a/modules/extensions_framework/ui.py
+++ /dev/null
@@ -1,337 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# ***** BEGIN GPL LICENSE BLOCK *****
-#
-# --------------------------------------------------------------------------
-# Blender 2.5 Extensions Framework
-# --------------------------------------------------------------------------
-#
-# Authors:
-# Doug Hammond
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, see <http://www.gnu.org/licenses/>.
-#
-# ***** END GPL LICENCE BLOCK *****
-#
-import bpy
-
-from extensions_framework.validate import Logician
-
-class EF_OT_msg(bpy.types.Operator):
-    """An operator to show simple messages in the UI"""
-    bl_idname = 'ef.msg'
-    bl_label = 'Show UI Message'
-    msg_type = bpy.props.StringProperty(default='INFO')
-    msg_text = bpy.props.StringProperty(default='')
-    def execute(self, context):
-        self.report({self.properties.msg_type}, self.properties.msg_text)
-        return {'FINISHED'}
-
-def _get_item_from_context(context, path):
-    """Utility to get an object when the path to it is known:
-    _get_item_from_context(context, ['a','b','c']) returns
-    context.a.b.c
-    No error checking is performed other than checking that context
-    is not None. Exceptions caused by invalid path should be caught in
-    the calling code.
-
-    """
-
-    if context is not None:
-        for p in path:
-            context = getattr(context, p)
-    return context
-
-class property_group_renderer(bpy.types.Panel):
-    """Mix-in class for sub-classes of bpy.types.Panel. This class
-    will provide the draw() method which implements drawing one or
-    more property groups derived from
-    extensions_framework.declarative_propery_group.
-    The display_property_groups list attribute describes which
-    declarative_property_groups should be drawn in the Panel, and
-    how to extract those groups from the context passed to draw().
-
-    """
-
-    """The display_property_groups list attribute specifies which
-    custom declarative_property_groups this panel should draw, and
-    where to find that property group in the active context.
-    Example item:
-        ( ('scene',), 'myaddon_property_group')
-    In this case, this renderer will look for properties in
-    context.scene.myaddon_property_group to draw in the Panel.
-
-    """
-    display_property_groups = []
-
-    def draw(self, context):
-        """Sub-classes should override this if they need to display
-        other (object-related) property groups. super().draw(context)
-        can be a useful call in those cases.
-
-        """
-        for property_group_path, property_group_name in \
-            self.display_property_groups:
-            ctx = _get_item_from_context(context, property_group_path)
-            property_group = getattr(ctx, property_group_name)
-            for p in property_group.controls:
-                self.draw_column(p, self.layout, ctx, context,
-                    property_group=property_group)
-            property_group.draw_callback(context)
-
-    def check_visibility(self, lookup_property, property_group):
-        """Determine if the lookup_property should be drawn in the Panel"""
-        vt = Logician(property_group)
-        if lookup_property in property_group.visibility.keys():
-            if hasattr(property_group, lookup_property):
-                member = getattr(property_group, lookup_property)
-            else:
-                member = None
-            return vt.test_logic(member,
-                property_group.visibility[lookup_property])
-        else:
-            return True
-
-    def check_enabled(self, lookup_property, property_group):
-        """Determine if the lookup_property should be enabled in the Panel"""
-        et = Logician(property_group)
-        if lookup_property in property_group.enabled.keys():
-            if hasattr(property_group, lookup_property):
-                member = getattr(property_group, lookup_property)
-            else:
-                member = None
-            return et.test_logic(member,
-                property_group.enabled[lookup_property])
-        else:
-            return True
-
-    def check_alert(self, lookup_property, property_group):
-        """Determine if the lookup_property should be in an alert state in the Panel"""
-        et = Logician(property_group)
-        if lookup_property in property_group.alert.keys():
-            if hasattr(property_group, lookup_property):
-                member = getattr(property_group, lookup_property)
-            else:
-                member = None
-            return et.test_logic(member,
-                property_group.alert[lookup_property])
-        else:
-            return False
-
-    def is_real_property(self, lookup_property, property_group):
-        for prop in property_group.properties:
-            if prop['attr'] == lookup_property:
-                return prop['type'] not in ['text', 'prop_search']
-
-        return False
-
-    def draw_column(self, control_list_item, layout, context,
-                    supercontext=None, property_group=None):
-        """Draw a column's worth of UI controls in this Panel"""
-        if type(control_list_item) is list:
-            draw_row = False
-
-            found_percent = None
-            for sp in control_list_item:
-                if type(sp) is float:
-                    found_percent = sp
-                elif type(sp) is list:
-                    for ssp in [s for s in sp if self.is_real_property(s, property_group)]:
-                        draw_row = draw_row or self.check_visibility(ssp,
-                            property_group)
-                else:
-                    draw_row = draw_row or self.check_visibility(sp,
-                        property_group)
-
-            next_items = [s for s in control_list_item if type(s) in [str, list]]
-            if draw_row and len(next_items) > 0:
-                if found_percent is not None:
-                    splt = layout.split(percentage=found_percent)
-                else:
-                    splt = layout.row(True)
-                for sp in next_items:
-                    col2 = splt.column(align=True)
-                    self.draw_column(sp, col2, context, supercontext,
-                        property_group)
-        else:
-            if self.check_visibility(control_list_item, property_group):
-
-                for current_property in property_group.properties:
-                    if current_property['attr'] == control_list_item:
-                        current_property_keys = current_property.keys()
-
-                        sub_layout_created = False
-                        if not self.check_enabled(control_list_item, property_group):
-                            last_layout = layout
-                            sub_layout_created = True
-
-                            layout = layout.row()
-                            layout.enabled = False
-
-                        if self.check_alert(control_list_item, property_group):
-                            if not sub_layout_created:
-                                last_layout = layout
-                                sub_layout_created = True
-                            layout = layout.row()
-                            layout.alert = True
-
-                        if 'type' in current_property_keys:
-                            if current_property['type'] in ['int', 'float',
-                                'float_vector', 'string']:
-                                layout.prop(
-                                    property_group,
-                                    control_list_item,
-                                    text = current_property['name'],
-                                    expand = current_property['expand'] \
-                                        if 'expand' in current_property_keys \
-                                        else False,
-                                    slider = current_property['slider'] \
-                                        if 'slider' in current_property_keys \
-                                        else False,
-                                    toggle = current_property['toggle'] \
-                                        if 'toggle' in current_property_keys \
-                                        else False,
-                                    icon_only = current_property['icon_only'] \
-                                        if 'icon_only' in current_property_keys \
-                                        else False,
-                                    event = current_property['event'] \
-                                        if 'event' in current_property_keys \
-                                        else False,
-                                    full_event = current_property['full_event'] \
-                                        if 'full_event' in current_property_keys \
-                                        else False,
-                                    emboss = current_property['emboss'] \
-                                        if 'emboss' in current_property_keys \
-                                        else True,
-                                )
-                            if current_property['type'] in ['enum']:
-                                if 'use_menu' in current_property_keys and \
-                                    current_property['use_menu']:
-                                    layout.prop_menu_enum(
-                                        property_group,
-                                        control_list_item,
-                                        text = current_property['name']
-                                    )
-                                else:
-                                    layout.prop(
-                                        property_group,
-                                        control_list_item,
-                                        text = current_property['name'],
-                                        expand = current_property['expand'] \
-                                            if 'expand' in current_property_keys \
-                                            else False,
-                                        slider = current_property['slider'] \
-                                            if 'slider' in current_property_keys \
-                                            else False,
-                                        toggle = current_property['toggle'] \
-                                            if 'toggle' in current_property_keys \
-                                            else False,
-                                        icon_only = current_property['icon_only'] \
-                                            if 'icon_only' in current_property_keys \
-                                            else False,
-                                        event = current_property['event'] \
-                                            if 'event' in current_property_keys \
-                                            else False,
-                                        full_event = current_property['full_event'] \
-                                            if 'full_event' in current_property_keys \
-                                            else False,
-                                        emboss = current_property['emboss'] \
-                                            if 'emboss' in current_property_keys \
-                                            else True,
-                                    )
-                            if current_property['type'] in ['bool']:
-                                layout.prop(
-                                    property_group,
-                                    control_list_item,
-                                    text = current_property['name'],
-                                    toggle = current_property['toggle'] \
-                                        if 'toggle' in current_property_keys \
-                                        else False,
-                                    icon_only = current_property['icon_only'] \
-                                        if 'icon_only' in current_property_keys \
-                                        else False,
-                                    event = current_property['event'] \
-                                        if 'event' in current_property_keys \
-                                        else False,
-                                    full_event = current_property['full_event'] \
-                                        if 'full_event' in current_property_keys \
-                                        else False,
-                                    emboss = current_property['emboss'] \
-                                        if 'emboss' in current_property_keys \
-                                        else True,
-                                )
-                            elif current_property['type'] in ['operator']:
-                                args = {}
-                                for optional_arg in ('text', 'icon'):
-                                    if optional_arg in current_property_keys:
-                                        args.update({
-                                            optional_arg: current_property[optional_arg],
-                                        })
-                                layout.operator( current_property['operator'], **args )
-
-                            elif current_property['type'] in ['menu']:
-                                args = {}
-                                for optional_arg in ('text', 'icon'):
-                                    if optional_arg in current_property_keys:
-                                        args.update({
-                                            optional_arg: current_property[optional_arg],
-                                        })
-                                layout.menu(current_property['menu'], **args)
-
-                            elif current_property['type'] in ['text']:
-                                layout.label(
-                                    text = current_property['name']
-                                )
-
-                            elif current_property['type'] in ['template_list']:
-                                layout.template_list("UI_UL_list", current_property['src_attr'],  # Use that as uid...
-                                    current_property['src'](supercontext, context),
-                                    current_property['src_attr'],
-                                    current_property['trg'](supercontext, context),
-                                    current_property['trg_attr'],
-                                    rows = 4 \
-                                        if not 'rows' in current_property_keys \
-                                        else current_property['rows'],
-                                    maxrows = 4 \
-                                        if not 'rows' in current_property_keys \
-                                        else current_property['rows'],
-                                    type = 'DEFAULT' \
-                                        if not 'list_type' in current_property_keys \
-                                        else current_property['list_type']
-                                )
-
-                            elif current_property['type'] in ['prop_search']:
-                                layout.prop_search(
-                                    current_property['trg'](supercontext,
-                                        context),
-                                    current_property['trg_attr'],
-                                    current_property['src'](supercontext,
-                                        context),
-                                    current_property['src_attr'],
-                                    text = current_property['name'],
-                                )
-
-                            elif current_property['type'] in ['ef_callback']:
-                                getattr(self, current_property['method'])(supercontext)
-                        else:
-                            layout.prop(property_group, control_list_item)
-
-                        if sub_layout_created:
-                            layout = last_layout
-
-                        # Fire a draw callback if specified
-                        if 'draw' in current_property_keys:
-                            current_property['draw'](supercontext, context)
-
-                        break
diff --git a/modules/extensions_framework/util.py b/modules/extensions_framework/util.py
deleted file mode 100644
index 2ad450b7..00000000
--- a/modules/extensions_framework/util.py
+++ /dev/null
@@ -1,270 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# ***** BEGIN GPL LICENSE BLOCK *****
-#
-# --------------------------------------------------------------------------
-# Blender 2.5 Extensions Framework
-# --------------------------------------------------------------------------
-#
-# Authors:
-# Doug Hammond
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software Foundation,
-# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ***** END GPL LICENCE BLOCK *****
-#
-import configparser
-import datetime
-import os
-import tempfile
-import threading
-
-import bpy
-
-"""List of possibly appropriate paths to load/save addon config from/to"""
-config_paths = []
-if bpy.utils.user_resource('CONFIG', '') != "": config_paths.append(bpy.utils.user_resource('CONFIG', '', create=True))
-if bpy.utils.user_resource('SCRIPTS', '') != "": config_paths.append(bpy.utils.user_resource('SCRIPTS', '', create=True))
-# want to scan other script paths in reverse order, since the user path comes last
-sp = [p for p in bpy.utils.script_paths() if p != '']
-sp.reverse()
-config_paths.extend(sp)
-
-"""This path is set at the start of export, so that calls to
-path_relative_to_export() can make all exported paths relative to
-this one.
-"""
-export_path = '';
-
-def path_relative_to_export(p):
-    """Return a path that is relative to the export path"""
-    global export_path
-    p = filesystem_path(p)
-    ep = os.path.dirname(export_path)
-
-    if os.sys.platform[:3] == "win":
-        # Prevent an error whereby python thinks C: and c: are different drives
-        if p[1] == ':': p = p[0].lower() + p[1:]
-        if ep[1] == ':': ep = ep[0].lower() + ep[1:]
-
-    try:
-        relp = os.path.relpath(p, ep)
-    except ValueError: # path on different drive on windows
-        relp = p
-
-    return relp.replace('\\', '/')
-
-def filesystem_path(p):
-    """Resolve a relative Blender path to a real filesystem path"""
-    if p.startswith('//'):
-        pout = bpy.path.abspath(p)
-    else:
-        pout = os.path.realpath(p)
-
-    return pout.replace('\\', '/')
-
-# TODO: - somehow specify TYPES to get/set from config
-
-def find_config_value(module, section, key, default):
-    """Attempt to find the configuration value specified by string key
-    in the specified section of module's configuration file. If it is
-    not found, return default.
-
-    """
-    global config_paths
-    fc = []
-    for p in config_paths:
-        if os.path.exists(p) and os.path.isdir(p) and os.access(p, os.W_OK):
-            fc.append( '/'.join([p, '%s.cfg' % module]))
-
-    if len(fc) < 1:
-        print('Cannot find %s config file path' % module)
-        return default
-
-    cp = configparser.SafeConfigParser()
-
-    cfg_files = cp.read(fc)
-    if len(cfg_files) > 0:
-        try:
-            val = cp.get(section, key)
-            if val == 'true':
-                return True
-            elif val == 'false':
-                return False
-            else:
-                return val
-        except:
-            return default
-    else:
-        return default
-
-def write_config_value(module, section, key, value):
-    """Attempt to write the configuration value specified by string key
-    in the specified section of module's configuration file.
-
-    """
-    global config_paths
-    fc = []
-    for p in config_paths:
-        if os.path.exists(p) and os.path.isdir(p) and os.access(p, os.W_OK):
-            fc.append( '/'.join([p, '%s.cfg' % module]))
-
-    if len(fc) < 1:
-        raise Exception('Cannot find a writable path to store %s config file' %
-            module)
-
-    cp = configparser.SafeConfigParser()
-
-    cfg_files = cp.read(fc)
-
-    if not cp.has_section(section):
-        cp.add_section(section)
-
-    if value == True:
-        cp.set(section, key, 'true')
-    elif value == False:
-        cp.set(section, key, 'false')
-    else:
-        cp.set(section, key, value)
-
-    if len(cfg_files) < 1:
-        cfg_files = fc
-
-    fh=open(cfg_files[0],'w')
-    cp.write(fh)
-    fh.close()
-
-    return True
-
-def scene_filename():
-    """Construct a safe scene filename, using 'untitled' instead of ''"""
-    filename = os.path.splitext(os.path.basename(bpy.data.filepath))[0]
-    if filename == '':
-        filename = 'untitled'
-    return bpy.path.clean_name(filename)
-
-def temp_directory():
-    """Return the system temp directory"""
-    return tempfile.gettempdir()
-
-def temp_file(ext='tmp'):
-    """Get a temporary filename with the given extension. This function
-    will actually attempt to create the file."""
-    tf, fn = tempfile.mkstemp(suffix='.%s'%ext)
-    os.close(tf)
-    return fn
-
-class TimerThread(threading.Thread):
-    """Periodically call self.kick(). The period of time in seconds
-    between calling is given by self.KICK_PERIOD, and the first call
-    may be delayed by setting self.STARTUP_DELAY, also in seconds.
-    self.kick() will continue to be called at regular intervals until
-    self.stop() is called. Since this is a thread, calling self.join()
-    may be wise after calling self.stop() if self.kick() is performing
-    a task necessary for the continuation of the program.
-    The object that creates this TimerThread may pass into it data
-    needed during self.kick() as a dict LocalStorage in __init__().
-
-    """
-    STARTUP_DELAY = 0
-    KICK_PERIOD = 8
-
-    active = True
-    timer = None
-
-    LocalStorage = None
-
-    def __init__(self, LocalStorage=dict()):
-        threading.Thread.__init__(self)
-        self.LocalStorage = LocalStorage
-
-    def set_kick_period(self, period):
-        """Adjust the KICK_PERIOD between __init__() and start()"""
-        self.KICK_PERIOD = period + self.STARTUP_DELAY
-
-    def stop(self):
-        """Stop this timer. This method does not join()"""
-        self.active = False
-        if self.timer is not None:
-            self.timer.cancel()
-
-    def run(self):
-        """Timed Thread loop"""
-        while self.active:
-            self.timer = threading.Timer(self.KICK_PERIOD, self.kick_caller)
-            self.timer.start()
-            if self.timer.isAlive(): self.timer.join()
-
-    def kick_caller(self):
-        """Intermediary between the kick-wait-loop and kick to allow
-        adjustment of the first KICK_PERIOD by STARTUP_DELAY
-
-        """
-        if self.STARTUP_DELAY > 0:
-            self.KICK_PERIOD -= self.STARTUP_DELAY
-            self.STARTUP_DELAY = 0
-
-        self.kick()
-
-    def kick(self):
-        """Sub-classes do their work here"""
-        pass
-
-def format_elapsed_time(t):
-    """Format a duration in seconds as an HH:MM:SS format time"""
-
-    td = datetime.timedelta(seconds=t)
-    min = td.days*1440  + td.seconds/60.0
-    hrs = td.days*24    + td.seconds/3600.0
-
-    return '%i:%02i:%02i' % (hrs, min%60, td.seconds%60)
-
-def getSequenceTexturePath(it, f):
-    import bpy.path
-    import os.path
-    import string
-    fd = it.image_user.frame_duration
-    fs = it.image_user.frame_start
-    fo = it.image_user.frame_offset
-    cyclic = it.image_user.use_cyclic
-    ext = os.path.splitext(it.image.filepath)[-1]
-    fb = bpy.path.display_name_from_filepath(it.image.filepath)
-    dn = os.path.dirname(it.image.filepath)
-    rf = fb[::-1]
-    nl = 0
-    for i in range (len(fb)):
-        if rf[i] in string.digits:
-            nl += 1
-        else:
-            break
-    head = fb[:len(fb)-nl]
-    fnum = f
-    if fs != 1:
-        if f != fs:
-            fnum -= (fs-1)
-        elif f == fs:
-            fnum = 1
-    if fnum <= 0:
-        if cyclic:
-            fnum = fd - abs(fnum) % fd
-        else:
-            fnum = 1
-    elif fnum > fd:
-        if cyclic:
-            fnum = fnum % fd
-        else:
-            fnum = fd
-    fnum += fo
-    return dn + "/" + head + str(fnum).rjust(nl, "0") + ext
diff --git a/modules/extensions_framework/validate.py b/modules/extensions_framework/validate.py
deleted file mode 100644
index 85851b8f..00000000
--- a/modules/extensions_framework/validate.py
+++ /dev/null
@@ -1,213 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# ***** BEGIN GPL LICENSE BLOCK *****
-#
-# --------------------------------------------------------------------------
-# Blender 2.5 Extensions Framework
-# --------------------------------------------------------------------------
-#
-# Authors:
-# Doug Hammond
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, see <http://www.gnu.org/licenses/>.
-#
-# ***** END GPL LICENCE BLOCK *****
-#
-"""
-Pure logic and validation class.
-
-By using a Subject object, and a dict of described logic tests, it
-is possible to arrive at a True or False result for various purposes:
-1. Data validation
-2. UI control visibility
-
-A Subject can be any object whose members are readable with getattr() :
-class Subject(object):
-    a = 0
-    b = 1
-    c = 'foo'
-    d = True
-    e = False
-    f = 8
-    g = 'bar'
-
-
-Tests are described thus:
-
-Use the special list types Logic_AND and Logic_OR to describe
-combinations of values and other members. Use Logic_Operator for
-numerical comparison.
-
-With regards to Subject, each of these evaluate to True:
-TESTA = {
-    'a': 0,
-    'c': Logic_OR([ 'foo', 'bar' ]),
-    'd': Logic_AND([True, True]),
-    'f': Logic_AND([8, {'b': 1}]),
-    'e': {'b': Logic_Operator({'gte':1, 'lt':3}) },
-    'g': Logic_OR([ 'baz', Logic_AND([{'b': 1}, {'f': 8}]) ])
-}
-
-With regards to Subject, each of these evaluate to False:
-TESTB = {
-    'a': 'foo',
-    'c': Logic_OR([ 'bar', 'baz' ]),
-    'd': Logic_AND([ True, 'foo' ]),
-    'f': Logic_AND([9, {'b': 1}]),
-    'e': {'b': Logic_Operator({'gte':-10, 'lt': 1}) },
-    'g': Logic_OR([ 'baz', Logic_AND([{'b':0}, {'f': 8}]) ])
-}
-
-With regards to Subject, this test is invalid
-TESTC = {
-    'n': 0
-}
-
-Tests are executed thus:
-S = Subject()
-L = Logician(S)
-L.execute(TESTA)
-
-"""
-
-class Logic_AND(list):
-    pass
-class Logic_OR(list):
-    pass
-class Logic_Operator(dict):
-    pass
-
-class Logician(object):
-    """Given a subject and a dict that describes tests to perform on
-    its members, this class will evaluate True or False results for
-    each member/test pair. See the examples below for test syntax.
-
-    """
-
-    subject = None
-    def __init__(self, subject):
-        self.subject = subject
-
-    def get_member(self, member_name):
-        """Get a member value from the subject object. Raise exception
-        if subject is None or member not found.
-
-        """
-        if self.subject is None:
-            raise Exception('Cannot run tests on a subject which is None')
-
-        return getattr(self.subject, member_name)
-
-    def test_logic(self, member, logic, operator='eq'):
-        """Find the type of test to run on member, and perform that test"""
-
-        if type(logic) is dict:
-            return self.test_dict(member, logic)
-        elif type(logic) is Logic_AND:
-            return self.test_and(member, logic)
-        elif type(logic) is Logic_OR:
-            return self.test_or(member, logic)
-        elif type(logic) is Logic_Operator:
-            return self.test_operator(member, logic)
-        else:
-            # compare the value, I think using Logic_Operator() here
-            # allows completeness in test_operator(), but I can't put
-            # my finger on why for the minute
-            return self.test_operator(member,
-                Logic_Operator({operator: logic}))
-
-    def test_operator(self, member, value):
-        """Execute the operators contained within value and expect that
-        ALL operators are True
-
-        """
-
-        # something in this method is incomplete, what if operand is
-        # a dict, Logic_AND, Logic_OR or another Logic_Operator ?
-        # Do those constructs even make any sense ?
-
-        result = True
-        for operator, operand in value.items():
-            operator = operator.lower().strip()
-            if operator in ['eq', '==']:
-                result &= member==operand
-            if operator in ['not', '!=']:
-                result &= member!=operand
-            if operator in ['lt', '<']:
-                result &= member<operand
-            if operator in ['lte', '<=']:
-                result &= member<=operand
-            if operator in ['gt', '>']:
-                result &= member>operand
-            if operator in ['gte', '>=']:
-                result &= member>=operand
-            if operator in ['and', '&']:
-                result &= member&operand
-            if operator in ['or', '|']:
-                result &= member|operand
-            if operator in ['len']:
-                result &= len(member)==operand
-            # I can think of some more, but they're probably not useful.
-
-        return result
-
-    def test_or(self, member, logic):
-        """Member is a value, logic is a set of values, ANY of which
-        can be True
-
-        """
-        result = False
-        for test in logic:
-            result |= self.test_logic(member, test)
-
-        return result
-
-    def test_and(self, member, logic):
-        """Member is a value, logic is a list of values, ALL of which
-        must be True
-
-        """
-        result = True
-        for test in logic:
-            result &= self.test_logic(member, test)
-
-        return result
-
-    def test_dict(self, member, logic):
-        """Member is a value, logic is a dict of other members to
-        compare to. All other member tests must be True
-
-        """
-        result = True
-        for other_member, test in logic.items():
-            result &= self.test_logic(self.get_member(other_member), test)
-
-        return result
-
-    def execute(self, test):
-        """Subject is an object, test is a dict of {member: test} pairs
-        to perform on subject's members. Wach key in test is a member
-        of subject.
-
-        """
-
-        for member_name, logic in test.items():
-            result = self.test_logic(self.get_member(member_name), logic)
-            print('member %s is %s' % (member_name, result))
-
-# A couple of name aliases
-class Validation(Logician):
-    pass
-class Visibility(Logician):
-    pass