*** empty log message ***

direct/src/showbase/Particles.py

@@ -31,6 +31,8 @@ import LinearEulerIntegrator
 import ClockObject
 
 globalClock = ClockObject.ClockObject.getGlobalClock()
+SparkleParticleRenderer.SparkleParticleRenderer.SPNOSCALE = 0
+SparkleParticleRenderer.SparkleParticleRenderer.SPSCALE = 1
 
 class Particles(ParticleSystem.ParticleSystem):
 
@@ -45,13 +47,13 @@ class Particles(ParticleSystem.ParticleSystem):
 
 	self.factory = None 
 	self.factoryType = "undefined"
-	self.setFactory("Point")
+	self.setFactory("PointParticleFactory")
 	self.renderer = None 
 	self.rendererType = "undefined"
-	self.setRenderer("Line")
+	self.setRenderer("PointParticleRenderer")
 	self.emitter = None 
 	self.emitterType = "undefined"
-	self.setEmitter("Sphere Volume")
+	self.setEmitter("SphereVolumeEmitter")
 
 	self.node = PhysicalNode.PhysicalNode()
 	self.node.addPhysical(self)
@@ -73,16 +75,16 @@ class Particles(ParticleSystem.ParticleSystem):
 	if (self.factory):
 	    self.factory = None
 	self.factoryType = type
-	if (type == "Point"):
+	if (type == "PointParticleFactory"):
 	    self.factory = PointParticleFactory.PointParticleFactory() 
-	elif (type == "Z Spin"):
+	elif (type == "ZSpinParticleFactory"):
 	    self.factory = ZSpinParticleFactory.ZSpinParticleFactory()
-	elif (type == "Oriented"):
+	elif (type == "OrientedParticleFactory"):
 	    self.factory = OrientedParticleFactory.OrientedParticleFactory()
 	else:
 	    print "unknown factory type: %s" % type
 	    return None
-	#self.factory.setLifespanBase(0.5)
+	self.factory.setLifespanBase(0.5)
 	ParticleSystem.ParticleSystem.setFactory(self, self.factory)
 
     def setRenderer(self, type):
@@ -92,18 +94,18 @@ class Particles(ParticleSystem.ParticleSystem):
 	if (self.renderer):
 	    self.renderer = None
 	self.rendererType = type
-	if (type == "Point"):
+	if (type == "PointParticleRenderer"):
 	    self.renderer = PointParticleRenderer.PointParticleRenderer()
 	    self.renderer.setPointSize(1.0)
-	elif (type == "Line"):
+	elif (type == "LineParticleRenderer"):
 	    self.renderer = LineParticleRenderer.LineParticleRenderer()
 	    self.renderer.setHeadColor(Vec4(1.0, 1.0, 1.0, 1.0))
 	    self.renderer.setTailColor(Vec4(1.0, 1.0, 1.0, 1.0))
-	elif (type == "Geom"):
+	elif (type == "GeomParticleRenderer"):
 	    self.renderer = GeomParticleRenderer.GeomParticleRenderer()
-	elif (type == "Sparkle"):
+	elif (type == "SparkleParticleRenderer"):
 	    self.renderer = SparkleParticleRenderer.SparkleParticleRenderer()
-	elif (type == "Sprite"):
+	elif (type == "SpriteParticleRenderer"):
 	    self.renderer = SpriteParticleRenderer.SpriteParticleRenderer()
 	else:
 	    print "unknown renderer type: %s" % type
@@ -120,24 +122,24 @@ class Particles(ParticleSystem.ParticleSystem):
 	if (self.emitter):
 	    self.emitter = None
 	self.emitterType = type
-	if (type == "Box"):
+	if (type == "BoxEmitter"):
 	    self.emitter = BoxEmitter.BoxEmitter()
-	elif (type == "Disc"):
+	elif (type == "DiscEmitter"):
 	    self.emitter = DiscEmitter.DiscEmitter()
-	elif (type == "Line"):
+	elif (type == "LineEmitter"):
 	    self.emitter = LineEmitter.LineEmitter()
-	elif (type == "Point"):
+	elif (type == "PointEmitter"):
 	    self.emitter = PointEmitter.PointEmitter()
-	elif (type == "Rectangle"):
+	elif (type == "RectangleEmitter"):
 	    self.emitter = RectangleEmitter.RectangleEmitter()
-	elif (type == "Ring"):
+	elif (type == "RingEmitter"):
 	    self.emitter = RingEmitter.RingEmitter()
-	elif (type == "Sphere Surface"):
+	elif (type == "SphereSurfaceEmitter"):
 	    self.emitter = SphereSurfaceEmitter.SphereSurfaceEmitter()
-	elif (type == "Sphere Volume"):
+	elif (type == "SphereVolumeEmitter"):
 	    self.emitter = SphereVolumeEmitter.SphereVolumeEmitter()
 	    self.emitter.setRadius(1.0)
-	elif (type == "Tangent Ring"):
+	elif (type == "TangentRingEmitter"):
 	    self.emitter = TangentRingEmitter.TangentRingEmitter()
 	else:
 	    print "unknown emitter type: %s" % type
@@ -176,15 +178,15 @@ class Particles(ParticleSystem.ParticleSystem):
 	print "factory.setMassSpread(%f)" % self.factory.getMassSpread()
 	print "factory.setTerminalVelocityBase(%f)" % self.factory.getTerminalVelocityBase()
 	print "factory.setTerminalVelocitySpread(%f)" % self.factory.getTerminalVelocitySpread()
-	if (self.factoryType == "Point"):
+	if (self.factoryType == "PointParticleFactory"):
 	    print "# Point factory parameters"
-	elif (self.factoryType == "Z Spin"):
+	elif (self.factoryType == "ZSpinParticleFactory"):
 	    print "# Z Spin factory parameters"
 	    print "factory.setInitialAngle(%f)" % self.factory.getInitialAngle()
 	    print "factory.setFinalAngle(%f)" % self.factory.getFinalAngle()
 	    print "factory.setInitialAngleSpread(%f)" % self.factory.getInitialAngleSpread()
 	    print "factory.setFinalAngleSpread(%f)" % self.factory.getFinalAngleSpread()
-	elif (self.factoryType == "Oriented"):
+	elif (self.factoryType == "OrientedParticleFactory"):
 	    print "# Oriented factory parameters"
 	    print 'factory.setInitialOrientation(' + self.factory.getInitialOrientation + ')'
 	    print 'factory.setFinalOrientation(' + self.factory.getFinalOrientation + ')'
@@ -230,17 +232,17 @@ class Particles(ParticleSystem.ParticleSystem):
 	    elif (blendMethod == BaseParticleRenderer.BaseParticleRenderer.PPBLENDCUBIC):
 		bMethod = "PP_BLEND_CUBIC"
 	    print 'renderer.setBlendMethod(BaseParticleRenderer.BaseParticleRenderer.' + bMethod + ')'
-	elif (self.rendererType == "Line"):
+	elif (self.rendererType == "LineParticleRenderer"):
 	    print "# Line parameters"
 	    sColor = self.renderer.getHeadColor()
 	    print ('renderer.setHeadColor(Colorf(%f, %f, %f, %f))' % (sColor[0], sColor[1], sColor[2], sColor[3]))
 	    sColor = self.renderer.getTailColor()
 	    print ('renderer.setTailColor(Colorf(%f, %f, %f, %f))' % (sColor[0], sColor[1], sColor[2], sColor[3]))
-	elif (self.rendererType == "Geom"):
+	elif (self.rendererType == "GeomParticleRenderer"):
 	    print "# Geom parameters"
 	    node = self.renderer.getGeomNode()
 	    print 'renderer.setGeomNode(' + node.getName() + ')'
-	elif (self.rendererType == "Sparkle"):
+	elif (self.rendererType == "SparkleParticleRenderer"):
 	    print "# Sparkle parameters"
 	    sColor = self.renderer.getCenterColor()
 	    print ('renderer.setCenterColor(Colorf(%f, %f, %f, %f))' % (sColor[0], sColor[1], sColor[2], sColor[3]))
@@ -253,7 +255,7 @@ class Particles(ParticleSystem.ParticleSystem):
 	    if (lifeScale == SparkleParticleRenderer.SparkleParticleRenderer.SPSCALE):
 		lScale = "SP_SCALE"
 	    print 'renderer.setLifeScale(SparkleParticleRenderer.SparkleParticleRenderer.' + lScale + ')'
-	elif (self.rendererType == "Sprite"):
+	elif (self.rendererType == "SpriteParticleRenderer"):
 	    print "# Sprite parameters"
 	    tex = self.renderer.getTexture()
 	    print 'renderer.setTexture(' + tex.getName() + ')'
@@ -296,13 +298,13 @@ class Particles(ParticleSystem.ParticleSystem):
 	print ('emitter.setExplicitLaunchVector(Vec3(%f, %f, %f))' % (oForce[0], oForce[1], oForce[2]))
 	orig = self.emitter.getRadiateOrigin()
 	print ('emitter.setRadiateOrigin(Point3(%f, %f, %f))' % (orig[0], orig[1], orig[2]))
-	if (self.emitterType == "Box"):
+	if (self.emitterType == "BoxEmitter"):
 	    print "# Box parameters"
 	    bound = self.emitter.getMinBound()
 	    print ('emitter.setMinBound(Point3(%f, %f, %f))' % (bound[0], bound[1], bound[2]))
 	    bound = self.emitter.getMaxBound()
 	    print ('emitter.setMaxBound(Point3(%f, %f, %f))' % (bound[0], bound[1], bound[2]))
-	elif (self.emitterType == "Disc"):
+	elif (self.emitterType == "DiscEmitter"):
 	    print "# Disc parameters"
 	    print 'emitter.setRadius(%f)' % self.emitter.getRadius()
 	    print 'emitter.setOuterAngle(%f)' % self.emitter.getOuterAngle()
@@ -311,32 +313,32 @@ class Particles(ParticleSystem.ParticleSystem):
 	    print 'emitter.setInnerMagnitude(%f)' % self.emitter.getInnerMagnitude()
 	    print 'emitter.setCubicLerping(%d)' % self.emitter.getCubicLerping()
 
-	elif (self.emitterType == "Line"):
+	elif (self.emitterType == "LineEmitter"):
 	    print "# Line parameters"
 	    point = self.emitter.getEndpoint1()
 	    print ('emitter.setEndpoint1(Point3(%f, %f, %f))' % (point[0], point[1], point[2]))
 	    point = self.emitter.getEndpoint2()
 	    print ('emitter.setEndpoint2(Point3(%f, %f, %f))' % (point[0], point[1], point[2]))
-	elif (self.emitterType == "Point"):
+	elif (self.emitterType == "PointEmitter"):
 	    print "# Point parameters"
 	    point = self.emitter.getLocation()
 	    print ('emitter.setLocation(Point3(%f, %f, %f))' % (point[0], point[1], point[2]))
-	elif (self.emitterType == "Rectangle"):
+	elif (self.emitterType == "RectangleEmitter"):
 	    print "# Rectangle parameters"
 	    bound = self.emitter.getMinBound()
 	    print ('emitter.setMinBound(Point2(%f, %f))' % (point[0], point[1]))
 	    bound = self.emitter.getMaxBound()
 	    print ('emitter.setMaxBound(Point2(%f, %f))' % (point[0], point[1]))
-	elif (self.emitterType == "Ring"):
+	elif (self.emitterType == "RingEmitter"):
 	    print "# Ring parameters"
 	    print 'emitter.setRadius(%f)' % self.emitter.getRadius()
 	    print 'emitter.setAngle(%f)' % self.emitter.getAngle()
-	elif (self.emitterType == "Sphere Surface"):
+	elif (self.emitterType == "SphereSurfaceEmitter"):
 	    print "# Sphere Surface parameters"
 	    print 'emitter.setRadius(%f)' % self.emitter.getRadius()
-	elif (self.emitterType == "Sphere Volume"):
+	elif (self.emitterType == "SphereVolumeEmitter"):
 	    print "# Sphere Volume parameters"
 	    print 'emitter.setRadius(%f)' % self.emitter.getRadius()
-	elif (self.emitterType == "Tangent Ring"):
+	elif (self.emitterType == "TangentRingEmitter"):
 	    print "# Tangent Ring parameters"
 	    print 'emitter.setRadius(%f)' % self.emitter.getRadius()

direct/src/showbase/showBase.cxx

@@ -100,10 +100,10 @@ PT(GraphicsPipe) make_graphics_pipe() {
   GraphicsPipe::resolve_modules();
 
   nout << "Known pipe types:" << endl;
-  GraphicsPipe::_factory.write_types(nout, 2);
+  GraphicsPipe::get_factory().write_types(nout, 2);
 
   // Create a window
-  main_pipe = GraphicsPipe::_factory.
+  main_pipe = GraphicsPipe::get_factory().
     make_instance(InteractiveGraphicsPipe::get_class_type());
 
   if (main_pipe == (GraphicsPipe*)0L) {

direct/src/tkpanels/ParticlePanel.py

@@ -106,11 +106,12 @@ class ParticlePanel(AppShell):
         hpr.addMenuItem('Popup Placer Panel', Placer.Placer)
 
         ## FACTORY PAGE ##
-        self.factorType = self.createOptionMenu(
+        self.factoryTypeMenu = self.createOptionMenu(
             factoryPage,
             'Factory', 'Factory Type',
             'Select type of particle factory',
-            ('Point', 'Z Spin', 'Oriented'),
+            ('PointParticleFactory', 'ZSpinParticleFactory',
+             'OrientedParticleFactory'),
             self.selectFactoryType)
         factoryWidgets = (
             ('Factory', 'Life Span',
@@ -141,9 +142,10 @@ class ParticlePanel(AppShell):
 
         self.factoryNotebook = Pmw.NoteBook(factoryPage, tabpos = None)
         # Point page #
-        factoryPointPage = self.factoryNotebook.add('Point')
+        factoryPointPage = self.factoryNotebook.add('PointParticleFactory')
+        Label(factoryPointPage, text = "").pack()
         # Z spin page #
-        zSpinPage = self.factoryNotebook.add('Z Spin')
+        zSpinPage = self.factoryNotebook.add('ZSpinParticleFactory')
         self.createAngleDial(zSpinPage, 'Z Spin Factory', 'Initial Angle',
                              'Starting angle in degrees',
                              command = self.setFactoryZSpinInitialAngle)
@@ -154,23 +156,24 @@ class ParticlePanel(AppShell):
                              'Spread of the final angle',
                              command = self.setFactoryZSpinAngleSpread)
         # Oriented page #
-        orientedPage = self.factoryNotebook.add('Oriented')
+        orientedPage = self.factoryNotebook.add('OrientedParticleFactory')
         Label(orientedPage, text = 'Not implemented').pack(expand = 1,
                                                            fill = BOTH)
-        self.factoryNotebook.pack(expand = 1, fill = BOTH)
+        #self.factoryNotebook.pack(expand = 1, fill = BOTH)
 
         ## EMITTER PAGE ##
-        self.createOptionMenu(emitterPage, 'Emitter',
-                              'Emitter type',
-                              'Select type of particle emitter',
-			      ('Box', 'Disc', 'Line', 'Point', 'Rectangle',
-                               'Ring', 'Sphere Volume', 'Sphere Surface',
-                               'Tangent Ring'),
-                              self.selectEmitterType)
+        self.emitterTypeMenu = self.createOptionMenu(
+            emitterPage, 'Emitter',
+            'Emitter type',
+            'Select type of particle emitter',
+            ('BoxEmitter', 'DiscEmitter', 'LineEmitter', 'PointEmitter',
+             'RectangleEmitter', 'RingEmitter', 'SphereVolumeEmitter',
+             'SphereSurfaceEmitter', 'TangentRingEmitter'),
+            self.selectEmitterType)
         
         self.emitterNotebook = Pmw.NoteBook(emitterPage, tabpos = None)
         # Box page #
-        boxPage = self.emitterNotebook.add('Box')
+        boxPage = self.emitterNotebook.add('BoxEmitter')
         self.createVector3Entry(boxPage, 'Box Emitter', 'Min',
                                 'Min point defining emitter box',
                                 command = self.setEmitterBoxPoint1)
@@ -182,7 +185,7 @@ class ParticlePanel(AppShell):
                                 'Initial particle velocity vector',
                                 command = self.setEmitterBoxVelocityVector)
         # Disc page #
-        discPage = self.emitterNotebook.add('Disc')
+        discPage = self.emitterNotebook.add('DiscEmitter')
         self.createFloater(discPage, 'Disc Emitter', 'Radius',
                            'Radius of disc',
                            command = self.setEmitterDiscRadius)
@@ -202,7 +205,7 @@ class ParticlePanel(AppShell):
             discPage, 'Disc Emitter', 'Cubic Lerping',
             self.toggleEmitterDiscCubicLerping, 0)
         # Line page #
-        linePage = self.emitterNotebook.add('Line')
+        linePage = self.emitterNotebook.add('LineEmitter')
         self.createVector3Entry(linePage, 'Line Emitter', 'Min',
                                 'Min point defining emitter line',
                                 command = self.setEmitterLinePoint1)
@@ -215,7 +218,7 @@ class ParticlePanel(AppShell):
                                 command = self.setEmitterLineVelocityVector,
                                 initialValue = (0.0, 0.0, 1.0))
         # Point page #
-        emitterPointPage = self.emitterNotebook.add('Point')
+        emitterPointPage = self.emitterNotebook.add('PointEmitter')
         self.createVector3Entry(emitterPointPage, 'Point Emitter', 'Position',
                                'Position of emitter point',
                                 command = self.setEmitterPointPosition)
@@ -225,7 +228,7 @@ class ParticlePanel(AppShell):
                                 command = self.setEmitterPointVelocityVector,
                                 initialValue = (0.0, 0.0, 1.0))
         # Rectangle #
-        rectanglePage = self.emitterNotebook.add('Rectangle')
+        rectanglePage = self.emitterNotebook.add('RectangleEmitter')
         self.createVector2Entry(rectanglePage,
                                 'Rectangle Emitter', 'Min',
                                'Point defining rectangle',
@@ -240,7 +243,7 @@ class ParticlePanel(AppShell):
             command = self.setEmitterRectangleVelocityVector,
             initialValue = (0.0, 0.0, 1.0))
         # Ring #
-        ringPage = self.emitterNotebook.add('Ring')
+        ringPage = self.emitterNotebook.add('RingEmitter')
         self.createFloater(ringPage, 'Ring Emitter', 'Radius',
                            'Radius of ring',
                            command = self.setEmitterRingRadius)
@@ -251,31 +254,34 @@ class ParticlePanel(AppShell):
                            'Launch velocity multiplier at outer edge of ring',
                            command = self.setEmitterRingVelocityMultiplier)
         # Sphere volume #
-        sphereVolumePage = self.emitterNotebook.add('Sphere Volume')
+        sphereVolumePage = self.emitterNotebook.add('SphereVolumeEmitter')
         self.createFloater(sphereVolumePage, 'Sphere Volume Emitter', 'Radius',
                            'Radius of sphere',
                            command = self.setEmitterSphereVolumeRadius)
         # Sphere surface #
-        sphereSurfacePage = self.emitterNotebook.add('Sphere Surface')
+        sphereSurfacePage = self.emitterNotebook.add('SphereSurfaceEmitter')
         self.createFloater(sphereSurfacePage, 'Sphere Surface Emitter',
                            'Radius',
                            'Radius of sphere',
                            command = self.setEmitterSphereSurfaceRadius)
         # Tangent ring # 
-        tangentRingPage = self.emitterNotebook.add('Tangent Ring')
+        tangentRingPage = self.emitterNotebook.add('TangentRingEmitter')
         self.createFloater(tangentRingPage, 'Tangent Ring Emitter', 'Radius',
                            'Radius of ring',
                            command = self.setEmitterTangentRingRadius)
         self.emitterNotebook.pack(fill = X)
 
         ## RENDERER PAGE ##
-        self.createOptionMenu(rendererPage, 'Renderer', 'Renderer type',
-                              'Select type of particle renderer',
-                              ('Line', 'Geom', 'Point', 'Sparkle', 'Sprite'),
-                              self.selectRendererType)
+        self.rendererTypeMenu = self.createOptionMenu(
+            rendererPage, 'Renderer', 'Renderer type',
+            'Select type of particle renderer',
+            ('LineParticleRenderer', 'GeomParticleRenderer',
+             'PointParticleRenderer', 'SparkleParticleRenderer',
+             'SpriteParticleRenderer'),
+            self.selectRendererType)
         self.rendererNotebook = Pmw.NoteBook(rendererPage, tabpos = None)
 	# Line page #
-	linePage = self.rendererNotebook.add('Line')
+	linePage = self.rendererNotebook.add('LineParticleRenderer')
 	self.createColorEntry(linePage, 'Line Renderer', 'Head Color',
 				'Head color of line',
 				command = self.setRendererLineHeadColor)
@@ -283,7 +289,7 @@ class ParticlePanel(AppShell):
 				'Tail color of line',
 				command = self.setRendererLineTailColor)
         # Geom page #
-        geomPage = self.rendererNotebook.add('Geom')
+        geomPage = self.rendererNotebook.add('GeomParticleRenderer')
         f = Frame(geomPage)
         f.pack(fill = X)
         Label(f, width = 12, text = 'Geom Node').pack(side = LEFT)
@@ -294,7 +300,7 @@ class ParticlePanel(AppShell):
         self.rendererGeomNodeEntry.bind('<Return>', self.setRendererGeomNode)
         self.rendererGeomNodeEntry.pack(side = LEFT, expand = 1, fill = X)
         # Point #
-        rendererPointPage = self.rendererNotebook.add('Point')
+        rendererPointPage = self.rendererNotebook.add('PointParticleRenderer')
         self.createFloater(rendererPointPage, 'Point Renderer', 'Point Size',
                            'Width and height of points in pixels',
                            command = self.setRendererPointSize)
@@ -319,7 +325,7 @@ class ParticlePanel(AppShell):
                                'PP_BLEND_CUBIC'),
                               self.rendererPointSelectBlendMethod)
         # Sparkle #
-        sparklePage = self.rendererNotebook.add('Sparkle')
+        sparklePage = self.rendererNotebook.add('SparkleParticleRenderer')
         self.createColorEntry(sparklePage, 'Sparkle Renderer',
                               'Center Color',
                               'Color of sparkle center',
@@ -342,7 +348,7 @@ class ParticlePanel(AppShell):
                               ('SP_NO_SCALE', 'SP_SCALE'),
                               self.setRendererSparkleLifeScale)
         # Sprite #
-        spritePage = self.rendererNotebook.add('Sprite')
+        spritePage = self.rendererNotebook.add('SpriteParticleRenderer')
         f = Frame(spritePage)
         f.pack(fill = X)
         Label(f, width = 12, text = 'Texture').pack(side = LEFT)
@@ -506,10 +512,13 @@ class ParticlePanel(AppShell):
         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()
             
     ## SYSTEM PAGE ##
@@ -554,6 +563,10 @@ class ParticlePanel(AppShell):
         self.factoryNotebook.selectpage(type)
 	self.particles.setFactory(type)
         self.updateFactoryWidgets()
+
+    def selectFactoryPage(self):
+        pass
+        
     def updateFactoryWidgets(self):
         factory = self.particles.factory
         lifespan = factory.getLifespanBase()
@@ -569,6 +582,7 @@ class ParticlePanel(AppShell):
         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):
@@ -595,6 +609,11 @@ class ParticlePanel(AppShell):
         self.emitterNotebook.selectpage(type)
 	self.particles.setEmitter(type)
         self.updateEmitterWidgets()
+
+    def selectEmitterPage(self):
+        type = self.particles.emitter.__class__.__name__
+        self.emitterNotebook.selectpage(type)
+        self.emitterTypeMenu.set(type)
         
     def updateEmitterWidgets(self):
         emitter = self.particles.emitter
@@ -722,6 +741,7 @@ class ParticlePanel(AppShell):
         self.rendererNotebook.selectpage(type)
 	self.particles.setRenderer(type)
         self.updateRendererWidgets()
+        
     def updateRendererWidgets(self):
         renderer = self.particles.renderer
         if isinstance(renderer, LineParticleRenderer):
@@ -806,7 +826,12 @@ class ParticlePanel(AppShell):
 	    elif (blendMethod == BaseParticleRenderer.PPBLENDCUBIC):
 		bMethod = "PP_BLEND_CUBIC"
             self.rendererSpriteAlphaDisable.set(renderer.getAlphaDisable())
-            
+
+    def selectRendererPage(self):
+        type = self.particles.renderer.__class__.__name__
+        self.rendererNotebook.selectpage(type)
+        self.rendererTypeMenu.set(type)
+        
     # Line #
     def setRendererLineHeadColor(self, color):
 	self.particles.renderer.setHeadColor(