Poodletooth-iLand/panda/direct/tkpanels/ParticlePanel.py

"""PANDA3D Particle Panel"""

__all__ = ['ParticlePanel']

# Import Tkinter, Pmw, and the floater code from this directory tree.
from direct.tkwidgets.AppShell import *
from direct.showbase.TkGlobal import *
from tkFileDialog import *
from tkSimpleDialog import askstring
from direct.tkwidgets import Dial
from direct.tkwidgets import Floater
from direct.tkwidgets import Slider
from direct.tkwidgets import VectorWidgets
from direct.particles import ForceGroup
from direct.particles import Particles
from direct.particles import ParticleEffect
from Tkinter import *
import Pmw, os,Placer

from pandac.PandaModules import *

class ParticlePanel(AppShell):
    # Override class variables
    appname = 'Particle Panel'
    frameWidth  = 375
    frameHeight = 675
    usecommandarea = 0
    usestatusarea  = 0
    balloonState = 'both'

    def __init__(self, particleEffect = None, **kw):
        INITOPT = Pmw.INITOPT
        optiondefs = (
            ('title',     self.appname,       None),
            )
        self.defineoptions(kw, optiondefs)

        # Record particle effect
        if particleEffect != None:
            self.particleEffect = particleEffect
        else:
            # Make sure particles are enabled
            base.enableParticles()
        
            # Or create a new one if none given
            particles = Particles.Particles()
            particles.setBirthRate(0.02)
            particles.setLitterSize(10)
            particles.setLitterSpread(0)
            particles.setFactory("PointParticleFactory")
            particles.setRenderer("PointParticleRenderer")
            particles.setEmitter("SphereVolumeEmitter")
            particles.enable()
            pe = ParticleEffect.ParticleEffect('effect-1', particles)
            self.particleEffect = pe
            pe.reparentTo(render)
            pe.enable()

        # Initialize application specific info
        AppShell.__init__(self)

        # Initialize panel Pmw options
        self.initialiseoptions(ParticlePanel)

        # Update panel values to reflect particle effect's state
        self.selectEffectNamed(self.effectsDict.keys()[0])
        # Make sure labels/menus reflect current state
        self.updateMenusAndLabels()
        # Make sure there is a page for each forceGroup objects
        for forceGroup in self.particleEffect.getForceGroupList():
            self.addForceGroupNotebookPage(self.particleEffect, forceGroup)

    def appInit(self):
        # Create dictionaries to keep track of panel objects
        self.widgetDict = {}
        self.variableDict = {}
        self.effectsDict = {}
        self.effectsDict[self.particleEffect.getName()] = (
            self.particleEffect)
        self.forcePagesDict = {}


    def createInterface(self):
        # Handle to the toplevels hull
        interior = self.interior()

        # Create particle panel menu items

        ## MENUBAR ENTRIES ##
        # FILE MENU
        # Get a handle on the file menu so commands can be inserted
        # before quit item
        fileMenu = self.menuBar.component('File-menu')
        # MRM: Need to add load and save effects methods
        fileMenu.insert_command(
            fileMenu.index('Quit'),
            label = 'Load Params',
            command = self.loadParticleEffectFromFile)
        fileMenu.insert_command(
            fileMenu.index('Quit'),
            label = 'Save Params',
            command = self.saveParticleEffectToFile)
        fileMenu.insert_command(
            fileMenu.index('Quit'),
            label = 'Print Params',
            command = lambda s = self: s.particles.printParams())

        # PARTICLE MANAGER MENU
        self.menuBar.addmenu('ParticleMgr', 'ParticleMgr Operations')
        self.particleMgrActive = IntVar()
        self.particleMgrActive.set(base.isParticleMgrEnabled())
        self.menuBar.addmenuitem(
            'ParticleMgr', 'checkbutton',
            'Enable/Disable ParticleMgr',
            label = 'Active',
            variable = self.particleMgrActive,
            command = self.toggleParticleMgr)

        ## MENUBUTTON LABELS ##
        # Menubutton/label to identify the current objects being configured
        labelFrame = Frame(interior)
        # Current effect
        self.effectsLabel = Menubutton(labelFrame, width = 10,
                                       relief = RAISED,
                                       borderwidth = 2,
                                       font=('MSSansSerif', 12, 'bold'),
                                       activebackground = '#909090')
        self.effectsLabelMenu = Menu(self.effectsLabel, tearoff = 0)
        self.effectsLabel['menu'] = self.effectsLabelMenu
        self.effectsLabel.pack(side = LEFT, fill = 'x', expand = 1)
        self.bind(self.effectsLabel,
                  'Select effect to configure or create new effect')
        self.effectsLabelMenu.add_command(label = 'Create New Effect',
                                          command = self.createNewEffect)
        self.effectsLabelMenu.add_command(
            label = 'Select Particle Effect',
            command = lambda s = self: base.direct.select(s.particleEffect))
        self.effectsLabelMenu.add_command(
            label = 'Place Particle Effect',
            command = lambda s = self: Placer.place(s.particleEffect))
        def togglePEVis(s = self):
            if s.particleEffect.isHidden():
                s.particleEffect.show()
            else:
                s.particleEffect.hide()
        self.effectsLabelMenu.add_command(
            label = 'Toggle Effect Vis',
            command = togglePEVis)
        self.effectsEnableMenu = Menu(self.effectsLabelMenu, tearoff = 0)
        self.effectsLabelMenu.add_cascade(label = 'Enable/Disable',
                                          menu = self.effectsEnableMenu)
        self.effectsLabelMenu.add_separator()
        # Current particles
        self.particlesLabel = Menubutton(labelFrame, width = 10,
                                         relief = RAISED,
                                         borderwidth = 2,
                                         font=('MSSansSerif', 12, 'bold'),
                                         activebackground = '#909090')
        self.particlesLabelMenu = Menu(self.particlesLabel, tearoff = 0)
        self.particlesLabel['menu'] = self.particlesLabelMenu
        self.particlesLabel.pack(side = LEFT, fill = 'x', expand = 1)
        self.bind(self.particlesLabel,
                  ('Select particles object to configure ' +
                   'or add new particles object to current effect'))
        self.particlesLabelMenu.add_command(label = 'Create New Particles',
                                            command = self.createNewParticles)
        self.particlesEnableMenu = Menu(self.particlesLabelMenu, tearoff = 0)
        self.particlesLabelMenu.add_cascade(label = 'Enable/Disable',
                                            menu = self.particlesEnableMenu)
        self.particlesLabelMenu.add_separator()
        # Current force
        self.forceGroupLabel = Menubutton(labelFrame, width = 10,
                                      relief = RAISED,
                                      borderwidth = 2,
                                      font=('MSSansSerif', 12, 'bold'),
                                      activebackground = '#909090')
        self.forceGroupLabelMenu = Menu(self.forceGroupLabel, tearoff = 0)
        self.forceGroupLabel['menu'] = self.forceGroupLabelMenu
        self.forceGroupLabel.pack(side = LEFT, fill = 'x', expand = 1)
        self.bind(self.forceGroupLabel,
                  ('Select force group to configure ' +
                   'or add a new force group to current effect'))
        self.forceGroupLabelMenu.add_command(
            label = 'Create New ForceGroup',
            command = self.createNewForceGroup)
        self.forceGroupEnableMenu = Menu(self.forceGroupLabelMenu, tearoff = 0)
        self.forceGroupLabelMenu.add_cascade(label = 'Enable/Disable',
                                             menu = self.forceGroupEnableMenu)
        self.forceGroupLabelMenu.add_separator()
        # Pack labels
        labelFrame.pack(fill = 'x', expand = 0)

        # Create the toplevel notebook pages
        self.mainNotebook = Pmw.NoteBook(interior)
        self.mainNotebook.pack(fill = BOTH, expand = 1)
        systemPage = self.mainNotebook.add('System')
        factoryPage = self.mainNotebook.add('Factory')
        emitterPage = self.mainNotebook.add('Emitter')
        rendererPage = self.mainNotebook.add('Renderer')
        forcePage = self.mainNotebook.add('Force')
        # Put this here so it isn't called right away
        self.mainNotebook['raisecommand'] = self.updateInfo

        ## SYSTEM PAGE WIDGETS ##
        # Create system floaters
        systemFloaterDefs = (
            ('System', 'Pool Size',
             'Max number of simultaneous particles',
             self.setSystemPoolSize,
             1.0, 1.0),
            ('System', 'Birth Rate',
             'Seconds between particle births',
             self.setSystemBirthRate,
             0.0, None),
            ('System', 'Litter Size',
             'Number of particle created at each birth',
             self.setSystemLitterSize,
             1.0, 1.0),
            ('System', 'Litter Spread',
             'Variation in litter size',
             self.setSystemLitterSpread,
             0.0, 1.0),
            ('System', 'Lifespan',
             'Age in seconds at which the system (vs. particles) should die',
             self.setSystemLifespan,
             0.0, None)
            )
        self.createFloaters(systemPage, systemFloaterDefs)

        # Checkboxes
        self.createCheckbutton(
            systemPage, 'System', 'Render Space Velocities',
            ('On: velocities are in render space; ' +
             'Off: velocities are in particle local space'),
            self.toggleSystemLocalVelocity, 0)
        self.createCheckbutton(
            systemPage, 'System', 'System Grows Older',
            'On: system has a lifespan',
            self.toggleSystemGrowsOlder, 0)

        # Vector widgets
        pos = self.createVector3Entry(systemPage, 'System', 'Pos',
                                      'Particle system position',
                                      command = self.setSystemPos)
        pos.addMenuItem('Popup Placer Panel', Placer.Placer)
        hpr = self.createVector3Entry(systemPage, 'System', 'Hpr',
                                     'Particle system orientation',
                                      fGroup_labels = ('H', 'P', 'R'),
                                      command = self.setSystemHpr)
        hpr.addMenuItem('Popup Placer Panel', Placer.Placer)

        ## FACTORY PAGE WIDGETS ##
        self.createOptionMenu(
            factoryPage,
            'Factory', 'Factory Type',
            'Select type of particle factory',
            ('PointParticleFactory', 'ZSpinParticleFactory',
             'OrientedParticleFactory'),
            self.selectFactoryType)
        factoryWidgets = (
            ('Factory', 'Life Span',
             'Average particle lifespan in seconds',
             self.setFactoryLifeSpan,
             0.0, None),
            ('Factory', 'Life Span Spread',
             'Variation in lifespan',
             self.setFactoryLifeSpanSpread,
             0.0, None),
            ('Factory', 'Mass',
             'Average particle mass',
             self.setFactoryParticleMass,
             0.001, None),
            ('Factory', 'Mass Spread',
             'Variation in particle mass',
             self.setFactoryParticleMassSpread,
             0.0, None),
            ('Factory', 'Terminal Velocity',
             'Cap on average particle velocity',
             self.setFactoryTerminalVelocity,
             0.0, None),
            ('Factory', 'Terminal Vel. Spread',
             'Variation in terminal velocity',
             self.setFactoryTerminalVelocitySpread,
             0.0, None),
        )
        self.createFloaters(factoryPage, factoryWidgets)

        self.factoryNotebook = Pmw.NoteBook(factoryPage, tabpos = None)
        # Point page #
        factoryPointPage = self.factoryNotebook.add('PointParticleFactory')
        # Z spin page #
        zSpinPage = self.factoryNotebook.add('ZSpinParticleFactory')

        self.createCheckbutton(
            zSpinPage, 'Z Spin Factory', 'Enable Angular Velocity',
            ("On: angular velocity is used; " +
             "Off: final angle is used"),
            self.toggleAngularVelocity, 0, side = TOP),

        self.createFloater(
            zSpinPage, 'Z Spin Factory', 'Angular Velocity',
             'How fast sprites rotate',
             command = self.setFactoryZSpinAngularVelocity)

        self.createFloater(
            zSpinPage, 'Z Spin Factory', 'Angular Velocity Spread',
             'Variation in how fast sprites rotate',
             command = self.setFactoryZSpinAngularVelocitySpread)

        self.createAngleDial(zSpinPage, 'Z Spin Factory', 'Initial Angle',
                             'Starting angle in degrees',
                             fRollover = 1,
                             command = self.setFactoryZSpinInitialAngle)
        self.createAngleDial(
            zSpinPage, 'Z Spin Factory',
            'Initial Angle Spread',
            'Spread of the initial angle',
            fRollover = 1,
            command = self.setFactoryZSpinInitialAngleSpread)
        self.createAngleDial(zSpinPage, 'Z Spin Factory', 'Final Angle',
                             'Final angle in degrees',
                             fRollover = 1,
                             command = self.setFactoryZSpinFinalAngle)
        self.createAngleDial(
            zSpinPage, 'Z Spin Factory',
            'Final Angle Spread',
            'Spread of the final angle',
            fRollover = 1,
            command = self.setFactoryZSpinFinalAngleSpread)
        # Oriented page #
        orientedPage = self.factoryNotebook.add('OrientedParticleFactory')
        Label(orientedPage, text = 'Not implemented').pack(expand = 1,
                                                           fill = BOTH)
        self.factoryNotebook.pack(expand = 1, fill = BOTH)

        ## EMITTER PAGE WIDGETS ##
        self.createOptionMenu(
            emitterPage, 'Emitter',
            'Emitter Type',
            'Select type of particle emitter',
            ('BoxEmitter', 'DiscEmitter', 'LineEmitter', 'PointEmitter',
             'RectangleEmitter', 'RingEmitter', 'SphereVolumeEmitter',
             'SphereSurfaceEmitter', 'TangentRingEmitter'),
            self.selectEmitterType)

        # Emitter modes
        self.emissionType = IntVar()
        self.emissionType.set(BaseParticleEmitter.ETRADIATE)
        emissionFrame = Frame(emitterPage)
        self.createRadiobutton(
            emissionFrame, 'left',
            'Emitter', 'Explicit Emission',
            ('particles are all emitted in parallel, direction is based ' +
             'on explicit velocity vector'),
            self.emissionType, BaseParticleEmitter.ETEXPLICIT,
            self.setEmissionType)
        self.createRadiobutton(
            emissionFrame, 'left',
            'Emitter', 'Radiate Emission',
            'particles are emitted away from a specific point',
            self.emissionType, BaseParticleEmitter.ETRADIATE,
            self.setEmissionType)
        self.createRadiobutton(
            emissionFrame, 'left',
            'Emitter', 'Custom Emission',
            ('particles are emitted with a velocity that ' +
             'is determined by the particular emitter'),
            self.emissionType, BaseParticleEmitter.ETCUSTOM,
            self.setEmissionType)
        emissionFrame.pack(fill = 'x', expand = 0)

        self.createFloater(
            emitterPage, 'Emitter', 'Velocity Multiplier',
            'launch velocity multiplier (all emission modes)',
            command = self.setEmitterAmplitude,
            min = None)

        self.createFloater(
            emitterPage, 'Emitter', 'Velocity Multiplier Spread',
            'spread for launch velocity multiplier (all emission modes)',
            command = self.setEmitterAmplitudeSpread)

        self.createVector3Entry(
            emitterPage, 'Emitter', 'Offset Velocity',
            'Velocity vector applied to all particles',
            command = self.setEmitterOffsetForce)

        self.createVector3Entry(
            emitterPage, 'Emitter', 'Explicit Velocity',
            'all particles launch with this velocity in Explicit mode',
            command = self.setEmitterExplicitLaunchVector)

        self.createVector3Entry(
            emitterPage, 'Emitter', 'Radiate Origin',
            'particles launch away from this point in Radiate mode',
            command = self.setEmitterRadiateOrigin)

        self.emitterNotebook = Pmw.NoteBook(emitterPage, tabpos = None)
        # Box page #
        boxPage = self.emitterNotebook.add('BoxEmitter')
        self.createVector3Entry(boxPage, 'Box Emitter', 'Min',
                                'Min point defining emitter box',
                                command = self.setEmitterBoxPoint1)
        self.createVector3Entry(boxPage, 'Box Emitter', 'Max',
                                'Max point defining emitter box',
                                command = self.setEmitterBoxPoint2,
                                value = (1.0, 1.0, 1.0))
        # Disc page #
        discPage = self.emitterNotebook.add('DiscEmitter')
        self.createFloater(discPage, 'Disc Emitter', 'Radius',
                           'Radius of disc',
                           command = self.setEmitterDiscRadius,
                           min = 0.01)
        customPage = self.discCustomFrame = Frame(discPage)
        self.createAngleDial(customPage, 'Disc Emitter', 'Inner Angle',
                             'Particle launch angle at center of disc',
                             command = self.setEmitterDiscInnerAngle)
        self.createFloater(customPage, 'Disc Emitter', 'Inner Velocity',
                           'Launch velocity multiplier at center of disc',
                           command = self.setEmitterDiscInnerVelocity)
        self.createAngleDial(customPage, 'Disc Emitter', 'Outer Angle',
                             'Particle launch angle at outer edge of disc',
                             command = self.setEmitterDiscOuterAngle)
        self.createFloater(customPage, 'Disc Emitter', 'Outer Velocity',
                           'Launch velocity multiplier at edge of disc',
                           command = self.setEmitterDiscOuterVelocity)
        self.createCheckbutton(
            customPage, 'Disc Emitter', 'Cubic Lerping',
            'On: magnitude/angle interpolation from center',
            self.toggleEmitterDiscCubicLerping, 0)
        customPage.pack(fill = BOTH, expand = 1)

        # Line page #
        linePage = self.emitterNotebook.add('LineEmitter')
        self.createVector3Entry(linePage, 'Line Emitter', 'Min',
                                'Min point defining emitter line',
                                command = self.setEmitterLinePoint1)
        self.createVector3Entry(linePage, 'Line Emitter', 'Max',
                                'Max point defining emitter line',
                                command = self.setEmitterLinePoint2,
                                value = (1.0, 0.0, 0.0))
        # Point page #
        emitterPointPage = self.emitterNotebook.add('PointEmitter')
        self.createVector3Entry(emitterPointPage, 'Point Emitter', 'Position',
                               'Position of emitter point',
                                command = self.setEmitterPointPosition)
        # Rectangle #
        rectanglePage = self.emitterNotebook.add('RectangleEmitter')
        self.createVector2Entry(rectanglePage,
                                'Rectangle Emitter', 'Min',
                               'Point defining rectangle',
                                command = self.setEmitterRectanglePoint1)
        self.createVector2Entry(rectanglePage,
                                'Rectangle Emitter', 'Max',
                               'Point defining rectangle',
                                command = self.setEmitterRectanglePoint2)
        # Ring #
        ringPage = self.emitterNotebook.add('RingEmitter')
        self.createFloater(ringPage, 'Ring Emitter', 'Radius',
                           'Radius of ring',
                           command = self.setEmitterRingRadius,
                           min = 0.01)
        self.createFloater(ringPage, 'Ring Emitter', 'Radius Spread',
                           'Variation in radius of ring',
                           command = self.setEmitterRingRadiusSpread,
                           min = 0.0)
        self.ringCustomFrame = Frame(ringPage)
        self.createAngleDial(self.ringCustomFrame, 'Ring Emitter', 'Angle',
                             'Particle launch angle',
                             command = self.setEmitterRingLaunchAngle)
        self.ringCustomFrame.pack(fill = BOTH, expand = 1)

        # Sphere volume #
        sphereVolumePage = self.emitterNotebook.add('SphereVolumeEmitter')
        self.createFloater(sphereVolumePage, 'Sphere Volume Emitter', 'Radius',
                           'Radius of sphere',
                           command = self.setEmitterSphereVolumeRadius,
                           min = 0.01)
        # Sphere surface #
        sphereSurfacePage = self.emitterNotebook.add('SphereSurfaceEmitter')
        self.createFloater(sphereSurfacePage, 'Sphere Surface Emitter',
                           'Radius',
                           'Radius of sphere',
                           command = self.setEmitterSphereSurfaceRadius,
                           min = 0.01)
        # Tangent ring #
        tangentRingPage = self.emitterNotebook.add('TangentRingEmitter')
        self.createFloater(tangentRingPage, 'Tangent Ring Emitter', 'Radius',
                           'Radius of ring',
                           command = self.setEmitterTangentRingRadius,
                           min = 0.01)
        self.createFloater(tangentRingPage, 'Tangent Ring Emitter',
                           'Radius Spread',
                           'Variation in radius of ring',
                           command = self.setEmitterTangentRingRadiusSpread)
        self.emitterNotebook.pack(fill = X)

        ## RENDERER PAGE WIDGETS ##
        self.createOptionMenu(
            rendererPage, 'Renderer', 'Renderer Type',
            'Select type of particle renderer',
            ('LineParticleRenderer', 'GeomParticleRenderer',
             'PointParticleRenderer', 'SparkleParticleRenderer',
             'SpriteParticleRenderer'),
            self.selectRendererType)

        self.createOptionMenu(rendererPage,
                              'Renderer', 'Alpha Mode',
                              "alpha setting over particles' lifetime",
                              ('NO_ALPHA','ALPHA_IN','ALPHA_OUT',
                               'ALPHA_IN_OUT', 'ALPHA_USER'),
                              self.setRendererAlphaMode)

        self.createSlider(
            rendererPage, 'Renderer', 'User Alpha',
            'alpha value for ALPHA_USER alpha mode',
            command = self.setRendererUserAlpha)

        self.rendererNotebook = Pmw.NoteBook(rendererPage, tabpos = None)
        self.rendererNotebook.pack(fill = BOTH, expand = 1)

        # Line page #
        linePage = self.rendererNotebook.add('LineParticleRenderer')
        self.createColorEntry(linePage, 'Line Renderer', 'Head Color',
                                'Head color of line',
                                command = self.setRendererLineHeadColor)
        self.createColorEntry(linePage, 'Line Renderer', 'Tail Color',
                                'Tail color of line',
                                command = self.setRendererLineTailColor)
        self.createFloater(linePage, 'Line Renderer', 'Line Scale Factor',
                           'Scale Factor applied to length of line',
                           command = self.setRendererLineScaleFactor)

        ############################################################################
        # GEOM PARTICLE RENDERER PAGE #
        ############################################################################
        geomPage = self.rendererNotebook.add('GeomParticleRenderer')
        f = Frame(geomPage)
        f.pack(fill = X)

        # Geom Node input field
        Label(f, width = 12, text = 'Geom Node', pady = 3).pack(side = LEFT)
        self.rendererGeomNode = StringVar()
        self.rendererGeomNodeEntry = Entry(f, width = 12,
                                           textvariable = self.rendererGeomNode)
        self.rendererGeomNodeEntry.bind('<Return>', self.setRendererGeomNode)
        self.rendererGeomNodeEntry.pack(side = LEFT, expand = 1, fill = X)

        # Setup frames
        f = Frame(geomPage)
        f.pack(fill = BOTH, expand = 1)
        rendererGeomNotebook = Pmw.NoteBook(f)
        rendererGeomNotebook.pack(fill = BOTH, expand = 1)

        rendererGeomBlendPage = rendererGeomNotebook.add('Blend')
        rendererGeomScalePage = rendererGeomNotebook.add('Scale')
        rendererGeomInterpolationPage = rendererGeomNotebook.add('Interpolate')
        
        ############################################################################
        # Blend tab
        p = Frame(rendererGeomBlendPage)
        p.pack(fill = X)
        self.createOptionMenu(p, 'Geom Renderer',
                              'Color Blend',
                              'How to render semi-transparent colors',
                              ('MNone','MAdd','MSubtract','MInvSubtract','MMin','MMax'),
                              self.setRendererGeomColorBlendMethod)
        self.createOptionMenu(p, 'Geom Renderer',
                              'Incoming Op.',
                              'See ColorBlendAttrib.h for explanation',
                              ('OOne','OIncomingColor','OOneMinusIncomingColor','OFbufferColor',
                               'OOneMinusFbufferColor','OIncomingAlpha','OOneMinusIncomingAlpha',
                               'OFbufferAlpha','OOneMinusFbufferAlpha','OConstantColor',
                               'OOneMinusConstantColor','OConstantAlpha','OOneMinusConstantAlpha',
                               'OIncomingColorSaturate','OZero'),
                              self.setRendererGeomColorBlendIncomingOperand)
        self.getVariable('Geom Renderer','Incoming Op.').set('OIncomingAlpha')
        self.createOptionMenu(p, 'Geom Renderer',
                              'Fbuffer Op.',
                              'See ColorBlendAttrib.h for explanation',
                              ('OOne','OIncomingColor','OOneMinusIncomingColor','OFbufferColor',
                               'OOneMinusFbufferColor','OIncomingAlpha','OOneMinusIncomingAlpha',
                               'OFbufferAlpha','OOneMinusFbufferAlpha','OConstantColor',
                               'OOneMinusConstantColor','OConstantAlpha','OOneMinusConstantAlpha',
                               'OZero'),
                              self.setRendererGeomColorBlendFbufferOperand)
        self.getVariable('Geom Renderer','Fbuffer Op.').set('OOneMinusIncomingAlpha')

        ############################################################################
        # Scale tab
        p = Frame(rendererGeomScalePage)
        p.pack(fill = X)
        
        self.createCheckbutton(
            p, 'Geom Renderer', 'X Scale',
            ("On: x scale is interpolated over particle's life; " +
             "Off: stays as start_X_Scale"),
            self.toggleRendererGeomXScale, 0, side = LEFT)
        self.createCheckbutton(
            p, 'Geom Renderer', 'Y Scale',
            ("On: y scale is interpolated over particle's life; " +
             "Off: stays as start_Y_Scale"),
            self.toggleRendererGeomYScale, 0, side = LEFT)
        self.createCheckbutton(
            p, 'Geom Renderer', 'Z Scale',
            ("On: z scale is interpolated over particle's life; " +
             "Off: stays as start_Z_Scale"),
            self.toggleRendererGeomZScale, 0, side = LEFT)
        
        p = Frame(rendererGeomScalePage)
        p.pack(fill = X)
        
        self.createFloater(p, 'Geom Renderer',
                           'Initial X Scale',
                           'Initial X scaling factor',
                           command = self.setRendererGeomInitialXScale)
        self.createFloater(p, 'Geom Renderer',
                           'Final X Scale',
                           'Final X scaling factor, if xScale enabled',
                           command = self.setRendererGeomFinalXScale)
        self.createFloater(p, 'Geom Renderer',
                           'Initial Y Scale',
                           'Initial Y scaling factor',
                           command = self.setRendererGeomInitialYScale)
        self.createFloater(p, 'Geom Renderer',
                           'Final Y Scale',
                           'Final Y scaling factor, if yScale enabled',
                           command = self.setRendererGeomFinalYScale)
        self.createFloater(p, 'Geom Renderer',
                           'Initial Z Scale',
                           'Initial Z scaling factor',
                           command = self.setRendererGeomInitialZScale)
        self.createFloater(p, 'Geom Renderer',
                           'Final Z Scale',
                           'Final Z scaling factor, if zScale enabled',
                           command = self.setRendererGeomFinalZScale)

        ############################################################################
        # Interpolate tab
        p = Frame(rendererGeomInterpolationPage)
        p.pack(fill = X)
        addSegmentButton = Menubutton(p, text = 'Add Segment',
                                      relief = RAISED,
                                      borderwidth = 2,
                                      font=('MSSansSerif', 14, 'bold'),
                                      activebackground = '#909090')
        segmentMenu = Menu(addSegmentButton)
        addSegmentButton['menu'] = segmentMenu
        segmentMenu.add_command(label = 'Add Constant segment',
                                command = self.addConstantInterpolationSegment)
        segmentMenu.add_command(label = 'Add Linear segment',
                                command = self.addLinearInterpolationSegment)
        segmentMenu.add_command(label = 'Add Stepwave segment',
                                command = self.addStepwaveInterpolationSegment)
        segmentMenu.add_command(label = 'Add Sinusoid segment',
                                command = self.addSinusoidInterpolationSegment)
        addSegmentButton.pack(expand = 0)

        sf = Pmw.ScrolledFrame(p, horizflex = 'elastic')
        sf.pack(fill = BOTH, expand = 1)

        self.rendererGeomSegmentFrame = sf.interior()
        self.rendererGeomSegmentFrame.pack(fill = BOTH, expand = 1)
        self.rendererSegmentWidgetList = []

        rendererGeomNotebook.setnaturalsize()

        ############################################################################
        # POINT PARTICLE RENDERER PAGE #
        ############################################################################
        rendererPointPage = self.rendererNotebook.add('PointParticleRenderer')
        self.createFloater(rendererPointPage, 'Point Renderer', 'Point Size',
                           'Width and height of points in pixels',
                           command = self.setRendererPointSize)
        self.createColorEntry(rendererPointPage, 'Point Renderer',
                              'Start Color',
                               'Starting color of point',
                              command = self.setRendererPointStartColor)
        self.createColorEntry(rendererPointPage, 'Point Renderer',
                              'End Color',
                               'Ending color of point',
                              command = self.setRendererPointEndColor)
        self.createOptionMenu(rendererPointPage, 'Point Renderer',
                              'Blend Type',
                              'Type of color blending used for particle',
                              ('PP_ONE_COLOR', 'PP_BLEND_LIFE',
                               'PP_BLEND_VEL'),
                              self.rendererPointSelectBlendType)
        self.createOptionMenu(rendererPointPage, 'Point Renderer',
                              'Blend Method',
                              'Interpolation method between colors',
                              ('PP_NO_BLEND', 'PP_BLEND_LINEAR',
                               'PP_BLEND_CUBIC'),
                              self.rendererPointSelectBlendMethod)
        # Sparkle #
        sparklePage = self.rendererNotebook.add('SparkleParticleRenderer')
        self.createColorEntry(sparklePage, 'Sparkle Renderer',
                              'Center Color',
                              'Color of sparkle center',
                              command = self.setRendererSparkleCenterColor)
        self.createColorEntry(sparklePage, 'Sparkle Renderer',
                              'Edge Color',
                              'Color of sparkle line endpoints',
                              command = self.setRendererSparkleEdgeColor)
        self.createFloater(sparklePage, 'Sparkle Renderer',
                           'Birth Radius',
                           'Initial sparkle radius',
                           command = self.setRendererSparkleBirthRadius)
        self.createFloater(sparklePage, 'Sparkle Renderer',
                           'Death Radius',
                           'Final sparkle radius',
                           command = self.setRendererSparkleDeathRadius)
        self.createOptionMenu(sparklePage,
                              'Sparkle Renderer', 'Life Scale',
                              'Does particle scale over its lifetime?',
                              ('SP_NO_SCALE', 'SP_SCALE'),
                              self.setRendererSparkleLifeScale)
        # Sprite #
        spritePage = self.rendererNotebook.add('SpriteParticleRenderer')
        f = Frame(spritePage)
        f.pack(fill = BOTH, expand = 1)

        rendererSpriteNotebook = Pmw.NoteBook(f)
        rendererSpriteNotebook.pack(fill = BOTH, expand = 1)

        rendererSpriteTexturePage = rendererSpriteNotebook.add('Texture')
        rendererSpriteScalePage = rendererSpriteNotebook.add('Scale')
        rendererSpriteBlendPage = rendererSpriteNotebook.add('Blend')
        rendererSpriteInterpolationPage = rendererSpriteNotebook.add('Interpolate')
##################################################################################

        p = Frame(rendererSpriteTexturePage)
        p.pack(fill = BOTH, expand = 1)

        bp = Frame(p)
        bp.pack(expand = 0, side = TOP)

        bbp = Frame(bp)
        bbp.pack()
        self.createCheckbutton(
            bbp, 'Sprite Renderer', 'Enable Animation',
            ("On: Multitexture node will be animated; " +
             "Off: Only the first frame of a node is rendered"),
            self.setRendererSpriteAnimationEnable, 0, side = LEFT)
        self.createFloater(bbp, 'Sprite Renderer', 'Frame Rate', 'Animation frame rate',
                           command = self.setRendererSpriteAnimationFrameRate).pack(side = LEFT)

        bbp = Frame(bp)
        bbp.pack(pady=3)
        Button(bbp, text = 'Add Texture',
               command = self.addRendererSpriteAnimationTexture).pack(pady = 3, padx = 15, side = LEFT)
        Button(bbp, text = 'Add Animation',
               command = self.addRendererSpriteAnimationFromNode).pack(pady = 3, padx = 15, side = LEFT)

        pp = Frame(p)
        pp.pack(fill = BOTH, expand = 1, pady = 3)
        sf = Pmw.ScrolledFrame(pp, horizflex = 'elastic')
        sf.pack(fill = BOTH, expand = 1)

        self.rendererSpriteAnimationFrame = sf.interior()
        self.rendererSpriteAnimationFrame.pack(fill = BOTH, expand = 1)
        self.rendererSpriteAnimationWidgetList = []

        self.rendererSpriteTexture = StringVar()
        self.rendererSpriteFile = StringVar()
        self.rendererSpriteNode = StringVar()

##################################################################################
        p = Frame(rendererSpriteScalePage)
        p.pack(fill = X)
        
        self.createCheckbutton(
            p, 'Sprite Renderer', 'X Scale',
            ("On: x scale is interpolated over particle's life; " +
             "Off: stays as start_X_Scale"),
            self.toggleRendererSpriteXScale, 0, side = LEFT)
        self.createCheckbutton(
            p, 'Sprite Renderer', 'Y Scale',
            ("On: y scale is interpolated over particle's life; " +
             "Off: stays as start_Y_Scale"),
            self.toggleRendererSpriteYScale, 0, side = LEFT)
        self.createCheckbutton(
            p, 'Sprite Renderer', 'Anim Angle',
            ("On: particles that are set to spin on the Z axis will " +
             "spin appropriately"),
            self.toggleRendererSpriteAnimAngle, 0, side = LEFT)
        p = Frame(rendererSpriteScalePage)
        p.pack(fill = X)
        self.createFloater(p, 'Sprite Renderer',
                           'Initial X Scale',
                           'Initial X scaling factor',
                           command = self.setRendererSpriteInitialXScale)
        self.createFloater(p, 'Sprite Renderer',
                           'Final X Scale',
                           'Final X scaling factor, if xScale enabled',
                           command = self.setRendererSpriteFinalXScale)
        self.createFloater(p, 'Sprite Renderer',
                           'Initial Y Scale',
                           'Initial Y scaling factor',
                           command = self.setRendererSpriteInitialYScale)
        self.createFloater(p, 'Sprite Renderer',
                           'Final Y Scale',
                           'Final Y scaling factor, if yScale enabled',
                           command = self.setRendererSpriteFinalYScale)
        self.createAngleDial(p, 'Sprite Renderer',
                             'Non Animated Theta',
                             ('If animAngle is false: counter clockwise ' +
                              'Z rotation of all sprites'),
                             command = self.setRendererSpriteNonAnimatedTheta)
        p = Frame(rendererSpriteBlendPage)
        p.pack(fill = X)
        self.createOptionMenu(p, 'Sprite Renderer',
                              'Blend Type',
                              'Interpolation blend type for X and Y scaling',
                              ('PP_NO_BLEND', 'PP_LINEAR', 'PP_CUBIC'),
                              self.setRendererSpriteBlendMethod)
        self.createCheckbutton(
            p, 'Sprite Renderer', 'Alpha Disable',
            'On: alpha blending is disabled',
            self.toggleRendererSpriteAlphaDisable, 0)
        self.createOptionMenu(p, 'Sprite Renderer',
                              'Color Blend',
                              'How to render semi-transparent colors',
                              ('MNone','MAdd','MSubtract','MInvSubtract','MMin','MMax'),
                              self.setRendererSpriteColorBlendMethod)
        self.createOptionMenu(p, 'Sprite Renderer',
                              'Incoming Op.',
                              'See ColorBlendAttrib.h for explanation',
                              ('OOne','OIncomingColor','OOneMinusIncomingColor','OFbufferColor',
                               'OOneMinusFbufferColor','OIncomingAlpha','OOneMinusIncomingAlpha',
                               'OFbufferAlpha','OOneMinusFbufferAlpha','OConstantColor',
                               'OOneMinusConstantColor','OConstantAlpha','OOneMinusConstantAlpha',
                               'OIncomingColorSaturate','OZero'),
                              self.setRendererSpriteColorBlendIncomingOperand)
        self.getVariable('Sprite Renderer','Incoming Op.').set('OIncomingAlpha')
        self.createOptionMenu(p, 'Sprite Renderer',
                              'Fbuffer Op.',
                              'See ColorBlendAttrib.h for explanation',
                              ('OOne','OIncomingColor','OOneMinusIncomingColor','OFbufferColor',
                               'OOneMinusFbufferColor','OIncomingAlpha','OOneMinusIncomingAlpha',
                               'OFbufferAlpha','OOneMinusFbufferAlpha','OConstantColor',
                               'OOneMinusConstantColor','OConstantAlpha','OOneMinusConstantAlpha',
                               'OZero'),
                              self.setRendererSpriteColorBlendFbufferOperand)
        self.getVariable('Sprite Renderer','Fbuffer Op.').set('OOneMinusIncomingAlpha')
        p = Frame(rendererSpriteInterpolationPage)
        p.pack(fill = BOTH, expand = 1)
        addSegmentButton = Menubutton(p, text = 'Add Segment',
                                      relief = RAISED,
                                      borderwidth = 2,
                                      font=('MSSansSerif', 14, 'bold'),
                                      activebackground = '#909090')
        segmentMenu = Menu(addSegmentButton)
        addSegmentButton['menu'] = segmentMenu
        segmentMenu.add_command(label = 'Add Constant segment',
                                command = self.addConstantInterpolationSegment)
        segmentMenu.add_command(label = 'Add Linear segment',
                                command = self.addLinearInterpolationSegment)
        segmentMenu.add_command(label = 'Add Stepwave segment',
                                command = self.addStepwaveInterpolationSegment)
        segmentMenu.add_command(label = 'Add Sinusoid segment',
                                command = self.addSinusoidInterpolationSegment)
        addSegmentButton.pack(expand = 0)

        pp = Frame(p)
        pp.pack(fill = BOTH, expand = 1, pady = 3)
        sf = Pmw.ScrolledFrame(pp, horizflex = 'elastic')
        sf.pack(fill = BOTH, expand = 1)

        self.rendererSpriteSegmentFrame = sf.interior()
        self.rendererSpriteSegmentFrame.pack(fill = BOTH, expand = 1)
        self.rendererSegmentWidgetList = []

        rendererSpriteNotebook.setnaturalsize()
        ##########################################################
        ## FORCE PAGE WIDGETS ##
        self.addForceButton = Menubutton(forcePage, text = 'Add Force',
                                          relief = RAISED,
                                          borderwidth = 2,
                                          font=('MSSansSerif', 14, 'bold'),
                                          activebackground = '#909090')
        forceMenu = Menu(self.addForceButton)
        self.addForceButton['menu'] = forceMenu
        # DERIVED FROM LINEAR FORCE
        # This also has: setVector
        forceMenu.add_command(label = 'Add Linear Vector Force',
                            command = self.addLinearVectorForce)
        # Parameters: setAmplitude, setMassDependent, setVectorMasks
        forceMenu.add_command(label = 'Add Linear Noise Force',
                            command = self.addLinearNoiseForce)
        forceMenu.add_command(label = 'Add Linear Jitter Force',
                            command = self.addLinearJitterForce)
        # This also has setCoef
        forceMenu.add_command(label = 'Add Linear Friction Force',
                            command = self.addLinearFrictionForce)
        # This also has: setCoef, setLength, setRadius,
        forceMenu.add_command(label = 'Add Linear Cylinder Vortex Force',
                            command = self.addLinearCylinderVortexForce)

        # DERIVED FROM LINEAR DISTANCE FORCE
        # Parameters: setFalloffType, setForceCenter, setRadius
        forceMenu.add_command(label = 'Add Linear Sink Force',
                            command = self.addLinearSinkForce)
        forceMenu.add_command(label = 'Add Linear Source Force',
                            command = self.addLinearSourceForce)
        """
        # Avoid for now
        forceMenu.add_command(label = 'Add Linear User Defined Force',
                            command = self.addLinearUserDefinedForce)
        """

        self.addForceButton.pack(expand = 0)

        # Scrolled frame to hold force widgets
        self.sf = Pmw.ScrolledFrame(forcePage, horizflex = 'elastic')
        self.sf.pack(fill = 'both', expand = 1)
        self.forceFrame = self.sf.interior()
        # Notebook to hold force widgets as the are added
        self.forceGroupNotebook = Pmw.NoteBook(self.forceFrame, tabpos = None)
        self.forceGroupNotebook.pack(fill = X)

        ########################################################################
        self.factoryNotebook.setnaturalsize()
        self.emitterNotebook.setnaturalsize()
        self.rendererNotebook.setnaturalsize()
        self.forceGroupNotebook.setnaturalsize()
        self.mainNotebook.setnaturalsize()

        # Make sure input variables processed
        self.initialiseoptions(ParticlePanel)

    ### WIDGET UTILITY FUNCTIONS ###
    def createCheckbutton(self, parent, category, text,
                          balloonHelp, command, initialState, side = 'top'):
        bool = BooleanVar()
        bool.set(initialState)
        widget = Checkbutton(parent, text = text, anchor = W,
                         variable = bool)
        # Do this after the widget so command isn't called on creation
        widget['command'] = command
        widget.pack(fill = X, side = side)
        self.bind(widget, balloonHelp)
        self.widgetDict[category + '-' + text] = widget
        self.variableDict[category + '-' + text] = bool
        return widget

    def createRadiobutton(self, parent, side, category, text,
                          balloonHelp, variable, value,
                          command):
        widget = Radiobutton(parent, text = text, anchor = W,
                             variable = variable, value = value)
        # Do this after the widget so command isn't called on creation
        widget['command'] = command
        widget.pack(side = side, fill = X)
        self.bind(widget, balloonHelp)
        self.widgetDict[category + '-' + text] = widget
        return widget

    def createFloaters(self, parent, widgetDefinitions):
        widgets = []
        for category, label, balloonHelp, command, min, resolution in widgetDefinitions:
            widgets.append(
                self.createFloater(parent, category, label, balloonHelp,
                                   command, min, resolution)
                )
        return widgets

    def createFloater(self, parent, category, text, balloonHelp,
                      command = None, min = 0.0, resolution = None,
                      numDigits = 3, **kw):
        kw['text'] = text
        kw['min'] = min
        kw['resolution'] = resolution
        kw['numDigits'] = numDigits
        widget = apply(Floater.Floater, (parent,), kw)
        # Do this after the widget so command isn't called on creation
        widget['command'] = command
        widget.pack(fill = X)
        self.bind(widget, balloonHelp)
        self.widgetDict[category + '-' + text] = widget
        return widget

    def createAngleDial(self, parent, category, text, balloonHelp,
                        command = None, **kw):
        kw['text'] = text
        kw['style'] = 'mini'
        widget = apply(Dial.AngleDial, (parent,), kw)
        # Do this after the widget so command isn't called on creation
        widget['command'] = command
        widget.pack(fill = X)
        self.bind(widget, balloonHelp)
        self.widgetDict[category + '-' + text] = widget
        return widget

    def createSlider(self, parent, category, text, balloonHelp,
                     command = None, min = 0.0, max = 1.0,
                     resolution = 0.001, **kw):
        kw['text'] = text
        kw['min'] = min
        kw['max'] = max
        kw['resolution'] = resolution
        widget = apply(Slider.Slider, (parent,), kw)
        # Do this after the widget so command isn't called on creation
        widget['command'] = command
        widget.pack(fill = X)
        self.bind(widget, balloonHelp)
        self.widgetDict[category + '-' + text] = widget
        return widget

    def createVector2Entry(self, parent, category, text, balloonHelp,
                           command = None, **kw):
        # Set label's text
        kw['text'] = text
        widget = apply(VectorWidgets.Vector2Entry, (parent,), kw)
        # Do this after the widget so command isn't called on creation
        widget['command'] = command
        widget.pack(fill = X)
        self.bind(widget, balloonHelp)
        self.widgetDict[category + '-' + text] = widget
        return widget

    def createVector3Entry(self, parent, category, text, balloonHelp,
                           command = None, **kw):
        # Set label's text
        kw['text'] = text
        widget = apply(VectorWidgets.Vector3Entry, (parent,), kw)
        # Do this after the widget so command isn't called on creation
        widget['command'] = command
        widget.pack(fill = X)
        self.bind(widget, balloonHelp)
        self.widgetDict[category + '-' + text] = widget
        return widget

    def createColorEntry(self, parent, category, text, balloonHelp,
                         command = None, **kw):
        # Set label's text
        kw['text'] = text
        widget = apply(VectorWidgets.ColorEntry, (parent,), kw)
        # Do this after the widget so command isn't called on creation
        widget['command'] = command
        widget.pack(fill = X)
        self.bind(widget, balloonHelp)
        self.widgetDict[category + '-' + text] = widget
        return widget

    def createOptionMenu(self, parent, category, text, balloonHelp,
                         items, command):
        optionVar = StringVar()
        if len(items) > 0:
            optionVar.set(items[0])
        widget = Pmw.OptionMenu(parent, labelpos = W, label_text = text,
                                label_width = 12, menu_tearoff = 1,
                                menubutton_textvariable = optionVar,
                                items = items)
        # Do this after the widget so command isn't called on creation
        widget['command'] = command
        widget.pack(fill = X)
        self.bind(widget.component('menubutton'), balloonHelp)
        self.widgetDict[category + '-' + text] = widget
        self.variableDict[category + '-' + text] = optionVar
        return optionVar

    def createComboBox(self, parent, category, text, balloonHelp,
                         items, command, history = 0):
        widget = Pmw.ComboBox(parent,
                              labelpos = W,
                              label_text = text,
                              label_anchor = 'w',
                              label_width = 12,
                              entry_width = 16,
                              history = history,
                              scrolledlist_items = items)
        # Don't allow user to edit entryfield
        widget.configure(entryfield_entry_state = 'disabled')
        # Select first item if it exists
        if len(items) > 0:
            widget.selectitem(items[0])
        # Bind selection command
        widget['selectioncommand'] = command
        widget.pack(side = 'left', expand = 0)
        # Bind help
        self.bind(widget, balloonHelp)
        # Record widget
        self.widgetDict[category + '-' + text] = widget
        return widget

    def updateMenusAndLabels(self):
        self.updateMenus()
        self.updateLabels()

    def updateLabels(self):
        self.effectsLabel['text'] = self.particleEffect.getName()
        self.particlesLabel['text'] = self.particles.getName()
        if self.forceGroup != None:
            self.forceGroupLabel['text'] = self.forceGroup.getName()
        else:
            self.forceGroupLabel['text'] = 'Force Group'

    def updateMenus(self):
        self.updateEffectsMenus()
        self.updateParticlesMenus()
        self.updateForceGroupMenus()

    def updateEffectsMenus(self):
        # Get rid of old effects entries if any
        self.effectsEnableMenu.delete(0, 'end')
        self.effectsLabelMenu.delete(5, 'end')
        self.effectsLabelMenu.add_separator()
        # Add in a checkbutton for each effect (to toggle on/off)
        keys = self.effectsDict.keys()
        keys.sort()
        for name in keys:
            effect = self.effectsDict[name]
            self.effectsLabelMenu.add_command(
                label = effect.getName(),
                command = (lambda s = self,
                           e = effect: s.selectEffectNamed(e.getName()))
                )
            effectActive = IntVar()
            effectActive.set(effect.isEnabled())
            self.effectsEnableMenu.add_checkbutton(
                label = effect.getName(),
                variable = effectActive,
                command = (lambda s = self,
                           e = effect,
                           v = effectActive: s.toggleEffect(e, v)))

    def updateParticlesMenus(self):
        # Get rid of old particles entries if any
        self.particlesEnableMenu.delete(0, 'end')
        self.particlesLabelMenu.delete(2, 'end')
        self.particlesLabelMenu.add_separator()
        # Add in a checkbutton for each effect (to toggle on/off)
        particles = self.particleEffect.getParticlesList()
        names = [x.getName() for x in particles]
        names.sort()
        for name in names:
            particle = self.particleEffect.getParticlesNamed(name)
            self.particlesLabelMenu.add_command(
                label = name,
                command = (lambda s = self,
                           n = name: s.selectParticlesNamed(n))
                )
            particleActive = IntVar()
            particleActive.set(particle.isEnabled())
            self.particlesEnableMenu.add_checkbutton(
                label = name,
                variable = particleActive,
                command = (lambda s = self,
                           p = particle,
                           v = particleActive: s.toggleParticles(p, v)))

    def updateForceGroupMenus(self):
        # Get rid of old forceGroup entries if any
        self.forceGroupEnableMenu.delete(0, 'end')
        self.forceGroupLabelMenu.delete(2, 'end')
        self.forceGroupLabelMenu.add_separator()
        # Add in a checkbutton for each effect (to toggle on/off)
        forceGroupList = self.particleEffect.getForceGroupList()
        names = [x.getName() for x in forceGroupList]
        names.sort()
        for name in names:
            force = self.particleEffect.getForceGroupNamed(name)
            self.forceGroupLabelMenu.add_command(
                label = name,
                command = (lambda s = self,
                           n = name: s.selectForceGroupNamed(n))
                )
            forceActive = IntVar()
            forceActive.set(force.isEnabled())
            self.forceGroupEnableMenu.add_checkbutton(
                label = name,
                variable = forceActive,
                command = (lambda s = self,
                           f = force,
                           v = forceActive: s.toggleForceGroup(f, v)))

    def selectEffectNamed(self, name):
        effect = self.effectsDict.get(name, None)
        if effect != None:
            self.particleEffect = effect
            # Default to first particle in particlesDict
            self.particles = self.particleEffect.getParticlesList()[0]
            # See if particle effect has any forceGroup
            forceGroupList = self.particleEffect.getForceGroupList()
            if len(forceGroupList) > 0:
                self.forceGroup = forceGroupList[0]
            else:
                self.forceGroup = None
            self.mainNotebook.selectpage('System')
            self.updateInfo('System')
        else:
            print 'ParticlePanel: No effect named ' + name

    def toggleEffect(self, effect, var):
        if var.get():
            effect.enable()
        else:
            effect.disable()

    def selectParticlesNamed(self, name):
        particles = self.particleEffect.getParticlesNamed(name)
        if particles != None:
            self.particles = particles
            self.updateInfo()

    def toggleParticles(self, particles, var):
        if var.get():
            particles.enable()
        else:
            particles.disable()

    def selectForceGroupNamed(self, name):
        forceGroup = self.particleEffect.getForceGroupNamed(name)
        if forceGroup != None:
            self.forceGroup = forceGroup
            self.updateInfo('Force')

    def toggleForceGroup(self, forceGroup, var):
        if var.get():
            forceGroup.enable()
        else:
            forceGroup.disable()

    def toggleForce(self, force, pageName, variableName):
        v = self.getVariable(pageName, variableName)
        if v.get():
            force.setActive(1)
        else:
            force.setActive(0)

    def getWidget(self, category, text):
        return self.widgetDict[category + '-' + text]

    def getVariable(self, category, text):
        return self.variableDict[category + '-' + text]

    def loadParticleEffectFromFile(self):
        # Find path to particle directory
        pPath = getParticlePath()
        if pPath.getNumDirectories() > 0:
            if repr(pPath.getDirectory(0)) == '.':
                path = '.'
            else:
                path = pPath.getDirectory(0).toOsSpecific()
        else:
            path = '.'
        if not os.path.isdir(path):
            print 'ParticlePanel Warning: Invalid default DNA directory!'
            print 'Using current directory'
            path = '.'
        particleFilename = askopenfilename(
            defaultextension = '.ptf',
            filetypes = (('Particle Files', '*.ptf'), ('All files', '*')),
            initialdir = path,
            title = 'Load Particle Effect',
            parent = self.parent)
        if particleFilename:
            # Delete existing particles and forces
            self.particleEffect.loadConfig(
                Filename.fromOsSpecific(particleFilename))
            self.selectEffectNamed(self.particleEffect.getName())
            # Enable effect
            self.particleEffect.enable()

    def saveParticleEffectToFile(self):
        # Find path to particle directory
        pPath = getParticlePath()
        if pPath.getNumDirectories() > 0:
            if repr(pPath.getDirectory(0)) == '.':
                path = '.'
            else:
                path = pPath.getDirectory(0).toOsSpecific()
        else:
            path = '.'
        if not os.path.isdir(path):
            print 'ParticlePanel Warning: Invalid default DNA directory!'
            print 'Using current directory'
            path = '.'
        particleFilename = asksaveasfilename(
            defaultextension = '.ptf',
            filetypes = (('Particle Files', '*.ptf'), ('All files', '*')),
            initialdir = path,
            title = 'Save Particle Effect as',
            parent = self.parent)
        if particleFilename:
            self.particleEffect.saveConfig(Filename(particleFilename))

    ### PARTICLE EFFECTS COMMANDS ###
    def toggleParticleMgr(self):
        if self.particleMgrActive.get():
            base.enableParticles()
        else:
            base.disableParticles()

    ### PARTICLE SYSTEM COMMANDS ###
    def updateInfo(self, page = 'System'):
        self.updateMenusAndLabels()
        if page == 'System':
            self.updateSystemWidgets()
        elif page == 'Factory':
            self.selectFactoryPage()
            self.updateFactoryWidgets()
        elif page == 'Emitter':
            self.selectEmitterPage()
            self.updateEmitterWidgets()
        elif page == 'Renderer':
            self.selectRendererPage()
            self.updateRendererWidgets()
        elif page == 'Force':
            self.updateForceWidgets()

    def toggleParticleEffect(self):
        if self.getVariable('Effect', 'Active').get():
            self.particleEffect.enable()
        else:
            self.particleEffect.disable()

    ## SYSTEM PAGE ##
    def updateSystemWidgets(self):
        poolSize = self.particles.getPoolSize()
        self.getWidget('System', 'Pool Size').set(int(poolSize), 0)
        birthRate = self.particles.getBirthRate()
        self.getWidget('System', 'Birth Rate').set(birthRate, 0)
        litterSize = self.particles.getLitterSize()
        self.getWidget('System', 'Litter Size').set(int(litterSize), 0)
        litterSpread = self.particles.getLitterSpread()
        self.getWidget('System', 'Litter Spread').set(litterSpread, 0)
        systemLifespan = self.particles.getSystemLifespan()
        self.getWidget('System', 'Lifespan').set(systemLifespan, 0)
        pos = self.particles.nodePath.getPos()
        self.getWidget('System', 'Pos').set([pos[0], pos[1], pos[2]], 0)
        hpr = self.particles.nodePath.getHpr()
        self.getWidget('System', 'Hpr').set([hpr[0], hpr[1], hpr[2]], 0)
        self.getVariable('System', 'Render Space Velocities').set(
            self.particles.getLocalVelocityFlag())
        self.getVariable('System', 'System Grows Older').set(
            self.particles.getSystemGrowsOlderFlag())
    def setSystemPoolSize(self, value):
        self.particles.setPoolSize(int(value))
    def setSystemBirthRate(self, value):
        self.particles.setBirthRate(value)
    def setSystemLitterSize(self, value):
        self.particles.setLitterSize(int(value))
    def setSystemLitterSpread(self, value):
        self.particles.setLitterSpread(int(value))
    def setSystemLifespan(self, value):
        self.particles.setSystemLifespan(value)
    def toggleSystemLocalVelocity(self):
        self.particles.setLocalVelocityFlag(
            self.getVariable('System', 'Render Space Velocities').get())
    def toggleSystemGrowsOlder(self):
        self.particles.setSystemGrowsOlderFlag(
            self.getVariable('System', 'System Grows Older').get())
    def setSystemPos(self, pos):
        self.particles.nodePath.setPos(Vec3(pos[0], pos[1], pos[2]))
    def setSystemHpr(self, pos):
        self.particles.nodePath.setHpr(Vec3(pos[0], pos[1], pos[2]))

    ## FACTORY PAGE ##
    def selectFactoryType(self, type):
        self.factoryNotebook.selectpage(type)
        self.particles.setFactory(type)
        self.updateFactoryWidgets()

    def selectFactoryPage(self):
        pass

    def updateFactoryWidgets(self):
        factory = self.particles.factory
        lifespan = factory.getLifespanBase()
        self.getWidget('Factory', 'Life Span').set(lifespan, 0)
        lifespanSpread = factory.getLifespanSpread()
        self.getWidget('Factory', 'Life Span Spread').set(lifespanSpread, 0)
        mass = factory.getMassBase()
        self.getWidget('Factory', 'Mass').set(mass, 0)
        massSpread = factory.getMassSpread()
        self.getWidget('Factory', 'Mass Spread').set(massSpread, 0)
        terminalVelocity = factory.getTerminalVelocityBase()
        self.getWidget('Factory', 'Terminal Velocity').set(terminalVelocity, 0)
        terminalVelocitySpread = factory.getTerminalVelocitySpread()
        self.getWidget('Factory', 'Terminal Vel. Spread').set(
            terminalVelocitySpread, 0)

    def setFactoryLifeSpan(self, value):
        self.particles.factory.setLifespanBase(value)
    def setFactoryLifeSpanSpread(self, value):
        self.particles.factory.setLifespanSpread(value)
    def setFactoryParticleMass(self, value):
        self.particles.factory.setMassBase(value)
    def setFactoryParticleMassSpread(self, value):
        self.particles.factory.setMassSpread(value)
    def setFactoryTerminalVelocity(self, value):
        self.particles.factory.setTerminalVelocityBase(value)
    def setFactoryTerminalVelocitySpread(self, value):
        self.particles.factory.setTerminalVelocitySpread(value)
    # Point Page #
    # Z Spin Page #
    def setFactoryZSpinInitialAngle(self, angle):
        self.particles.factory.setInitialAngle(angle)
    def setFactoryZSpinInitialAngleSpread(self, spread):
        self.particles.factory.setInitialAngleSpread(spread)
    def setFactoryZSpinFinalAngle(self, angle):
        self.particles.factory.setFinalAngle(angle)
    def setFactoryZSpinFinalAngleSpread(self, spread):
        self.particles.factory.setFinalAngleSpread(spread)
    def setFactoryZSpinAngularVelocity(self, vel):
        self.particles.factory.setAngularVelocity(vel)
    def setFactoryZSpinAngularVelocitySpread(self, spread):
        self.particles.factory.setAngularVelocitySpread(spread)

    ## EMITTER PAGE ##
    def selectEmitterType(self, type):
        self.emitterNotebook.selectpage(type)
        self.particles.setEmitter(type)
        self.updateEmitterWidgets()

    def selectEmitterPage(self):
        type = self.particles.emitter.__class__.__name__
        self.emitterNotebook.selectpage(type)
        self.getVariable('Emitter', 'Emitter Type').set(type)

    def updateEmitterWidgets(self):
        emitter = self.particles.emitter
        self.setEmissionType(self.particles.emitter.getEmissionType())
        amp = emitter.getAmplitude()
        self.getWidget('Emitter', 'Velocity Multiplier').set(amp)
        spread = emitter.getAmplitudeSpread()
        self.getWidget('Emitter', 'Velocity Multiplier Spread').set(spread)
        vec = emitter.getOffsetForce()
        self.getWidget('Emitter', 'Offset Velocity').set(
            [vec[0], vec[1], vec[2]], 0)
        vec = emitter.getRadiateOrigin()
        self.getWidget('Emitter', 'Radiate Origin').set(
            [vec[0], vec[1], vec[2]], 0)
        vec = emitter.getExplicitLaunchVector()
        self.getWidget('Emitter', 'Explicit Velocity').set(
            [vec[0], vec[1], vec[2]], 0)
        if isinstance(emitter, BoxEmitter):
            min = emitter.getMinBound()
            self.getWidget('Box Emitter', 'Min').set(
                [min[0], min[1], min[2]], 0)
            max = emitter.getMaxBound()
            self.getWidget('Box Emitter', 'Max').set(
                [max[0], max[1], max[2]], 0)
        elif isinstance(emitter, DiscEmitter):
            radius = emitter.getRadius()
            self.getWidget('Disc Emitter', 'Radius').set(radius, 0)
            innerAngle = emitter.getInnerAngle()
            self.getWidget('Disc Emitter', 'Inner Angle').set(innerAngle, 0)
            innerMagnitude = emitter.getInnerMagnitude()
            self.getWidget('Disc Emitter', 'Inner Velocity').set(
                innerMagnitude, 0)
            outerAngle = emitter.getOuterAngle()
            self.getWidget('Disc Emitter', 'Outer Angle').set(outerAngle, 0)
            outerMagnitude = emitter.getOuterMagnitude()
            self.getWidget('Disc Emitter', 'Inner Velocity').set(
                outerMagnitude, 0)
            cubicLerping = emitter.getCubicLerping()
            self.getVariable('Disc Emitter', 'Cubic Lerping').set(cubicLerping)
        elif isinstance(emitter, LineEmitter):
            min = emitter.getEndpoint1()
            self.getWidget('Line Emitter', 'Min').set(
                [min[0], min[1], min[2]], 0)
            max = emitter.getEndpoint2()
            self.getWidget('Line Emitter', 'Max').set(
                [max[0], max[1], max[2]], 0)
        elif isinstance(emitter, PointEmitter):
            location = emitter.getLocation()
            self.getWidget('Point Emitter', 'Position').set(
                [location[0], location[1], location[2]], 0)
        elif isinstance(emitter, RectangleEmitter):
            min = emitter.getMinBound()
            self.getWidget('Rectangle Emitter', 'Min').set(
                [min[0], min[1]], 0)
            max = emitter.getMaxBound()
            self.getWidget('Rectangle Emitter', 'Max').set(
                [max[0], max[1]], 0)
        elif isinstance(emitter, RingEmitter):
            radius = emitter.getRadius()
            self.getWidget('Ring Emitter', 'Radius').set(radius, 0)
            radiusSpread = emitter.getRadiusSpread()
            self.getWidget('Ring Emitter', 'Radius Spread').set(radiusSpread, 0)
            angle = emitter.getAngle()
            self.getWidget('Ring Emitter', 'Angle').set(angle, 0)
        elif isinstance(emitter, SphereVolumeEmitter):
            radius = emitter.getRadius()
            self.getWidget('Sphere Volume Emitter', 'Radius').set(radius, 0)
        elif isinstance(emitter, SphereSurfaceEmitter):
            radius = emitter.getRadius()
            self.getWidget('Sphere Surface Emitter', 'Radius').set(radius, 0)
        elif isinstance(emitter, TangentRingEmitter):
            radius = emitter.getRadius()
            self.getWidget('Tangent Ring Emitter', 'Radius').set(radius, 0)
            radiusSpread = emitter.getRadiusSpread()
            self.getWidget('Tangent Ring Emitter', 'Radius Spread').set(
                radiusSpread, 0)
    # All #
    def setEmissionType(self, newType = None):
        if newType:
            type = newType
            self.emissionType.set(type)
        else:
            type = self.emissionType.get()
        self.particles.emitter.setEmissionType(type)
        if type == BaseParticleEmitter.ETEXPLICIT:
            self.getWidget(
                'Emitter', 'Radiate Origin')['state'] = 'disabled'
            self.getWidget(
                'Emitter', 'Explicit Velocity')['state'] = 'normal'
            # Hide custom widgets
            if isinstance(self.particles.emitter, DiscEmitter):
                self.discCustomFrame.pack_forget()
            elif isinstance(self.particles.emitter, RingEmitter):
                self.ringCustomFrame.pack_forget()
        elif type == BaseParticleEmitter.ETRADIATE:
            self.getWidget(
                'Emitter', 'Radiate Origin')['state'] = 'normal'
            self.getWidget(
                'Emitter', 'Explicit Velocity')['state'] = 'disabled'

            # Hide custom widgets
            if isinstance(self.particles.emitter, DiscEmitter):
                self.discCustomFrame.pack_forget()
            elif isinstance(self.particles.emitter, RingEmitter):
                self.ringCustomFrame.pack_forget()
        elif type == BaseParticleEmitter.ETCUSTOM:
            self.getWidget(
                'Emitter', 'Radiate Origin')['state'] = 'disabled'
            self.getWidget(
                'Emitter', 'Explicit Velocity')['state'] = 'disabled'
            # Show custom widgets
            if isinstance(self.particles.emitter, DiscEmitter):
                self.discCustomFrame.pack(fill = BOTH, expand = 1)
            elif isinstance(self.particles.emitter, RingEmitter):
                self.ringCustomFrame.pack(fill = BOTH, expand = 1)

    def setEmitterAmplitude(self, value):
        self.particles.emitter.setAmplitude(value)

    def setEmitterAmplitudeSpread(self, value):
        self.particles.emitter.setAmplitudeSpread(value)

    def setEmitterOffsetForce(self, vec):
        self.particles.emitter.setOffsetForce(
            Vec3(vec[0], vec[1], vec[2]))

    def setEmitterRadiateOrigin(self, origin):
        self.particles.emitter.setRadiateOrigin(
            Point3(origin[0], origin[1], origin[2]))

    def setEmitterExplicitLaunchVector(self, vec):
        self.particles.emitter.setExplicitLaunchVector(
            Vec3(vec[0], vec[1], vec[2]))

    # Box #
    def setEmitterBoxPoint1(self, point):
        self.particles.emitter.setMinBound(Point3(point[0],
                                                  point[1],
                                                  point[2]))
    def setEmitterBoxPoint2(self, point):
        self.particles.emitter.setMaxBound(Point3(point[0],
                                                  point[1],
                                                  point[2]))
    # Disc #
    def setEmitterDiscRadius(self, radius):
        self.particles.emitter.setRadius(radius)
    def setEmitterDiscInnerAngle(self, angle):
        self.particles.emitter.setInnerAngle(angle)
    def setEmitterDiscInnerVelocity(self, velocity):
        self.particles.emitter.setInnerMagnitude(velocity)
    def setEmitterDiscOuterAngle(self, angle):
        self.particles.emitter.setOuterAngle(angle)
    def setEmitterDiscOuterVelocity(self, velocity):
        self.particles.emitter.setOuterMagnitude(velocity)
    def toggleEmitterDiscCubicLerping(self):
        self.particles.emitter.setCubicLerping(
            self.getVariable('Disc Emitter', 'Cubic Lerping').get())
    # Line #
    def setEmitterLinePoint1(self, point):
        self.particles.emitter.setEndpoint1(Point3(point[0],
                                                   point[1],
                                                   point[2]))
    def setEmitterLinePoint2(self, point):
        self.particles.emitter.setEndpoint2(Point3(point[0],
                                                   point[1],
                                                   point[2]))
    # Point #
    def setEmitterPointPosition(self, pos):
        self.particles.emitter.setLocation(Point3(pos[0], pos[1], pos[2]))
    # Rectangle #
    def setEmitterRectanglePoint1(self, point):
        self.particles.emitter.setMinBound(Point2(point[0], point[1]))
    def setEmitterRectanglePoint2(self, point):
        self.particles.emitter.setMaxBound(Point2(point[0], point[1]))
    # Ring #
    def setEmitterRingRadius(self, radius):
        self.particles.emitter.setRadius(radius)
    def setEmitterRingRadiusSpread(self, radiusSpread):
        self.particles.emitter.setRadiusSpread(radiusSpread)
    def setEmitterRingLaunchAngle(self, angle):
        self.particles.emitter.setAngle(angle)
    # Sphere surface #
    def setEmitterSphereSurfaceRadius(self, radius):
        self.particles.emitter.setRadius(radius)
    # Sphere volume #
    def setEmitterSphereVolumeRadius(self, radius):
        self.particles.emitter.setRadius(radius)
    # Tangent ring #
    def setEmitterTangentRingRadius(self, radius):
        self.particles.emitter.setRadius(radius)
    def setEmitterTangentRingRadiusSpread(self, radiusSpread):
        self.particles.emitter.setRadiusSpread(radiusSpread)

    ## RENDERER PAGE ##
    def selectRendererType(self, type):
        self.rendererNotebook.selectpage(type)
        self.particles.setRenderer(type)
        self.updateRendererWidgets()

    def updateRendererWidgets(self):
        renderer = self.particles.renderer
        alphaMode = renderer.getAlphaMode()
        if alphaMode == BaseParticleRenderer.PRALPHANONE:
            aMode = 'NO_ALPHA'
        elif alphaMode == BaseParticleRenderer.PRALPHAOUT:
            aMode = 'ALPHA_OUT'
        elif alphaMode == BaseParticleRenderer.PRALPHAIN:
            aMode = 'ALPHA_IN'
        elif alphaMode == BaseParticleRenderer.PRALPHAINOUT:
            aMode = 'ALPHA_IN_OUT'
        elif alphaMode == BaseParticleRenderer.PRALPHAUSER:
            aMode = 'ALPHA_USER'
        self.getVariable('Renderer', 'Alpha Mode').set(aMode)
        userAlpha = renderer.getUserAlpha()
        self.getWidget('Renderer', 'User Alpha').set(userAlpha)
        
        if isinstance(renderer, LineParticleRenderer):
            headColor = renderer.getHeadColor() * 255.0
            self.getWidget('Line Renderer', 'Head Color').set(
                [headColor[0], headColor[1], headColor[2], headColor[3]])
            tailColor = renderer.getTailColor() * 255.0
            self.getWidget('Line Renderer', 'Tail Color').set(
                [tailColor[0], tailColor[1], tailColor[2], tailColor[3]])
            self.getWidget('Line Renderer', 'Line Scale Factor').set(
                renderer.getLineScaleFactor())
            
        elif isinstance(renderer, GeomParticleRenderer):
            self.getVariable('Geom Renderer', 'X Scale').set(
                renderer.getXScaleFlag())
            self.getVariable('Geom Renderer', 'Y Scale').set(
                renderer.getYScaleFlag())
            self.getVariable('Geom Renderer', 'Z Scale').set(
                renderer.getZScaleFlag())
            initialXScale = renderer.getInitialXScale()
            self.getWidget('Geom Renderer', 'Initial X Scale').set(
                initialXScale)
            initialYScale = renderer.getInitialYScale()
            self.getWidget('Geom Renderer', 'Initial Y Scale').set(
                initialYScale)
            initialZScale = renderer.getInitialZScale()
            self.getWidget('Geom Renderer', 'Initial Z Scale').set(
                initialZScale)
            finalXScale = renderer.getFinalXScale()
            self.getWidget('Geom Renderer', 'Final X Scale').set(
                finalXScale)
            finalYScale = renderer.getFinalYScale()
            self.getWidget('Geom Renderer', 'Final Y Scale').set(
                finalYScale)
            finalZScale = renderer.getFinalZScale()
            self.getWidget('Geom Renderer', 'Final Z Scale').set(
                finalZScale)
            if(self.getVariable('Geom Renderer','Color Blend').get() in ['MAdd','MSubtract','MInvSubtract']):
                self.getWidget('Geom Renderer','Incoming Op.').pack(fill = X)
                self.getWidget('Geom Renderer','Fbuffer Op.').pack(fill = X)
            else:
                self.getWidget('Geom Renderer','Incoming Op.').pack_forget()
                self.getWidget('Geom Renderer','Fbuffer Op.').pack_forget()
            for x in self.rendererSegmentWidgetList:
                x.pack_forget()
                x.destroy()
            self.rendererSegmentWidgetList = []
            for id in self.particles.renderer.getColorInterpolationManager().getSegmentIdList().split():
                self.createWidgetForExistingInterpolationSegment(eval(id))

        elif isinstance(renderer, PointParticleRenderer):
            pointSize = renderer.getPointSize()
            self.getWidget('Point Renderer', 'Point Size').set(pointSize)
            startColor = renderer.getStartColor() * 255.0
            self.getWidget('Point Renderer', 'Start Color').set(
                [startColor[0], startColor[1], startColor[2], startColor[3]])
            endColor = renderer.getEndColor() * 255.0
            self.getWidget('Point Renderer', 'End Color').set(
                [endColor[0], endColor[1], endColor[2], endColor[3]])
            blendType = renderer.getBlendType()
            if (blendType == PointParticleRenderer.PPONECOLOR):
                bType = "PP_ONE_COLOR"
            elif (blendType == PointParticleRenderer.PPBLENDLIFE):
                bType = "PP_BLEND_LIFE"
            elif (blendType == PointParticleRenderer.PPBLENDVEL):
                bType = "PP_BLEND_VEL"
            self.getVariable('Point Renderer', 'Blend Type').set(bType)
            blendMethod = renderer.getBlendMethod()
            bMethod = "PP_NO_BLEND"
            if (blendMethod == BaseParticleRenderer.PPNOBLEND):
                bMethod = "PP_NO_BLEND"
            elif (blendMethod == BaseParticleRenderer.PPBLENDLINEAR):
                bMethod = "PP_BLEND_LINEAR"
            elif (blendMethod == BaseParticleRenderer.PPBLENDCUBIC):
                bMethod = "PP_BLEND_CUBIC"
            self.getVariable('Point Renderer', 'Blend Method').set(bMethod)
            
        elif isinstance(renderer, SparkleParticleRenderer):
            centerColor = renderer.getCenterColor() * 255.0
            self.getWidget('Sparkle Renderer', 'Center Color').set(
                [centerColor[0], centerColor[1],
                 centerColor[2], centerColor[3]])
            edgeColor = renderer.getEdgeColor() * 255.0
            self.getWidget('Sparkle Renderer', 'Edge Color').set(
                [edgeColor[0], edgeColor[1], edgeColor[2], edgeColor[3]])
            birthRadius = renderer.getBirthRadius()
            self.getWidget('Sparkle Renderer', 'Birth Radius').set(birthRadius)
            deathRadius = renderer.getDeathRadius()
            self.getWidget('Sparkle Renderer', 'Death Radius').set(deathRadius)
            lifeScale = renderer.getLifeScale()
            lScale = "SP_NO_SCALE"
            if (lifeScale == SparkleParticleRenderer.SPSCALE):
                lScale = "SP_SCALE"
            self.getVariable('Sparkle Renderer', 'Life Scale').set(lScale)
            
        elif isinstance(renderer, SpriteParticleRenderer):
            self.getWidget('Sprite Renderer','Frame Rate').set(renderer.getAnimateFramesRate(), 0)
            self.getVariable('Sprite Renderer','Enable Animation').set(
                renderer.getAnimateFramesEnable())
            self.readSpriteRendererAnimations() # Updates widgets with renderer data.
            self.getVariable('Sprite Renderer', 'X Scale').set(
                renderer.getXScaleFlag())
            self.getVariable('Sprite Renderer', 'Y Scale').set(
                renderer.getYScaleFlag())
            self.getVariable('Sprite Renderer', 'Anim Angle').set(
                renderer.getAnimAngleFlag())
            initialXScale = renderer.getInitialXScale()
            self.getWidget('Sprite Renderer', 'Initial X Scale').set(
                initialXScale)
            initialYScale = renderer.getInitialYScale()
            self.getWidget('Sprite Renderer', 'Initial Y Scale').set(
                initialYScale)
            finalXScale = renderer.getFinalXScale()
            self.getWidget('Sprite Renderer', 'Final X Scale').set(
                finalXScale)
            finalYScale = renderer.getFinalYScale()
            self.getWidget('Sprite Renderer', 'Final Y Scale').set(
                finalYScale)
            nonanimatedTheta = renderer.getNonanimatedTheta()
            self.getWidget('Sprite Renderer', 'Non Animated Theta').set(
                nonanimatedTheta)
            blendMethod = renderer.getAlphaBlendMethod()
            bMethod = "PP_NO_BLEND"
            if (blendMethod == BaseParticleRenderer.PPNOBLEND):
                bMethod = "PP_NO_BLEND"
            elif (blendMethod == BaseParticleRenderer.PPBLENDLINEAR):
                bMethod = "PP_BLEND_LINEAR"
            elif (blendMethod == BaseParticleRenderer.PPBLENDCUBIC):
                bMethod = "PP_BLEND_CUBIC"
            self.getVariable('Sprite Renderer', 'Alpha Disable').set(
                renderer.getAlphaDisable())
            if(self.getVariable('Sprite Renderer','Color Blend').get() in ['MAdd','MSubtract','MInvSubtract']):
                self.getWidget('Sprite Renderer','Incoming Op.').pack(fill = X)
                self.getWidget('Sprite Renderer','Fbuffer Op.').pack(fill = X)
            else:
                self.getWidget('Sprite Renderer','Incoming Op.').pack_forget()
                self.getWidget('Sprite Renderer','Fbuffer Op.').pack_forget()
            for x in self.rendererSegmentWidgetList:
                x.pack_forget()
                x.destroy()
            self.rendererSegmentWidgetList = []
            for id in self.particles.renderer.getColorInterpolationManager().getSegmentIdList().split():
                self.createWidgetForExistingInterpolationSegment(eval(id))

    def selectRendererPage(self):
        type = self.particles.renderer.__class__.__name__
        if(type == 'SpriteParticleRendererExt'):
           type = 'SpriteParticleRenderer'
        self.rendererNotebook.selectpage(type)
        self.getVariable('Renderer', 'Renderer Type').set(type)

    # All #
    def setRendererAlphaMode(self, alphaMode):
        if alphaMode == 'NO_ALPHA':
            aMode = BaseParticleRenderer.PRALPHANONE
        elif alphaMode == 'ALPHA_OUT':
            aMode = BaseParticleRenderer.PRALPHAOUT
        elif alphaMode == 'ALPHA_IN':
            aMode = BaseParticleRenderer.PRALPHAIN
        elif alphaMode == 'ALPHA_IN_OUT':
            aMode = BaseParticleRenderer.PRALPHAINOUT
        elif alphaMode == 'ALPHA_USER':
            aMode = BaseParticleRenderer.PRALPHAUSER
        self.particles.renderer.setAlphaMode(aMode)

    def setRendererUserAlpha(self, alpha):
        self.particles.renderer.setUserAlpha(alpha)

    # Line #
    def setRendererLineHeadColor(self, color):
        self.particles.renderer.setHeadColor(
            Vec4(color[0]/255.0, color[1]/255.0,
                 color[2]/255.0, color[3]/255.0))
    def setRendererLineTailColor(self, color):
        self.particles.renderer.setTailColor(
            Vec4(color[0]/255.0, color[1]/255.0,
                 color[2]/255.0, color[3]/255.0))
    def setRendererLineScaleFactor(self, sf):
        self.particles.renderer.setLineScaleFactor(sf)
    # Geom #
    def setRendererGeomNode(self, event):
        node = None
        nodePath = loader.loadModel(self.rendererGeomNode.get())
        if nodePath != None:
            node = nodePath.node()
        if (node != None):
            self.particles.geomReference = self.rendererGeomNode.get()
            self.particles.renderer.setGeomNode(node)
    # Point #
    def setRendererPointSize(self, size):
        self.particles.renderer.setPointSize(size)
    def setRendererPointStartColor(self, color):
        self.particles.renderer.setStartColor(
            Vec4(color[0]/255.0, color[1]/255.0,
                 color[2]/255.0, color[3]/255.0))
    def setRendererPointEndColor(self, color):
        self.particles.renderer.setEndColor(
            Vec4(color[0]/255.0, color[1]/255.0,
                 color[2]/255.0, color[3]/255.0))
    def rendererPointSelectBlendType(self, blendType):
        if blendType == "PP_ONE_COLOR":
            bType = PointParticleRenderer.PPONECOLOR
        elif blendType == "PP_BLEND_LIFE":
            bType = PointParticleRenderer.PPBLENDLIFE
        elif blendType == "PP_BLEND_VEL":
            bType = PointParticleRenderer.PPBLENDVEL
        self.particles.renderer.setBlendType(bType)
    def rendererPointSelectBlendMethod(self, blendMethod):
        if blendMethod == "PP_NO_BLEND":
            bMethod = BaseParticleRenderer.PPNOBLEND
        elif blendMethod == "PP_BLEND_LINEAR":
            bMethod = BaseParticleRenderer.PPBLENDLINEAR
        elif blendMethod == "PP_BLEND_CUBIC":
            bMethod = BaseParticleRenderer.PPBLENDCUBIC
        self.particles.renderer.setBlendMethod(bMethod)
    # Sparkle #
    def setRendererSparkleCenterColor(self, color):
        self.particles.renderer.setCenterColor(
            Vec4(color[0]/255.0, color[1]/255.0,
                 color[2]/255.0, color[3]/255.0))
    def setRendererSparkleEdgeColor(self, color):
        self.particles.renderer.setEdgeColor(
            Vec4(color[0]/255.0, color[1]/255.0,
                 color[2]/255.0, color[3]/255.0))
    def setRendererSparkleBirthRadius(self, radius):
        self.particles.renderer.setBirthRadius(radius)
    def setRendererSparkleDeathRadius(self, radius):
        self.particles.renderer.setDeathRadius(radius)
    def setRendererSparkleLifeScale(self, lifeScaleMethod):
        if lifeScaleMethod == 'SP_NO_SCALE':
            lScale = SparkleParticleRenderer.SPNOSCALE
        else:
            lScale = SparkleParticleRenderer.SPSCALE
        self.particles.renderer.setLifeScale(lScale)
    # Sprite #
    def setSpriteSourceType(self):
        if self.rendererSpriteSourceType.get() == 0:
            self.rendererSpriteTextureEntry['state'] = 'normal'
            self.rendererSpriteFileEntry['state'] = 'disabled'
            self.rendererSpriteNodeEntry['state'] = 'disabled'
            self.rendererSpriteTextureEntry['background'] = '#FFFFFF'
            self.rendererSpriteFileEntry['background'] = '#C0C0C0'
            self.rendererSpriteNodeEntry['background'] = '#C0C0C0'
        else:
            self.rendererSpriteTextureEntry['state'] = 'disabled'
            self.rendererSpriteFileEntry['state'] = 'normal'
            self.rendererSpriteNodeEntry['state'] = 'normal'
            self.rendererSpriteTextureEntry['background'] = '#C0C0C0'
            self.rendererSpriteFileEntry['background'] = '#FFFFFF'
            self.rendererSpriteNodeEntry['background'] = '#FFFFFF'

    def setRendererSpriteAnimationFrameRate(self, rate):
        self.particles.renderer.setAnimateFramesRate(rate)
    def setRendererSpriteAnimationEnable(self):
        self.particles.renderer.setAnimateFramesEnable(
            self.getVariable('Sprite Renderer','Enable Animation').get())
    def addRendererSpriteAnimationTexture(self):
        ren = self.particles.getRenderer()
        parent = self.rendererSpriteAnimationFrame

        if ren.addTextureFromFile():
            animId = len([x for x in self.rendererSpriteAnimationWidgetList if x and x.valid])
            anim = ren.getAnim(animId)

            frameNum = len([x for x in self.rendererSpriteAnimationWidgetList if x])

            self.rendererSpriteAnimationWidgetList.append(
                self.createSpriteAnimationTextureWidget(parent, anim, repr(frameNum)))
        else:
            animId = len([x for x in self.rendererSpriteAnimationWidgetList if x and x.valid])
            anim = SpriteAnim.STTexture

            frameNum = len([x for x in self.rendererSpriteAnimationWidgetList if x])

            self.rendererSpriteAnimationWidgetList.append(
                self.createSpriteAnimationTextureWidget(parent, anim, repr(frameNum)))
        parent.pack(fill=BOTH, expand=1)
    def addRendererSpriteAnimationFromNode(self):
        ren = self.particles.getRenderer()
        parent = self.rendererSpriteAnimationFrame

        if ren.addTextureFromNode():
            animId = len([x for x in self.rendererSpriteAnimationWidgetList if x and x.valid])
            anim = ren.getAnim(animId)

            frameNum = len([x for x in self.rendererSpriteAnimationWidgetList if x])

            self.rendererSpriteAnimationWidgetList.append(
                self.createSpriteAnimationNodeWidget(parent, anim, repr(frameNum)))
        else:
            animId = len([x for x in self.rendererSpriteAnimationWidgetList if x and x.valid])
            anim = SpriteAnim.STFromNode

            frameNum = len([x for x in self.rendererSpriteAnimationWidgetList if x])

            self.rendererSpriteAnimationWidgetList.append(
                self.createSpriteAnimationNodeWidget(parent, anim, repr(frameNum)))
        parent.pack(fill=BOTH, expand=1)

    def toggleRendererSpriteXScale(self):
        self.particles.renderer.setXScaleFlag(
            self.getVariable('Sprite Renderer', 'X Scale').get())
    def toggleRendererSpriteYScale(self):
        self.particles.renderer.setYScaleFlag(
            self.getVariable('Sprite Renderer', 'Y Scale').get())
    def toggleRendererSpriteAnimAngle(self):
        self.particles.renderer.setAnimAngleFlag(
            self.getVariable('Sprite Renderer', 'Anim Angle').get())

    def toggleAngularVelocity(self):
        self.particles.factory.enableAngularVelocity(
            self.getVariable('Z Spin Factory', 'Enable Angular Velocity').get())

    def setRendererSpriteInitialXScale(self, xScale):
        self.particles.renderer.setInitialXScale(xScale)
    def setRendererSpriteFinalXScale(self, xScale):
        self.particles.renderer.setFinalXScale(xScale)
    def setRendererSpriteInitialYScale(self, yScale):
        self.particles.renderer.setInitialYScale(yScale)
    def setRendererSpriteFinalYScale(self, yScale):
        self.particles.renderer.setFinalYScale(yScale)
    def setRendererSpriteNonAnimatedTheta(self, theta):
        self.particles.renderer.setNonanimatedTheta(theta)
    def setRendererSpriteBlendMethod(self, blendMethod):
        if blendMethod == 'PP_NO_BLEND':
            bMethod = BaseParticleRenderer.PPNOBLEND
        elif blendMethod == 'PP_BLEND_LINEAR':
            bMethod = BaseParticleRenderer.PPBLENDLINEAR
        elif blendMethod == 'PP_BLEND_CUBIC':
            bMethod = BaseParticleRenderer.PPBLENDCUBIC
        else:
            bMethod = BaseParticleRenderer.PPNOBLEND
    def toggleRendererSpriteAlphaDisable(self):
        self.particles.renderer.setAlphaDisable(
            self.getVariable('Sprite Renderer', 'Alpha Disable').get())
    def setRendererColorBlendAttrib(self, rendererName, blendMethodStr, incomingOperandStr, fbufferOperandStr):
        self.particles.getRenderer().setColorBlendMode(eval('ColorBlendAttrib.'+blendMethodStr),
                                                       eval('ColorBlendAttrib.'+incomingOperandStr),
                                                       eval('ColorBlendAttrib.'+fbufferOperandStr))

        if(blendMethodStr in ['MAdd','MSubtract','MInvSubtract']):
            self.getWidget(rendererName,'Incoming Op.').pack(fill = X)
            self.getWidget(rendererName,'Fbuffer Op.').pack(fill = X)
        else:
            self.getWidget(rendererName,'Incoming Op.').pack_forget()
            self.getWidget(rendererName,'Fbuffer Op.').pack_forget()

        self.updateRendererWidgets()
    def setRendererSpriteColorBlendMethod(self, blendMethod):
        blendMethodStr = blendMethod
        incomingOperandStr = self.getVariable('Sprite Renderer','Incoming Op.').get()
        fbufferOperandStr = self.getVariable('Sprite Renderer','Fbuffer Op.').get()

        self.setRendererColorBlendAttrib('Sprite Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)
    def setRendererSpriteColorBlendIncomingOperand(self, operand):
        blendMethodStr = self.getVariable('Sprite Renderer','Color Blend').get()
        incomingOperandStr = operand
        fbufferOperandStr = self.getVariable('Sprite Renderer','Fbuffer Op.').get()

        self.setRendererColorBlendAttrib('Sprite Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)
    def setRendererSpriteColorBlendFbufferOperand(self, operand):
        blendMethodStr = self.getVariable('Sprite Renderer','Color Blend').get()
        incomingOperandStr = self.getVariable('Sprite Renderer','Incoming Op.').get()
        fbufferOperandStr = operand
        self.setRendererColorBlendAttrib('Sprite Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)


    # GeomParticleRenderer Functionality
    def toggleRendererGeomXScale(self):
        self.particles.renderer.setXScaleFlag(
            self.getVariable('Geom Renderer', 'X Scale').get())
    def toggleRendererGeomYScale(self):
        self.particles.renderer.setYScaleFlag(
            self.getVariable('Geom Renderer', 'Y Scale').get())
    def toggleRendererGeomZScale(self):
        self.particles.renderer.setZScaleFlag(
            self.getVariable('Geom Renderer', 'Z Scale').get())
        
    def setRendererGeomInitialXScale(self, xScale):
        self.particles.renderer.setInitialXScale(xScale)
    def setRendererGeomFinalXScale(self, xScale):
        self.particles.renderer.setFinalXScale(xScale)
        
    def setRendererGeomInitialYScale(self, yScale):
        self.particles.renderer.setInitialYScale(yScale)
    def setRendererGeomFinalYScale(self, yScale):
        self.particles.renderer.setFinalYScale(yScale)
        
    def setRendererGeomInitialZScale(self, zScale):
        self.particles.renderer.setInitialZScale(zScale)
    def setRendererGeomFinalZScale(self, zScale):
        self.particles.renderer.setFinalZScale(zScale)
    
    def setRendererGeomColorBlendMethod(self, blendMethod):
        blendMethodStr = blendMethod
        incomingOperandStr = self.getVariable('Geom Renderer','Incoming Op.').get()
        fbufferOperandStr = self.getVariable('Geom Renderer','Fbuffer Op.').get()
        self.setRendererColorBlendAttrib('Geom Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)

    def setRendererGeomColorBlendIncomingOperand(self, operand):
        blendMethodStr = self.getVariable('Geom Renderer','Color Blend').get()
        incomingOperandStr = operand
        fbufferOperandStr = self.getVariable('Geom Renderer','Fbuffer Op.').get()
        self.setRendererColorBlendAttrib('Geom Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)

    def setRendererGeomColorBlendFbufferOperand(self, operand):
        blendMethodStr = self.getVariable('Geom Renderer','Color Blend').get()
        incomingOperandStr = self.getVariable('Geom Renderer','Incoming Op.').get()
        fbufferOperandStr = operand
        self.setRendererColorBlendAttrib('Geom Renderer', blendMethodStr, incomingOperandStr, fbufferOperandStr)


    def addConstantInterpolationSegment(self, id = None):
        ren = self.particles.getRenderer()
        cim = ren.getColorInterpolationManager()
        if id is None:
            seg = cim.getSegment(cim.addConstant())
        else:
            seg = cim.getSegment(id)

        if(ren.__class__.__name__ == 'SpriteParticleRendererExt'):
            parent = self.rendererSpriteSegmentFrame
            segName = repr(len(self.rendererSegmentWidgetList))+':Constant'
            self.rendererSegmentWidgetList.append(
                self.createConstantInterpolationSegmentWidget(parent, segName, seg))
        elif(ren.__class__.__name__ == 'GeomParticleRenderer'):
            parent = self.rendererGeomSegmentFrame
            segName = repr(len(self.rendererSegmentWidgetList))+':Constant'
            self.rendererSegmentWidgetList.append(
                self.createConstantInterpolationSegmentWidget(parent, segName, seg))
        parent.pack(fill=BOTH, expand=1)

    def addLinearInterpolationSegment(self, id = None):
        ren = self.particles.getRenderer()
        cim = ren.getColorInterpolationManager()
        if id is None:
            seg = cim.getSegment(cim.addLinear())
        else:
            seg = cim.getSegment(id)
            
        if(ren.__class__.__name__ == 'SpriteParticleRendererExt'):
            parent = self.rendererSpriteSegmentFrame
            segName = repr(len(self.rendererSegmentWidgetList))+':Linear'
            self.rendererSegmentWidgetList.append(
                self.createLinearInterpolationSegmentWidget(parent, segName, seg))
        elif(ren.__class__.__name__ == 'GeomParticleRenderer'):
            parent = self.rendererGeomSegmentFrame
            segName = repr(len(self.rendererSegmentWidgetList))+':Linear'
            self.rendererSegmentWidgetList.append(
                self.createLinearInterpolationSegmentWidget(parent, segName, seg))
        parent.pack(fill=BOTH, expand=1)

    def addStepwaveInterpolationSegment(self, id = None):
        ren = self.particles.getRenderer()
        cim = ren.getColorInterpolationManager()
        if id is None:
            seg = cim.getSegment(cim.addStepwave())
        else:
            seg = cim.getSegment(id)
            
        if(ren.__class__.__name__ == 'SpriteParticleRendererExt'):
            parent = self.rendererSpriteSegmentFrame
            segName = repr(len(self.rendererSegmentWidgetList))+':Stepwave'
            self.rendererSegmentWidgetList.append(
                self.createStepwaveInterpolationSegmentWidget(parent, segName, seg))
        elif(ren.__class__.__name__ == 'GeomParticleRenderer'):
            parent = self.rendererGeomSegmentFrame
            segName = repr(len(self.rendererSegmentWidgetList))+':Stepwave'
            self.rendererSegmentWidgetList.append(
                self.createStepwaveInterpolationSegmentWidget(parent, segName, seg))
        parent.pack(fill=BOTH, expand=1)

    def addSinusoidInterpolationSegment(self, id = None):
        ren = self.particles.getRenderer()
        cim = ren.getColorInterpolationManager()
        if id is None:
            seg = cim.getSegment(cim.addSinusoid())
        else:
            seg = cim.getSegment(id)
            
        if(ren.__class__.__name__ == 'SpriteParticleRendererExt'):
            parent = self.rendererSpriteSegmentFrame
            segName = repr(len(self.rendererSegmentWidgetList))+':Sinusoid'
            self.rendererSegmentWidgetList.append(
                self.createSinusoidInterpolationSegmentWidget(parent, segName, seg))
        elif(ren.__class__.__name__ == 'GeomParticleRenderer'):
            parent = self.rendererGeomSegmentFrame
            segName = repr(len(self.rendererSegmentWidgetList))+':Sinusoid'
            self.rendererSegmentWidgetList.append(
                self.createSinusoidInterpolationSegmentWidget(parent, segName, seg))
        parent.pack(fill=BOTH, expand=1)

    def createWidgetForExistingInterpolationSegment(self, id):
        ren = self.particles.getRenderer()
        cim = ren.getColorInterpolationManager()
        seg = cim.getSegment(id)
        assert seg

        fun = seg.getFunction()
        if isinstance(fun,ColorInterpolationFunctionSinusoid):
            self.addSinusoidInterpolationSegment(id)
        elif isinstance(fun,ColorInterpolationFunctionStepwave):
            self.addStepwaveInterpolationSegment(id)
        elif isinstance(fun,ColorInterpolationFunctionLinear):
            self.addLinearInterpolationSegment(id)
        elif isinstance(fun,ColorInterpolationFunctionConstant):
            self.addConstantInterpolationSegment(id)
        
    def createInterpolationSegmentFrame(self, parent, segName, seg):
        frame = Frame(parent, relief = RAISED, borderwidth = 2)
        lFrame = Frame(frame, relief = FLAT)
        def removeInterpolationSegmentFrame(s = self, seg = seg, fr = frame):
            s.particles.getRenderer().getColorInterpolationManager().clearSegment(seg.getId())
            fr.pack_forget()
        def setSegEnabled(s=self, n=segName):
            enabled = s.getVariable('Sprite Renderer', n+' Enabled')
            seg.setEnabled(enabled.get())
        def setIsModulated(s=self, n=segName):
            modulated = s.getVariable('Sprite Renderer', n+' isModulated')
            seg.setIsModulated(modulated.get())
        def setSegBegin(time):
            seg.setTimeBegin(time)
        def setSegEnd(time):
            seg.setTimeEnd(time)
        Button(lFrame, text = 'X',
               command = removeInterpolationSegmentFrame).pack(side = RIGHT, expand = 0)
        Label(lFrame, text = segName,
              foreground = 'Blue',
              font = ('MSSansSerif', 12, 'bold'),
              ).pack(fill = X, expand = 1)
        lFrame.pack(fill = X, expand = 1)
        lFrame = Frame(frame, relief = FLAT)
        self.createCheckbutton(
            lFrame, 'Sprite Renderer', segName + ' Enabled',
            ('On: Enabled\n' +
             'Off: Disabled'),
            command = setSegEnabled, initialState = seg.isEnabled())
        self.createCheckbutton(
            lFrame, 'Sprite Renderer', segName + ' isModulated',
            ('On: Modulate\n' +
             'Off: Add'),
            command = setIsModulated, initialState = seg.isModulated())
        lFrame.pack(fill = X, expand = 1)

        f = Frame(frame)
        self.createSlider(f,
                          'Sprite Renderer', segName + ' Begin',
                          '',
                          command = setSegBegin,
                          value = seg.getTimeBegin())
        self.createSlider(f,'Sprite Renderer', segName + ' End',
                          '',
                          command = setSegEnd,
                          value = seg.getTimeEnd())
        f.pack(fill = X, expand = 0)
        frame.pack(pady = 3, fill = X, expand = 0)
        return frame

    def createConstantInterpolationSegmentWidget(self, parent, segName, segment):
        fun = segment.getFunction()
        def setSegColorA(color):
            fun.setColorA(
                Vec4(color[0]/255.0, color[1]/255.0,
                     color[2]/255.0, color[3]/255.0))

        frame = self.createInterpolationSegmentFrame(parent, segName, segment)
        f = Frame(frame)

        c = fun.getColorA()
        c = [c[0]*255.0, c[1]*255.0, c[2]*255.0, c[3]*255.0]
        self.createColorEntry(f,'Sprite Renderer', segName + ' Color A',
                              '',
                              command = setSegColorA,
                              value = c)
        f.pack(fill = X)
        return frame

    def createLinearInterpolationSegmentWidget(self, parent, segName, segment):
        fun = segment.getFunction()
        def setSegColorA(color):
            fun.setColorA(
                Vec4(color[0]/255.0, color[1]/255.0,
                     color[2]/255.0, color[3]/255.0))
        def setSegColorB(color):
            fun.setColorB(
                Vec4(color[0]/255.0, color[1]/255.0,
                     color[2]/255.0, color[3]/255.0))

        frame = self.createInterpolationSegmentFrame(parent, segName, segment)
        f = Frame(frame)

        c = fun.getColorA()
        c = [c[0]*255.0, c[1]*255.0, c[2]*255.0, c[3]*255.0]
        self.createColorEntry(f,'Sprite Renderer', segName + ' Color A',
                              '',
                              command = setSegColorA,
                              value = c)
        c = fun.getColorB()
        c = [c[0]*255.0, c[1]*255.0, c[2]*255.0, c[3]*255.0]
        self.createColorEntry(f,'Sprite Renderer', segName + ' Color B',
                              '',
                              command = setSegColorB,
                              value = c)
        f.pack(fill = X)
        return frame

    def createStepwaveInterpolationSegmentWidget(self, parent, segName, segment):
        fun = segment.getFunction()
        def setColorA(color):
            fun.setColorA(
                Vec4(color[0]/255.0, color[1]/255.0,
                     color[2]/255.0, color[3]/255.0))
        def setColorB(color):
            fun.setColorB(
                Vec4(color[0]/255.0, color[1]/255.0,
                     color[2]/255.0, color[3]/255.0))
        def setWidthA(width):
            fun.setWidthA(width)
        def setWidthB(width):
            fun.setWidthB(width)

        frame = self.createInterpolationSegmentFrame(parent, segName, segment)
        f = Frame(frame)

        c = fun.getColorA()
        c = [c[0]*255.0, c[1]*255.0, c[2]*255.0, c[3]*255.0]
        self.createColorEntry(f,'Sprite Renderer', segName + ' Color A',
                              '',
                              command = setColorA,
                              value = c)
        c = fun.getColorB()
        c = [c[0]*255.0, c[1]*255.0, c[2]*255.0, c[3]*255.0]
        self.createColorEntry(f,'Sprite Renderer', segName + ' Color B',
                              '',
                              command = setColorB,
                              value = c)
        w = fun.getWidthA()
        self.createSlider(f,'Sprite Renderer', segName + ' Width A',
                          '',
                          command = setWidthA,
                          value = w)
        w = fun.getWidthB()
        self.createSlider(f,'Sprite Renderer', segName + ' Width B',
                          '',
                          command = setWidthB,
                          value = w)
        f.pack(fill = X)
        return frame

    def createSinusoidInterpolationSegmentWidget(self, parent, segName, segment):
        fun = segment.getFunction()
        def setColorA(color):
            fun.setColorA(
                Vec4(color[0]/255.0, color[1]/255.0,
                     color[2]/255.0, color[3]/255.0))
        def setColorB(color):
            fun.setColorB(
                Vec4(color[0]/255.0, color[1]/255.0,
                     color[2]/255.0, color[3]/255.0))
        def setPeriod(period):
            fun.setPeriod(period)

        frame = self.createInterpolationSegmentFrame(parent, segName, segment)
        f = Frame(frame)

        c = fun.getColorA()
        c = [c[0]*255.0, c[1]*255.0, c[2]*255.0, c[3]*255.0]
        self.createColorEntry(f,'Sprite Renderer', segName + ' Color A',
                              '',
                              command = setColorA,
                              value = c)
        c = fun.getColorB()
        c = [c[0]*255.0, c[1]*255.0, c[2]*255.0, c[3]*255.0]
        self.createColorEntry(f,'Sprite Renderer', segName + ' Color B',
                              '',
                              command = setColorB,
                              value = c)
        p = fun.getPeriod()
        self.createFloater(f,'Sprite Renderer', segName + ' Period',
                          '',
                          command = setPeriod,
                          value = p)
        f.pack(fill = X)
        return frame

    def createSpriteAnimationFrame(self, parent, anim, animName):
        ren = self.particles.getRenderer()
        pass
        frame = Frame(parent, relief = RAISED, borderwidth = 2)
        frame.pack(pady = 1, fill = X, expand = 0)

        lFrame = Frame(frame, relief = FLAT)
        lFrame.pack(fill = X, expand = 1)

        def delete(s = self, fr = frame):
            i = s.rendererSpriteAnimationWidgetList.index(fr)
            s.rendererSpriteAnimationWidgetList[i] = None
            fr.pack_forget()
            fr.destroy()
            s.writeSpriteRendererAnimations()
            s.readSpriteRendererAnimations()

        Button(lFrame, text = 'X', foreground = 'Red', font = ('MSSansSerif', 8, 'bold'),
               command = delete).pack(side = RIGHT, expand = 0)

        if(anim == SpriteAnim.STTexture or
           anim == SpriteAnim.STFromNode):
            frame.valid = False
            frame.animSourceType = anim
            if(anim == SpriteAnim.STTexture):
                type = 'Texture'
            else:
                type = 'From Node'
        else:
            frame.valid = True

            if(anim.getSourceType()==SpriteAnim.STTexture):
                frame.animSourceType = SpriteAnim.STTexture
                type = 'Texture'
            else:
                frame.animSourceType = SpriteAnim.STFromNode
                type = 'From Node'

        Label(lFrame, text = animName+': '+type,
              foreground = 'Blue',
              font = ('MSSansSerif', 12, 'bold'),
              ).pack(fill = X, expand = 1)

        return frame

    def createSpriteAnimationTextureWidget(self, parent, anim, animName):
        ren = self.particles.getRenderer()
        frame = self.createSpriteAnimationFrame(parent, anim, animName)
        f = Frame(frame)
        f.pack(fill=X)

        Label(f, text = 'Texture: ', font = ('MSSansSerif', 12), width=7).pack(side = LEFT)
        strVar = StringVar()
        entry = Entry(f, textvariable = strVar).pack(padx=3, pady=3, side=LEFT, fill=X, expand=1)
        if frame.valid:
            strVar.set(anim.getTexSource())
        else:
            strVar.set('Base model path: ' + repr(getModelPath().getValue()))

        def checkForTexture(strVar = strVar):
            tex = loader.loadTexture(strVar.get())
            if tex:
                frame.valid = True
            else:
                frame.valid = False
            self.writeSpriteRendererAnimations()

        Button(f, text = 'Update',
               command = checkForTexture).pack(side=LEFT)
        self.variableDict['Sprite Renderer-'+animName+' Anim Texture'] = strVar
        self.widgetDict['Sprite Renderer-'+animName+' Anim Texture'] = entry

        return frame

    def createSpriteAnimationNodeWidget(self, parent, anim, animName):
        ren = self.particles.getRenderer()
        frame = self.createSpriteAnimationFrame(parent, anim, animName)
        f = Frame(frame)
        f.pack(fill=X)

        lf = Frame(f)
        lf.pack(fill=X, expand=1)
        Label(lf, text = 'Model: ', font = ('MSSansSerif', 12), width=7).pack(side = LEFT)
        mStrVar = StringVar()
        entry = Entry(lf, textvariable = mStrVar).pack(padx=3, pady=3, side=LEFT, fill=X, expand=1)
        if frame.valid:
            mStrVar.set(anim.getModelSource())
        else:
            mStrVar.set('Base model path: ' + repr(getModelPath().getValue()))

        mlf = lf

        self.variableDict['Sprite Renderer-'+animName+' Anim Model'] = mStrVar
        self.widgetDict['Sprite Renderer-'+animName+' Anim Model'] = entry

        lf = Frame(f)
        lf.pack(fill=X, expand=1)
        Label(lf, text = 'Node: ', font = ('MSSansSerif', 12), width=7).pack(side = LEFT)
        nStrVar = StringVar()
        entry = Entry(lf, textvariable = nStrVar).pack(padx=3, pady=3, side=LEFT, fill=X, expand=1)
        if frame.valid:
            nStrVar.set(anim.getNodeSource())
        else:
            nStrVar.set('**/*')
        nlf = lf

        self.variableDict['Sprite Renderer-'+animName+' Anim Node'] = nStrVar
        self.widgetDict['Sprite Renderer-'+animName+' Anim Node'] = entry

        def checkForNode(modelStrVar=mStrVar, nodeStrVar=nStrVar):
            mod = loader.loadModel(modelStrVar.get())
            if mod:
                node = mod.find(nodeStrVar.get())
                if node:
                    frame.valid = True
                else:
                    frame.valid = False
            else:
                frame.valid = False

            self.writeSpriteRendererAnimations()

        Button(mlf, text = 'Update',
               command = checkForNode).pack(side=LEFT)
        Button(nlf, text = 'Update',
               command = checkForNode).pack(side=LEFT)

        return frame

    # get animation info from renderer into panel
    def readSpriteRendererAnimations(self):
        ren = self.particles.getRenderer()

        for widget in self.rendererSpriteAnimationWidgetList:
            if(widget):
                widget.pack_forget()
                widget.destroy()

        self.rendererSpriteAnimationWidgetList = []

        for anim in [ren.getAnim(x) for x in range(ren.getNumAnims())]:
            if(anim.getSourceType() == SpriteAnim.STTexture):
                w = self.createSpriteAnimationTextureWidget(self.rendererSpriteAnimationFrame, anim, repr(len(self.rendererSpriteAnimationWidgetList)))
            else:
                w = self.createSpriteAnimationNodeWidget(self.rendererSpriteAnimationFrame, anim, repr(len(self.rendererSpriteAnimationWidgetList)))
            self.rendererSpriteAnimationWidgetList.append(w)

    # set animation info from panel into renderer
    def writeSpriteRendererAnimations(self):
        ren = self.particles.getRenderer()

        for x in range(ren.getNumAnims()):
            ren.removeAnimation(0)

        for x in range(len(self.rendererSpriteAnimationWidgetList)):
            widget = self.rendererSpriteAnimationWidgetList[x]
            if(widget and widget.valid):
                if(widget.animSourceType == SpriteAnim.STTexture):
                    texSource = self.getVariable('Sprite Renderer', repr(x) + ' Anim Texture').get()
                    ren.addTextureFromFile(texSource)
                else:
                    modelSource = self.getVariable('Sprite Renderer', repr(x) + ' Anim Model').get()
                    nodeSource = self.getVariable('Sprite Renderer', repr(x) + ' Anim Node').get()
                    ren.addTextureFromNode(modelSource, nodeSource)

    ## FORCEGROUP COMMANDS ##
    def updateForceWidgets(self):
        # Select appropriate notebook page
        if self.forceGroup != None:
            self.forceGroupNotebook.pack(fill = X)
            self.forcePageName = (self.particleEffect.getName() + '-' +
                                  self.forceGroup.getName())
            self.forcePage = self.forcePagesDict.get(
                self.forcePageName, None)
            # Page doesn't exist, add it
            if self.forcePage == None:
                self.addForceGroupNotebookPage(
                    self.particleEffect, self.forceGroup)
            self.forceGroupNotebook.selectpage(self.forcePageName)
        else:
            self.forceGroupNotebook.pack_forget()

    def addLinearVectorForce(self):
        self.addForce(LinearVectorForce())
    def addLinearFrictionForce(self):
        self.addForce(LinearFrictionForce())
    def addLinearJitterForce(self):
        self.addForce(LinearJitterForce())
    def addLinearNoiseForce(self):
        self.addForce(LinearNoiseForce())
    def addLinearSinkForce(self):
        self.addForce(LinearSinkForce())
    def addLinearSourceForce(self):
        self.addForce(LinearSourceForce())
    def addLinearCylinderVortexForce(self):
        self.addForce(LinearCylinderVortexForce())
    def addLinearUserDefinedForce(self):
        self.addForce(LinearUserDefinedForce())

    def addForce(self, f):
        if self.forceGroup == None:
            self.createNewForceGroup()
        self.forceGroup.addForce(f)
        self.addForceWidget(self.forceGroup, f)

    ## SYSTEM COMMANDS ##
    def createNewEffect(self):
        name = askstring('Particle Panel', 'Effect Name:',
                         parent = self.parent)
        if name:
            particles = Particles.Particles()
            particles.setBirthRate(0.02)
            particles.setLitterSize(10)
            particles.setLitterSpread(0)
            particles.setFactory("PointParticleFactory")
            particles.setRenderer("PointParticleRenderer")
            particles.setEmitter("SphereVolumeEmitter")
            particles.enable()
            effect = ParticleEffect.ParticleEffect(name, particles)
            self.effectsDict[name] = effect
            self.updateMenusAndLabels()
            self.selectEffectNamed(name)
            effect.reparentTo(render)
            effect.enable()

    def createNewParticles(self):
        name = askstring('Particle Panel', 'Particles Name:',
                         parent = self.parent)
        if name:
            p = Particles.Particles(name)
            self.particleEffect.addParticles(p)
            self.updateParticlesMenus()
            self.selectParticlesNamed(name)
            p.enable()

    def createNewForceGroup(self):
        name = askstring('Particle Panel', 'ForceGroup Name:',
                         parent = self.parent)
        if name:
            forceGroup = ForceGroup.ForceGroup(name)
            self.particleEffect.addForceGroup(forceGroup)
            self.updateForceGroupMenus()
            self.addForceGroupNotebookPage(self.particleEffect, forceGroup)
            self.selectForceGroupNamed(name)
            forceGroup.enable()

    def addForceGroupNotebookPage(self, particleEffect, forceGroup):
        self.forcePageName = (particleEffect.getName() + '-' +
                              forceGroup.getName())
        self.forcePage = self.forceGroupNotebook.add(self.forcePageName)
        self.forcePagesDict[self.forcePageName] = self.forcePage
        for force in forceGroup:
            self.addForceWidget(forceGroup, force)

    def addForceWidget(self, forceGroup, force):
        forcePage = self.forcePage
        pageName = self.forcePageName
        # How many forces of the same type in the force group object
        count = 0
        for f in forceGroup:
            if f.getClassType() == force.getClassType():
                count += 1
        if isinstance(force, LinearVectorForce):
            self.createLinearVectorForceWidget(
                forcePage, pageName, count, force)
        elif isinstance(force, LinearNoiseForce):
            self.createLinearRandomForceWidget(
                forcePage, pageName, count, force, 'Noise')
        elif isinstance(force, LinearJitterForce):
            self.createLinearRandomForceWidget(
                forcePage, pageName, count, force, 'Jitter')
        elif isinstance(force, LinearFrictionForce):
            self.createLinearFrictionForceWidget(
                forcePage, pageName, count, force)
        elif isinstance(force, LinearCylinderVortexForce):
            self.createLinearCylinderVortexForceWidget(
                forcePage, pageName, count, force)
        elif isinstance(force, LinearSinkForce):
            self.createLinearDistanceForceWidget(
                forcePage, pageName, count, force, 'Sink')
        elif isinstance(force, LinearSourceForce):
            self.createLinearDistanceForceWidget(
                forcePage, pageName, count, force, 'Source')
        elif isinstance(force, LinearUserDefinedForce):
            # Nothing
            pass
        self.forceGroupNotebook.setnaturalsize()

    def createForceFrame(self, forcePage, forceName, force):
        frame = Frame(forcePage, relief = RAISED, borderwidth = 2)
        lFrame = Frame(frame, relief = FLAT)
        def removeForce(s = self, f = force, fr = frame):
            s.forceGroup.removeForce(f)
            fr.pack_forget()
        b = Button(lFrame, text = 'X',
                   command = removeForce)
        b.pack(side = 'right', expand = 0)
        Label(lFrame, text = forceName,
              foreground = 'Blue',
              font=('MSSansSerif', 12, 'bold'),
              ).pack(expand = 1, fill = 'x')
        lFrame.pack(fill = 'x', expand =1)
        frame.pack(pady = 3, fill = 'x', expand =0)
        return frame

    def createLinearForceWidgets(self, frame, pageName, forceName, force):
        def setAmplitude(amp, f = force):
            f.setAmplitude(amp)
        def toggleMassDependent(s=self, f=force, p=pageName, n=forceName):
            v = s.getVariable(p, n+' Mass Dependent')
            f.setMassDependent(v.get())
        def setVectorMasks(s=self, f=force, p=pageName, n=forceName):
            xMask = s.getVariable(p, n+' Mask X').get()
            yMask = s.getVariable(p, n+' Mask Y').get()
            zMask = s.getVariable(p, n+' Mask Z').get()
            f.setVectorMasks(xMask, yMask, zMask)
        self.createFloater(frame, pageName, forceName + ' Amplitude',
                           'Force amplitude multiplier',
                           command = setAmplitude,
                           value = force.getAmplitude())
        cbf = Frame(frame, relief = FLAT)
        self.createCheckbutton(cbf, pageName, forceName + ' Mass Dependent',
                               ('On: force depends on mass; ' +
                                'Off: force does not depend on mass'),
                               toggleMassDependent,
                               force.getMassDependent())
        self.createCheckbutton(cbf, pageName, forceName + ' Mask X',
                               'On: enable force along X axis',
                               setVectorMasks, 1)
        self.createCheckbutton(cbf, pageName, forceName + ' Mask Y',
                               'On: enable force along X axis',
                               setVectorMasks, 1)
        self.createCheckbutton(cbf, pageName, forceName + ' Mask Z',
                               'On: enable force along X axis',
                               setVectorMasks, 1)
        cbf.pack(fill = 'x', expand = 0)

    def createForceActiveWidget(self, frame, pageName, forceName, force):
        cbName = forceName + ' Active'
        def toggle(s = self, f = force, p = pageName, n = cbName):
            s.toggleForce(f, p, n)
        self.createCheckbutton(frame, pageName, cbName,
                               'On: force is enabled; Off: force is disabled',
                               toggle, 1)

    def createLinearVectorForceWidget(self, forcePage, pageName,
                                      count, force):
        def setVec(vec, f = force):
            f.setVector(vec[0], vec[1], vec[2])
        forceName = 'Vector Force-' + repr(count)
        frame = self.createForceFrame(forcePage, forceName, force)
        self.createLinearForceWidgets(frame, pageName, forceName, force)
        vec = force.getLocalVector()
        self.createVector3Entry(frame, pageName, forceName,
                                'Set force direction and magnitude',
                                command = setVec,
                                value = [vec[0], vec[1], vec[2]])
        self.createForceActiveWidget(frame, pageName, forceName, force)

    def createLinearRandomForceWidget(self, forcePage, pageName, count,
                                force, type):
        forceName = type + ' Force-' + repr(count)
        frame = self.createForceFrame(forcePage, forceName, force)
        self.createLinearForceWidgets(frame, pageName, forceName, force)
        self.createForceActiveWidget(frame, pageName, forceName, force)

    def createLinearFrictionForceWidget(self, forcePage, pageName,
                                        count, force):
        def setCoef(coef, f = force):
            f.setCoef(coef)
        forceName = 'Friction Force-' + repr(count)
        frame = self.createForceFrame(forcePage, forceName, force)
        self.createLinearForceWidgets(frame, pageName, forceName, force)
        self.createFloater(frame, pageName, forceName + ' Coef',
                           'Set linear friction force',
                           command = setCoef, min = None,
                           value = force.getCoef())
        self.createForceActiveWidget(frame, pageName, forceName, force)

    def createLinearCylinderVortexForceWidget(self, forcePage, pageName,
                                              count, force):
        forceName = 'Vortex Force-' + repr(count)
        def setCoef(coef, f = force):
            f.setCoef(coef)
        def setLength(length, f = force):
            f.setLength(length)
        def setRadius(radius, f = force):
            f.setRadius(radius)
        frame = self.createForceFrame(forcePage, forceName, force)
        self.createLinearForceWidgets(frame, pageName, forceName, force)
        self.createFloater(frame, pageName, forceName + ' Coef',
                           'Set linear cylinder vortex coefficient',
                           command = setCoef,
                           value = force.getCoef())
        self.createFloater(frame, pageName, forceName + ' Length',
                           'Set linear cylinder vortex length',
                           command = setLength,
                           value = force.getLength())
        self.createFloater(frame, pageName, forceName + ' Radius',
                           'Set linear cylinder vortex radius',
                           command = setRadius,
                           value = force.getRadius())
        self.createForceActiveWidget(frame, pageName, forceName, force)

    def createLinearDistanceForceWidget(self, forcePage, pageName,
                                        count, force, type):
        def setFalloffType(type, f=force):
            if type == 'FT_ONE_OVER_R':
                #f.setFalloffType(LinearDistanceForce.FTONEOVERR)
                f.setFalloffType(0)
            if type == 'FT_ONE_OVER_R_SQUARED':
                #f.setFalloffType(LinearDistanceForce.FTONEOVERRSQUARED)
                f.setFalloffType(1)
            if type == 'FT_ONE_OVER_R_CUBED':
                #f.setFalloffType(LinearDistanceForce.FTONEOVERRCUBED)
                f.setFalloffType(2)
        def setForceCenter(vec, f = force):
            f.setForceCenter(Point3(vec[0], vec[1], vec[2]))
        def setRadius(radius, f = force):
            f.setRadius(radius)
        forceName = type + ' Force-' + repr(count)
        frame = self.createForceFrame(forcePage, forceName, force)
        self.createLinearForceWidgets(frame, pageName, forceName, force)
        var = self.createOptionMenu(
            frame, pageName, forceName + ' Falloff',
            'Set force falloff type',
            ('FT_ONE_OVER_R',
             'FT_ONE_OVER_R_SQUARED',
             'FT_ONE_OVER_R_CUBED'),
            command = setFalloffType)
        self.getWidget(pageName, forceName + ' Falloff').configure(
            label_width = 16)
        falloff = force.getFalloffType()
        if falloff == LinearDistanceForce.FTONEOVERR:
            var.set('FT_ONE_OVER_R')
        elif falloff == LinearDistanceForce.FTONEOVERRSQUARED:
            var.set('FT_ONE_OVER_R_SQUARED')
        elif falloff == LinearDistanceForce.FTONEOVERRCUBED:
            var.set('FT_ONE_OVER_R_CUBED')
        vec = force.getForceCenter()
        self.createVector3Entry(frame, pageName, forceName + ' Center',
                                'Set center of force',
                                command = setForceCenter,
                                label_width = 16,
                                value = [vec[0], vec[1], vec[2]])
        self.createFloater(frame, pageName, forceName + ' Radius',
                           'Set falloff radius',
                           command = setRadius,
                           min = 0.01,
                           value = force.getRadius())
        self.createForceActiveWidget(frame, pageName, forceName, force)

######################################################################

# Create demo in root window for testing.
if __name__ == '__main__':

    try:
        base
    except:
        from direct.directbase import DirectStart

    root = Pmw.initialise()
    pp = ParticlePanel()
    base.pp=pp
    #ve = VectorEntry(Toplevel(), relief = GROOVE)
    #ve.pack()
    run()