+++ /dev/null
-#!/usr/bin/env python
-
-try:
- import numpy as N
- import numpy.random as RandomArray
- haveNumpy = True
- #print "Using numpy, version:", N.__version__
-except ImportError:
- # numpy isn't there
- haveNumpy = False
- errorText = (
- "The FloatCanvas requires the numpy module, version 1.* \n\n"
- "You can get info about it at:\n"
- "http://numpy.scipy.org/\n\n"
- )
-
-#---------------------------------------------------------------------------
-
-
-def BuildDrawFrame(): # this gets called when needed, rather than on import
- try:
- from floatcanvas import NavCanvas, FloatCanvas, Resources
- except ImportError: # if it's not there locally, try the wxPython lib.
- from wx.lib.floatcanvas import NavCanvas, FloatCanvas, Resources
- import wx.lib.colourdb
- import time, random
-
- class DrawFrame(wx.Frame):
-
- """
- A frame used for the FloatCanvas Demo
-
- """
-
-
- def __init__(self,parent, id,title,position,size):
- wx.Frame.__init__(self,parent, id,title,position, size)
-
- ## Set up the MenuBar
- MenuBar = wx.MenuBar()
-
- file_menu = wx.Menu()
- item = file_menu.Append(-1, "&Close","Close this frame")
- self.Bind(wx.EVT_MENU, self.OnQuit, item)
-
- item = file_menu.Append(-1, "&SavePNG","Save the current image as a PNG")
- self.Bind(wx.EVT_MENU, self.OnSavePNG, item)
- MenuBar.Append(file_menu, "&File")
-
- draw_menu = wx.Menu()
-
- item = draw_menu.Append(-1, "&Clear","Clear the Canvas")
- self.Bind(wx.EVT_MENU, self.Clear, item)
-
- item = draw_menu.Append(-1, "&Draw Test","Run a test of drawing random components")
- self.Bind(wx.EVT_MENU, self.DrawTest, item)
-
- item = draw_menu.Append(-1, "&Line Test","Run a test of drawing random lines")
- self.Bind(wx.EVT_MENU, self.LineTest, item)
-
- item = draw_menu.Append(-1, "Draw &Map","Run a test of drawing a map")
- self.Bind(wx.EVT_MENU, self.DrawMap, item)
-
- item = draw_menu.Append(-1, "&Text Test","Run a test of text drawing")
- self.Bind(wx.EVT_MENU, self.TestText, item)
-
- item = draw_menu.Append(-1, "&ScaledText Test","Run a test of text drawing")
- self.Bind(wx.EVT_MENU, self.TestScaledText, item)
-
- item = draw_menu.Append(-1, "&ScaledTextBox Test","Run a test of the Scaled Text Box")
- self.Bind(wx.EVT_MENU, self.TestScaledTextBox, item)
-
- item = draw_menu.Append(-1, "&Bitmap Test","Run a test of the Bitmap Object")
- self.Bind(wx.EVT_MENU, self.TestBitmap, item)
-
- item = draw_menu.Append(-1, "&Hit Test","Run a test of the hit test code")
- self.Bind(wx.EVT_MENU, self.TestHitTest, item)
-
- item = draw_menu.Append(-1, "Hit Test &Foreground","Run a test of the hit test code with a foreground Object")
- self.Bind(wx.EVT_MENU, self.TestHitTestForeground, item)
-
- item = draw_menu.Append(-1, "&Animation","Run a test of Animation")
- self.Bind(wx.EVT_MENU, self.TestAnimation, item)
-
- #item = draw_menu.Append(-1, "&Speed","Run a test of Drawing Speed")
- #self.Bind(wx.EVT_MENU, self.SpeedTest, item)
-
- item = draw_menu.Append(-1, "Change &Properties","Run a test of Changing Object Properties")
- self.Bind(wx.EVT_MENU, self.PropertiesChangeTest, item)
-
- item = draw_menu.Append(-1, "&Arrows","Run a test of Arrows")
- self.Bind(wx.EVT_MENU, self.ArrowTest, item)
-
- item = draw_menu.Append(-1, "&ArrowLine Test","Run a test of drawing Arrow Lines")
- self.Bind(wx.EVT_MENU, self.ArrowLineTest, item)
-
- item = draw_menu.Append(-1, "&Hide","Run a test of hiding and showing objects")
- self.Bind(wx.EVT_MENU, self.HideTest, item)
-
- MenuBar.Append(draw_menu, "&Tests")
-
- view_menu = wx.Menu()
- item = view_menu.Append(-1, "Zoom to &Fit","Zoom to fit the window")
- self.Bind(wx.EVT_MENU, self.ZoomToFit, item)
- MenuBar.Append(view_menu, "&View")
-
- help_menu = wx.Menu()
- item = help_menu.Append(-1, "&About",
- "More information About this program")
- self.Bind(wx.EVT_MENU, self.OnAbout, item)
- MenuBar.Append(help_menu, "&Help")
-
- self.SetMenuBar(MenuBar)
-
- self.CreateStatusBar()
-
-
- # Add the Canvas
- NC = NavCanvas.NavCanvas(self,
- Debug = 0,
- BackgroundColor = "DARK SLATE BLUE")
-
- self.Canvas = NC.Canvas # reference the contained FloatCanvas
-
- self.MsgWindow = wx.TextCtrl(self, wx.ID_ANY,
- "Look Here for output from events\n",
- style = (wx.TE_MULTILINE |
- wx.TE_READONLY |
- wx.SUNKEN_BORDER)
- )
-
- ##Create a sizer to manage the Canvas and message window
- MainSizer = wx.BoxSizer(wx.VERTICAL)
- MainSizer.Add(NC, 4, wx.EXPAND)
- MainSizer.Add(self.MsgWindow, 1, wx.EXPAND | wx.ALL, 5)
-
- self.SetSizer(MainSizer)
- self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
-
- self.Canvas.Bind(FloatCanvas.EVT_MOTION, self.OnMove)
- self.Canvas.Bind(FloatCanvas.EVT_MOUSEWHEEL, self.OnWheel)
-
- self.EventsAreBound = False
-
- ## getting all the colors for random objects
- wx.lib.colourdb.updateColourDB()
- self.colors = wx.lib.colourdb.getColourList()
-
-
- return None
-
- def Log(self, text):
- self.MsgWindow.AppendText(text)
- if not text[-1] == "\n":
- self.MsgWindow.AppendText("\n")
-
-
- def BindAllMouseEvents(self):
- if not self.EventsAreBound:
- ## Here is how you catch FloatCanvas mouse events
- self.Canvas.Bind(FloatCanvas.EVT_LEFT_DOWN, self.OnLeftDown)
- self.Canvas.Bind(FloatCanvas.EVT_LEFT_UP, self.OnLeftUp)
- self.Canvas.Bind(FloatCanvas.EVT_LEFT_DCLICK, self.OnLeftDouble)
-
- self.Canvas.Bind(FloatCanvas.EVT_MIDDLE_DOWN, self.OnMiddleDown)
- self.Canvas.Bind(FloatCanvas.EVT_MIDDLE_UP, self.OnMiddleUp)
- self.Canvas.Bind(FloatCanvas.EVT_MIDDLE_DCLICK, self.OnMiddleDouble)
-
- self.Canvas.Bind(FloatCanvas.EVT_RIGHT_DOWN, self.OnRightDown)
- self.Canvas.Bind(FloatCanvas.EVT_RIGHT_UP, self.OnRightUp)
- self.Canvas.Bind(FloatCanvas.EVT_RIGHT_DCLICK, self.OnRightDouble)
-
- self.EventsAreBound = True
-
-
- def UnBindAllMouseEvents(self):
- ## Here is how you unbind FloatCanvas mouse events
- self.Canvas.Unbind(FloatCanvas.EVT_LEFT_DOWN)
- self.Canvas.Unbind(FloatCanvas.EVT_LEFT_UP)
- self.Canvas.Unbind(FloatCanvas.EVT_LEFT_DCLICK)
-
- self.Canvas.Unbind(FloatCanvas.EVT_MIDDLE_DOWN)
- self.Canvas.Unbind(FloatCanvas.EVT_MIDDLE_UP)
- self.Canvas.Unbind(FloatCanvas.EVT_MIDDLE_DCLICK)
-
- self.Canvas.Unbind(FloatCanvas.EVT_RIGHT_DOWN)
- self.Canvas.Unbind(FloatCanvas.EVT_RIGHT_UP)
- self.Canvas.Unbind(FloatCanvas.EVT_RIGHT_DCLICK)
-
- self.EventsAreBound = False
-
-
- def PrintCoords(self,event):
- self.Log("coords are: %s"%(event.Coords,))
- self.Log("pixel coords are: %s\n"%(event.GetPosition(),))
-
- def OnSavePNG(self, event=None):
- import os
- dlg = wx.FileDialog(
- self, message="Save file as ...", defaultDir=os.getcwd(),
- defaultFile="", wildcard="*.png", style=wx.SAVE
- )
- if dlg.ShowModal() == wx.ID_OK:
- path = dlg.GetPath()
- if not(path[-4:].lower() == ".png"):
- path = path+".png"
- self.Canvas.SaveAsImage(path)
-
-
- def OnLeftDown(self, event):
- self.Log("LeftDown")
- self.PrintCoords(event)
-
- def OnLeftUp(self, event):
- self.Log("LeftUp")
- self.PrintCoords(event)
-
- def OnLeftDouble(self, event):
- self.Log("LeftDouble")
- self.PrintCoords(event)
-
- def OnMiddleDown(self, event):
- self.Log("MiddleDown")
- self.PrintCoords(event)
-
- def OnMiddleUp(self, event):
- self.Log("MiddleUp")
- self.PrintCoords(event)
-
- def OnMiddleDouble(self, event):
- self.Log("MiddleDouble")
- self.PrintCoords(event)
-
- def OnRightDown(self, event):
- self.Log("RightDown")
- self.PrintCoords(event)
-
- def OnRightUp(self, event):
- self.Log("RightUp")
- self.PrintCoords(event)
-
- def OnRightDouble(self, event):
- self.Log("RightDouble")
- self.PrintCoords(event)
-
- def OnWheel(self, event):
- self.Log("Mouse Wheel")
- self.PrintCoords(event)
- Rot = event.GetWheelRotation()
- Rot = Rot / abs(Rot) * 0.1
- if event.ControlDown(): # move left-right
- self.Canvas.MoveImage( (Rot, 0), "Panel" )
- else: # move up-down
- self.Canvas.MoveImage( (0, Rot), "Panel" )
-
- def OnMove(self, event):
- """
- Updates the status bar with the world coordinates
- """
- self.SetStatusText("%.2f, %.2f"%tuple(event.Coords))
- event.Skip()
-
- def OnAbout(self, event):
- dlg = wx.MessageDialog(self,
- "This is a small program to demonstrate\n"
- "the use of the FloatCanvas\n",
- "About Me",
- wx.OK | wx.ICON_INFORMATION)
- dlg.ShowModal()
- dlg.Destroy()
-
- def ZoomToFit(self,event):
- self.Canvas.ZoomToBB()
-
- def Clear(self,event = None):
- self.UnBindAllMouseEvents()
- self.Canvas.InitAll()
- self.Canvas.Draw()
-
- def OnQuit(self,event):
- self.Close(True)
-
- def OnCloseWindow(self, event):
- self.Destroy()
-
- def DrawTest(self,event=None):
- """
- This demo draws a few of everything
-
- """
-
- wx.GetApp().Yield(True)
-
- Range = (-10,10)
- colors = self.colors
-
- self.BindAllMouseEvents()
- Canvas = self.Canvas
-
- Canvas.InitAll()
- #
- ## these set the limits for how much you can zoom in and out
- Canvas.MinScale = 14
- Canvas.MaxScale = 500
-
-
- ############# Random tests of everything ##############
-
- # Rectangles
- for i in range(3):
- xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- lw = random.randint(1,5)
- cf = random.randint(0,len(colors)-1)
- wh = (random.randint(1,5), random.randint(1,5))
- Canvas.AddRectangle(xy, wh, LineWidth = lw, FillColor = colors[cf])
-
- # Ellipses
- for i in range(3):
- xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- lw = random.randint(1,5)
- cf = random.randint(0,len(colors)-1)
- h = random.randint(1,5)
- w = random.randint(1,5)
- Canvas.AddEllipse(xy, (h,w), LineWidth = lw,FillColor = colors[cf])
-
- # Points
- for i in range(5):
- xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- D = random.randint(1,50)
- cf = random.randint(0,len(colors)-1)
- Canvas.AddPoint(xy, Color = colors[cf], Diameter = D)
-
- # SquarePoints
- for i in range(500):
- xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- S = random.randint(1, 50)
- cf = random.randint(0,len(colors)-1)
- Canvas.AddSquarePoint(xy, Color = colors[cf], Size = S)
-
- # Circles
- for i in range(5):
- xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- D = random.randint(1,5)
- lw = random.randint(1,5)
- cf = random.randint(0,len(colors)-1)
- cl = random.randint(0,len(colors)-1)
- Canvas.AddCircle(xy, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf])
- Canvas.AddText("Circle # %i"%(i), xy, Size = 12, BackgroundColor = None, Position = "cc")
- # Lines
- for i in range(5):
- points = []
- for j in range(random.randint(2,10)):
- point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1]))
- points.append(point)
- lw = random.randint(1,10)
- cf = random.randint(0,len(colors)-1)
- cl = random.randint(0,len(colors)-1)
- Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl])
- # Polygons
- for i in range(3):
- points = []
- for j in range(random.randint(2,6)):
- point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- points.append(point)
- lw = random.randint(1,6)
- cf = random.randint(0,len(colors)-1)
- cl = random.randint(0,len(colors)-1)
- Canvas.AddPolygon(points,
- LineWidth = lw,
- LineColor = colors[cl],
- FillColor = colors[cf],
- FillStyle = 'Solid')
-
- ## Pointset
- for i in range(4):
- points = []
- points = RandomArray.uniform(Range[0],Range[1],(100,2))
- cf = random.randint(0,len(colors)-1)
- D = random.randint(1,4)
- Canvas.AddPointSet(points, Color = colors[cf], Diameter = D)
-
- # Text
- String = "Unscaled text"
- for i in range(3):
- ts = random.randint(10,40)
- cf = random.randint(0,len(colors)-1)
- xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- Canvas.AddText(String, xy, Size = ts, Color = colors[cf], Position = "cc")
-
- # Scaled Text
- String = "Scaled text"
- for i in range(3):
- ts = random.random()*3 + 0.2
- cf = random.randint(0,len(colors)-1)
- Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- Canvas.AddScaledText(String, Point, Size = ts, Color = colors[cf], Position = "cc")
-
- # Arrows
- N = 5
- Points = RandomArray.uniform(Range[0], Range[1], (N,2) )
- for i in range(N):
- Canvas.AddArrow(Points[i],
- random.uniform(20,100),
- Direction = random.uniform(0,360),
- LineWidth = random.uniform(1,5),
- LineColor = colors[random.randint(0,len(colors)-1)],
- ArrowHeadAngle = random.uniform(20,90))
-
- # ArrowLines
- for i in range(5):
- points = []
- for j in range(random.randint(2,10)):
- point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1]))
- points.append(point)
- lw = random.randint(1,10)
- cf = random.randint(0,len(colors)-1)
- cl = random.randint(0,len(colors)-1)
- Canvas.AddArrowLine(points, LineWidth = lw, LineColor = colors[cl], ArrowHeadSize= 16)
-
-
- Canvas.ZoomToBB()
-
- def TestAnimation(self,event=None):
- """
-
- In this test, a relatively complex background is drawn, and
- a simple object placed in the foreground is moved over
- it. This demonstrates how to use the InForeground attribute
- to make an object in the foregorund draw fast, without
- having to re-draw the whole background.
-
- """
- wx.GetApp().Yield(True)
- Range = (-10,10)
- self.Range = Range
-
- self.UnBindAllMouseEvents()
- Canvas = self.Canvas
- Canvas.InitAll()
-
- ## Random tests of everything:
- colors = self.colors
- # Rectangles
- for i in range(3):
- xy = (random.uniform(Range[0],Range[1]), random.uniform(Range[0],Range[1]))
- lw = random.randint(1,5)
- cf = random.randint(0,len(colors)-1)
- wh = (random.randint(1,5), random.randint(1,5) )
- Canvas.AddRectangle(xy, wh, LineWidth = lw, FillColor = colors[cf])
-
- # Ellipses
- for i in range(3):
- xy = (random.uniform(Range[0],Range[1]), random.uniform(Range[0],Range[1]))
- lw = random.randint(1,5)
- cf = random.randint(0,len(colors)-1)
- wh = (random.randint(1,5), random.randint(1,5) )
- Canvas.AddEllipse(xy, wh, LineWidth = lw, FillColor = colors[cf])
-
- # Circles
- for i in range(5):
- xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- D = random.randint(1,5)
- lw = random.randint(1,5)
- cf = random.randint(0,len(colors)-1)
- cl = random.randint(0,len(colors)-1)
- Canvas.AddCircle(xy, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf])
- Canvas.AddText("Circle # %i"%(i), xy, Size = 12, BackgroundColor = None, Position = "cc")
-
- # Lines
- for i in range(5):
- points = []
- for j in range(random.randint(2,10)):
- point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1]))
- points.append(point)
- lw = random.randint(1,10)
- cf = random.randint(0,len(colors)-1)
- cl = random.randint(0,len(colors)-1)
- Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl])
-
- # Polygons
- for i in range(3):
- points = []
- for j in range(random.randint(2,6)):
- point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- points.append(point)
- lw = random.randint(1,6)
- cf = random.randint(0,len(colors)-1)
- cl = random.randint(0,len(colors)-1)
- Canvas.AddPolygon(points,
- LineWidth = lw,
- LineColor = colors[cl],
- FillColor = colors[cf],
- FillStyle = 'Solid')
-
- # Scaled Text
- String = "Scaled text"
- for i in range(3):
- ts = random.random()*3 + 0.2
- cf = random.randint(0,len(colors)-1)
- xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- Canvas.AddScaledText(String, xy, Size = ts, Color = colors[cf], Position = "cc")
-
-
- # Now the Foreground Object:
- C = Canvas.AddCircle((0,0), 7, LineWidth = 2,LineColor = "Black",FillColor = "Red", InForeground = True)
- T = Canvas.AddScaledText("Click to Move", (0,0), Size = 0.6, Position = 'cc', InForeground = True)
- C.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.MoveMe)
- C.Text = T
-
- self.Timer = wx.PyTimer(self.ShowFrame)
- self.FrameDelay = 50 # milliseconds
-
- Canvas.ZoomToBB()
-
- def ShowFrame(self):
- Object = self.MovingObject
- Range = self.Range
- if self.TimeStep < self.NumTimeSteps:
- x,y = Object.XY
- if x > Range[1] or x < Range[0]:
- self.dx = -self.dx
- if y > Range[1] or y < Range[0]:
- self.dy = -self.dy
- Object.Move( (self.dx,self.dy) )
- Object.Text.Move( (self.dx,self.dy))
- self.Canvas.Draw()
- self.TimeStep += 1
- wx.GetApp().Yield(True)
- else:
- self.Timer.Stop()
-
-
- def MoveMe(self, Object):
- self.MovingObject = Object
- Range = self.Range
- self.dx = random.uniform(Range[0]/4,Range[1]/4)
- self.dy = random.uniform(Range[0]/4,Range[1]/4)
- #import time
- #start = time.time()
- self.NumTimeSteps = 200
- self.TimeStep = 1
- self.Timer.Start(self.FrameDelay)
- #print "Did %i frames in %f seconds"%(N, (time.time() - start) )
-
- def TestHitTest(self, event=None):
- wx.GetApp().Yield(True)
-
- self.UnBindAllMouseEvents()
- Canvas = self.Canvas
-
- Canvas.InitAll()
-
- #Add a Hit-able rectangle
- w, h = 60, 20
-
- dx = 80
- dy = 40
- x, y = 20, 20
- FontSize = 10
-
- #Add one that is not HitAble
- Canvas.AddRectangle((x,y), (w, h), LineWidth = 2)
- Canvas.AddText("Not Hit-able", (x,y), Size = FontSize, Position = "bl")
-
-
- x += dx
- R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2)
- R.Name = "Line Rectangle"
- R.HitFill = False
- R.HitLineWidth = 5 # Makes it a little easier to hit
- R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
- Canvas.AddText("Left Click Line", (x,y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x += dx
- color = "Red"
- R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
- R.Name = color + "Rectangle"
- R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
- Canvas.AddText("Left Click Fill", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x = 20
- y += dy
- color = "LightBlue"
- R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
- R.Name = color + " Rectangle"
- R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHit)
- Canvas.AddText("Right Click Fill", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x += dx
- color = "Grey"
- R = Canvas.AddEllipse((x, y), (w, h),LineWidth = 2,FillColor = color)
- R.Name = color +" Ellipse"
- R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHit)
- Canvas.AddText("Right Click Fill", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x += dx
- color = "Brown"
- R = Canvas.AddCircle((x+dx/2, y+dy/2), dx/4, LineWidth = 2, FillColor = color)
- R.Name = color + " Circle"
- R.HitFill = True
- R.Bind(FloatCanvas.EVT_FC_LEFT_DCLICK, self.RectGotHit)
- Canvas.AddText("Left D-Click Fill", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x = 20
- y += dy
- color = "Pink"
- R = Canvas.AddCircle((x+dx/2, y+dy/2), dx/4, LineWidth = 2,FillColor = color)
- R.Name = color + " Circle"
- R.Bind(FloatCanvas.EVT_FC_LEFT_UP, self.RectGotHit)
- Canvas.AddText("Left Up Fill", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x += dx
- color = "White"
- R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
- R.Name = color + " Rectangle"
- R.Bind(FloatCanvas.EVT_FC_MIDDLE_DOWN, self.RectGotHit)
- Canvas.AddText("Middle Down", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x += dx
- color = "AQUAMARINE"
- R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
- R.Name = color + " Rectangle"
- R.Bind(FloatCanvas.EVT_FC_MIDDLE_UP, self.RectGotHit)
- Canvas.AddText("Middle Up", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x = 20
- y += dy
- color = "CORAL"
- R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
- R.Name = color + " Rectangle"
- R.Bind(FloatCanvas.EVT_FC_MIDDLE_DCLICK, self.RectGotHit)
- Canvas.AddText("Middle DoubleClick", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x += dx
- color = "CYAN"
- R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
- R.Name = color + " Rectangle"
- R.Bind(FloatCanvas.EVT_FC_RIGHT_UP, self.RectGotHit)
- Canvas.AddText("Right Up", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x += dx
- color = "LIME GREEN"
- R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
- R.Name = color + " Rectangle"
- R.Bind(FloatCanvas.EVT_FC_RIGHT_DCLICK, self.RectGotHit)
- Canvas.AddText("Right Double Click", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x = 20
- y += dy
- color = "MEDIUM GOLDENROD"
- R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
- R.Name = color
- R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHitRight)
- R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
- Canvas.AddText("L and R Click", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x += dx
- color = "SALMON"
- R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
- R.Name = color + " Rectangle"
- R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
- Canvas.AddText("Mouse Enter", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x += dx
- color = "MEDIUM VIOLET RED"
- R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
- R.Name = color
- R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
- Canvas.AddText("Mouse Leave", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x = 20
- y += dy
- color = "SKY BLUE"
- R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color)
- R.Name = color
- R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
- R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
- Canvas.AddText("Enter and Leave", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x += dx
- color = "WHEAT"
- R = Canvas.AddRectangle((x, y), (w+12, h), LineColor = None, FillColor = color)
- R.Name = color
- R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
- R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
- Canvas.AddText("Mouse Enter&Leave", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x += dx
- color = "KHAKI"
- R = Canvas.AddRectangle((x-12, y), (w+12, h), LineColor = None, FillColor = color)
- R.Name = color
- R.Bind(FloatCanvas.EVT_FC_ENTER_OBJECT, self.RectMouseOver)
- R.Bind(FloatCanvas.EVT_FC_LEAVE_OBJECT, self.RectMouseLeave)
- Canvas.AddText("Mouse Enter&Leave", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x = 20
- y += dy
- L = Canvas.AddLine(( (x, y), (x+10, y+10), (x+w, y+h) ), LineWidth = 2, LineColor = "Red")
- L.Name = "A Line"
- L.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
- Canvas.AddText("Left Down", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(L.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x += dx
- color = "SEA GREEN"
- Points = N.array(( (x, y), (x, y+2.*h/3), (x+w, y+h), (x+w, y+h/2.), (x + 2.*w/3, y+h/2.), (x + 2.*w/3,y) ), N.float_)
- R = Canvas.AddPolygon(Points, LineWidth = 2, FillColor = color)
- R.Name = color + " Polygon"
- R.Bind(FloatCanvas.EVT_FC_RIGHT_DOWN, self.RectGotHitRight)
- Canvas.AddText("RIGHT_DOWN", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x += dx
- color = "Red"
- Points = N.array(( (x, y), (x, y+2.*h/3), (x+w, y+h), (x+w, y+h/2.), (x + 2.*w/3, y+h/2.), (x + 2.*w/3,y) ), N.float_)
- R = Canvas.AddPointSet(Points, Diameter = 4, Color = color)
- R.Name = "PointSet"
- R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.PointSetGotHit)
- Canvas.AddText("LEFT_DOWN", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Size = FontSize, Position = "tl")
-
- x = 20
- y += dy
- T = Canvas.AddText("Hit-able Text", (x, y), Size = 15, Color = "Red", Position = 'tl')
- T.Name = "Hit-able Text"
- T.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
- Canvas.AddText("Left Down", (x, y), Size = FontSize, Position = "bl")
-
- x += dx
- T = Canvas.AddScaledText("Scaled Text", (x, y), Size = 1./2*h, Color = "Pink", Position = 'bl')
- Canvas.AddPointSet( (x, y), Diameter = 3)
- T.Name = "Scaled Text"
- T.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHitLeft)
- Canvas.AddText("Left Down", (x, y), Size = FontSize, Position = "tl")
-
- x += dx
- color = "Cyan"
- Point = (x + w/2, y)
- #Points = N.array(( (x, y), (x, y+2.*h/3), (x+w, y+h), (x+w, y+h/2.), (x + 2.*w/3, y+h/2.), (x + 2.*w/3,y) ), N.float_)
- R = Canvas.AddSquarePoint(Point, Size = 8, Color = color)
- R.Name = "SquarePoint"
- R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
- Canvas.AddText("LEFT_DOWN", (x, y), Size = FontSize, Position = "bl")
- Canvas.AddText(R.Name, (x, y), Size = FontSize, Position = "tl")
-
-
- self.Canvas.ZoomToBB()
-
- def TestHitTestForeground(self,event=None):
- wx.GetApp().Yield(True)
-
- self.UnBindAllMouseEvents()
- Canvas = self.Canvas
-
- Canvas.InitAll()
-
- #Add a Hitable rectangle
- w, h = 60, 20
-
- dx = 80
- dy = 40
- x,y = 20, 20
-
- color = "Red"
- R = Canvas.AddRectangle((x, y), (w, h), LineWidth = 2, FillColor = color, InForeground = False)
- R.Name = color + "Rectangle"
- R.HitFill = True
- R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectGotHit)
- Canvas.AddText("Left Click Fill", (x, y), Position = "bl")
- Canvas.AddText(R.Name, (x, y+h), Position = "tl")
-
- ## A set of Rectangles that move together
-
- ## NOTE: In a real app, it might be better to create a new
- ## custom FloatCanvas DrawObject
-
- self.MovingRects = []
- WH = (w/2, h/2)
- x += dx
- color = "LightBlue"
- R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
- R.HitFill = True
- R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveLeft)
- L = Canvas.AddText("Left", (x + w/4, y + h/4), Position = "cc", InForeground = True)
- self.MovingRects.extend( (R,L) )
-
- x += w/2
- R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
- R.HitFill = True
- R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveRight)
- L = Canvas.AddText("Right", (x + w/4, y + h/4), Position = "cc", InForeground = True)
- self.MovingRects.extend( (R,L) )
-
- x -= w/2
- y += h/2
- R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
- R.HitFill = True
- R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveUp)
- L = Canvas.AddText("Up", (x + w/4, y + h/4), Position = "cc", InForeground = True)
- self.MovingRects.extend( (R,L) )
-
-
- x += w/2
- R = Canvas.AddRectangle((x, y), WH, LineWidth = 2, FillColor = color, InForeground = True)
- R.HitFill = True
- R.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RectMoveDown)
- L = Canvas.AddText("Down", (x + w/4, y + h/4), Position = "cc", InForeground = True)
- self.MovingRects.extend( (R,L) )
-
- self.Canvas.ZoomToBB()
-
- def RectMoveLeft(self,Object):
- self.MoveRects("left")
-
- def RectMoveRight(self,Object):
- self.MoveRects("right")
-
- def RectMoveUp(self,Object):
- self.MoveRects("up")
-
- def RectMoveDown(self,Object):
- self.MoveRects("down")
-
- def MoveRects(self, Dir):
- for Object in self.MovingRects:
- X,Y = Object.XY
- if Dir == "left": X -= 10
- elif Dir == "right": X += 10
- elif Dir == "up": Y += 10
- elif Dir == "down": Y -= 10
- Object.SetPoint((X,Y))
- self.Canvas.Draw()
-
- def PointSetGotHit(self, Object):
- self.Log(Object.Name + "Got Hit\n")
-
- def RectGotHit(self, Object):
- self.Log(Object.Name + "Got Hit\n")
-
- def RectGotHitRight(self, Object):
- self.Log(Object.Name + "Got Hit With Right\n")
-
- def RectGotHitLeft(self, Object):
- self.Log(Object.Name + "Got Hit with Left\n")
-
- def RectMouseOver(self, Object):
- self.Log("Mouse entered:" + Object.Name)
-
- def RectMouseLeave(self, Object):
- self.Log("Mouse left " + Object.Name)
-
-
- def TestText(self, event= None):
- wx.GetApp().Yield(True)
-
- self.BindAllMouseEvents()
- Canvas = self.Canvas
- Canvas.InitAll()
-
-
- DefaultSize = 12
- Point = (3, 0)
-
- ## Add a non-visible rectangle, just to get a Bounding Box
- ## Text objects have a zero-size bounding box, because it changes with zoom
- Canvas.AddRectangle((-10,-10),
- (20,20),
- LineWidth = 1,
- LineColor = None)
-
- # Text
- String = "Some text"
- self.Canvas.AddText("Top Left",Point,Size = DefaultSize,Color = "Yellow",BackgroundColor = "Blue", Position = "tl")
- self.Canvas.AddText("Bottom Left",Point,Size = DefaultSize,Color = "Cyan",BackgroundColor = "Black",Position = "bl")
- self.Canvas.AddText("Top Right",Point,Size = DefaultSize,Color = "Black",BackgroundColor = "Cyan",Position = "tr")
- self.Canvas.AddText("Bottom Right",Point,Size = DefaultSize,Color = "Blue",BackgroundColor = "Yellow",Position = "br")
- Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
-
- Point = (3, 2)
-
- Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
- self.Canvas.AddText("Top Center",Point,Size = DefaultSize,Color = "Black",Position = "tc")
- self.Canvas.AddText("Bottom Center",Point,Size = DefaultSize,Color = "White",Position = "bc")
-
- Point = (3, 4)
-
- Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
- self.Canvas.AddText("Center Right",Point,Size = DefaultSize,Color = "Black",Position = "cr")
- self.Canvas.AddText("Center Left",Point,Size = DefaultSize,Color = "Black",Position = "cl")
-
- Point = (3, -2)
-
- Canvas.AddPointSet((Point), Color = "White", Diameter = 2)
- self.Canvas.AddText("Center Center",
- Point, Size = DefaultSize,
- Color = "Black",
- Position = "cc")
-
- self.Canvas.AddText("40 Pixels", (-10,8), Size = 40)
- self.Canvas.AddText("20 Pixels", (-10,5), Size = 20)
- self.Canvas.AddText("10 Pixels", (-10,3), Size = 10)
-
- self.Canvas.AddText("MODERN Font", (-10, 0), Family = wx.MODERN)
- self.Canvas.AddText("DECORATIVE Font", (-10, -1), Family = wx.DECORATIVE)
- self.Canvas.AddText("ROMAN Font", (-10, -2), Family = wx.ROMAN)
- self.Canvas.AddText("SCRIPT Font", (-10, -3), Family = wx.SCRIPT)
- self.Canvas.AddText("ROMAN BOLD Font", (-10, -4), Family = wx.ROMAN, Weight=wx.BOLD)
- self.Canvas.AddText("ROMAN ITALIC BOLD Font", (-10, -5), Family = wx.ROMAN, Weight=wx.BOLD, Style=wx.ITALIC)
-
- # NOTE: this font exists on my Linux box..who knows were else you'll find it!
- Font = wx.Font(20, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "helvetica")
- self.Canvas.AddText("Helvetica Italic", (-10, -6), Font = Font)
-
- self.Canvas.ZoomToBB()
-
- def TestScaledText(self, event= None):
- wx.GetApp().Yield(True)
-
- self.BindAllMouseEvents()
- Canvas = self.Canvas
- Canvas.InitAll()
-
- Point = (0, 0)
-
- T = Canvas.AddScaledText("Top Left",
- Point,
- Size = 5,
- Color = "Yellow",
- BackgroundColor = "Blue",
- Position = "tl")
- T = Canvas.AddScaledText("Bottom Left",Point,Size = 5,Color = "Cyan",BackgroundColor = "Black",Position = "bl")
- T = Canvas.AddScaledText("Top Right",Point,Size = 5,Color = "Black",BackgroundColor = "Cyan",Position = "tr")
- T = Canvas.AddScaledText("Bottom Right",Point,Size = 5,Color = "Blue",BackgroundColor = "Yellow",Position = "br")
- Canvas.AddPointSet((Point), Color = "Red", Diameter = 4)
-
-
- Point = (0, 20)
-
- Canvas.AddScaledText("Top Center",Point,Size = 7,Color = "Black",Position = "tc")
- Canvas.AddScaledText("Bottom Center",Point,Size = 7,Color = "White",Position = "bc")
- Canvas.AddPointSet((Point), Color = "White", Diameter = 4)
-
- Point = (0, -20)
-
- Canvas.AddScaledText("Center Right",Point,Size = 9,Color = "Black",Position = "cr")
- Canvas.AddScaledText("Center Left",Point,Size = 9,Color = "Black",Position = "cl")
- Canvas.AddPointSet((Point), Color = "White", Diameter = 4)
-
- x = -200
-
- self.Canvas.AddScaledText("MODERN Font", (x, 0), Size = 7, Family = wx.MODERN, Color = (0,0,0))
- self.Canvas.AddScaledText("DECORATIVE Font", (x, -10), Size = 7, Family = wx.DECORATIVE, Color = (0,0,1))
- self.Canvas.AddScaledText("ROMAN Font", (x, -20), Size = 7, Family = wx.ROMAN)
- self.Canvas.AddScaledText("SCRIPT Font", (x, -30), Size = 7, Family = wx.SCRIPT)
- self.Canvas.AddScaledText("ROMAN BOLD Font", (x, -40), Size = 7, Family = wx.ROMAN, Weight=wx.BOLD)
- self.Canvas.AddScaledText("ROMAN ITALIC BOLD Font", (x, -50), Size = 7, Family = wx.ROMAN, Weight=wx.BOLD, Style=wx.ITALIC)
- Canvas.AddPointSet((x,0), Color = "White", Diameter = 4)
-
-
- # NOTE: this font exists on my OS-X.who knows were else you'll find it!
- Point = (-100, 50)
- Font = wx.Font(12, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "helvetica")
- T = self.Canvas.AddScaledText("Helvetica Italic", Point, Size = 20, Font = Font, Position = 'bc')
-
- Point = (-50, -50)
- Font = wx.Font(12, wx.DEFAULT, wx.ITALIC, wx.NORMAL, False, "times")
- T = self.Canvas.AddScaledText("Times Font", Point, Size = 8, Font = Font)
-
- self.Canvas.ZoomToBB()
-
- def TestScaledTextBox(self, event= None):
- wx.GetApp().Yield(True)
-
- self.UnBindAllMouseEvents()
- Canvas = self.Canvas
- Canvas.InitAll()
-
- Point = (45,40)
- Box = Canvas.AddScaledTextBox("A Two Line\nString",
- Point,
- 2,
- Color = "Black",
- BackgroundColor = None,
- LineColor = "Red",
- LineStyle = "Solid",
- LineWidth = 1,
- Width = None,
- PadSize = 5,
- Family = wx.ROMAN,
- Style = wx.NORMAL,
- Weight = wx.NORMAL,
- Underlined = False,
- Position = 'br',
- Alignment = "left",
- InForeground = False)
-
- # All defaults
- Box = Canvas.AddScaledTextBox("A Two Line\nString",
- Point,
- 2)
-
- Box = Canvas.AddScaledTextBox("A Two Line\nString",
- Point,
- 2,
- BackgroundColor = "Yellow",
- LineColor = "Red",
- LineStyle = "Solid",
- PadSize = 5,
- Family = wx.TELETYPE,
- Position = 'bl')
-
- Box = Canvas.AddScaledTextBox("A String\nThis box is clickable",
- Point,
- 2,
- BackgroundColor = "Yellow",
- LineColor = "Red",
- LineStyle = "Solid",
- PadSize = 5,
- Family = wx.TELETYPE,
- Position = 'tr')
-
- Box.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.binding2)
-
- Canvas.AddPoint(Point, Diameter = 4)
-
- Point = (45,15)
- Box = Canvas.AddScaledTextBox("A Two Line\nString",
- Point,
- 2,
- Color = "Black",
- BackgroundColor = 'Red',
- LineColor = "Blue",
- LineStyle = "LongDash",
- LineWidth = 2,
- Width = None,
- PadSize = 5,
- Family = wx.TELETYPE,
- Style = wx.NORMAL,
- Weight = wx.NORMAL,
- Underlined = False,
- Position = 'cr',
- Alignment = "left",
- InForeground = False)
-
- Box = Canvas.AddScaledTextBox("A Two Line\nString",
- Point,
- 1.5,
- Color = "Black",
- BackgroundColor = 'Red',
- LineColor = "Blue",
- LineStyle = "LongDash",
- LineWidth = 2,
- Width = None,
- PadSize = 5,
- Family = wx.TELETYPE,
- Style = wx.NORMAL,
- Weight = wx.NORMAL,
- Underlined = False,
- Position = 'cl',
- Alignment = "left",
- InForeground = False)
-
- Canvas.AddPoint(Point, Diameter = 4)
-
- Point = (45,-10)
- Box = Canvas.AddScaledTextBox("A Two Line\nString",
- Point,
- 2,
- Color = "Black",
- BackgroundColor = 'Red',
- LineColor = "Blue",
- LineStyle = "LongDash",
- LineWidth = 2,
- Width = None,
- PadSize = 3,
- Family = wx.TELETYPE,
- Style = wx.NORMAL,
- Weight = wx.NORMAL,
- Underlined = False,
- Position = 'tc',
- Alignment = "left",
- InForeground = False)
-
- Box = Canvas.AddScaledTextBox("A three\nLine\nString",
- Point,
- 1.5,
- Color = "Black",
- BackgroundColor = 'Red',
- LineColor = "Blue",
- LineStyle = "LongDash",
- LineWidth = 2,
- Width = None,
- PadSize = 0.5,
- Family = wx.TELETYPE,
- Style = wx.NORMAL,
- Weight = wx.NORMAL,
- Underlined = False,
- Position = 'bc',
- Alignment = "left",
- InForeground = False)
-
-
- Canvas.AddPoint(Point, Diameter = 4)
-
- Box = Canvas.AddScaledTextBox("Some Auto Wrapped Text. There is enough to do.",
- (80,40),
- 2,
- BackgroundColor = 'White',
- LineWidth = 2,
- Width = 20,
- PadSize = 0.5,
- Family = wx.TELETYPE,
- )
-
- Box = Canvas.AddScaledTextBox("Some more auto wrapped text. Wrapped to a different width.\n\nThis is another paragraph.",
- (80,20),
- 2,
- BackgroundColor = 'White',
- LineWidth = 2,
- Width = 40,
- PadSize = 0.5,
- Family = wx.ROMAN,
- Alignment = "right"
- )
- Point = N.array((100, -20), N.float_)
- Box = Canvas.AddScaledTextBox("Here is even more auto wrapped text. This time the line spacing is set to 0.8. \n\nThe Padding is set to 0.",
- Point,
- Size = 3,
- BackgroundColor = 'White',
- LineWidth = 1,
- Width = 40,
- PadSize = 0.0,
- Family = wx.ROMAN,
- Position = "cc",
- LineSpacing = 0.8
- )
- Canvas.AddPoint(Point, "Red", 2)
-
- Point = N.array((0, -40), N.float_)
- # Point = N.array((0, 0), N.float_)
- for Position in ["tl", "bl", "tr", "br"]:
- # for Position in ["br"]:
- Box = Canvas.AddScaledTextBox("Here is a\nfour liner\nanother line\nPosition=%s"%Position,
- Point,
- Size = 4,
- Color = "Red",
- BackgroundColor = None,#'LightBlue',
- LineWidth = 1,
- LineColor = "White",
- Width = None,
- PadSize = 2,
- Family = wx.ROMAN,
- Position = Position,
- LineSpacing = 0.8
- )
- Canvas.AddPoint(Point, "Red", 4)
-
- Point = N.array((-20, 60), N.float_)
- Box = Canvas.AddScaledTextBox("Here is some\ncentered\ntext",
- Point,
- Size = 4,
- Color = "Red",
- BackgroundColor = 'LightBlue',
- LineWidth = 1,
- LineColor = "White",
- Width = None,
- PadSize = 2,
- Family = wx.ROMAN,
- Position = "tl",
- Alignment = "center",
- LineSpacing = 0.8
- )
-
- Point = N.array((-20, 20), N.float_)
- Box = Canvas.AddScaledTextBox("Here is some\nright aligned\ntext",
- Point,
- Size = 4,
- Color = "Red",
- BackgroundColor = 'LightBlue',
- LineColor = None,
- Width = None,
- PadSize = 2,
- Family = wx.ROMAN,
- Position = "tl",
- Alignment = "right",
- LineSpacing = 0.8
- )
-
- Point = N.array((100, -60), N.float_)
- Box = Canvas.AddScaledTextBox("Here is some auto wrapped text. This time it is centered, rather than right aligned.\n\nThe Padding is set to 2.",
- Point,
- Size = 3,
- BackgroundColor = 'White',
- LineWidth = 1,
- Width = 40,
- PadSize = 2.0,
- Family = wx.ROMAN,
- Position = "cc",
- LineSpacing = 0.8,
- Alignment = 'center',
- )
-
-
-
-
- self.Canvas.ZoomToBB()
-
- def binding2(self, event):
- self.Log("I'm the TextBox")
-
- def TestBitmap(self, event= None):
- wx.GetApp().Yield(True)
-
- self.UnBindAllMouseEvents()
- Canvas = self.Canvas
- Canvas.InitAll()
-
- Canvas.AddRectangle((10, 20),
- (400, 100),
- LineWidth = 3,
- LineColor = "Blue",
- FillColor = "Red")
-
- bmp = Resources.getMagPlusBitmap()
-
- Canvas.AddText("These are Unscaled Bitmaps:", (140, 90))
-
- Point = (150, 50)
- BitMap = Canvas.AddBitmap(bmp, Point, Position = "cc" )
- Canvas.AddPoint(Point, Diameter=4, Color="Green")
-
- Point = (200, 50)
- BitMap = Canvas.AddBitmap(bmp, Point, Position = "br" )
- Canvas.AddPoint(Point, Diameter=4, Color="Green")
-
- Point = (200, 50)
- BitMap = Canvas.AddBitmap(bmp, Point, Position = "bl" )
- Canvas.AddPoint(Point, Diameter=4, Color="Green")
-
- Point = (200, 50)
- BitMap = Canvas.AddBitmap(bmp, Point, Position = "tr" )
- Canvas.AddPoint(Point, Diameter=4, Color="Green")
-
- Point = (200, 50)
- BitMap = Canvas.AddBitmap(bmp, Point, Position = "tl" )
- Canvas.AddPoint(Point, Diameter=4, Color="Green")
-
- Point = (250, 50)
- BitMap = Canvas.AddBitmap(bmp, Point, Position = "cr" )
- Canvas.AddPoint(Point, Diameter=4, Color="Green")
-
- Point = (250, 50)
- BitMap = Canvas.AddBitmap(bmp, Point, Position = "cl" )
- Canvas.AddPoint(Point, Diameter=4, Color="Green")
-
- Point = (300, 50)
- BitMap = Canvas.AddBitmap(bmp, Point, Position = "tc" )
- Canvas.AddPoint(Point, Diameter=4, Color="Green")
-
- Point = (300, 50)
- BitMap = Canvas.AddBitmap(bmp, Point, Position = "bc" )
- Canvas.AddPoint(Point, Diameter=4, Color="Green")
-
- Canvas.AddScaledText("These are Scaled Bitmaps:", (220, -60), Size = 10, Position = "tr")
- Point = (250, -100)
- BitMap = Canvas.AddScaledBitmap(bmp, Point, Height = 50, Position = "bc" )
- BitMap = Canvas.AddScaledBitmap(bmp, Point, Height = 50, Position = "tc" )
- Canvas.AddPoint(Point, Diameter=4, Color="Green")
-
- Point = (300, -100)
- BitMap = Canvas.AddScaledBitmap(Resources.getMondrianImage(), Point, Height = 50)
-
- self.Canvas.ZoomToBB()
-
- def DrawMap(self,event = None):
- wx.GetApp().Yield(True)
- import os, time
-
- self.Canvas.InitAll()
- self.Canvas.SetProjectionFun("FlatEarth")
- self.BindAllMouseEvents()
-
- ## Test of Actual Map Data
- #start = time.clock()
- self.Log("Loading Map from a File")
- wx.GetApp().Yield(True) # so log text will get displayed now.
- Shorelines = self.Read_MapGen(os.path.join("data",'world.dat'),stats = 0)
- #print "It took %f seconds to load %i shorelines"%(time.clock() - start,len(Shorelines) )
- #start = time.clock()
- for segment in Shorelines:
- self.Canvas.AddLine(segment)
- #print "It took %f seconds to add %i shorelines"%(time.clock() - start,len(Shorelines) )
- #start = time.clock()
- self.Canvas.ZoomToBB()
- #print "It took %f seconds to draw %i shorelines"%(time.clock() - start,len(Shorelines) )
-
-
-
- def LineTest(self,event = None):
- wx.GetApp().Yield(True)
- import os, time
-# import random
- colors = self.colors
- Range = (-10,10)
- ## Test of drawing lots of lines
- Canvas = self.Canvas
- Canvas.InitAll()
- #start = time.clock()
- linepoints = []
- linecolors = []
- linewidths = []
- for i in range(2000):
- points = (random.randint(Range[0],Range[1]),
- random.randint(Range[0],Range[1]),
- random.randint(Range[0],Range[1]),
- random.randint(Range[0],Range[1]))
- linepoints.append(points)
- linewidths.append(random.randint(1,10) )
- linecolors.append(random.randint(0,len(colors)-1) )
- for (points,color,width) in zip(linepoints,linecolors,linewidths):
- Canvas.AddLine((points[0:2],points[2:4]), LineWidth = width, LineColor = colors[color])
- #print "It took %f seconds to add %i lines"%(time.clock() - start,len(linepoints) )
- #start = time.clock()
- Canvas.ZoomToBB()
- #print "It took %f seconds to draw %i lines"%(time.clock() - start,len(linepoints) )
-
- def ArrowLineTest(self,event = None):
- wx.GetApp().Yield(True)
- Canvas = self.Canvas
- Canvas.InitAll()
- # import os, time
-## import random
- Range = (-100,100)
- colors = self.colors
-
- # Lines
- for i in range(5):
- points = []
- for j in range(random.randint(2,10)):
- point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1]))
- points.append(point)
- lw = random.randint(1,4)
- cf = random.randint(0,len(colors)-1)
- cl = random.randint(0,len(colors)-1)
- al = random.randint(8,20)
- aa = random.randint(20,90)
- Canvas.AddArrowLine(points,
- LineWidth = lw,
- LineColor = colors[cl],
- ArrowHeadSize = al,
- ArrowHeadAngle = aa)
-
- Canvas.ZoomToBB()
-
- def SpeedTest(self,event=None):
- wx.GetApp().Yield(True)
- BigRange = (-1000,1000)
- colors = self.colors
-
- self.UnBindAllMouseEvents()
- Canvas = self.Canvas
-
- Canvas.InitAll()
-
- # Pointset
- coords = []
- for i in range(1000):
- Point = (random.uniform(BigRange[0],BigRange[1]),random.uniform(BigRange[0],BigRange[1]))
- coords.append( (Point) )
- print "Drawing the Points"
- start = time.clock()
- for Point in coords:
- Canvas.AddPoint(Point, Diameter = 4)
- print "It took %s seconds to add the points"%(time.clock() - start)
- Canvas.ZoomToBB()
-
- def PropertiesChangeTest(self,event=None):
- wx.GetApp().Yield(True)
-
- Range = (-10,10)
- colors = self.colors
-
- self.UnBindAllMouseEvents()
- Canvas = self.Canvas
-
- Canvas.InitAll()
-
- self.ColorObjectsAll = []
- self.ColorObjectsLine = []
- self.ColorObjectsColor = []
- self.ColorObjectsText = []
- ##One of each object:
- # Rectangle
- Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- lw = random.randint(1,5)
- cf = random.randint(0,len(colors)-1)
- wh = ( random.randint(1,5), random.randint(1,5) )
- self.Rectangle = Canvas.AddRectangle(Point, wh, LineWidth = lw, FillColor = colors[cf])
- self.ColorObjectsAll.append(self.Rectangle)
-
- # Ellipse
- Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- lw = random.randint(1,5)
- cf = random.randint(0,len(colors)-1)
- wh = ( random.randint(1,5), random.randint(1,5) )
- self.Ellipse = Canvas.AddEllipse(Point, wh, LineWidth = lw, FillColor = colors[cf])
- self.ColorObjectsAll.append(self.Ellipse)
-
- # Point
- xy = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- D = random.randint(1,50)
- lw = random.randint(1,5)
- cf = random.randint(0,len(colors)-1)
- cl = random.randint(0,len(colors)-1)
- self.ColorObjectsColor.append(Canvas.AddPoint(xy, colors[cf], D))
-
- # Circle
- Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- D = random.randint(1,5)
- lw = random.randint(1,5)
- cf = random.randint(0,len(colors)-1)
- cl = random.randint(0,len(colors)-1)
- self.Circle = Canvas.AddCircle(Point, D, LineWidth = lw, LineColor = colors[cl], FillColor = colors[cf])
- self.ColorObjectsAll.append(self.Circle)
-
- # Line
- points = []
- for j in range(random.randint(2,10)):
- point = (random.randint(Range[0],Range[1]),random.randint(Range[0],Range[1]))
- points.append(point)
- lw = random.randint(1,10)
- cf = random.randint(0,len(colors)-1)
- cl = random.randint(0,len(colors)-1)
- self.ColorObjectsLine.append(Canvas.AddLine(points, LineWidth = lw, LineColor = colors[cl]))
-
- # Polygon
-## points = []
-## for j in range(random.randint(2,6)):
-## point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
-## points.append(point)
- points = RandomArray.uniform(Range[0],Range[1],(6,2))
- lw = random.randint(1,6)
- cf = random.randint(0,len(colors)-1)
- cl = random.randint(0,len(colors)-1)
- self.ColorObjectsAll.append(Canvas.AddPolygon(points,
- LineWidth = lw,
- LineColor = colors[cl],
- FillColor = colors[cf],
- FillStyle = 'Solid'))
-
- ## Pointset
- points = RandomArray.uniform(Range[0],Range[1],(100,2))
- cf = random.randint(0,len(colors)-1)
- D = random.randint(1,4)
- self.PointSet = Canvas.AddPointSet(points, Color = colors[cf], Diameter = D)
- self.ColorObjectsColor.append(self.PointSet)
-
- ## Point
- point = RandomArray.uniform(Range[0],Range[1],(2,))
- cf = random.randint(0,len(colors)-1)
- D = random.randint(1,4)
- self.Point = Canvas.AddPoint(point, Color = colors[cf], Diameter = D)
- self.ColorObjectsColor.append(self.Point)
-
- # Text
- String = "Unscaled text"
- ts = random.randint(10,40)
- cf = random.randint(0,len(colors)-1)
- Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- self.ColorObjectsText.append(Canvas.AddText(String, Point, Size = ts, Color = colors[cf], Position = "cc"))
-
- # Scaled Text
- String = "Scaled text"
- ts = random.random()*3 + 0.2
- cf = random.randint(0,len(colors)-1)
- Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- self.ColorObjectsText.append(Canvas.AddScaledText(String, Point, Size = ts, Color = colors[cf], Position = "cc"))
-
- # A "Button"
- Button = Canvas.AddRectangle((-10, -12), (20, 3), LineStyle = None, FillColor = "Red")
- Canvas.AddScaledText("Click Here To Change Properties",
- (0, -10.5),
- Size = 0.7,
- Color = "Black",
- Position = "cc")
-
- Button.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.ChangeProperties)
-
- Canvas.ZoomToBB()
-
- def ChangeProperties(self, Object = None):
- colors = self.colors
- Range = (-10,10)
-
- for Object in self.ColorObjectsAll:
- pass
- Object.SetFillColor(colors[random.randint(0,len(colors)-1)])
- Object.SetLineColor(colors[random.randint(0,len(colors)-1)])
- Object.SetLineWidth(random.randint(1,7))
- Object.SetLineStyle(FloatCanvas.DrawObject.LineStyleList.keys()[random.randint(0,5)])
- for Object in self.ColorObjectsLine:
- Object.SetLineColor(colors[random.randint(0,len(colors)-1)])
- Object.SetLineWidth(random.randint(1,7))
- Object.SetLineStyle(FloatCanvas.DrawObject.LineStyleList.keys()[random.randint(0,5)])
- for Object in self.ColorObjectsColor:
- Object.SetColor(colors[random.randint(0,len(colors)-1)])
- for Object in self.ColorObjectsText:
- Object.SetColor(colors[random.randint(0,len(colors)-1)])
- Object.SetBackgroundColor(colors[random.randint(0,len(colors)-1)])
- self.Circle.SetDiameter(random.randint(1,10))
- self.PointSet.SetDiameter(random.randint(1,8))
- self.Point.SetDiameter(random.randint(1,8))
- for Object in (self.Rectangle, self.Ellipse):
- Point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- wh = ( random.randint(1,5), random.randint(1,5) )
- Object.SetShape(Point, wh)
- self.Canvas.Draw(Force = True)
-
- def ArrowTest(self,event=None):
- wx.GetApp().Yield(True)
- self.UnBindAllMouseEvents()
- Canvas = self.Canvas
-
- Canvas.InitAll()
- Canvas.MinScale = 15
- Canvas.MaxScale = 30
-
- # put in a rectangle to get a bounding box
- Canvas.AddRectangle((0,0), (20,20), LineColor = None)
-
- # Draw some Arrows
- Canvas.AddArrow((10,10),Length = 40, Direction = 0)
- Canvas.AddArrow((10,10),Length = 50, Direction = 45 ,LineWidth = 2, LineColor = "Black", ArrowHeadAngle = 20)
- Canvas.AddArrow((10,10),Length = 60, Direction = 90 ,LineWidth = 3, LineColor = "Red", ArrowHeadAngle = 30)
- Canvas.AddArrow((10,10),Length = 70, Direction = 135,LineWidth = 4, LineColor = "Red", ArrowHeadAngle = 40)
- Canvas.AddArrow((10,10),Length = 80, Direction = 180,LineWidth = 5, LineColor = "Blue", ArrowHeadAngle = 50)
- Canvas.AddArrow((10,10),Length = 90, Direction = 225,LineWidth = 4, LineColor = "Blue", ArrowHeadAngle = 60)
- Canvas.AddArrow((10,10),Length = 100,Direction = 270,LineWidth = 3, LineColor = "Green", ArrowHeadAngle = 70)
- Canvas.AddArrow((10,10),Length = 110,Direction = 315,LineWidth = 2, LineColor = "Green", ArrowHeadAngle = 90 )
-
- Canvas.AddText("Clickable Arrow", (4,18), Position = "bc")
- Arrow = Canvas.AddArrow((4,18), 80, Direction = 90 ,LineWidth = 3, LineColor = "Red", ArrowHeadAngle = 30)
- Arrow.HitLineWidth = 6
- Arrow.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.ArrowClicked)
-
- Canvas.AddText("Changable Arrow: try clicking it", (16,4), Position = "tc")
- self.RotArrow = Canvas.AddArrow((16,4), 80, Direction = 0 ,LineWidth = 3, LineColor = "Green", ArrowHeadAngle = 30)
- self.RotArrow.HitLineWidth = 6
- self.RotArrow.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.RotateArrow)
-
- Canvas.ZoomToBB()
-
- def ArrowClicked(self,event):
- self.Log("The Arrow was Clicked")
-
- def RotateArrow(self,event):
- ##print "The Changeable Arrow was Clicked"
- ## You can do them either one at a time, or both at once
- ## Doing them both at once prevents the arrow points from being calculated twice
- #self.RotArrow.SetDirection(self.RotArrow.Direction + random.uniform(-90,90))
- #self.RotArrow.SetLength(self.RotArrow.Length + random.randint(-20,20))
- self.RotArrow.SetLengthDirection(self.RotArrow.Length + random.randint(-20,20),
- self.RotArrow.Direction + random.uniform(-90,90) )
-
- self.Canvas.Draw(Force = True)
-
- def HideTest(self, event=None):
- wx.GetApp().Yield(True)
-
- self.UnBindAllMouseEvents()
- Canvas = self.Canvas
- Canvas.InitAll()
-
- Range = (-10,10)
-
- # Create a couple random Polygons
- points = []
- for j in range(6):
- point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- points.append(point)
- Poly = Canvas.AddPolygon(points,
- LineWidth = 2,
- LineColor = "Black",
- FillColor = "LightBlue",
- FillStyle = 'Solid')
-
- points = []
- for j in range(6):
- point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- points.append(point)
- Poly2 = Canvas.AddPolygon(points,
- LineWidth = 2,
- LineColor = "Black",
- FillColor = "Purple",
- FillStyle = 'Solid',
- InForeground = True)
-
- HideButton = Canvas.AddScaledTextBox("Click To Hide\nBackground Polygon",
- (-10, 0),
- .5,
- BackgroundColor="Red",
- PadSize = 0.5,
- Position = 'tr',
- Alignment="center",
- )
- HideButton.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.HidePoly)
- HideButton.HidePoly = Poly
-
- HideButton2 = Canvas.AddScaledTextBox("Click To Hide\nForeground Polygon",
- (-10, 5),
- .5,
- BackgroundColor="Red",
- PadSize = 0.5,
- Position = 'tr',
- Alignment="center",
- )
- # Put a reference to the Polygon in the Button object
- HideButton2.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.HidePoly)
- HideButton2.HidePoly = Poly2
-
-
- Canvas.ZoomToBB()
-
- def HidePoly(self, Button):
- Poly = Button.HidePoly
-
- if Poly.Visible:
- Poly.Visible = False
- Button.SetText(Button.String.replace("Hide","Show"))
- else:
- Poly.Visible = True
- Button.SetText(Button.String.replace("Show", "Hide"))
- self.Canvas.Draw(True)
-
-
- def TempTest(self, event= None):
- """
-
- This is the start of a poly editor test, but it's not complete
- so you can only run it through a command line flag:
-
- python FloatCanvasDemo.py --temp
-
- """
-
- wx.GetApp().Yield(True)
-
- self.UnBindAllMouseEvents()
- Canvas = self.Canvas
- Canvas.InitAll()
-
- Range = (-10,10)
-
- # Create a random Polygon
- points = []
- for j in range(6):
- point = (random.uniform(Range[0],Range[1]),random.uniform(Range[0],Range[1]))
- points.append(point)
- Poly = Canvas.AddPolygon(points,
- LineWidth = 2,
- LineColor = "Black",
- FillColor = "LightBlue",
- FillStyle = 'Solid')
-
- Poly.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.SelectPoly)
-
- self.SelectedPoly = None
- self.SelectPoints = []
- self.SelectedPoint = None
-
- Canvas.ZoomToBB()
-
- def SelectPoly(self, Object):
- Canvas = self.Canvas
- if Object is self.SelectedPoly:
- pass
- else:
- #fixme: Do something to unselect the old one
- self.SelectedPoly = Object
- Canvas.RemoveObjects(self.SelectPoints)
- self.SelectPoints = []
- # Draw points on the Vertices of the Selected Poly:
- for i, point in enumerate(Object.Points):
- P = Canvas.AddPointSet(point, Diameter = 6, Color = "Red")
- P.VerticeNum = i
- P.Bind(FloatCanvas.EVT_FC_LEFT_DOWN, self.SelectPointHit)
- self.SelectPoints.append(P)
- #Canvas.ZoomToBB()
- Canvas.Draw()
-
- def SelectPointHit(self, Point):
- self.Log("Point Num: %i Hit"%Point.VerticeNum)
- self.SelectedPoint = Point
-
- def Read_MapGen(self, filename, stats = 0,AllLines=0):
- """
- This function reads a MapGen Format file, and
- returns a list of NumPy arrays with the line segments in them.
-
- Each NumPy array in the list is an NX2 array of Python Floats.
-
- The demo should have come with a file, "world.dat" that is the
- shorelines of the whole world, in MapGen format.
-
- """
- import string
- file = open(filename,'rt')
- data = file.readlines()
- data = map(string.strip,data)
-
- Shorelines = []
- segment = []
- for line in data:
- if line:
- if line == "# -b": #New segment beginning
- if segment: Shorelines.append(N.array(segment))
- segment = []
- else:
- segment.append(map(float,string.split(line)))
- if segment: Shorelines.append(N.array(segment))
-
- if stats:
- NumSegments = len(Shorelines)
- NumPoints = 0
- for segment in Shorelines:
- NumPoints = NumPoints + len(segment)
- AvgPoints = NumPoints / NumSegments
- print "Number of Segments: ", NumSegments
- print "Average Number of Points per segment: ",AvgPoints
- if AllLines:
- Lines = []
- for segment in Shorelines:
- Lines.append(segment[0])
- for point in segment[1:-1]:
- Lines.append(point)
- Lines.append(point)
- Lines.append(segment[-1])
- return Lines
- else:
- return Shorelines
- return DrawFrame
-
-#---------------------------------------------------------------------------
-
-if __name__ == "__main__":
-
- # running stand alone, Use wxversion:
-# import wxversion
-# wxversion.select("2.6")
-# wxversion.select("2.8")
- import wx
-
-
- # check options:
- import sys, getopt
- optlist, args = getopt.getopt(sys.argv[1:],'l',["all",
- "text",
- "map",
- "stext",
- "stextbox",
- "bitmap",
- "hit",
- "hitf",
- "animate",
- "speed",
- "temp",
- "props",
- "arrow",
- "arrowline",
- "hide"])
-
- if not haveNumpy:
- raise ImportError(errorText)
- StartUpDemo = "all" # the default
- if optlist:
- StartUpDemo = optlist[0][0][2:]
-
-
- class DemoApp(wx.App):
- """
- How the demo works:
-
- Under the Draw menu, there are three options:
-
- *Draw Test: will put up a picture of a bunch of randomly generated
- objects, of each kind supported.
-
- *Draw Map: will draw a map of the world. Be patient, it is a big map,
- with a lot of data, and will take a while to load and draw (about 10 sec
- on my 450Mhz PIII). Redraws take about 2 sec. This demonstrates how the
- performance is not very good for large drawings.
-
- *Clear: Clears the Canvas.
-
- Once you have a picture drawn, you can zoom in and out and move about
- the picture. There is a tool bar with three tools that can be
- selected.
-
- The magnifying glass with the plus is the zoom in tool. Once selected,
- if you click the image, it will zoom in, centered on where you
- clicked. If you click and drag the mouse, you will get a rubber band
- box, and the image will zoom to fit that box when you release it.
-
- The magnifying glass with the minus is the zoom out tool. Once selected,
- if you click the image, it will zoom out, centered on where you
- clicked. (note that this takes a while when you are looking at the map,
- as it has a LOT of lines to be drawn. The image is double buffered, so
- you don't see the drawing in progress)
-
- The hand is the move tool. Once selected, if you click and drag on the
- image, it will move so that the part you clicked on ends up where you
- release the mouse. Nothing is changed while you are dragging. The
- drawing is too slow for that.
-
- I'd like the cursor to change as you change tools, but the stock
- wxCursors didn't include anything I liked, so I stuck with the
- pointer. Please let me know if you have any nice cursor images for me to
- use.
-
-
- Any bugs, comments, feedback, questions, and especially code are welcome:
-
- -Chris Barker
-
- Chris.Barker@noaa.gov
-
- """
-
- def __init__(self, *args, **kwargs):
- wx.App.__init__(self, *args, **kwargs)
-
- def OnInit(self):
- wx.InitAllImageHandlers()
- DrawFrame = BuildDrawFrame()
- frame = DrawFrame(None, -1, "FloatCanvas Demo App",wx.DefaultPosition,(700,700))
-
- self.SetTopWindow(frame)
- frame.Show()
-
- ## check to see if the demo is set to start in a particular mode.
- ## fixme: should this be in a dict instead?
- if StartUpDemo == "text":
- frame.TestText()
- elif StartUpDemo == "stext":
- frame.TestScaledText()
- elif StartUpDemo == "stextbox":
- frame.TestScaledTextBox()
- elif StartUpDemo == "bitmap":
- frame.TestBitmap()
- elif StartUpDemo == "all":
- frame.DrawTest()
- elif StartUpDemo == "map":
- frame.DrawMap()
- elif StartUpDemo == "hit":
- frame.TestHitTest()
- elif StartUpDemo == "hitf":
- frame.TestHitTestForeground()
- elif StartUpDemo == "animate":
- frame.TestAnimation()
- elif StartUpDemo == "speed":
- frame.SpeedTest()
- elif StartUpDemo == "temp":
- frame.TempTest()
- elif StartUpDemo == "props":
- frame.PropertiesChangeTest()
- elif StartUpDemo == "arrow":
- frame.ArrowTest()
- elif StartUpDemo == "arrowline":
- frame.ArrowLineTest()
- elif StartUpDemo == "hide":
- frame.HideTest()
-
- return True
-
- app = DemoApp(False)# put in True if you want output to go to it's own window.
- app.MainLoop()
-
-else:
- # It's not running stand-alone, set up for wxPython demo.
- # don't neeed wxversion here.
- import wx
- if not haveNumpy:
- ## TestPanel and runTest used for integration into wxPython Demo
- class TestPanel(wx.Panel):
- def __init__(self, parent, log):
- self.log = log
- wx.Panel.__init__(self, parent, -1)
-
- from wx.lib.floatcanvas.ScreenShot import getScreenShotBitmap
-
- note1 = wx.StaticText(self, -1, errorText)
- note2 = wx.StaticText(self, -1, "This is what the FloatCanvas can look like:")
- S = wx.BoxSizer(wx.VERTICAL)
- S.Add((10, 10), 1)
- S.Add(note1, 0, wx.ALIGN_CENTER)
- S.Add(note2, 0, wx.ALIGN_CENTER | wx.BOTTOM, 4)
- S.Add(wx.StaticBitmap(self,-1,getScreenShotBitmap()),0,wx.ALIGN_CENTER)
- S.Add((10, 10), 1)
- self.SetSizer(S)
- self.Layout()
-
- else:
- ## TestPanel and runTest used for integration into wxPython Demo
- class TestPanel(wx.Panel):
- def __init__(self, parent, log):
- self.log = log
- wx.Panel.__init__(self, parent, -1)
- note1 = wx.StaticText(self, -1, "The FloatCanvas Demo needs")
- note2 = wx.StaticText(self, -1, "a separate frame")
- b = wx.Button(self, -1, "Open Demo Frame Now")
- b.Bind(wx.EVT_BUTTON, self.OnButton)
-
- S = wx.BoxSizer(wx.VERTICAL)
- S.Add((10, 10), 1)
- S.Add(note1, 0, wx.ALIGN_CENTER)
- S.Add(note2, 0, wx.ALIGN_CENTER | wx.BOTTOM, 5)
- S.Add(b, 0, wx.ALIGN_CENTER | wx.ALL, 5)
- S.Add((10, 10), 1)
- self.SetSizer(S)
- self.Layout()
-
- def OnButton(self, evt):
- DrawFrame = BuildDrawFrame()
- frame = DrawFrame(None, -1, "FloatCanvas Drawing Window",wx.DefaultPosition,(500,500))
-
- #win = wx.lib.plot.TestFrame(self, -1, "PlotCanvas Demo")
- frame.Show()
- frame.DrawTest()
-
- def runTest(frame, nb, log):
- win = TestPanel(nb, log)
- return win
-
- # import to get the doc
- from wx.lib import floatcanvas
- overview = floatcanvas.__doc__
-
-
-
-
-
-
-
-
projects / wxWidgets.git / blobdiff