[Ocemp-CVS] ocempgui/ocempgui/access Magnifier.py,1.6,1.7

[Marcus v. A. <mar...@us...>]

Update of /cvsroot/ocemp/ocempgui/ocempgui/access
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv20200/ocempgui/access

Modified Files:
	Magnifier.py 
Log Message:

Added external zoom_func support to Magnifier class.

Index: Magnifier.py
===================================================================
RCS file: /cvsroot/ocemp/ocempgui/ocempgui/access/Magnifier.py,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- Magnifier.py	12 Sep 2006 19:59:31 -0000	1.6
+++ Magnifier.py	23 Jan 2007 22:35:47 -0000	1.7
@@ -1,6 +1,6 @@
 # $Id$
 #
-# Copyright (c) 2006, Marcus von Appen
+# Copyright (c) 2006-2007, Marcus von Appen
 # All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are met:
@@ -69,11 +69,42 @@
     magnifier.factor = 3
     magnifier.set_factor (3)
 
+    By default the Magnifier uses a simple call to pygame.transform.scale(),
+    which does not provide optimal results for each surface. The 'zoom_func'
+    attribute and set_zoom_func() method allow you to provide an own zoom
+    function, which has to return the zoomed surface. It receives the actual
+    screen surface, the mouse position the zoomed area will be centered at and
+    the sizes and scaling factor to use for zooming.
+
+    def own_zoom_func (screen, mousepos, resultsize, size, factor):
+        ...
+        return zoomed_surface
+
+    magnifier.zoom_func = own_zoom_func
+    magnifier.set_zoom_func (own_zoom_func)
+    
+    The resultsize is a tuple containing the magnifier size multiplied with the
+    set factor of the magnifier:
+    resultsize = int (size[0] * factor), int (size[1] * factor)
+    size and factor contain the currently set values of the respective
+    attributes of the Magnifier instance. An implementation of the default zoom
+    functionality of the Magnifier using the 'zoom_func' attribute would look
+    like the following:
+
+    def own_zoom_func (screen, mousepos, resultsize, size, factor):
+        offset = mousepos[0] - size[0] / 2, mousepos[1] - size[1] / 2
+        # Create zoomable surface.
+        surface = pygame.Surface ((size[0], size[1]))
+        surface.blit (screen, (0, 0), (offset[0], offset[1], size[0], size[1]))
+        # Zoom and blit.
+        return pygame.transform.scale (surface, (resultsize[0], resultsize[1]))
+    
     Attributes:
-    factor - The zoom factor to use for magnification.
-    size   - The size of the area around the mouse cursor to zoom.
-    border - Indicates whether a 1px border around the magnified area should
-             be drawn.
+    factor    - The zoom factor to use for magnification.
+    size      - The size of the area around the mouse cursor to zoom.
+    border    - Indicates whether a 1px border around the magnified area should
+                be drawn.
+    zoom_func -
     """
     def __init__ (self, size=(20, 20), factor=2):
         self._factor = factor
@@ -82,6 +113,7 @@
         self._oldpos = None # The topleft offset of the area.
         self._mousepos = None  # The mouse position.
         self._border = True
+        self._zoomfunc = None
 
     def set_factor (self, factor):
         """M.set_factor (...) -> None
@@ -137,6 +169,19 @@
             screen.blit (self._oldsurface, self._oldpos)
             self._oldsurface = None
 
+    def set_zoom_func (self, func):
+        """D.set_zoom_func (...) -> None
+
+        Sets the zoom function to use for the Magnifier..
+
+        Raises a TypeError, if func is not callable.
+        """
+        if not callable (func):
+            raise TypeError ("func must be callable")
+        self._zoomfunc = func
+        if self._mousepos:
+            self._update (self._mousepos)
+
     def notify (self, *events):
         """M.notify (...) -> bool
 
@@ -160,12 +205,13 @@
 
         Update the magnification area.
         """
+        surface = None
+        screen = pygame.display.get_surface ()
+
         rsize = int (self.size[0] * self.factor), \
                 int (self.size[1] * self.factor)
         offset = position[0] - rsize[0] / 2, position[1] - rsize[1] / 2
         zoffset = position[0] - self.size[0] / 2, position[1] - self.size[1] / 2
-            
-        screen = pygame.display.get_surface ()
 
         # Restore old surface area.
         if self._oldsurface:
@@ -176,13 +222,17 @@
         self._oldsurface.blit (screen, (0, 0), (offset[0], offset[1],
                                                 rsize[0], rsize[1]))
 
-        # Create zoomable surface.
-        surface = pygame.Surface ((self.size[0], self.size[1]))
-        surface.blit (screen, (0, 0), (zoffset[0], zoffset[1],
-                                       self.size[0], self.size[1]))
-            
-        # Zoom and blit.
-        surface = pygame.transform.scale (surface, (rsize[0], rsize[1]))
+        if self._zoomfunc:
+            surface = self.zoom_func (screen, position, rsize, self.size,
+                                      self.factor)
+        else:
+            # Create zoomable surface.
+            surface = pygame.Surface ((self.size[0], self.size[1]))
+            surface.blit (screen, (0, 0), (zoffset[0], zoffset[1],
+                                           self.size[0], self.size[1]))
+
+            # Zoom and blit.
+            surface = pygame.transform.scale (surface, (rsize[0], rsize[1]))
 
         if self.border:
             pygame.draw.line (surface, (0, 0, 0), (0, 0), (0, rsize[1]))
@@ -204,3 +254,6 @@
     border = property (lambda self: self._border,
                        lambda self, var: self.enable_border (var),
                        doc = "Indicates whether a border should be shown.")
+    zoom_func = property (lambda self: self._zoomfunc,
+                          lambda self, var: self.set_zoom_func (var),
+                          doc = "The zoom function to use.")