# space_view_3d_display_tools.py Copyright (C) 2012, Jordi Vall-llovera
#
# Multiple display tools for fast navigate/interact with the viewport
#
# ***** BEGIN GPL LICENSE BLOCK *****
#
#
# 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 *****

bl_info = {
    "name": "Display Tools",
    "author": "Jordi Vall-llovera Medina",
    "version": (1, 2, 6),
    "blender": (2, 6, 4),
    "location": "Toolshelf",
    "description": "Display tools for fast navigate/interact with the viewport",
    "warning": "",
    "wiki_url": "http://jordiart3d.blogspot.com.es/",
    "tracker_url": "",
    "category": "3D View"}

"""
Additional links:
    Author Site: http://jordiart3d.blogspot.com.es/
"""

import bpy

from bpy.props import IntProperty, BoolProperty, FloatProperty, EnumProperty

# init delay variables
bpy.types.Scene.Delay = bpy.props.BoolProperty(
        default = False,
        description = "Activate delay return to normal viewport mode")

bpy.types.Scene.DelayTime = bpy.props.IntProperty(
        default = 30,
        min = 1,
        max = 500,
        soft_min = 10,
        soft_max = 250,
        description = "Delay time to return to normal viewport\
         mode after move your mouse cursor")

bpy.types.Scene.DelayTimeGlobal = bpy.props.IntProperty(
        default = 30,
        min = 1,
        max = 500,
        soft_min = 10,
        soft_max = 250,
        description = "Delay time to return to normal viewport\
         mode after move your mouse cursor")

#init variable for fast navigate
bpy.types.Scene.EditActive = bpy.props.BoolProperty(
        default = True,
        description = "Activate for fast navigate in edit mode too")

#Fast Navigate toggle function
def trigger_fast_navigate(trigger):
    scene = bpy.context.scene
    scene.FastNavigateStop = False
    
    if trigger == True:
        trigger = False
    else:
        trigger = True

#Control how to display particles during fast navigate
def display_particles(mode):
    scene = bpy.context.scene
    
    if mode == True:
        for particles in bpy.data.particles:
            if particles.type == 'EMITTER':
                particles.draw_method = 'DOT'
                particles.draw_percentage = 100
            else:
                particles.draw_method = 'RENDER'  
                particles.draw_percentage = 100
    else:
        for particles in bpy.data.particles:
            if particles.type == 'EMITTER':
                particles.draw_method = 'DOT'
                particles.draw_percentage = scene.ParticlesPercentageDisplay
            else:
                particles.draw_method = 'RENDER'  
                particles.draw_percentage = scene.ParticlesPercentageDisplay

#Do repetitive fast navigate related stuff         
def fast_navigate_stuff(self, context, event):    
    scene = bpy.context.scene
    view = context.space_data
        
    if bpy.context.area.type != 'VIEW_3D':
        return self.cancel(context)    
                          
    if event.type == 'ESC' or event.type == 'RET' or event.type == 'SPACE':
        return self.cancel(context)
     
    if scene.FastNavigateStop == True:
        return self.cancel(context)    
    
    #fast navigate while orbit/panning
    if event.type == 'MIDDLEMOUSE':
        if scene.Delay == True:
            if scene.DelayTime < scene.DelayTimeGlobal:
                scene.DelayTime += 1
        view.viewport_shade = scene.FastMode
        self.mode = False
        
    #fast navigate while transform operations
    if event.type == 'G' or event.type == 'R' or event.type == 'S': 
        if scene.Delay == True:
            if scene.DelayTime < scene.DelayTimeGlobal:
                scene.DelayTime += 1
        view.viewport_shade = scene.FastMode
        self.mode = False
     
    #fast navigate while menu popups or duplicates  
    if event.type == 'W' or event.type == 'D' or event.type == 'L'\
        or event.type == 'U' or event.type == 'I' or event.type == 'M'\
        or event.type == 'A' or event.type == 'B': 
        if scene.Delay == True:
            if scene.DelayTime < scene.DelayTimeGlobal:
                scene.DelayTime += 1
        view.viewport_shade = scene.FastMode
        self.mode = False
    
    #fast navigate while numpad navigation
    if event.type == 'NUMPAD_PERIOD' or event.type == 'NUMPAD_1'\
        or event.type == 'NUMPAD_2' or event.type == 'NUMPAD_3'\
        or event.type == 'NUMPAD_4' or event.type == 'NUMPAD_5'\
        or event.type == 'NUMPAD_6' or event.type == 'NUMPAD_7'\
        or event.type == 'NUMPAD_8' or event.type == 'NUMPAD_9': 
        if scene.Delay == True:
            if scene.DelayTime < scene.DelayTimeGlobal:
                scene.DelayTime += 1
        view.viewport_shade = scene.FastMode
        self.mode = False
        
    #fast navigate while zooming with mousewheel too
    if event.type == 'WHEELUPMOUSE' or event.type == 'WHEELDOWNMOUSE':
        scene.DelayTime = scene.DelayTimeGlobal
        view.viewport_shade = scene.FastMode
        self.mode = False
        
    if event.type == 'MOUSEMOVE': 
        if scene.Delay == True:
            if scene.DelayTime == 0:
                scene.DelayTime = scene.DelayTimeGlobal
                view.viewport_shade = scene.OriginalMode 
                self.mode = True
        else:
            view.viewport_shade = scene.OriginalMode 
            self.mode = True
    
    if scene.Delay == True:
        scene.DelayTime -= 1   
        if scene.DelayTime == 0:
            scene.DelayTime = scene.DelayTimeGlobal
            view.viewport_shade = scene.OriginalMode 
            self.mode = True
        
    if scene.ShowParticles == False:
        for particles in bpy.data.particles:
            if particles.type == 'EMITTER':
                particles.draw_method = 'NONE'
            else:
                particles.draw_method = 'NONE'    
    else:
        display_particles(self.mode)   
    
#Fast Navigate operator
class FastNavigate(bpy.types.Operator):
    """Operator that runs Fast navigate in modal mode"""
    bl_idname = "view3d.fast_navigate_operator"
    bl_label = "Fast Navigate"
    trigger = BoolProperty(default = False)
    mode = BoolProperty(default = False)
    scene = bpy.context.scene
    scene.DelayTime = scene.DelayTimeGlobal

    def modal(self, context, event):     
        scene = bpy.context.scene
        view = context.space_data
        
        if scene.EditActive == True:     
            fast_navigate_stuff(self, context ,event)
            return {'PASS_THROUGH'}       
        else:
            obj = context.active_object
            if obj: 
                if obj.mode != 'EDIT':
                    fast_navigate_stuff(self, context ,event)
                    return {'PASS_THROUGH'}            
                else:
                    return {'PASS_THROUGH'}        
            else:
                fast_navigate_stuff(self, context ,event)
                return {'PASS_THROUGH'}
     
    def execute(self, context):
        context.window_manager.modal_handler_add(self)
        trigger_fast_navigate(self.trigger)
        return {'RUNNING_MODAL'}
    
    def cancel(self, context):
        scene = context.scene
        for particles in bpy.data.particles:
            particles.draw_percentage = scene.InitialParticles
        return {'CANCELLED'}

#Fast Navigate Stop
def fast_navigate_stop(context):
    scene = bpy.context.scene
    scene.FastNavigateStop = True

#Fast Navigate Stop Operator
class FastNavigateStop(bpy.types.Operator):
    '''Stop Fast Navigate Operator'''
    bl_idname = "view3d.fast_navigate_stop"
    bl_label = "Stop"    
    FastNavigateStop = IntProperty(name = "FastNavigateStop", 
		description = "Stop fast navigate mode",
		default = 0)

    def execute(self,context):
        fast_navigate_stop(context)
        return {'FINISHED'}
    
#Drawtype textured
def draw_textured(context):   
    view = context.space_data
    view.viewport_shade = 'TEXTURED'
    bpy.context.scene.game_settings.material_mode = 'GLSL'
    selection = bpy.context.selected_objects  
    
    if not(selection):
        for obj in bpy.data.objects:
            obj.draw_type = 'TEXTURED'
    else:
        for obj in selection:
            obj.draw_type = 'TEXTURED' 
    
class DisplayTextured(bpy.types.Operator):
    '''Display objects in textured mode'''
    bl_idname = "view3d.display_textured"
    bl_label = "Textured"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        draw_textured(context)
        return {'FINISHED'}
    
#Drawtype solid
def draw_solid(context):
    view = context.space_data
    view.viewport_shade = 'TEXTURED'
    bpy.context.scene.game_settings.material_mode = 'GLSL'
    selection = bpy.context.selected_objects 
    
    if not(selection):
        for obj in bpy.data.objects:
            obj.draw_type = 'SOLID'
    else:
        for obj in selection:
            obj.draw_type = 'SOLID'

class DisplaySolid(bpy.types.Operator):
    '''Display objects in solid mode'''
    bl_idname = "view3d.display_solid"
    bl_label = "Solid"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        draw_solid(context)
        return {'FINISHED'}
    
#Drawtype wire
def draw_wire(context):
    view = context.space_data
    view.viewport_shade = 'TEXTURED'
    bpy.context.scene.game_settings.material_mode = 'GLSL'
    selection = bpy.context.selected_objects 
    
    if not(selection):
        for obj in bpy.data.objects:
            obj.draw_type = 'WIRE'
    else:
        for obj in selection:
            obj.draw_type = 'WIRE'

class DisplayWire(bpy.types.Operator):
    '''Display objects in wireframe mode'''
    bl_idname = "view3d.display_wire"
    bl_label = "Wire"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        draw_wire(context)
        return {'FINISHED'}
    
#Drawtype bounds
def draw_bounds(context):
    view = context.space_data
    view.viewport_shade = 'TEXTURED'
    bpy.context.scene.game_settings.material_mode = 'GLSL'
    selection = bpy.context.selected_objects 
    
    if not(selection):
        for obj in bpy.data.objects:
            obj.draw_type = 'BOUNDS'
    else:
        for obj in selection:
            obj.draw_type = 'BOUNDS'

class DisplayBounds(bpy.types.Operator):
    '''Display objects in bounds mode'''
    bl_idname = "view3d.display_bounds"
    bl_label = "Bounds"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        draw_bounds(context)
        return {'FINISHED'}

#Shade smooth
def shade_smooth(context):
    selection = bpy.context.selected_objects   
    
    if not(selection): 
        for obj in bpy.data.objects:
            bpy.ops.object.select_all(action = 'TOGGLE')
            bpy.ops.object.shade_smooth()
            bpy.ops.object.select_all(action = 'TOGGLE')               
    else:
        obj = context.active_object
        if obj.mode == 'OBJECT':
            for obj in selection:
                bpy.ops.object.shade_smooth()
        else:
            bpy.ops.mesh.faces_shade_smooth()

class DisplayShadeSmooth(bpy.types.Operator):
    '''Display shade smooth meshes'''
    bl_idname = "view3d.display_shade_smooth"
    bl_label = "Smooth"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        shade_smooth(context)
        return {'FINISHED'}
    
#Shade flat
def shade_flat(context):
    selection = bpy.context.selected_objects 
      
    if not(selection): 
        for obj in bpy.data.objects:
            bpy.ops.object.select_all(action = 'TOGGLE')
            bpy.ops.object.shade_flat()
            bpy.ops.object.select_all(action = 'TOGGLE')
    else:
        obj = context.active_object
        if obj.mode == 'OBJECT':
            for obj in selection:
                bpy.ops.object.shade_flat()
        else:
            bpy.ops.mesh.faces_shade_flat()    

class DisplayShadeFlat(bpy.types.Operator):
    '''Display shade flat meshes'''
    bl_idname = "view3d.display_shade_flat"
    bl_label = "Flat"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        shade_flat(context)
        return {'FINISHED'}
    
#Shadeless on
def shadeless_on(context):
    selection = bpy.context.selected_objects
    
    if not(selection): 
        for obj in bpy.data.materials:
            obj.use_shadeless = True
    else:
        for sel in selection:
            if sel.type == 'MESH':
                materials = sel.data.materials
                for mat in materials:
                    mat.use_shadeless = True  
            
class DisplayShadelessOn(bpy.types.Operator):
    '''Display shadeless material'''
    bl_idname = "view3d.display_shadeless_on"
    bl_label = "On"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        shadeless_on(context)
        return {'FINISHED'}
    
#Shadeless off
def shadeless_off(context):
    selection = bpy.context.selected_objects
    
    if not(selection): 
        for obj in bpy.data.materials:
            obj.use_shadeless = False
    else:
        for sel in selection:
            if sel.type == 'MESH':
                materials = sel.data.materials
                for mat in materials:
                    mat.use_shadeless = False   

class DisplayShadelessOff(bpy.types.Operator):
    '''Display shaded material'''
    bl_idname = "view3d.display_shadeless_off"
    bl_label = "Off"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        shadeless_off(context)
        return {'FINISHED'}

#Wireframe on
def wire_on(context):
    selection = bpy.context.selected_objects  
     
    if not(selection): 
        for obj in bpy.data.objects:
            obj.show_wire = True
            
        for mesh in bpy.data.meshes:
            mesh.show_all_edges = True
    else:
        for obj in selection:
            obj.show_wire = True
                
        for sel in selection:
            if sel.type == 'MESH':
                mesh = sel.data
                mesh.show_all_edges = True      

class DisplayWireframeOn(bpy.types.Operator):
    '''Display wireframe overlay on'''
    bl_idname = "view3d.display_wire_on"
    bl_label = "On"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        wire_on(context)
        return {'FINISHED'}
    
#Wireframe off
def wire_off(context):
    selection = bpy.context.selected_objects  
    
    if not(selection): 
        for obj in bpy.data.objects:
            obj.show_wire = False
            
        for mesh in bpy.data.meshes:
            mesh.show_all_edges = False
    else:
        for obj in selection:
            obj.show_wire = False
                
        for sel in selection:
            if sel.type == 'MESH':
                mesh = sel.data
                mesh.show_all_edges = False   

class DisplayWireframeOff(bpy.types.Operator):
    '''Display wireframe overlay off'''
    bl_idname = "view3d.display_wire_off"
    bl_label = "Off"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        wire_off(context)
        return {'FINISHED'}

#Bounds on
def bounds_on(context):
    scene = context.scene
    selection = bpy.context.selected_objects 
      
    if not(selection): 
        for obj in bpy.data.objects:
            obj.show_bounds = True
            obj.draw_bounds_type = scene.BoundingMode 
    else:
        for obj in selection:
            obj.show_bounds = True
            obj.draw_bounds_type = scene.BoundingMode                 

class DisplayBoundsOn(bpy.types.Operator):
    '''Display Bounding box overlay on'''
    bl_idname = "view3d.display_bounds_on"
    bl_label = "On"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        bounds_on(context)
        return {'FINISHED'}
    
#Wireframe off
def bounds_off(context):
    scene = context.scene
    selection = bpy.context.selected_objects 
     
    if not(selection): 
        for obj in bpy.data.objects:
            obj.show_bounds = False
    else:
        for obj in selection:
            obj.show_bounds = False    

class DisplayBoundsOff(bpy.types.Operator):
    '''Display Bounding box overlay off'''
    bl_idname = "view3d.display_bounds_off"
    bl_label = "Off"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        bounds_off(context)
        return {'FINISHED'}
    
#Double Sided on
def double_sided_on(context):
    selection = bpy.context.selected_objects
    
    if not(selection):
        for mesh in bpy.data.meshes:
            mesh.show_double_sided = True
    else:
        for sel in selection:
            if sel.type == 'MESH':
                mesh = sel.data
                mesh.show_double_sided = True        

class DisplayDoubleSidedOn(bpy.types.Operator):
    '''Turn on face double shaded mode'''
    bl_idname = "view3d.display_double_sided_on"
    bl_label = "On"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        double_sided_on(context)
        return {'FINISHED'}
    
#Double Sided off
def double_sided_off(context):
    selection = bpy.context.selected_objects
    
    if not(selection):
        for mesh in bpy.data.meshes:
            mesh.show_double_sided = False
    else:
        for sel in selection:
            if sel.type == 'MESH':
                mesh = sel.data
                mesh.show_double_sided = False 

class DisplayDoubleSidedOff(bpy.types.Operator):
    '''Turn off face double sided shade mode'''
    bl_idname = "view3d.display_double_sided_off"
    bl_label = "Off"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        double_sided_off(context)
        return {'FINISHED'}
    
#XRay on
def x_ray_on(context):
    selection = bpy.context.selected_objects 
    
    if not(selection):  
        for obj in bpy.data.objects:
            obj.show_x_ray = True
    else:
        for obj in selection:
            obj.show_x_ray = True        

class DisplayXRayOn(bpy.types.Operator):
    '''X-Ray display on'''
    bl_idname = "view3d.display_x_ray_on"
    bl_label = "On"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        x_ray_on(context)
        return {'FINISHED'}
    
#XRay off
def x_ray_off(context):
    selection = bpy.context.selected_objects  
              
    if not(selection):  
        for obj in bpy.data.objects:
            obj.show_x_ray = False
    else:
        for obj in selection:
            obj.show_x_ray = False  

class DisplayXRayOff(bpy.types.Operator):
    '''X-Ray display off'''
    bl_idname = "view3d.display_x_ray_off"
    bl_label = "Off"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        x_ray_off(context)
        return {'FINISHED'}
    
#Init properties for scene
bpy.types.Scene.FastNavigateStop = bpy.props.BoolProperty(
        name = "Fast Navigate Stop", 
        description = "Stop fast navigate mode",
        default = False)

bpy.types.Scene.OriginalMode = bpy.props.EnumProperty(
        items = [('TEXTURED', 'Texture', 'Texture display mode'), 
            ('SOLID', 'Solid', 'Solid display mode')], 
        name = "Normal",
        default = 'SOLID')

bpy.types.Scene.BoundingMode = bpy.props.EnumProperty(
        items = [('BOX', 'Box', 'Box shape'), 
            ('SPHERE', 'Sphere', 'Sphere shape'),
            ('CYLINDER', 'Cylinder', 'Cylinder shape'),
            ('CONE', 'Cone', 'Cone shape')], 
        name = "BB Mode")

bpy.types.Scene.FastMode = bpy.props.EnumProperty(
        items = [('WIREFRAME', 'Wireframe', 'Wireframe display'), 
            ('BOUNDBOX', 'Bounding Box', 'Bounding Box display')], 
        name = "Fast")
        
bpy.types.Scene.ShowParticles = bpy.props.BoolProperty(
        name = "Show Particles", 
        description = "Show or hide particles on fast navigate mode",
		default = True)

bpy.types.Scene.ParticlesPercentageDisplay = bpy.props.IntProperty(
        name = "Display", 
        description = "Display only a percentage of particles",
		default = 25,
        min = 0,
        max = 100,
        soft_min = 0,
        soft_max = 100,
        subtype = 'FACTOR')
    
bpy.types.Scene.InitialParticles = bpy.props.IntProperty(
        name = "Count for initial particle setting before enter fast navigate", 
        description = "Display a percentage value of particles",
		default = 100,
        min = 0,
        max = 100,
        soft_min = 0,
        soft_max = 100)

#Set Render Settings
def set_render_settings(conext):
    scene = bpy.context.scene
    render = bpy.context.scene.render
    view = bpy.context.space_data
    render.simplify_subdivision = 0
    render.simplify_shadow_samples = 0
    render.simplify_child_particles = 0
    render.simplify_ao_sss = 0

class DisplaySimplify(bpy.types.Operator):
    '''Display scene simplified'''
    bl_idname = "view3d.display_simplify"
    bl_label = "Reset"
    
    Mode = EnumProperty(
        items = [('WIREFRAME', 'Wireframe', ''), 
            ('BOUNDBOX', 'Bounding Box', '')], 
        name = "Mode")
        
    ShowParticles = BoolProperty(
        name = "ShowParticles", 
        description = "Show or hide particles on fast navigate mode",
		default = True)
    
    ParticlesPercentageDisplay = IntProperty(
        name = "Display", 
        description = "Display a percentage value of particles",
		default = 25,
        min = 0,
        max = 100,
        soft_min = 0,
        soft_max = 100,
        subtype = 'FACTOR')

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        set_render_settings(context)
        return {'FINISHED'}

#Display Modifiers Render on
def modifiers_render_on(context):    
    scene = bpy.context.scene
    bpy.types.Scene.Symplify = IntProperty(
    name = "Integer",description = "Enter an integer")
    scene['Simplify'] = 1    
    selection = bpy.context.selected_objects  
    
    if not(selection):   
        for obj in bpy.data.objects:        
            for mod in obj.modifiers:
                mod.show_render = True
    else:
        for obj in selection:        
            for mod in obj.modifiers:
                mod.show_render = True
            
class DisplayModifiersRenderOn(bpy.types.Operator):
    '''Display modifiers in render'''
    bl_idname = "view3d.display_modifiers_render_on"
    bl_label = "On"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        modifiers_render_on(context)
        return {'FINISHED'}
    
#Display Modifiers Render off
def modifiers_render_off(context):
    selection = bpy.context.selected_objects  
    
    if not(selection):   
        for obj in bpy.data.objects:        
            for mod in obj.modifiers:
                mod.show_render = False
    else:
        for obj in selection:        
            for mod in obj.modifiers:
                mod.show_render = False

class DisplayModifiersRenderOff(bpy.types.Operator):
    '''Hide modifiers in render'''
    bl_idname = "view3d.display_modifiers_render_off"
    bl_label = "Off"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        modifiers_render_off(context)
        return {'FINISHED'}
    
#Display Modifiers Viewport on
def modifiers_viewport_on(context):
    selection = bpy.context.selected_objects 
    
    if not(selection):    
        for obj in bpy.data.objects:        
            for mod in obj.modifiers:
                mod.show_viewport = True
    else:
        for obj in selection:        
            for mod in obj.modifiers:
                mod.show_viewport = True
        
class DisplayModifiersViewportOn(bpy.types.Operator):
    '''Display modifiers in viewport'''
    bl_idname = "view3d.display_modifiers_viewport_on"
    bl_label = "On"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        modifiers_viewport_on(context)
        return {'FINISHED'}
    
#Display Modifiers Viewport off
def modifiers_viewport_off(context):
    selection = bpy.context.selected_objects 
    
    if not(selection):    
        for obj in bpy.data.objects:        
            for mod in obj.modifiers:
                mod.show_viewport = False
    else:
        for obj in selection:        
            for mod in obj.modifiers:
                mod.show_viewport = False

class DisplayModifiersViewportOff(bpy.types.Operator):
    '''Hide modifiers in viewport'''
    bl_idname = "view3d.display_modifiers_viewport_off"
    bl_label = "Off"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        modifiers_viewport_off(context)
        return {'FINISHED'}
    
#Display Modifiers Edit on
def modifiers_edit_on(context):
    selection = bpy.context.selected_objects 
      
    if not(selection):  
        for obj in bpy.data.objects:        
            for mod in obj.modifiers:
                mod.show_in_editmode = True
    else:
        for obj in selection:        
            for mod in obj.modifiers:
                mod.show_in_editmode = True

class DisplayModifiersEditOn(bpy.types.Operator):
    '''Display modifiers during edit mode'''
    bl_idname = "view3d.display_modifiers_edit_on"
    bl_label = "On"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        modifiers_edit_on(context)
        return {'FINISHED'}
    
#Display Modifiers Edit off
def modifiers_edit_off(context):
    selection = bpy.context.selected_objects  
     
    if not(selection):  
        for obj in bpy.data.objects:        
            for mod in obj.modifiers:
                mod.show_in_editmode = False
    else:
        for obj in selection:        
            for mod in obj.modifiers:
                mod.show_in_editmode = False

class DisplayModifiersEditOff(bpy.types.Operator):
    '''Hide modifiers during edit mode'''
    bl_idname = "view3d.display_modifiers_edit_off"
    bl_label = "Off"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        modifiers_edit_off(context)
        return {'FINISHED'}
    
#Display Modifiers Cage on
def modifiers_cage_on(context):
    selection = bpy.context.selected_objects  
      
    if not(selection): 
        for obj in bpy.data.objects:        
            for mod in obj.modifiers:
                mod.show_on_cage = True
    else:
        for obj in selection:        
            for mod in obj.modifiers:
                mod.show_on_cage = True

class DisplayModifiersCageOn(bpy.types.Operator):
    '''Display modifiers editing cage during edit mode'''
    bl_idname = "view3d.display_modifiers_cage_on"
    bl_label = "On"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        modifiers_cage_on(context)
        return {'FINISHED'}
    
#Display Modifiers Cage off
def modifiers_cage_off(context):
    selection = bpy.context.selected_objects 
       
    if not(selection): 
        for obj in bpy.data.objects:        
            for mod in obj.modifiers:
                mod.show_on_cage = False
    else:
        for obj in selection:        
            for mod in obj.modifiers:
                mod.show_on_cage = False

class DisplayModifiersCageOff(bpy.types.Operator):
    '''Hide modifiers editing cage during edit mode'''
    bl_idname = "view3d.display_modifiers_cage_off"
    bl_label = "Off"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        modifiers_cage_off(context)
        return {'FINISHED'}
    
#Display Modifiers Expand
def modifiers_expand(context):
    selection = bpy.context.selected_objects  
      
    if not(selection): 
        for obj in bpy.data.objects:        
            for mod in obj.modifiers:
                mod.show_expanded = True
    else:
        for obj in selection:        
            for mod in obj.modifiers:
                mod.show_expanded = True

class DisplayModifiersExpand(bpy.types.Operator):
    '''Expand all modifiers on modifier stack'''
    bl_idname = "view3d.display_modifiers_expand"
    bl_label = "Expand"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        modifiers_expand(context)
        return {'FINISHED'}
    
#Display Modifiers Collapse
def modifiers_collapse(context):
    selection = bpy.context.selected_objects  
      
    if not(selection): 
        for obj in bpy.data.objects:        
            for mod in obj.modifiers:
                mod.show_expanded = False
    else:
        for obj in selection:        
            for mod in obj.modifiers:
                mod.show_expanded = False

class DisplayModifiersCollapse(bpy.types.Operator):
    '''Collapse all modifiers on modifier stack'''
    bl_idname = "view3d.display_modifiers_collapse"
    bl_label = "Collapse"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        modifiers_collapse(context)
        return {'FINISHED'}
    
#Apply modifiers
def modifiers_apply(context):
    selection = bpy.context.selected_objects
    
    if not(selection):  
        bpy.ops.object.select_all(action = 'TOGGLE')
        bpy.ops.object.convert(target = 'MESH', keep_original = False)
        bpy.ops.object.select_all(action = 'TOGGLE')
    else:
        for mesh in selection:
            if mesh.type == "MESH":
                bpy.ops.object.convert(target='MESH', keep_original = False)
                
class DisplayModifiersApply(bpy.types.Operator):
    '''Apply modifiers'''
    bl_idname = "view3d.display_modifiers_apply"
    bl_label = "Apply All"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        modifiers_apply(context)
        return {'FINISHED'}
    
#Delete modifiers
def modifiers_delete(context):
    selection = bpy.context.selected_objects
    
    if not(selection):  
        for obj in bpy.data.objects:
            for mod in obj.modifiers:
                bpy.context.scene.objects.active = obj
                bpy.ops.object.modifier_remove(modifier = mod.name)
    else:
        for obj in selection:
            for mod in obj.modifiers:
                bpy.context.scene.objects.active = obj
                bpy.ops.object.modifier_remove(modifier = mod.name)
                
class DisplayModifiersDelete(bpy.types.Operator):
    '''Delete modifiers'''
    bl_idname = "view3d.display_modifiers_delete"
    bl_label = "Delete All"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        modifiers_delete(context)
        return {'FINISHED'}
    
#Put dummy modifier for boost subsurf
def modifiers_set_dummy(context):
    selection = bpy.context.selected_objects 
    
    if not(selection):
        print("funciona")
        for object in bpy.data.objects:
            if object.type == "MESH":
                mod = object.modifiers.new(type = 'SIMPLE_DEFORM',\
                                            name = "Dummy")
                mod.factor = 0
    else:
        for object in selection:
            if object.type == "MESH":
                mod = object.modifiers.new(type = 'SIMPLE_DEFORM',\
                                            name = "Dummy")
                mod.factor = 0
              
class DisplayAddDummy(bpy.types.Operator):
    '''Add a dummy simple deform modifier to boost\
     subsurf modifier viewport performance'''
    bl_idname = "view3d.display_modifiers_set_dummy"
    bl_label = "Put Dummy"

    @classmethod
    def poll(cls, context):
        return True

    def execute(self, context):
        modifiers_set_dummy(context)
        return {'FINISHED'}

# main class for Fast Navigate
class VIEW3D_PT_FastNavigate(bpy.types.Panel):
    bl_space_type = "VIEW_3D"
    bl_region_type = "TOOLS"
    bl_label = "Fast Navigate"
    bl_options = {"DEFAULT_CLOSED"}
    
    def draw(self, context):
        layout = self.layout
        
        # Tools   
        scene = context.scene
        row = layout.row(align=True)
        row.alignment = 'LEFT'
        row.operator("view3d.fast_navigate_operator")
        row.operator("view3d.fast_navigate_stop")
        layout.label("Settings :")
        row = layout.row()
        box = row.box()
        box.prop(scene,"OriginalMode")
        box.prop(scene,"FastMode")
        box.prop(scene, "EditActive", "Edit mode")
        box.prop(scene, "Delay")
        box.prop(scene, "DelayTimeGlobal", "Delay time")
        box.alignment = 'LEFT'
        box.prop(scene,"ShowParticles")
        box.prop(scene,"ParticlesPercentageDisplay")
        
# main class for Display Mode
class VIEW3D_PT_DisplayMode(bpy.types.Panel):
    bl_space_type = "VIEW_3D"
    bl_region_type = "TOOLS"
    bl_label = "Display Mode"
    bl_options = {"DEFAULT_CLOSED"}
    
    def draw(self, context):
        layout = self.layout
        
        # Tools
        col = layout.column()
        col.alignment = 'EXPAND'
        row = col.row()
        row.operator("view3d.display_textured" , icon ='TEXTURE_SHADED')
        row.operator("view3d.display_solid" , icon ='SOLID')
        col = layout.column()
        col.alignment = 'EXPAND'
        row = col.row()
        row.operator("view3d.display_wire" , icon = 'WIRE')
        row.operator("view3d.display_bounds" , icon = 'BBOX')

# main class for Shading Setup
class VIEW3D_PT_ShadingSetup(bpy.types.Panel):
    bl_space_type = "VIEW_3D"
    bl_region_type = "TOOLS"
    bl_label = "Shading Setup"
    bl_options = {"DEFAULT_CLOSED"}
    
    def draw(self, context):
        layout = self.layout
        
        # Tools
        col = layout.column(align=True)
        row = col.row()       
        row.operator("view3d.display_shade_smooth")
        row.operator("view3d.display_shade_flat")
        row = col.row()      
        row.operator("view3d.display_shadeless_on", "Shadeless On",\
                      icon = 'SOLID')
        row.operator("view3d.display_shadeless_off",\
                     "Shadeless Off", icon = 'SOLID')
        row = col.row()        
        row.operator("view3d.display_wire_on", "Wire On", icon = 'WIRE')
        row.operator("view3d.display_wire_off", "Wire Off", icon = 'WIRE')
        row = col.row()       
        row.operator("view3d.display_bounds_on", "Bounds On", icon = 'BBOX')
        row.operator("view3d.display_bounds_off", "Bounds Off", icon = 'BBOX')
        row = col.row()       
        row.operator("view3d.display_double_sided_on",\
                     "DSided On", icon = 'MESH_DATA')
        row.operator("view3d.display_double_sided_off",\
                     "DSided Off", icon = 'MESH_DATA')
        row = col.row()        
        row.operator("view3d.display_x_ray_on",\
                     "XRay On", icon = 'GHOST_ENABLED')
        row.operator("view3d.display_x_ray_off",\
                     "XRay Off", icon = 'GHOST_ENABLED')
        row = col.row()
        row.separator()
        row = col.row()
        
        scene = context.scene
        row.prop(scene, "BoundingMode")

# main class for Scene Visualization
class VIEW3D_PT_SceneVisualization(bpy.types.Panel):
    bl_space_type = "VIEW_3D"
    bl_region_type = "TOOLS"
    bl_label = "Scene Visualization"
    bl_options = {"DEFAULT_CLOSED"}
    
    def draw(self, context):
        layout = self.layout
        
        # Tools
        scene = context.scene
        render = scene.render
        space = context.space_data
        layout.prop(space, "show_manipulator")
        layout.prop(space, "show_outline_selected")
        layout.prop(space, "show_only_render")
        layout.prop(space, "show_textured_solid")
        layout.prop(space, "show_backface_culling")
        layout.prop(space, "show_all_objects_origin")
        layout.prop(render,"use_simplify", "Simplify")
        if scene.render.use_simplify == True:
            layout.label("Settings :")
            row = layout.row()
            box = row.box()
            box.prop(render, "simplify_subdivision", "Subdivision")
            box.prop(render, "simplify_shadow_samples", "Shadow Samples")
            box.prop(render, "simplify_child_particles", "Child Particles")
            box.prop(render, "simplify_ao_sss", "AO and SSS")
            layout.operator("view3d.display_simplify")

# main class for Modifier Tools
class VIEW3D_PT_ModifierTools(bpy.types.Panel):
    bl_space_type = "VIEW_3D"
    bl_region_type = "TOOLS"
    bl_label = "Modifier Tools"
    bl_options = {"DEFAULT_CLOSED"}
    
    def draw(self, context):
        layout = self.layout
        
        # Tools
        layout.label("Modifiers", icon = 'MODIFIER')
        col = layout.column(align=True)
        col.alignment = 'EXPAND'
        row = col.row()
        row.operator("view3d.display_modifiers_render_on",\
                      icon = 'RENDER_STILL')
        row.operator("view3d.display_modifiers_render_off")
        row.operator("view3d.display_modifiers_viewport_on",
        icon = 'RESTRICT_VIEW_OFF')
        row.operator("view3d.display_modifiers_viewport_off")       
        col = layout.column(align=True)
        col.alignment = 'EXPAND'
        row = col.row()
        row.operator("view3d.display_modifiers_edit_on", icon = 'EDITMODE_HLT')
        row.operator("view3d.display_modifiers_edit_off")  
        row.operator("view3d.display_modifiers_cage_on",\
                      icon = 'EDITMODE_DEHLT')
        row.operator("view3d.display_modifiers_cage_off")       
        row = layout.row(align=True)
        row.operator("view3d.display_modifiers_expand", icon = 'TRIA_DOWN')
        row.operator("view3d.display_modifiers_collapse", icon = 'TRIA_RIGHT')       
        row = layout.row(align=True)
        row.operator("view3d.display_modifiers_apply", icon = 'MODIFIER')
        row.operator("view3d.display_modifiers_delete", icon = 'X')
        row = layout.row(align=True)
        row.operator("view3d.display_modifiers_set_dummy",\
                     icon = 'OUTLINER_OB_ARMATURE')
             
# register the classes
def register():
    bpy.utils.register_class(FastNavigate)
    bpy.utils.register_class(DisplayTextured)
    bpy.utils.register_class(DisplaySolid)
    bpy.utils.register_class(DisplayWire)
    bpy.utils.register_class(DisplayBounds)
    bpy.utils.register_class(DisplayWireframeOn)
    bpy.utils.register_class(DisplayWireframeOff)
    bpy.utils.register_class(DisplayBoundsOn)
    bpy.utils.register_class(DisplayBoundsOff)
    bpy.utils.register_class(DisplayShadeSmooth)
    bpy.utils.register_class(DisplayShadeFlat)
    bpy.utils.register_class(DisplayShadelessOn)
    bpy.utils.register_class(DisplayShadelessOff)
    bpy.utils.register_class(DisplayDoubleSidedOn)
    bpy.utils.register_class(DisplayDoubleSidedOff)
    bpy.utils.register_class(DisplayXRayOn)
    bpy.utils.register_class(DisplayXRayOff)
    bpy.utils.register_class(DisplayModifiersRenderOn)
    bpy.utils.register_class(DisplayModifiersRenderOff)
    bpy.utils.register_class(DisplayModifiersViewportOn)
    bpy.utils.register_class(DisplayModifiersViewportOff)
    bpy.utils.register_class(DisplayModifiersEditOn)
    bpy.utils.register_class(DisplayModifiersEditOff)
    bpy.utils.register_class(DisplayModifiersCageOn)
    bpy.utils.register_class(DisplayModifiersCageOff)
    bpy.utils.register_class(DisplayModifiersExpand)
    bpy.utils.register_class(DisplayModifiersCollapse)
    bpy.utils.register_class(DisplayModifiersApply)
    bpy.utils.register_class(DisplayModifiersDelete)
    bpy.utils.register_class(DisplayAddDummy)
    bpy.utils.register_class(DisplaySimplify)
    bpy.utils.register_module(__name__) 
    pass 

def unregister():
    bpy.utils.unregister_class(FastNavigate)
    bpy.utils.unregister_class(DisplayTextured)
    bpy.utils.unregister_class(DisplaySolid)
    bpy.utils.unregister_class(DisplayWire)
    bpy.utils.unregister_class(DisplayBounds)
    bpy.utils.unregister_class(DisplayShadeSmooth)
    bpy.utils.unregister_class(DisplayShadeFlat)
    bpy.utils.unregister_class(DisplayShadelessOn)
    bpy.utils.unregister_class(DisplayShadelessOff)
    bpy.utils.unregister_class(DisplayWireframeOn)
    bpy.utils.unregister_class(DisplayWireframeOff)
    bpy.utils.unregister_class(DisplayBoundsOn)
    bpy.utils.unregister_class(DisplayBoundsOff)
    bpy.utils.unregister_class(DisplayDoubleSidedOn)
    bpy.utils.unregister_class(DisplayDoubleSidedOff)
    bpy.utils.unregister_class(DisplayXRayOn)
    bpy.utils.unregister_class(DisplayXRayOff)
    bpy.utils.unregister_class(DisplayModifiersRenderOn)
    bpy.utils.unregister_class(DisplayModifiersRenderOff)
    bpy.utils.unregister_class(DisplayModifiersViewportOn)
    bpy.utils.unregister_class(DisplayModifiersViewportOff)
    bpy.utils.unregister_class(DisplayModifiersEditOn)
    bpy.utils.unregister_class(DisplayModifiersEditOff)
    bpy.utils.unregister_class(DisplayModifiersCageOn)
    bpy.utils.unregister_class(DisplayModifiersCageOff)
    bpy.utils.unregister_class(DisplayModifiersExpand)
    bpy.utils.unregister_class(DisplayModifiersCollapse)
    bpy.utils.unregister_class(DisplayModifiersApply)
    bpy.utils.unregister_class(DisplayModifiersDelete)
    bpy.utils.unregister_class(DisplayAddDummy)
    bpy.utils.unregister_class(DisplaySimplify)
    bpy.utils.unregister_module(__name__)
    pass 

if __name__ == "__main__": 
    register()    