def register():
    bpy.utils.register_class(HookSocketType)
    bpy.utils.register_class(MyCustomNode)
    bpy.utils.register_class(HookNode)
    bpy.utils.register_class(StrangeInput)
    bpy.utils.register_class(StrangeOutput)
    nodeitems_utils.register_node_categories("REIGHLEYNODES", node_categories)

def register():
    bpy.utils.register_class(MyCustomTree)
    bpy.utils.register_class(MyCustomSocket)
    bpy.utils.register_class(MyCustomNode)
    bpy.utils.register_class(MyCustomGroup)

    nodeitems_utils.register_node_categories("CUSTOM_NODES", node_categories)

def register():
    bpy.utils.register_class(CrowdMasterTree)
    bpy.utils.register_class(DefaultSocket)
    bpy.utils.register_class(StateSocket)
    bpy.utils.register_class(DependanceSocket)
    bpy.utils.register_class(LogicNode)
    bpy.utils.register_class(StateNode)

    bpy.utils.register_class(InputNode)
    bpy.utils.register_class(GraphNode)
    bpy.utils.register_class(AndNode)
    bpy.utils.register_class(OrNode)
    bpy.utils.register_class(StrongNode)
    bpy.utils.register_class(WeakNode)
    bpy.utils.register_class(QueryTagNode)
    bpy.utils.register_class(SetTagNode)
    bpy.utils.register_class(VariableNode)
    bpy.utils.register_class(FilterNode)
    bpy.utils.register_class(MapNode)
    bpy.utils.register_class(OutputNode)
    bpy.utils.register_class(PriorityNode)
    bpy.utils.register_class(EventNode)
    bpy.utils.register_class(PythonNode)
    bpy.utils.register_class(PrintNode)

    bpy.utils.register_class(StartState)
    bpy.utils.register_class(ActionState)

    bpy.utils.register_class(NoteNode)

    nodeitems_utils.register_node_categories("CrowdMaster_NODES", node_categories)

def register():
    bpy.utils.register_class(CrowdMasterTree)
    bpy.utils.register_class(DefaultSocket)
    bpy.utils.register_class(StateSocket)
    bpy.utils.register_class(DependanceSocket)
    bpy.utils.register_class(LogicNode)
    bpy.utils.register_class(StateNode)

    bpy.utils.register_class(NewInputNode)
    bpy.utils.register_class(GraphNode)
    bpy.utils.register_class(MathNode)
    bpy.utils.register_class(AndNode)
    bpy.utils.register_class(OrNode)
    bpy.utils.register_class(NotNode)
    bpy.utils.register_class(StrongNode)
    bpy.utils.register_class(WeakNode)
    bpy.utils.register_class(SetTagNode)
    bpy.utils.register_class(FilterNode)
    bpy.utils.register_class(MapNode)
    bpy.utils.register_class(OutputNode)
    bpy.utils.register_class(PriorityNode)
    bpy.utils.register_class(PrintNode)

    bpy.utils.register_class(StartState)
    bpy.utils.register_class(ActionState)

    bpy.utils.register_class(NoteNode)
    bpy.utils.register_class(SimNoteTextFromClipboard)
    bpy.utils.register_class(SimNoteClear)

    nodeitems_utils.register_node_categories(
        "CrowdMaster_NODES", node_categories)

def register():
	bpy.utils.register_class(UwatelaNodeTree)
	bpy.utils.register_class(UwatelaNodeSocket)
	bpy.utils.register_class(UwatelaMeshMoveNode)
	bpy.utils.register_class(UwatelaObjectInputNode)

	nodeitems_utils.register_node_categories("UWATELA", node_categories)

def reload_menu():
    menu, node_count, original_categories = make_categories()
    if 'SVERCHOK' in nodeitems_utils._node_categories:
        nodeitems_utils.unregister_node_categories("SVERCHOK")
    nodeitems_utils.register_node_categories("SVERCHOK", menu)
    
    build_help_remap(original_categories)

def register():
    menu, node_count = make_categories()
    if 'SVERCHOK' in nodeitems_utils._node_categories:
        nodeitems_utils.unregister_node_categories("SVERCHOK")
    nodeitems_utils.register_node_categories("SVERCHOK", menu)

    print("\n** Sverchok loaded with {i} nodes **".format(i=node_count))

def register():
    from . import ui
    from . import properties
    preferences.register()
    properties.register()
    ui.register()
    node_tree.register()
    sockets.register()
    export_avango.register()
    starter.register()
    nodes.register()

    bpy.utils.register_module(__name__)

    # Idee: root am SceneGraph
    # 1.)
    # alle objects haben CollectionProperty,
    # sollte beim exportieren des scene graphs ein die CollectionProperty eines
    # Hierarchieknotens leer sein, wird ein default FieldContainer des
    # passenden typs erstellt
    # 2.) wenn ein Node gelöscht wird, soll auf referenzierten blender objecten
    #   vorher die Referenz auf diesen Node entfernt werden

    #bpy.types.Object.avango_nodes = bpy.props.CollectionProperty(
    #  type=bpy.types.PropertyGroup)

    if 'AVANGO_NODES' in nu._node_categories:
        nu.unregister_node_categories('AVANGO_NODES')
    nu.register_node_categories('AVANGO_NODES', node_categories)

def register():
	bpy.utils.register_module(__name__)
	try:
		nodeitems_utils.register_node_categories("CG_PIPELINE_NODES", node_categories)
		reload_blend_data()
	except:
		pass

def register():
	registerIfPossible(__name__)
	for moduleName in moduleNames:
		registerIfPossible(moduleName)
	categories = mn_node_register.getNodeCategories()
	register_node_categories("ANIMATIONNODES", categories)
	
	bpy.types.Scene.mn_settings = PointerProperty(type = AnimationNodesSettings, name = "Animation Node Settings")

def register():
    for cls in classes:
        bpy.utils.register_class(cls)

    bpy.types.Scene.splash = PointerProperty(type=SplashSettings)

    import nodeitems_utils
    nodeitems_utils.register_node_categories("SPLASH_NODES", nodes.node_categories)

def register():
    bpy.utils.register_class(NodeComment)
    bpy.utils.register_class(CommentNode)

    try:
        nodeitems_utils.register_node_categories("COMMENT_NODES", comment_node_categories)
    except:
        pass

def register():
    bpy.utils.register_class(B4W_LogicEditorErrTextWrap)
    bpy.utils.register_class(B4W_LogicEditorErrors)
    bpy.utils.register_class(B4W_LogicNodeTree)
    bpy.utils.register_class(B4W_LogicNode)
    bpy.utils.register_class(B4W_LogicNodeJumpSocket)
    bpy.utils.register_class(B4W_LogicNodeOrderSocket)

    nodeitems_utils.register_node_categories("B4W_LOGIC_CUSTOM_NODES", node_categories)
    register_hotkey()

def register():

    bpy.utils.register_module(__name__)
    nodeitems_utils.register_node_categories("POVRAYNODES", node_categories)
    bpy.types.DATA_PT_metaball.append(menu_func_meta)
    bpy.types.INFO_MT_add.append(menu_func_add)
    bpy.types.INFO_MT_file_import.append(menu_func_import)
    bpy.types.NODE_HT_header.append(menu_func_nodes)
    bpy.types.PARTICLE_PT_cache.append(menu_func_particles_bake)
    bpy.types.WORLD_PT_context_world.append(menu_func_world)

def register():
    util.safe_register_class(AppleseedOSLNodeTree)
    node_list = util.read_osl_shaders()
    for node in node_list:
        try:
            node_name, node_category = oslnode.generate_node(node)
            osl_node_names.append([node_name, node_category])
        except:
            pass
    register_node_categories("APPLESEED", node_categories(osl_node_names))

def register():

    bpy.utils.register_module(__name__)    
    
    #Only appends the header once during development
#    if not bpy.context.scene.appended_header:
    bpy.types.NODE_HT_header.append(SceneNodesHeader)
#        bpy.context.scene.appended_header = True    

    if 'SCENE_NODES' in nodeitems_utils._node_categories:
        nodeitems_utils.unregister_node_categories("SCENE_NODES")
    nodeitems_utils.register_node_categories("SCENE_NODES", node_categories)

def FLOW_nodecats(perform):
    import nodeitems_utils as nu
    node_categories = nu._node_categories

    if perform == 'unregister':
        if FLOW in node_categories:
            nu.unregister_node_categories(FLOW)

    elif perform == 'register':
        from FLOW.flow_nodes_index import make_categories
        if not (FLOW in node_categories):
            nu.register_node_categories(FLOW, make_categories())

def register():
    # === Blender classes ===
    bpy.utils.register_module(__name__)
    nodeitems_utils.register_node_categories("CUSTOM_CATEGORIES", categories)

    # === Model setup ===
    # Scene global used by NodeTree & Nodes for communication with Adapter
    # Workaround due to NodeTree/Node non-persistent classes
    bpy.types.Scene.observable = Observable()
    # Adapter observes nodetree scene global
    bpy.types.Scene.adapter = Adapter(bpy.types.Scene.observable)
    print("Nodearama registered successfully.")

    def register(self):
        class PyNodesCategory(nodeitems_utils.NodeCategory):
            @classmethod
            def poll(cls, context):
                space = context.space_data
                if not (space.type == 'NODE_EDITOR' and space.tree_type == self.nodetree_cls.bl_idname):
                    return False
                return True

        node_category_items = lambda node_classes : [ nodeitems_utils.NodeItem(getattr(cls, "bl_idname", cls.__name__)) for cls in node_classes ]
        node_categories = [ PyNodesCategory(name, name, items=node_category_items(node_classes)) for name, node_classes in self.node_items.items() ]
        nodeitems_utils.register_node_categories(self.nodetree_cls.bl_idname, node_categories)

def register():

    for cls in classes:
        bpy.utils.register_class(cls)
 
    user_preferences = bpy.context.user_preferences
    prefs = user_preferences.addons[__package__].preferences


    #Register pointer property if not already done
    if  not hasattr(bpy.types.Scene, "OSLProps"):
        bpy.types.Scene.OSLProps = bpy.props.PointerProperty(type=OSLProps, name="Renderman OSL Settings")
    
    
    #from bpy.app.handlers import persistent

    #@persistent
    #def load_handler(dummy):
    categories = {}

    for name, arg_file in args_files_in_path(prefs, None).items():
        generate_node_type(prefs, name, ET.parse(arg_file).getroot())

    pattern_nodeitems = []
    bxdf_nodeitems = []
    light_nodeitems = []
    for name, node_type in RendermanPatternGraph.nodetypes.items():
        node_item = NodeItem(name, label=node_type.bl_label)
        if node_type.renderman_node_type == 'pattern':
            pattern_nodeitems.append(node_item)
        elif node_type.renderman_node_type == 'bxdf':
            bxdf_nodeitems.append(node_item)
        elif node_type.renderman_node_type == 'light':
            light_nodeitems.append(node_item)
       

    # all categories in a list
    node_categories = [
        # identifier, label, items list
        RendermanPatternNodeCategory("PRMan_output_nodes", "PRMan outputs", 
            items = [RendermanOutputNode]),
        RendermanPatternNodeCategory("PRMan_bxdf", "PRMan Bxdfs",  
            items=sorted(bxdf_nodeitems, key=attrgetter('_label')) ),
        RendermanPatternNodeCategory("PRMan_patterns", "PRMan Patterns",  
            items=sorted(pattern_nodeitems, key=attrgetter('_label')) ),
        RendermanPatternNodeCategory("PRMan_lights", "PRMan Lights",  
            items=sorted(light_nodeitems, key=attrgetter('_label')) )

        ]
    nodeitems_utils.register_node_categories("RENDERMANSHADERNODES", 
        node_categories)