Suapapa's Wiki

User Tools

Site Tools

Trace: • gxlib • 아크릴
gxlib

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
gxlib [2009/08/24 07:43] – suapapagxlib [2013/08/03 05:04] (current) – external edit 127.0.0.1
Line 13: Line 13:
   *[[http://gnuwin32.sourceforge.net/packages/jpeg.htm|Jpeg for Windows]]   *[[http://gnuwin32.sourceforge.net/packages/jpeg.htm|Jpeg for Windows]]
   *[[http://gnuwin32.sourceforge.net/packages/libpng.htm|LibPng for Windows]]   *[[http://gnuwin32.sourceforge.net/packages/libpng.htm|LibPng for Windows]]
 +  *[[http://gnuwin32.sourceforge.net/packages/zlib.htm|zlib for Windows]]
 +
 +  *[[http://blog.naver.com/PostView.nhn?blogId=shine10ee&logNo=10040450571&widgetTypeCall=true|build libjpeg in VS200x]]
 +  *[[http://sourceforge.net/forum/message.php?msg_id=4053776|why libjpeg don't works]]
 +  *[[http://www.scons.org/wiki/CrossCompilingMingw|CrossCompillingMingw]]
 +  *[[http://www.mingw.org/|MinGW]]
  
 ====== mmap practice ====== ====== mmap practice ======
Line 19: Line 25:
 fbfp = tempfile.NamedTemporaryFile(bufsize = 640*480*3) fbfp = tempfile.NamedTemporaryFile(bufsize = 640*480*3)
 fbfp.write('\x00'*(640*480*3)) fbfp.write('\x00'*(640*480*3))
-fbfp.seek(0) 
 import mmap import mmap
 fbmap = mmap.mmap(fbfp.fileno(), 0) fbmap = mmap.mmap(fbfp.fileno(), 0)
 </code> </code>
  
-====== wxScrolledWindow practice ====== 
 <code python> <code python>
 +>>> fp = open("dummy.vfb", "w+b")
 +>>> fb = mmap.mmap(fp.fileno(),0)
 +>>> fp.close()
 +>>> for i in range(0,640*480*1,3):
 + m[i:i+3]='\x00\x00\xbb'
 +</code>
  
-import  wx +====== wxScrolledWindow practice ====== 
-import  images +  *[[http://wiki.wxpython.org/index.cgi/DoubleBufferedDrawing|wx Double Buffered Drawing]] 
- +  *[[http://wiki.wxpython.org/BufferedCanvas|widget BufferedCanvas]]
-BUFFERED = 1 +
- +
-#--------------------------------------------------------------------------- +
- +
-class MyCanvas(wx.ScrolledWindow): +
-    def __init__(self, parent, id = -1, size = wx.DefaultSize): +
-        wx.ScrolledWindow.__init__(self, parent, id, (0, 0), size=size, style=wx.SUNKEN_BORDER) +
- +
-        self.lines = [] +
-        self.maxWidth  = 1000 +
-        self.maxHeight = 1000 +
-        self.x = self.y = 0 +
-        self.curLine = [] +
-        self.drawing = False +
- +
-        self.SetBackgroundColour("WHITE") +
-        self.SetCursor(wx.StockCursor(wx.CURSOR_PENCIL)) +
-        bmp = images.Test2.GetBitmap() +
-        mask = wx.Mask(bmp, wx.BLUE) +
-        bmp.SetMask(mask) +
-        self.bmp = bmp +
- +
-        self.SetVirtualSize((self.maxWidth, self.maxHeight)) +
-        self.SetScrollRate(20,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 +
- +
-    def getHeight(self): +
-        return self.maxHeight +
- +
- +
-    def OnPaint(self, event): +
-        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, wx.BUFFER_VIRTUAL_AREA) +
-        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, printing=False): +
-        dc.BeginDrawing() +
-        dc.SetPen(wx.Pen('RED')) +
-        dc.DrawRectangle(5, 5, 50, 50) +
- +
-        dc.SetBrush(wx.LIGHT_GREY_BRUSH) +
-        dc.SetPen(wx.Pen('BLUE', 4)) +
-        dc.DrawRectangle(15, 15, 50, 50) +
- +
-        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.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(wx.GREY_PEN) +
-        dc.DrawPolygon(lst, 75) +
-        dc.SetPen(wx.GREEN_PEN) +
-        dc.DrawSpline(lst+[(100,100)]) +
- +
-        dc.DrawBitmap(self.bmp, 200, 20, True) +
-        dc.SetTextForeground(wx.Colour(0, 0xFF, 0x80)) +
-        dc.DrawText("a bitmap", 200, 85) +
- +
-##         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") +
- +
-        font = wx.Font(20, wx.SWISS, wx.NORMAL, wx.NORMAL) +
-        dc.SetFont(font) +
-        dc.SetTextForeground(wx.BLACK) +
- +
-        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) +
- +
-        dc.GradientFillLinear((20, 260, 50, 50), +
-                              "red", "blue") +
-        dc.GradientFillConcentric((20, 325, 50, 50), +
-                                  "red", "blue", (25,25)) +
-        self.DrawSavedLines(dc) +
-        dc.EndDrawing() +
- +
- +
-    def DrawSavedLines(self, dc): +
-        dc.SetPen(wx.Pen('MEDIUM FOREST GREEN', 4)) +
- +
-        for line in self.lines: +
-            for coords in line: +
-                apply(dc.DrawLine, coords) +
- +
- +
-    def SetXY(self, event): +
-        self.x, self.y = self.ConvertEventCoords(event) +
- +
-    def ConvertEventCoords(self, event): +
-        newpos = self.CalcUnscrolledPosition(event.GetX(), event.GetY()) +
-        return newpos +
- +
-    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 we'll just update the +
-                # buffer here and then refresh that portion of the +
-                # window, then that portion of the buffer will be +
-                # redrawn in the EVT_PAINT handler. +
-                dc = wx.BufferedDC(None, self.buffer) +
-            else: +
-                # otherwise we'll draw directly to a wx.ClientDC +
-                dc = wx.ClientDC(self) +
-                self.PrepareDC(dc) +
- +
-            dc.SetPen(wx.Pen('MEDIUM FOREST GREEN', 4)) +
-            coords = (self.x, self.y) + self.ConvertEventCoords(event) +
-            self.curLine.append(coords) +
-            dc.DrawLine(*coords) +
-            self.SetXY(event) +
-             +
-            if BUFFERED: +
-                # figure out what part of the window to refresh +
-                x1,y1, x2,y2 = dc.GetBoundingBox() +
-                x1,y1 = self.CalcScrolledPosition(x1, y1) +
-                x2,y2 = self.CalcScrolledPosition(x2, y2) +
-                # make a rectangle +
-                rect = wx.Rect() +
-                rect.SetTopLeft((x1,y1)) +
-                rect.SetBottomRight((x2,y2)) +
-                rect.Inflate(2,2) +
-                # refresh it +
-                self.RefreshRect(rect) +
- +
-        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 wx.ScrolledWindow 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) +
- +
-#--------------------------------------------------------------------------- +
- +
-def runTest(frame, nb, log): +
-    win = MyCanvas(nb) +
-    return win +
- +
-#--------------------------------------------------------------------------- +
- +
-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])] + sys.argv[1:]) +
-</code>+
   *wxDC::DrawBitmap   *wxDC::DrawBitmap
-  *wxBitmapFromBits(bits, width, height, depth=-1)+  *[[http://www.wxpython.org/docs/api/wx-module.html#BitmapFromBuffer|BitmapFromBuffer(width, height, dataBuffer, alphaBuffer=None)]]
  
 ====== references ====== ====== references ======
   *[[http://basic4gl.wikispaces.com/2D+Drawing+in+OpenGL|OpenGL 4 2D]]   *[[http://basic4gl.wikispaces.com/2D+Drawing+in+OpenGL|OpenGL 4 2D]]
-  *[[http://www.sixpak.org/fbe/|fbe]] - frame buffer emulator 
- 
-===== bterm ===== 
-<code bash> 
-$ sudo apt-get install bogl-bterm 
-$ sudo apt-get install libbogl-dev 
-... 
-$ bdftobogl -b gulim.bdf >gulim.bgf 
-$ bterm -f gulim.bgf  
-bogl: opening /dev/fb0: No such file or directory 
- 
-</code> 
gxlib.1251099834.txt.gz · Last modified: 2013/08/03 05:04 (external edit)