]> git.saurik.com Git - wxWidgets.git/blobdiff - wxPython/demo/wxScrolledWindow.py
Applied patch [ 827011 ] Event-based processing of item tooltips in wxTreeCtrl
[wxWidgets.git] / wxPython / demo / wxScrolledWindow.py
index c772f2ed6620eabb9384c65c27faeb219c61f4ba..8dcc92b5707ef45a91e8cba83e905af2dc0ae457 100644 (file)
@@ -1,32 +1,51 @@
+# 11/12/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o Updated for wx namespace
+# o Rudimentary overview doc added.
+#
 
-from wxPython.wx import *
+import  wx
+
+import  images
+
+BUFFERED = 1
 
 #---------------------------------------------------------------------------
 
-class MyCanvas(wxScrolledWindow):
-    def __init__(self, parent, id = -1, size = wxDefaultSize):
-        wxScrolledWindow.__init__(self, parent, id, wxPoint(0, 0), size, wxSUNKEN_BORDER)
+class MyCanvas(wx.ScrolledWindow):
+    def __init__(self, parent, id = -1):
+        wx.ScrolledWindow.__init__(self, parent, id, (0, 0), size=size, style=wx.SUNKEN_BORDER)
 
         self.lines = []
         self.maxWidth  = 1000
         self.maxHeight = 1000
-
-        self.SetBackgroundColour(wxNamedColor("WHITE"))
-        EVT_LEFT_DOWN(self, self.OnLeftButtonEvent)
-        EVT_LEFT_UP(self,   self.OnLeftButtonEvent)
-        EVT_MOTION(self,    self.OnLeftButtonEvent)
-
-        EVT_PAINT(self, self.OnPaint)
-
-
-        self.SetCursor(wxStockCursor(wxCURSOR_PENCIL))
-        bmp = wxBitmap('bitmaps/test2.bmp', wxBITMAP_TYPE_BMP)
-        mask = wxMaskColour(bmp, wxBLUE)
+        self.x = self.y = 0
+        self.curLine = []
+        self.drawing = False
+
+        self.SetBackgroundColour("WHITE")
+        self.SetCursor(wx.StockCursor(wx.CURSOR_PENCIL))
+        bmp = images.getTest2Bitmap()
+        mask = wx.MaskColour(bmp, wx.BLUE)
         bmp.SetMask(mask)
         self.bmp = bmp
 
         self.SetScrollbars(20, 20, self.maxWidth/20, self.maxHeight/20)
 
+        if BUFFERED:
+            # Initialize the buffer bitmap.  No real DC is needed at this point.
+            self.buffer = wx.EmptyBitmap(self.maxWidth, self.maxHeight)
+            dc = wx.BufferedDC(None, self.buffer)
+            dc.SetBackground(wx.Brush(self.GetBackgroundColour()))
+            dc.Clear()
+            self.DoDrawing(dc)
+
+        self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftButtonEvent)
+        self.Bind(wx.EVT_LEFT_UP,   self.OnLeftButtonEvent)
+        self.Bind(wx.EVT_MOTION,    self.OnLeftButtonEvent)
+        self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+
     def getWidth(self):
         return self.maxWidth
 
@@ -35,62 +54,101 @@ class MyCanvas(wxScrolledWindow):
 
 
     def OnPaint(self, event):
-        dc = wxPaintDC(self)
-        self.PrepareDC(dc)
-        self.DoDrawing(dc)
+        if BUFFERED:
+            # Create a buffered paint DC.  It will create the real
+            # wx.PaintDC and then blit the bitmap to it when dc is
+            # deleted.  Since we don't need to draw anything else
+            # here that's all there is to it.
+            dc = wx.BufferedPaintDC(self, self.buffer)
+        else:
+            dc = wx.PaintDC(self)
+            self.PrepareDC(dc)
+            # since we're not buffering in this case, we have to
+            # paint the whole window, potentially very time consuming.
+            self.DoDrawing(dc)
 
 
-    def DoDrawing(self, dc):
+    def DoDrawing(self, dc, printing=False):
         dc.BeginDrawing()
-        #pen1 = wxPen(wxNamedColour('RED'))
-        dc.SetPen(wxPen(wxNamedColour('RED')))
-        dc.DrawRectangle(5, 5, 50, 50)
+        dc.SetPen(wx.Pen('RED'))
+        dc.DrawRectangle((5, 5), (50, 50))
 
-        dc.SetBrush(wxLIGHT_GREY_BRUSH)
-        dc.SetPen(wxPen(wxNamedColour('BLUE'), 4))
-        dc.DrawRectangle(15, 15, 50, 50)
+        dc.SetBrush(wx.LIGHT_GREY_BRUSH)
+        dc.SetPen(wx.Pen('BLUE', 4))
+        dc.DrawRectangle((15, 15), (50, 50))
 
-        #font = wxFont(14, wxSWISS, wxNORMAL, wxNORMAL)
-        dc.SetFont(wxFont(14, wxSWISS, wxNORMAL, wxNORMAL))
-        dc.SetTextForeground(wxColour(0xFF, 0x20, 0xFF))
+        dc.SetFont(wx.Font(14, wx.SWISS, wx.NORMAL, wx.NORMAL))
+        dc.SetTextForeground(wx.Colour(0xFF, 0x20, 0xFF))
         te = dc.GetTextExtent("Hello World")
-        dc.DrawText("Hello World", 60, 65)
+        dc.DrawText("Hello World", (60, 65))
 
-        dc.SetPen(wxPen(wxNamedColour('VIOLET'), 4))
-        dc.DrawLine(5, 65+te[1], 60+te[0], 65+te[1])
+        dc.SetPen(wx.Pen('VIOLET', 4))
+        dc.DrawLine((5, 65+te[1]), (60+te[0], 65+te[1]))
 
         lst = [(100,110), (150,110), (150,160), (100,160)]
         dc.DrawLines(lst, -60)
-        dc.SetPen(wxGREY_PEN)
+        dc.SetPen(wx.GREY_PEN)
         dc.DrawPolygon(lst, 75)
-        dc.SetPen(wxGREEN_PEN)
+        dc.SetPen(wx.GREEN_PEN)
         dc.DrawSpline(lst+[(100,100)])
 
-        dc.DrawBitmap(self.bmp, 200, 20, true)
-        dc.SetTextForeground(wxColour(0, 0xFF, 0x80))
-        dc.DrawText("a bitmap", 200, 85)
+        dc.DrawBitmap(self.bmp, (200, 20), True)
+        dc.SetTextForeground(wx.Colour(0, 0xFF, 0x80))
+        dc.DrawText("a bitmap", (200, 85))
 
-        font = wxFont(20, wxSWISS, wxNORMAL, wxNORMAL)
-        dc.SetFont(font)
-        dc.SetTextForeground(wxBLACK)
-        for a in range(0, 360, 45):
-            dc.DrawRotatedText("Rotated text...", 300, 300, a)
+##         dc.SetFont(wx.Font(14, wx.SWISS, wx.NORMAL, wx.NORMAL))
+##         dc.SetTextForeground("BLACK")
+##         dc.DrawText("TEST this STRING", (10, 200))
+##         print dc.GetFullTextExtent("TEST this STRING")
 
-        dc.SetPen(wxTRANSPARENT_PEN)
-        dc.SetBrush(wxBLUE_BRUSH)
-        dc.DrawRectangle(50,500,50,50)
-        dc.DrawRectangle(100,500,50,50)
+        font = wx.Font(20, wx.SWISS, wx.NORMAL, wx.NORMAL)
+        dc.SetFont(font)
+        dc.SetTextForeground(wx.BLACK)
 
-        dc.SetPen(wxPen(wxNamedColour('RED')))
-        dc.DrawEllipticArc(200, 500, 50, 75, 0, 90)
+        for a in range(0, 360, 45):
+            dc.DrawRotatedText("Rotated text...", (300, 300), a)
+
+        dc.SetPen(wx.TRANSPARENT_PEN)
+        dc.SetBrush(wx.BLUE_BRUSH)
+        dc.DrawRectangle((50,500),(50,50))
+        dc.DrawRectangle((100,500),(50,50))
+
+        dc.SetPen(wx.Pen('RED'))
+        dc.DrawEllipticArc((200, 500), (50, 75), 0, 90)
+
+        if not printing:
+            # This has troubles when used on a print preview in wxGTK,
+            # probably something to do with the pen styles and the scaling
+            # it does...
+            y = 20
+
+            for style in [wx.DOT, wx.LONG_DASH, wx.SHORT_DASH, wx.DOT_DASH, wx.USER_DASH]:
+                pen = wx.Pen("DARK ORCHID", 1, style)
+                if style == wx.USER_DASH:
+                    pen.SetCap(wx.CAP_BUTT)
+                    pen.SetDashes([1,2])
+                    pen.SetColour("RED")
+                dc.SetPen(pen)
+                dc.DrawLine((300, y), (400, y))
+                y = y + 10
+
+        dc.SetBrush(wx.TRANSPARENT_BRUSH)
+        dc.SetPen(wx.Pen(wx.Colour(0xFF, 0x20, 0xFF), 1, wx.SOLID))
+        dc.DrawRectangle((450, 50), (100, 100))
+        old_pen = dc.GetPen()
+        new_pen = wx.Pen("BLACK", 5)
+        dc.SetPen(new_pen)
+        dc.DrawRectangle((470, 70), (60, 60))
+        dc.SetPen(old_pen)
+        dc.DrawRectangle((490, 90), (20, 20))
 
         self.DrawSavedLines(dc)
         dc.EndDrawing()
 
 
-
     def DrawSavedLines(self, dc):
-        dc.SetPen(wxPen(wxNamedColour('MEDIUM FOREST GREEN'), 4))
+        dc.SetPen(wx.Pen('MEDIUM FOREST GREEN', 4))
+
         for line in self.lines:
             for coords in line:
                 apply(dc.DrawLine, coords)
@@ -107,25 +165,60 @@ class MyCanvas(wxScrolledWindow):
 
     def OnLeftButtonEvent(self, event):
         if event.LeftDown():
+            self.SetFocus()
             self.SetXY(event)
             self.curLine = []
             self.CaptureMouse()
+            self.drawing = True
+
+        elif event.Dragging() and self.drawing:
+            if BUFFERED:
+                # If doing buffered drawing, create the buffered DC, giving it
+                # it a real DC to blit to when done.
+                cdc = wx.ClientDC(self)
+                self.PrepareDC(cdc)
+                dc = wx.BufferedDC(cdc, self.buffer)
+            else:
+                dc = wx.ClientDC(self)
+                self.PrepareDC(dc)
 
-        elif event.Dragging():
-            dc = wxClientDC(self)
-            self.PrepareDC(dc)
             dc.BeginDrawing()
-            dc.SetPen(wxPen(wxNamedColour('MEDIUM FOREST GREEN'), 4))
-            coords = (self.x, self.y) + self.ConvertEventCoords(event)
+            dc.SetPen(wx.Pen('MEDIUM FOREST GREEN', 4))
+            coords = [(self.x, self.y) , self.ConvertEventCoords(event)]
             self.curLine.append(coords)
             apply(dc.DrawLine, coords)
             self.SetXY(event)
             dc.EndDrawing()
 
-        elif event.LeftUp():
+
+        elif event.LeftUp() and self.drawing:
             self.lines.append(self.curLine)
             self.curLine = []
             self.ReleaseMouse()
+            self.drawing = False
+
+
+## This is an example of what to do for the EVT_MOUSEWHEEL event,
+## but since wxScrolledWindow does this already it's not
+## necessary to do it ourselves. You would need to add an event table 
+## entry to __init__() to direct wheelmouse events to this handler.
+
+##     wheelScroll = 0
+##     def OnWheel(self, evt):
+##         delta = evt.GetWheelDelta()
+##         rot = evt.GetWheelRotation()
+##         linesPer = evt.GetLinesPerAction()
+##         print delta, rot, linesPer
+##         ws = self.wheelScroll
+##         ws = ws + rot
+##         lines = ws / delta
+##         ws = ws - lines * delta
+##         self.wheelScroll = ws
+##         if lines != 0:
+##             lines = lines * linesPer
+##             vsx, vsy = self.GetViewStart()
+##             scrollTo = vsy - lines
+##             self.Scroll(-1, scrollTo)
 
 #---------------------------------------------------------------------------
 
@@ -137,15 +230,19 @@ def runTest(frame, nb, log):
 
 
 
+overview = """
+<html>
+<body>
+The wx.ScrolledWindow class manages scrolling for its client area, transforming the 
+coordinates according to the scrollbar positions, and setting the scroll positions, 
+thumb sizes and ranges according to the area in view.
+</body>
+</html>
+"""
 
 
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])])
 
-
-
-
-
-
-
-
-overview = """\
-"""