Merge pull request #80 from canadaduane/master

New UI for XYZ controls of Pronterface

bufferedcanvas.py

+"""
+BufferedCanvas -- flicker-free canvas widget
+Copyright (C) 2005, 2006 Daniel Keep, 2011 Duane Johnson
+
+To use this widget, just override or replace the draw method.
+This will be called whenever the widget size changes, or when
+the update method is explicitly called.
+
+Please submit any improvements/bugfixes/ideas to the following
+url:
+
+  http://wiki.wxpython.org/index.cgi/BufferedCanvas
+
+2006-04-29: Added bugfix for a crash on Mac provided by Marc Jans.
+"""
+
+# Hint: try removing '.sp4msux0rz'
+__author__ = 'Daniel Keep <daniel.keep.sp4msux0rz@gmail.com>'
+
+__license__ = """
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public License as
+published by the Free Software Foundation; either version 2.1 of the
+License, or (at your option) any later version.
+
+As a special exception, the copyright holders of this library 
+hereby recind Section 3 of the GNU Lesser General Public License. This
+means that you MAY NOT apply the terms of the ordinary GNU General 
+Public License instead of this License to any given copy of the
+Library. This has been done to prevent users of the Library from being
+denied access or the ability to use future improvements.
+
+This library is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
+General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+"""
+
+__all__ = ['BufferedCanvas']
+
+import wx
+
+class BufferedCanvas(wx.Panel):
+    """
+    Implements a flicker-free canvas widget.
+
+    Standard usage is to subclass this class, and override the
+    draw method.  The draw method is passed a device context, which
+    should be used to do your drawing.
+
+    If you want to force a redraw (for whatever reason), you should
+    call the update method.  This is because the draw method is never
+    called as a result of an EVT_PAINT event.
+    """
+
+    # These are our two buffers.  Just be aware that when the buffers
+    # are flipped, the REFERENCES are swapped.  So I wouldn't want to
+    # try holding onto explicit references to one or the other ;)
+    buffer = None
+    backbuffer = None
+
+    def __init__(self,
+                 parent,
+                 ID=-1,
+                 pos=wx.DefaultPosition,
+                 size=wx.DefaultSize,
+                 style=wx.NO_FULL_REPAINT_ON_RESIZE|wx.WANTS_CHARS):
+        wx.Panel.__init__(self,parent,ID,pos,size,style)
+
+        # Bind events
+        self.Bind(wx.EVT_PAINT, self.onPaint)
+
+        # Disable background erasing (flicker-licious)
+        def disable_event(*pargs,**kwargs):
+            pass # the sauce, please
+        self.Bind(wx.EVT_ERASE_BACKGROUND, disable_event)
+
+    ##
+    ## General methods
+    ##
+
+    def draw(self,dc):
+        """
+        Stub: called when the canvas needs to be re-drawn.
+        """
+        pass
+
+    def update(self):
+        """
+        Causes the canvas to be updated.
+        """
+        self.Refresh()
+    
+    def getWidthHeight(self):
+        width,height = self.GetClientSizeTuple()
+        if width == 0:
+            width = 1
+        if height == 0:
+            height = 1
+        return (width, height)
+
+    ##
+    ## Event handlers
+    ##
+
+    def onPaint(self, event):
+        # Blit the front buffer to the screen
+        w, h = self.GetClientSizeTuple()
+        if not w or not h:
+            return
+        else:
+            dc = wx.BufferedPaintDC(self)
+            self.draw(dc, w, h)

test.py

+import wx, os, math
+from bufferedcanvas import *
+
+from xybuttons import XYButtons
+from zbuttons import ZButtons
+
+class MyFrame(wx.Frame):
+    def __init__(self, parent, id, title):
+        wx.Frame.__init__(self, parent, id, title, wx.DefaultPosition, wx.Size(600, 400))
+        sizer = wx.BoxSizer()
+        self.xy = XYButtons(self, moveCallback=self.moveXY)
+        sizer.Add(self.xy, flag=wx.ALIGN_CENTER)
+        self.z = ZButtons(self, moveCallback=self.moveZ)
+        sizer.Add(self.z, flag=wx.ALIGN_CENTER)
+
+        self.SetSizer(sizer)
+        self.SetBackgroundColour("white")
+    
+    def moveXY(self, x, y):
+        print "got x", x, 'y', y
+    
+    def moveZ(self, z):
+        print "got z", z
+
+
+class MyApp(wx.App):
+    def OnInit(self):
+        frame = MyFrame(None, -1, 'test.py')
+        frame.Show(True)
+        frame.Centre()
+        return True
+
+app = MyApp(0)
+app.MainLoop()
\ No newline at end of file

zbuttons.py

+import wx, os, math
+from bufferedcanvas import *
+
+def imagefile(filename):
+    return os.path.join(os.path.dirname(__file__), "images", filename)
+
+def sign(n):
+    if n < 0: return -1
+    elif n > 0: return 1
+    else: return 0
+
+class ZButtons(BufferedCanvas):
+    button_ydistances = [7, 30, 55, 83, 112]
+    center = (30, 118)
+
+    def __init__(self, parent, moveCallback=None, ID=-1):
+        self.bg_bmp = wx.Image(imagefile("control_z.png"),wx.BITMAP_TYPE_PNG).ConvertToBitmap()
+        self.range = None
+        self.direction = None
+        self.orderOfMagnitudeIdx = 0 # 0 means '1', 1 means '10', 2 means '100', etc.
+        self.moveCallback = moveCallback
+        self.enabled = False
+
+        BufferedCanvas.__init__(self, parent, ID)
+
+        self.SetSize(wx.Size(59, 244))
+
+        # Set up mouse and keyboard event capture
+        self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
+        self.Bind(wx.EVT_LEFT_DCLICK, self.OnLeftDown)
+        self.Bind(wx.EVT_MOTION, self.OnMotion)
+        self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeaveWindow)
+
+    def disable(self):
+        self.enabled = False
+        self.update()
+    
+    def enable(self):
+        self.enabled = True
+        self.update()
+
+    def lookupRange(self, ydist):
+        idx = -1
+        for d in ZButtons.button_ydistances:
+            if ydist < d:
+                return idx
+            idx += 1
+        return None
+    
+    def highlight(self, gc, rng, dir):
+        assert(rng >= -1 and rng <= 3)
+        assert(dir >= -1 and dir <= 1)
+
+        fudge = 11
+        x = 0 + fudge
+        w = 59 - fudge*2
+        if rng >= 0:
+            k = 1 if dir > 0 else 0
+            y = ZButtons.center[1] - (dir * ZButtons.button_ydistances[rng+k])
+            h = ZButtons.button_ydistances[rng+1] - ZButtons.button_ydistances[rng]
+            gc.DrawRoundedRectangle(x, y, w, h, 4)
+            # gc.DrawRectangle(x, y, w, h)
+        # self.drawPartialPie(dc, center, r1-inner_ring_radius, r2-inner_ring_radius, a1+fudge, a2-fudge)
+    
+    def getRangeDir(self, pos):
+        ydelta = ZButtons.center[1] - pos[1]
+        return (self.lookupRange(abs(ydelta)), sign(ydelta))
+
+    def draw(self, dc, w, h):
+        dc.Clear()
+        gc = wx.GraphicsContext.Create(dc)
+        w, h = (self.bg_bmp.GetWidth(), self.bg_bmp.GetHeight())
+
+        gc.DrawBitmap(self.bg_bmp, 0, 0, w, h)
+
+        if self.enabled:
+            gc.SetPen(wx.Pen(wx.Colour(100,100,100,172), 4))
+            gc.SetBrush(wx.Brush(wx.Colour(0,0,0,128)))
+
+            if self.range != None and self.direction != None:
+                self.highlight(gc, self.range, self.direction)
+        else:
+            gc.SetPen(wx.Pen(wx.Colour(255,255,255,0), 4))
+            gc.SetBrush(wx.Brush(wx.Colour(255,255,255,128)))
+            gc.DrawRectangle(0, 0, w, h)
+
+    ## ------ ##
+    ## Events ##
+    ## ------ ##
+
+    def OnMotion(self, event):
+        if not self.enabled:
+            return
+        
+        oldr, oldd = self.range, self.direction
+
+        mpos = event.GetPosition()
+        self.range, self.direction = self.getRangeDir(mpos)
+
+        if oldr != self.range or oldd != self.direction:
+            self.update()
+
+    def OnLeftDown(self, event):
+        if not self.enabled:
+            return
+
+        mpos = event.GetPosition()
+        r, d = self.getRangeDir(mpos)
+        if r >= 0:
+            value = math.pow(10, self.orderOfMagnitudeIdx) * math.pow(10, r - 1) * d
+            if self.moveCallback:
+                self.moveCallback(value)
+
+    def OnLeaveWindow(self, evt):
+        self.range = None
+        self.direction = None
+        self.update()