# HG changeset patch
# User phoku@33b003aa-7bff-0310-803a-e67f0ece8222
# Date 1237032809 0
# Node ID 54bfd1015b35d793453d947ed07a824bee52c76e
# Parent  5816ab527da8410b2a33578f6155cc4bab501b9a
* PyChan event handling rework (part I)
** Unified listeners
** ...hopefully more robust attach/detach code.
* Added compat, layout and also the new autopsition feature.
* Documentation
* Minor style fixes in core.

diff -r 5816ab527da8 -r 54bfd1015b35 clients/pychan_demo/pychan_test.py
--- a/clients/pychan_demo/pychan_test.py	Sat Mar 14 12:03:56 2009 +0000
+++ b/clients/pychan_demo/pychan_test.py	Sat Mar 14 12:13:29 2009 +0000
@@ -38,7 +38,7 @@
 
 def testTimer():
 	import timer
-	timer.init( pychan.manager.engine.getTimeManager() )
+	timer.init( pychan.manager.hook.engine.getTimeManager() )
 	def spam():
 		print "SPAM SPAM"
 		return 1
diff -r 5816ab527da8 -r 54bfd1015b35 doc/dependencies/dirdeps.dot
--- a/doc/dependencies/dirdeps.dot	Sat Mar 14 12:03:56 2009 +0000
+++ b/doc/dependencies/dirdeps.dot	Sat Mar 14 12:13:29 2009 +0000
@@ -190,6 +190,7 @@
     "model/structures" -> "util/math"
     "model/structures" -> "util/resource"
     "model/structures" -> "util/structures"
+    "model/structures" -> "util/time"
     "pathfinder" -> "model/metamodel"
     "pathfinder" -> "model/structures"
     "pathfinder" -> "util/base"
@@ -263,6 +264,7 @@
     "view/renderers" -> "util/log"
     "view/renderers" -> "util/math"
     "view/renderers" -> "util/structures"
+    "view/renderers" -> "util/time"
     "view/renderers" -> "video"
     "view/renderers" -> "video/fonts"
     "view/renderers" -> "video/sdl"
diff -r 5816ab527da8 -r 54bfd1015b35 doc/dependencies/filedeps.dot
--- a/doc/dependencies/filedeps.dot	Sat Mar 14 12:03:56 2009 +0000
+++ b/doc/dependencies/filedeps.dot	Sat Mar 14 12:13:29 2009 +0000
@@ -165,6 +165,7 @@
     "engine/core/gui/widgets/clicklabel.cpp" -> "util/base/exception.h"
     "engine/core/gui/widgets/clicklabel.cpp" -> "video/image.h"
     "engine/core/gui/widgets/icon2.cpp" -> "icon2.hpp"
+    "engine/core/gui/widgets/togglebutton.cpp" -> "togglebutton.h"
     "engine/core/gui/widgets/twobutton.cpp" -> "twobutton.h"
     "engine/core/loaders/native/audio_loaders/ogg_loader.cpp" -> "audio/soundclip.h"
     "engine/core/loaders/native/audio_loaders/ogg_loader.cpp" -> "ogg_loader.h"
@@ -248,6 +249,7 @@
     "engine/core/model/structures/instance.cpp" -> "util/base/exception.h"
     "engine/core/model/structures/instance.cpp" -> "util/log/logger.h"
     "engine/core/model/structures/instance.cpp" -> "util/math/fife_math.h"
+    "engine/core/model/structures/instance.cpp" -> "util/time/timemanager.h"
     "engine/core/model/structures/instance.h" -> "location.h"
     "engine/core/model/structures/instance.h" -> "model/metamodel/abstractvisual.h"
     "engine/core/model/structures/instance.h" -> "model/metamodel/object.h"
@@ -636,6 +638,7 @@
     "engine/core/view/renderers/genericrenderer.cpp" -> "model/structures/location.h"
     "engine/core/view/renderers/genericrenderer.cpp" -> "util/log/logger.h"
     "engine/core/view/renderers/genericrenderer.cpp" -> "util/math/fife_math.h"
+    "engine/core/view/renderers/genericrenderer.cpp" -> "util/time/timemanager.h"
     "engine/core/view/renderers/genericrenderer.cpp" -> "video/animation.h"
     "engine/core/view/renderers/genericrenderer.cpp" -> "video/animationpool.h"
     "engine/core/view/renderers/genericrenderer.cpp" -> "video/fonts/abstractfont.h"
diff -r 5816ab527da8 -r 54bfd1015b35 engine/core/gui/guilistener.i
--- a/engine/core/gui/guilistener.i	Sat Mar 14 12:03:56 2009 +0000
+++ b/engine/core/gui/guilistener.i	Sat Mar 14 12:13:29 2009 +0000
@@ -22,36 +22,17 @@
 %module fife
 %{
 #include <guichan.hpp>
-#include "gui/guilistener.h"
+#include <guichan/actionevent.hpp>
+#include <guichan/keyevent.hpp>
 %}
 
 namespace gcn {
 
-	%nodefaultctor;
+	%feature("director") MouseListener;
 	class MouseListener {
 	public:
-	};
-
-	class KeyListener {
-	public:
-	};
+		virtual ~MouseListener();
 
-	class ActionListener {
-	public:
-	};
-	%clearnodefaultctor;
-}
-
-namespace FIFE {
-
-	%feature("director") GUIEventListener;
-	class GUIEventListener : 
-		public gcn::MouseListener, public gcn::KeyListener, public gcn::ActionListener {
-	public:
-		 GUIEventListener();
-		 virtual ~GUIEventListener();
-
-		/* Mouse events */
 		virtual void mouseEntered(gcn::MouseEvent& mouseEvent);
 		virtual void mouseExited(gcn::MouseEvent& mouseEvent);
 		virtual void mousePressed(gcn::MouseEvent& mouseEvent);
@@ -61,9 +42,27 @@
 		virtual void mouseWheelMovedDown(gcn::MouseEvent& mouseEvent);
 		virtual void mouseMoved(gcn::MouseEvent& mouseEvent);
 		virtual void mouseDragged(gcn::MouseEvent& mouseEvent);
-
-		virtual void action(const gcn::ActionEvent& actionEvent);
-
+	protected:
+		MouseListener() { }
 	};
 
+	%feature("director") MouseListener;
+	class KeyListener {
+	public:
+		virtual ~KeyListener() { }
+
+		virtual void keyPressed(gcn::KeyEvent& keyEvent) { }
+		virtual void keyReleased(gcn::KeyEvent& keyEvent) { }
+	protected:
+		KeyListener() { }
+	};
+
+	%feature("director") ActionListener;
+	class ActionListener {
+	public:
+		virtual ~ActionListener() { }
+		virtual void action(const gcn::ActionEvent& actionEvent) = 0;
+	};
 }
+
+
diff -r 5816ab527da8 -r 54bfd1015b35 engine/core/util/base/resourceclass.cpp
--- a/engine/core/util/base/resourceclass.cpp	Sat Mar 14 12:03:56 2009 +0000
+++ b/engine/core/util/base/resourceclass.cpp	Sat Mar 14 12:13:29 2009 +0000
@@ -56,7 +56,6 @@
 	
 	void ResourceClass::setResourceLocation(const ResourceLocation& location) {
 		delete m_location;
-		m_location = NULL;
 		m_location = location.clone();
 	}
 	
diff -r 5816ab527da8 -r 54bfd1015b35 engine/core/util/resource/pool.h
--- a/engine/core/util/resource/pool.h	Sat Mar 14 12:03:56 2009 +0000
+++ b/engine/core/util/resource/pool.h	Sat Mar 14 12:13:29 2009 +0000
@@ -130,7 +130,6 @@
 		 */
 		virtual void reset();
 
-	protected:
 	private:
 		class PoolEntry {
 		public:
diff -r 5816ab527da8 -r 54bfd1015b35 engine/core/video/animation.cpp
--- a/engine/core/video/animation.cpp	Sat Mar 14 12:03:56 2009 +0000
+++ b/engine/core/video/animation.cpp	Sat Mar 14 12:13:29 2009 +0000
@@ -46,16 +46,9 @@
 		}
 	
 	Animation::~Animation() {
-// 		std::vector<FrameInfo>::const_iterator i(m_frames.begin());
-// 		while (i != m_frames.end()) {
-// 			i->img->decRef();
-// 			i++;
-// 		}
+		// note: we don't need to free the images, as they are handled via
+		// smart references.
 	}
-	
-// 	void Animation::addFrame(Image* image, unsigned int duration) {
-// 		addFrame(ResourcePtr(image),duration);
-// 	}
 
 	void Animation::addFrame(ResourcePtr image, unsigned int duration) {
 		FrameInfo info;
diff -r 5816ab527da8 -r 54bfd1015b35 engine/extensions/pychan/__init__.py
--- a/engine/extensions/pychan/__init__.py	Sat Mar 14 12:03:56 2009 +0000
+++ b/engine/extensions/pychan/__init__.py	Sat Mar 14 12:13:29 2009 +0000
@@ -10,7 +10,7 @@
 --------
  - Simpler Interface
  - Very Basic XML Format support
- - Very Basic Layout Engine
+ - Basic Layout Engine
  - Pseudo-Synchronous Dialogs.
  - Automagic background tiling (WIP)
  - Basic Styling support.
@@ -24,8 +24,6 @@
  - Documentation ( Allways not enough :-( )
  - Handle Image Fonts
  - Move Font config files to XML, too ...
- - Add support for fixed size 'Spacers'
- - Add messageBox(text)
 
  - Implement real Menus
  - Implement StackWidget
@@ -37,9 +35,9 @@
 BUGS
 ----
  - Focus problems with Widget.execute.
- - Layout Bugs where max_size of a parent widget get's ignored.
  - Font.glyph_spacing is rendered incorrectly.
- - It just looks ugly.
+ - Is this a bug? At least inconvenient. MouseEntered events are not distributed for freshly shown widget.
+ - It just looks bad.
 
 Problems
 --------
@@ -154,6 +152,8 @@
      }
   }
 
+A new style is added to pychan with L{internal.Manager.addStyle}.
+
 The font is set via a string identifier pulled from a font definition
 in a PyChan configuration file. You have to load these by calling
 L{loadFonts} in your startup code::
@@ -225,8 +225,6 @@
 	'manager'
 ]
 
-import fife, pythonize
-
 from widgets import *
 from exceptions import *
 
@@ -244,9 +242,11 @@
 
 	@param engine: The FIFE engine object.
 	"""
-	from manager import Manager
+	from compat import _munge_engine_hook
+	from internal import Manager
 	global manager
-	manager = Manager(engine,debug)
+
+	manager = Manager(_munge_engine_hook(engine),debug)
 
 # XML Loader
 
@@ -326,6 +326,9 @@
 
 	def _createSpacer(self,cls,name,attrs):
 		obj = cls(parent=self.root)
+		for k,v in attrs.items():
+			self._setAttr(obj,k,v)
+
 		if hasattr(self.root,'add'):
 			self.root.addSpacer(obj)
 		else:
diff -r 5816ab527da8 -r 54bfd1015b35 engine/extensions/pychan/autoposition.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/engine/extensions/pychan/autoposition.py	Sat Mar 14 12:13:29 2009 +0000
@@ -0,0 +1,121 @@
+# coding: utf-8
+
+"""
+Automatic widget positioning
+============================
+
+You can use the C{position_techinque} attribute
+on top level widgets which can also be set from xml.
+
+For direct use call L{placeWidget}.
+"""
+
+from internal import screen_width, screen_height
+from exceptions import PyChanException
+
+EXPLICIT = "explicit"
+AUTOMATIC = "automatic"
+
+TOP = "top"
+LEFT = "left"
+RIGHT = "right"
+CENTER = "center"
+BOTTOM = "bottom"
+
+
+def _splicePosition(p):
+	if "+" in p:
+		technique,delta = p.split("+")
+	elif "-" in p:
+		technique,delta = p.split("-")
+		delta = '-' + delta
+	else:
+		technique,delta = p,0
+	delta = int(delta)
+	return technique,delta
+
+def _parsePosition(position):
+	try:
+		if position == AUTOMATIC:
+			position = "center+0:center+0"
+
+		x_pos,y_pos = position.split(":")
+		x_pos, x_delta = _splicePosition(x_pos)
+		y_pos, y_delta = _splicePosition(y_pos)
+
+		if x_pos not in [EXPLICIT,LEFT,CENTER,RIGHT]:
+			raise 
+		if y_pos not in [EXPLICIT,TOP,CENTER,BOTTOM]:
+			raise
+	except:
+		raise PyChanException("Malformed position definition: " + repr(position))
+	return x_pos,x_delta,y_pos,y_delta
+
+def placeWidget(widget,position):
+	"""
+	Place a widget according to a string defining relative coordinates to screen borders.
+
+	The position definition has to be of the form: C{"<x_pos><x_delta>:<y_pos><y_delta>"}
+
+	C{<x_pos>} may be one of:
+          - left
+          - right
+          - center
+          - explicit
+
+	C{<y_pos>} may be one of:
+          - top
+          - bottom
+          - center
+          - explicit
+
+        C{explicit} means that the widgets x or y position will not be touched. The rest should be
+        self explanatory.
+
+	C{<x_delta>} and C{<y_delta>} must be of the form: +pixel_number or -pixel_number. Or comletely
+        omitted. Note that the sign has to be there for for positive deltas, too.
+
+	For brevity two shortcuts exist:
+          - "explict" -> "explict:explict"
+          - "automatic" -> "center:center"
+        
+	A few examples::
+          "right-20:top"
+          "center:top+10"
+          "center:center"
+
+	@param widget: The PyChan widget.
+	@param position: A position definition.
+
+	If the position cannot be parsed a L{PyChanException} is thrown.
+
+	"""
+	if position == EXPLICIT:
+		return
+	x_pos,x_delta,y_pos,y_delta = _parsePosition(position)
+
+	x,y = widget.position
+	w,h = widget.size
+
+	if x_pos == CENTER:
+		x = (screen_width()-w)/2 + x_delta
+
+	if y_pos == CENTER:
+		y = (screen_height()-h)/2 + y_delta
+
+	if x_pos == LEFT:
+		x = x_delta
+
+	if y_pos == TOP:
+		y = y_delta
+
+	if x_pos == RIGHT:
+		x = screen_width() - w + x_delta
+
+	if y_pos == BOTTOM:
+		y = screen_height() - h + y_delta
+
+	widget.position = x,y
+
+
+
diff -r 5816ab527da8 -r 54bfd1015b35 engine/extensions/pychan/compat.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/engine/extensions/pychan/compat.py	Sat Mar 14 12:13:29 2009 +0000
@@ -0,0 +1,87 @@
+# coding: utf-8
+
+in_fife = None
+guichan = None
+
+def _import_guichan():
+	global in_fife
+
+	err_fife = ""
+	try:
+		import fife
+		in_fife = True
+		return fife
+	except ImportError, e:
+		err_fife = str(e)
+	
+	try:
+		import guichan
+		in_fife = False
+		return guichan
+	except ImportError, e:
+		import traceback
+		traceback.print_exc()
+		raise ImportError("Couldn't import neither fife nor guichan: fife:'%s' guichan:'%s'" % (err_fife,str(e)))
+guichan = _import_guichan()
+
+
+
+def _munge_engine_hook(engine):
+	engine.translate_mouse_event = getattr(engine,'translate_mouse_event',lambda x : x )
+	engine.translate_key_event   = getattr(engine,'translate_key_event',lambda x : x )
+
+	if not in_fife:
+		return engine
+	if not isinstance(engine,fife.Engine):
+		return engine
+
+	guimanager = engine.getGuiManager()
+
+	def _fife_load_image(filename):
+		index = engine.imagePool.addResourceFromFile(filename)
+		return guichan.GuiImage(index,engine.getImagePool())
+
+	class hook:
+		pass
+	hook = hook()
+
+	hook.add_widget    = guimanager.add
+	hook.remove_widget = guimanager.remove
+	hook.default_font  = engine.getDefaultFont()
+	hook.load_image    = _fife_load_image
+	hook.translate_mouse_event = guimanager.translateMouseEvent
+	hook.translate_key_event   = guimanager.translateKeyEvent
+
+	hook.screen_width  = engine.getRenderBackend().getScreenWidth()
+	hook.screen_height = engine.getRenderBackend().getScreenHeight()
+
+	hook.engine        = engine
+	return hook
+
+
+class _multilistener(guichan.ActionListener,guichan.MouseListener,guichan.KeyListener):
+	def __init__(self):
+		guichan.ActionListener.__init__(self)
+		guichan.MouseListener.__init__(self)
+		guichan.KeyListener.__init__(self)
+
+
+class _point(object):
+	def __init__(self,x=0,y=0):
+		self.x=0
+		self.y=0
+
+if in_fife:
+	fife = guichan
+	guichan.ActionListener._ActionListener_init__ = lambda x : x
+	#guichan.MouseListener.__init__ = lambda x : x
+	guichan.KeyListener.__init__ = lambda x : x
+else:
+	guichan.Point = _point
+	guichan.ScrollArea.SHOW_AUTO = guichan.ScrollArea.ShowAuto
+	guichan.ScrollArea.SHOW_NEVER = guichan.ScrollArea.ShowNever
+	guichan.ScrollArea.SHOW_ALWAYS = guichan.ScrollArea.ShowAlways
+
+assert isinstance(_multilistener(),guichan.ActionListener)
+assert isinstance(_multilistener(),guichan.MouseListener)
+assert isinstance(_multilistener(),guichan.KeyListener)
diff -r 5816ab527da8 -r 54bfd1015b35 engine/extensions/pychan/dialogs.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/engine/extensions/pychan/dialogs.py	Sat Mar 14 12:13:29 2009 +0000
@@ -0,0 +1,197 @@
+# coding: utf-8
+
+from pychan import loadXML
+import pychan.tools
+import widgets
+from internal import get_manager, screen_width, screen_height
+from StringIO import StringIO
+
+OK,YES,NO,CANCEL = True,True,False,None
+
+def print_event(**kwargs):
+	print kwargs
+
+class XMLDialog(object):
+	def __init__(self, xml, ok_field = None, cancel_field = None,initial_data={},data={}):
+		self.gui = loadXML(xml)
+		self.ok_field = ok_field
+		self.cancel_field = cancel_field
+		self.initial_data= initial_data
+		self.data= data
+		self.max_size=None
+		self.min_size=None
+		self.gui.capture(print_event,"mouseEntered")
+
+	def execute(self):
+		self.gui.distributeInitialData(self.initial_data)
+		self.gui.distributeData(self.data)
+
+		screen_w, screen_h = screen_width(), screen_height()
+		if self.max_size is None:
+			self.max_size = screen_w/2, screen_h/3
+		if self.min_size is None:
+			self.min_size = screen_w/2, screen_h/4
+		self.gui.max_size = self.max_size
+		self.gui.min_size = self.min_size
+
+		resultMap = {}
+		if self.gui.findChild(name="okButton"):
+			resultMap["okButton"] = OK
+
+		if self.gui.findChild(name="cancelButton"):
+			resultMap["cancelButton"] = CANCEL
+
+		if self.gui.findChild(name="yesButton"):
+			resultMap["noButton"] = NO
+
+		if self.gui.findChild(name="yesButton"):
+			resultMap["yesButton"] = YES
+
+		ok = self.gui.execute(resultMap)
+		if ok:
+			return self.getOkResult()
+		return self.getCancelResult()
+
+	def getOkResult(self):
+		if self.ok_field:
+			return self.gui.collectData(self.ok_field)
+		return True
+
+	def getCancelResult(self):
+		if self.cancel_field:
+			return self.gui.collectData(self.cancel_field)
+		return False
+
+MESSAGE_BOX_XML = """\
+<Window name="window" title="Message">
+<ScrollArea>
+<Label wrap_text="1" text="$MESSAGE" name="message" vexpanding="1"/>
+</ScrollArea>
+<HBox>
+<Spacer/><Button min_width="50" name="okButton" text="OK"/>
+</HBox>
+</Window>
+"""
+
+YESNO_BOX_XML = """\
+<Window name="window" title="Question">
+<ScrollArea>
+<Label wrap_text="1" text="$MESSAGE" name="message" vexpanding="1"/>
+</ScrollArea>
+<HBox>
+<Spacer/>
+<Button min_width="50" name="yesButton" text="Yes"/>
+<Button min_width="50" name="noButton" text="No"/>
+</HBox>
+</Window>
+"""
+
+YESNOCANCEL_BOX_XML = """\
+<Window name="window" title="Question">
+<ScrollArea>
+<Label wrap_text="1" text="$MESSAGE" name="message" vexpanding="1"/>
+</ScrollArea>
+<HBox>
+<Spacer/>
+<Button min_width="50" name="yesButton" text="Yes"/>
+<Button min_width="50" name="noButton" text="No"/>
+<Button min_width="50" name="cancelButton" text="Cancel"/>
+</HBox>
+</Window>
+"""
+
+SELECT_BOX_XML = """\
+<Window name="window" title="Select">
+<Label wrap_text="1" text="$MESSAGE" name="message"/>
+<ScrollArea>
+<ListBox name="selection">
+</ListBox>
+</ScrollArea>
+<HBox>
+<Spacer/>
+<Button min_width="50" name="okButton" text="Select"/>
+<Button min_width="50" name="cancelButton" text="Cancel"/>
+</HBox>
+</Window>
+"""
+
+EXCEPTION_CATCHER_XML="""\
+<Window name="window" title="An exception occurred - what now?">
+  <VBox hexpanding="1">
+    <Label wrap_text="1" max_width="400" text="$MESSAGE" name="message"/>
+    <ScrollArea>
+    <Label text="$MESSAGE" name="traceback"/>
+    </ScrollArea>
+  </VBox>
+  <HBox>
+    <Spacer/>
+    <Button name="yesButton" text="Retry"/>
+    <Button name="noButton" text="Ignore"/>
+    <Button name="cancelButton" text="Reraise"/>
+  </HBox>
+</Window>
+"""
+
+def _make_text(message):
+	if callable(message):
+		message = message()
+	if hasattr(message,"read"):
+		message = message.read()
+	return message
+
+def message(message="",caption="Message"):
+	text = _make_text(message)
+	dialog = XMLDialog(StringIO(MESSAGE_BOX_XML),
+		initial_data={'message':text,'window':caption})
+	dialog.gui.findChild(name="message").max_width = screen_width()/2 - 50
+	dialog.execute()
+
+def yesNo(message="",caption="Message"):
+	text = _make_text(message)
+	dialog = XMLDialog(StringIO(YESNO_BOX_XML),
+		initial_data={'message':text,'window':caption})
+	dialog.gui.findChild(name="message").max_width = screen_width()/2 - 50
+	return dialog.execute()
+
+def yesNoCancel(message="",caption="Message"):
+	text = _make_text(message)
+	dialog = XMLDialog(StringIO(YESNOCANCEL_BOX_XML),
+		initial_data={'message':text,'window':caption})
+	dialog.gui.findChild(name="message").max_width = screen_width()/2 - 50
+	return dialog.execute()
+
+def select(message="",options=[],caption="Message"):
+	text = _make_text(message)
+	dialog = XMLDialog(StringIO(SELECT_BOX_XML),
+		initial_data={'message':text,'window':caption})
+	dialog.size = screen_width()/3, 2*screen_height()/3
+
+	dialog.gui.findChild(name="message").max_width = screen_width()/2 - 50
+	listbox = dialog.gui.findChild(name="selection")
+	listbox.items = options
+	if dialog.execute():
+		return listbox.selected_item
+	return None
+
+def trace(f):
+	import sys, traceback
+	def new_f(*args,**kwargs):
+		try:
+			return pychan.tools.applyOnlySuitable(f,*args,**kwargs)
+
+		except Exception, e:
+			dialog = XMLDialog(StringIO(EXCEPTION_CATCHER_XML),
+			  initial_data={'message':str(e)}
+			)
+			tb = traceback.format_exception(sys.exc_type, sys.exc_value, sys.exc_traceback)
+			dialog.gui.findChild(name="traceback").text = "".join(tb)
+			dialog.min_size = screen_width()/2,3*screen_height()/4
+			dialog.max_size = screen_width()/2,3*screen_height()/4
+			result = dialog.execute()
+			if result == YES:
+				return new_f(*args,**kwargs)
+			elif result == NO:
+				return
+			raise
+	return new_f
+
diff -r 5816ab527da8 -r 54bfd1015b35 engine/extensions/pychan/events.py
--- a/engine/extensions/pychan/events.py	Sat Mar 14 12:03:56 2009 +0000
+++ b/engine/extensions/pychan/events.py	Sat Mar 14 12:13:29 2009 +0000
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 #coding: utf-8
 
 """
@@ -11,15 +12,39 @@
 Nevertheless to understand how its supposed to work
 take a look at L{EventMapper} and L{EventListener}
 
+Event callbacks
+---------------
+
+You can either write callbacks yourself or
+use L{tools.callBackWithArguments} or L{tools.attrSetCallback}
+to generate suitable callbacks.
+
+Here's an example callback::
+   def dumpEventInfo(event=0,widget=0):
+      print widget, " received the event ", event
+
+Note the signature - C{event} and C{widget} are keyword
+arguments passed to the callback. If doesn't accept either
+C{event} or C{widget} as argument, these are not passed.
+
+This way a simple function which ignores C{event} or C{widget}
+can be used, while they are available if needed.
+
+Currently only one callback can be set per event. In case
+you don't want to write your own callback that dispatches
+to different callbacks you can use L{tools.chainCallbacks}.
+
 Available Events
 ----------------
 
 """
 
-import fife
+from compat import guichan
+
 import exceptions
-import manager
+from internal import get_manager
 import tools
+import traceback
 
 EVENTS = [
 	"mouseEntered",
@@ -37,6 +62,11 @@
 # Add the EVENTS to the docs.
 __doc__ += "".join([" - %s\n" % event for event in EVENTS])
 
+# The line before seems to leak the variable event into the global namespace ... remove that!
+# This is a python problem, addressed in python3
+try: del event
+except:pass
+
 MOUSE_EVENT, KEY_EVENT, ACTION_EVENT = range(3)
 def getEventType(name):
 	if "mouse" in name:
@@ -50,8 +80,7 @@
 You passed None as parameter to %s.capture, which would normally remove a mapped event.
 But there was no event mapped. Did you accidently call a function instead of passing it?
 """
-
-class EventListener(fife.GUIEventListener):
+class EventListenerBase(object):
 	"""
 	Redirector for event callbacks.
 	Use *only* from L{EventMapper}.
@@ -60,45 +89,92 @@
 	virtual methods are called from C++ to - listen to
 	Guichan events.
 
-	When the module is first loaded the event handler
-	methods are auto-generated from the list L{EVENTS}.
-	This is effectively the same code as::
-	  def mouseEntered(self,event):
-	    self._redirectEvent("mouseEntered",event)
-
-	This way L{EVENTS} and the actually receivable events
-	are forced to be in sync.
 	"""
-	def __init__(self,debug=True):
-		super(EventListener,self).__init__()
+	def __init__(self):
+		super(EventListenerBase,self).__init__()
 		self.events = {}
 		self.indent = 0
-		self.debug = debug
-		self.guimanager = manager.Manager.manager.guimanager
+		self.debug = 1
+		self.is_attached = False
+
+	def attach(self,widget):
+		"""
+		Start receiving events.
+		No need to call this manually.
+		"""
+
+		if self.is_attached:
+			return
+		if not self.events:
+			return
+		if self.debug: print "Attach:",self
+		self.doAttach(widget.real_widget)
+		self.widget = widget
+		self.is_attached = True
+
+	def detach(self):
+		"""
+		Stop receiving events.
+		No need to call this manually.
+		"""
+		if not self.is_attached:
+			return
+		if self.debug: print "Detach:",self
+		self.doDetach(self.widget.real_widget)
+		self.widget = None
+		self.is_attached = False
 
 	def _redirectEvent(self,name,event):
 		self.indent += 4
-		event = self.translateEvent(getEventType(name), event)
-		if name in self.events:
-			if self.debug: print "-"*self.indent, name
-			for f in self.events[name].itervalues():
-				f( event )
-		self.indent -= 4
+		try:
+			event = self.translateEvent(getEventType(name), event)
+			if name in self.events:
+				if self.debug: print "-"*self.indent, name
+				for f in self.events[name].itervalues():
+					f( event )
+
+		except:
+			print name, event
+			traceback.print_exc()
+			raise
+
+		finally:
+			self.indent -= 4
 
 	def translateEvent(self,event_type,event):
 		if event_type == MOUSE_EVENT:
-			return self.guimanager.translateMouseEvent(event)
+			return get_manager().hook.translate_mouse_event(event)
 		if event_type == KEY_EVENT:
-			return self.guimanager.translateKeyEvent(event)
+			return get_manager().hook.translate_key_event(event)
 		return event
 
-def _redirect(name):
-	def redirectorFunc(self,event):
-		self._redirectEvent(name,event)
-	return redirectorFunc
+class _ActionEventListener(EventListenerBase,guichan.ActionListener):
+	def __init__(self):super(_ActionEventListener,self).__init__()
+	def doAttach(self,real_widget):	real_widget.addActionListener(self)
+	def doDetach(self,real_widget): real_widget.removeActionListener(self)
+
+	def action(self,e): self._redirectEvent("action",e)
+
+class _MouseEventListener(EventListenerBase,guichan.MouseListener):
+	def __init__(self):super(_MouseEventListener,self).__init__()
+	def doAttach(self,real_widget):	real_widget.addMouseListener(self)
+	def doDetach(self,real_widget): real_widget.removeMouseListener(self)
 
-for event_name in EVENTS:
-	setattr(EventListener,event_name,_redirect(event_name))
+	def mouseEntered(self,e): self._redirectEvent("mouseEntered",e)
+	def mouseExited(self,e): self._redirectEvent("mouseExited",e)
+	def mousePressed(self,e): self._redirectEvent("mousePressed",e)
+	def mouseReleased(self,e): self._redirectEvent("mouseReleased",e)
+	def mouseClicked(self,e): self._redirectEvent("mouseClicked",e)
+	def mouseMoved(self,e): self._redirectEvent("mouseMoved",e)
+	def mouseDragged(self,e): self._redirectEvent("mouseDragged",e)
+
+class _KeyEventListener(EventListenerBase,guichan.KeyListener):
+	def __init__(self):super(_KeyEventListener,self).__init__()
+	def doAttach(self,real_widget):	real_widget.addKeyListener(self)
+	def doDetach(self,real_widget): real_widget.removeKeyListener(self)
+
+	def keyPressed(self,e): self._redirectEvent("keyPressed",e)
+	def keyReleased(self,e): self._redirectEvent("keyReleased",e)
 
 class EventMapper(object):
 	"""
@@ -106,7 +182,7 @@
 	and derived classes.
 
 	Every PyChan widget has an L{EventMapper} instance
-	as attribute *event_mapper*.
+	as attribute B{event_mapper}.
 
 	This instance handles all necessary house-keeping.
 	Such an event mapper can be either *attached* or
@@ -124,44 +200,17 @@
 	def __init__(self,widget):
 		super(EventMapper,self).__init__()
 		self.widget = widget
-		self.listener = EventListener()
+		self.listener = {
+			KEY_EVENT    : _KeyEventListener(),
+			ACTION_EVENT : _ActionEventListener(),
+			MOUSE_EVENT  : _MouseEventListener(),
+		}
 		self.is_attached = False
-		self.debug = manager.Manager.manager.debug
+		self.debug = get_manager().debug
 
-	def __del__(self):
-		self.detach()
 	def __repr__(self):
 		return "EventMapper(%s)" % repr(self.widget)
 
-	def attach(self):
-		"""
-		Start receiving events.
-		No need to call this manually.
-		"""
-
-		if self.is_attached:
-			return
-		if not self.listener.events:
-			return
-		if self.debug: print "Attach:",self
-		self.widget.real_widget.addKeyListener( self.listener )
-		self.widget.real_widget.addMouseListener( self.listener )
-		self.widget.real_widget.addActionListener( self.listener )
-		self.is_attached = True
-
-	def detach(self):
-		"""
-		Stop receiving events.
-		No need to call this manually.
-		"""
-
-		if not self.is_attached:
-			return
-		if self.debug: print "Detach:",self
-		self.widget.real_widget.removeKeyListener( self.listener )
-		self.widget.real_widget.removeMouseListener( self.listener )
-		self.widget.real_widget.removeActionListener( self.listener )
-		self.is_attached = False
 
 	def capture(self,event_name,callback,group_name):
 		if event_name not in EVENTS:
@@ -169,32 +218,48 @@
 
 		if callback is None:
 			if self.isCaptured(event_name,group_name):
-				del self.listener.events[event_name][group_name]
-				if not self.listener.events[event_name]:
-					del self.listener.events[event_name]
-				if not self.listener.events:
-					self.detach()
+				self.removeEvent(event_name,group_name)
 			elif self.debug:
 				print CALLBACK_NONE_MESSAGE % str(self.widget)
 			return
+		self.addEvent(event_name,callback,group_name)
 
+	def isCaptured(self,event_name,group_name="default"):
+		return ("%s/%s" % (event_name,group_name)) in self.getCapturedEvents()
+
+	def getCapturedEvents(self):
+		events = []
+		for event_type, listener in self.listener.items():
+			for event_name, group in listener.events.items():
+				for group_name in group.keys():
+					events.append( "%s/%s" % (event_name, group_name) )
+		return events
+
+	def getListener(self,event_name):
+		return self.listener[getEventType(event_name)]
+
+	def removeEvent(self,event_name,group_name):
+		listener = self.getListener(event_name)
+		del listener.events[event_name][group_name]
+		if not listener.events[event_name]:
+			del listener.events[event_name]
+		if not listener.events:
+			listener.detach()
+
+	def addEvent(self,event_name,callback,group_name):
 		if not callable(callback):
 			raise RuntimeError("An event callback must be either a callable or None - not %s" % repr(callback))
 
 		def captured_f(event):
 			tools.applyOnlySuitable(callback,event=event,widget=self.widget)
 
-		if event_name not in self.listener.events:
-			self.listener.events[event_name] = {group_name : captured_f}
-		else:
-			self.listener.events[event_name][group_name] = captured_f
-		self.attach()
+		listener = self.getListener(event_name)
 
-	def isCaptured(self,event_name,group_name="default"):
-		return event_name in self.listener.events and group_name in self.listener.events[event_name]
-
-	def getCapturedEvents(self):
-		return self.listener.events.keys()
+		if event_name not in listener.events:
+			listener.events[event_name] = {group_name : captured_f}
+		else:
+			listener.events[event_name][group_name] = captured_f
+		listener.attach(self.widget)
 
 
 def splitEventDescriptor(name):
@@ -210,3 +275,4 @@
 		L = L[0],L[1],"default"
 	return L
 
+
diff -r 5816ab527da8 -r 54bfd1015b35 engine/extensions/pychan/exceptions.py
--- a/engine/extensions/pychan/exceptions.py	Sat Mar 14 12:03:56 2009 +0000
+++ b/engine/extensions/pychan/exceptions.py	Sat Mar 14 12:13:29 2009 +0000
@@ -31,6 +31,6 @@
 
 class PrivateFunctionalityError(RuntimeError):
 	"""
-	Exception raised if private attributes/functions are used."
+	Exception raised if private attributes/functions are used.
 	"""
 	pass
diff -r 5816ab527da8 -r 54bfd1015b35 engine/extensions/pychan/fonts.py
--- a/engine/extensions/pychan/fonts.py	Sat Mar 14 12:03:56 2009 +0000
+++ b/engine/extensions/pychan/fonts.py	Sat Mar 14 12:13:29 2009 +0000
@@ -5,7 +5,7 @@
 
 class Font(object):
 	def __init__(self,name,get):
-		from manager import Manager
+		from internal import get_manager
 		self.font = None
 		self.name = name
 		self.typename = get("type")
@@ -17,7 +17,7 @@
 			self.size = int(get("size"))
 			self.antialias = int(get("antialias",1))
 			self.color = map(int,get("color","255,255,255").split(','))
-			self.font = Manager.manager.guimanager.createFont(self.source,self.size,"")
+			self.font = get_manager().hook.engine.getGuiManager().createFont(self.source,self.size,"")
 
 			if self.font is None:
 				raise InitializationError("Could not load font %s" % name)
@@ -62,7 +62,7 @@
 	"""
 	Load fonts from a config file. These are then available via their name.
 	"""
-	from manager import Manager
+	from internal import get_manager
 
 	for font in Font.loadFromFile(filename):
-		Manager.manager.addFont(font)
+		get_manager().addFont(font)
diff -r 5816ab527da8 -r 54bfd1015b35 engine/extensions/pychan/internal.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/engine/extensions/pychan/internal.py	Sat Mar 14 12:13:29 2009 +0000
@@ -0,0 +1,208 @@
+# coding: utf-8
+
+from compat import guichan, in_fife
+import widgets
+import fonts
+from exceptions import *
+from traceback import print_exc
+
+def get_manager():
+	"""
+	Get the manager from inside pychan.
+
+	To avoid cyclic imports write::
+	   from internal import get_manager
+	"""
+	return Manager.manager
+
+def screen_width():
+	return get_manager().hook.screen_width
+
+def screen_height():
+	return get_manager().hook.screen_height
+
+class Manager(object):
+	manager = None
+
+	def __init__(self, hook, debug = False):
+		super(Manager,self).__init__()
+		self.hook = hook
+		self.debug = debug
+
+		if in_fife:
+			if not hook.engine.getEventManager():
+				raise InitializationError("No event manager installed.")
+			if not hook.engine.getGuiManager():
+				raise InitializationError("No GUI manager installed.")
+
+		self.fonts = {}
+		#glyphs = ' abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,!?-+/:();%`\'*#=[]"'
+		self.fonts['default'] = hook.default_font
+
+		self.styles = {}
+		self.addStyle('default',DEFAULT_STYLE)
+
+                Manager.manager = self
+
+		# Setup synchronous dialogs
+		self.mainLoop = None
+		self.breakFromMainLoop = None
+		self.can_execute = False
+
+		# Autopos
+		from autoposition import placeWidget
+		self.placeWidget = placeWidget
+
+	def setupModalExecution(self,mainLoop,breakFromMainLoop):
+		"""
+		Setup synchronous execution of dialogs.
+		"""
+		self.mainLoop = mainLoop
+		self.breakFromMainLoop = breakFromMainLoop
+		self.can_execute = True
+
+	def show(self,widget):
+		"""
+		Shows a widget on screen. Used by L{Widget.show} - do not use directly.
+		"""
+		self.placeWidget(widget, widget.position_technique)
+		self.hook.add_widget( widget.real_widget )
+
+	def hide(self,widget):
+		"""
+		Hides a widget again. Used by L{Widget.hide} - do not use directly.
+		"""
+		self.hook.remove_widget( widget.real_widget )
+
+	def setDefaultFont(self,name):
+		self.fonts['default'] = self.getFont(name)
+
+	def getFont(self,name):
+		"""
+		B{pending deprecation}
+
+		Returns a GuiFont identified by its name.
+
+		@param name: A string identifier from the font definitions in pychans config files.
+		"""
+		if in_fife:
+			font = self.fonts.get(name)
+			if isinstance(font,guichan.GuiFont):
+				return font
+			if hasattr(font,"font") and isinstance(getattr(font,"font"),guichan.GuiFont):
+				return font.font
+			return fonts.parseFontSpec(name)
+		else:
+			return self.hook.get_font(name)
+
+	def addFont(self,font):
+		"""
+		B{deprecated}
+
+		Add a font to the font registry. It's not necessary to call this directly.
+		But it expects a L{Font} instance and throws an L{InitializationError}
+		otherwise.
+
+		@param font: A L{Font} instance.
+		"""
+		if not isinstance(font,fonts.Font):
+			raise InitializationError("PyChan Manager expected a fonts.Font instance, not %s." % repr(font))
+		self.fonts[font.name] = font
+
+	def addStyle(self,name,style):
+		style = self._remapStyleKeys(style)
+
+		for k,v in self.styles.get('default',{}).items():
+			style[k] = style.get(k,v)
+		self.styles[name] = style
+
+	def stylize(self,widget, style, **kwargs):
+		style = self.styles[style]
+		for k,v in style.get('default',{}).items():
+			v = kwargs.get(k,v)
+			setattr(widget,k,v)
+
+		cls = widget.__class__
+		for applicable,specstyle in style.items():
+			if not isinstance(applicable,tuple):
+				applicable = (applicable,)
+			if cls in applicable:
+				for k,v in specstyle.items():
+					v = kwargs.get(k,v)
+					setattr(widget,k,v)
+
+	def _remapStyleKeys(self,style):
+		# Remap class names, create copy:
+		def _toClass(class_):
+			if class_ == "default":
+				return class_
+
+			if type(class_) == type(widgets.Widget) and issubclass(class_,widgets.Widget):
+				return class_
+			if not widgets.WIDGETS.has_key(str(class_)):
+				raise InitializationError("Can't resolve %s to a widget class." % repr(class_))
+			return widgets.WIDGETS[str(class_)]
+
+		style_copy = {}
+		for k,v in style.items():
+			if isinstance(k,tuple):
+				new_k = tuple(map(_toClass,k))
+			else:
+				new_k = _toClass(k)
+			style_copy[new_k] = v
+		return style_copy
+
+	def loadImage(self,filename):
+		if not filename:
+			  raise InitializationError("Empty Image file.")
+		return self.hook.load_image(filename)
+
+# Default Widget style.
+
+DEFAULT_STYLE = {
+	'default' : {
+		'border_size': 0,
+		'margins': (0,0),
+		'base_color' : guichan.Color(28,28,28),
+		'foreground_color' : guichan.Color(255,255,255),
+		'background_color' : guichan.Color(50,50,50),
+	},
+	'Button' : {
+		'border_size': 2,
+		'margins' : (5,2),
+		'min_size' : (15,10),
+	},
+	'CheckBox' : {
+		'border_size': 0,
+	},
+	'RadioButton' : {
+		'border_size': 0,
+		'background_color' : guichan.Color(0,0,0),
+	},
+	'Label' : {
+		'border_size': 0,
+	},
+	'ClickLabel' : {
+		'border_size': 0,
+	},
+	'ListBox' : {
+		'border_size': 0,
+	},
+	'Window' : {
+		'border_size': 0,
+		'margins': (5,5),
+		'opaque' : 1,
+		'titlebar_height' : 12,
+		'vexpanding' : 1,
+		#'background_image' : 'gui/backgrounds/background.png',
+		#'font' : 'samanata_large'
+	},
+	'TextBox' : {
+	},
+	('Container','HBox','VBox') : {
+		'border_size': 0,
+		'margins': (0,0),
+		'padding':2,
+		#'background_image' : 'gui/backgrounds/background.png',
+	}
+}
\ No newline at end of file
diff -r 5816ab527da8 -r 54bfd1015b35 engine/extensions/pychan/layout.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/engine/extensions/pychan/layout.py	Sat Mar 14 12:13:29 2009 +0000
@@ -0,0 +1,278 @@
+# coding: utf-8
+
+from attrs import IntAttr
+
+AlignTop, AlignBottom, AlignLeft, AlignRight, AlignCenter = range(5)
+def isLayouted(widget):
+	return isinstance(widget,LayoutBase)
+
+class LayoutBase(object):
+	"""
+	This class is at the core of the layout engine. The two MixIn classes L{VBoxLayoutMixin}
+	and L{HBoxLayoutMixin} specialise on this by reimplementing the C{resizeToContent} and
+	the C{expandContent} methods.
+
+	Dynamic Layouting
+	-----------------
+
+	The layout is calculated in the L{Widget.show} method. Thus if you modify the layout,
+	by adding or removing child widgets for example, you have to call L{widgets.Widget.adaptLayout}
+	so that the changes ripple through the widget hierachy.
+
+	Internals
+	---------
+
+	At the core the layout engine works in two passes:
+
+	Before a root widget loaded by the XML code is shown, its resizeToContent method
+	is called recursively (walking the widget containment relation in post order).
+	This shrinks all HBoxes and VBoxes to their minimum heigt and width.
+	After that the expandContent method is called recursively in the same order,
+	which will re-align the widgets if there is space left AND if a Spacer is contained.
+
+	Inside bare Container instances (without a Layout MixIn) absolute positioning
+	can be used.
+	"""
+	def __init__(self,align = (AlignLeft,AlignTop), **kwargs):
+		self.align = align
+		self.spacer = []
+		super(LayoutBase,self).__init__(**kwargs)
+
+	def addSpacer(self,spacer):
+		self.spacer.append(spacer)
+		spacer.index = len(self.children)
+
+	def xdelta(self,widget):return 0
+	def ydelta(self,widget):return 0
+
+	def _applyHeight(self, spacers = []):
+		y = self.border_size + self.margins[1]
+		ydelta = map(self.ydelta,self.children)
+		for index, child in enumerate(self.children):
+			while spacers and spacers[0].index == index:
+				y += spacers.pop(0).size
+			child.y = y
+			y += ydelta.pop(0)
+
+	def _adjustHeightWithSpacer(self):
+		pass
+
+	def _applyWidth(self, spacers = []):
+		x = self.border_size + self.margins[0]
+		xdelta = map(self.xdelta,self.children)
+		for index, child in enumerate(self.children):
+			while spacers and spacers[0].index == index:
+				x += spacers.pop(0).size
+			child.x = x
+			x += xdelta.pop(0)
+
+	def _expandWidthSpacer(self):
+		xdelta = map(self.xdelta,self.children)
+		xdelta += [spacer.min_size for spacer in self.spacer]
+
+		available_space = self.width - 2*self.margins[0] - 2*self.border_size - self._extra_border[0]
+
+		used_space = sum(xdelta)
+		if self.children:
+			used_space -= self.padding
+		if used_space >= available_space:
+			return
+
+		expandable_items = self._getExpanders(vertical=False)
+		#print "AS/US - before",self,[o.width for o in expandable_items]
+		#print "SPACERS",self.spacer
+
+		index = 0
+		while used_space < available_space and expandable_items:
+			index = index % len(expandable_items)
+
+			expander = expandable_items[index]
+			old_width = expander.width
+			expander.width += 1
+			if old_width == expander.width:
+				expandable_items.pop(index)
+			else:
+				used_space += 1
+				index += 1
+
+		#print "AS/US - after",self,[o.width for o in expandable_items]
+		#print "SPACERS",self.spacer
+		self._applyWidth(spacers = self.spacer[:])
+
+	def _expandHeightSpacer(self):
+		ydelta = map(self.ydelta,self.children)
+		ydelta += [spacer.min_size for spacer in self.spacer]
+
+		available_space = self.height - 2*self.margins[1] - 2*self.border_size - self._extra_border[1]
+
+		used_space = sum(ydelta)
+		if self.children:
+			used_space -= self.padding
+
+		if used_space >= available_space:
+			return
+
+		expandable_items = self._getExpanders(vertical=True)
+		#print "AS/US - before",self,[o.height for o in expandable_items]
+
+		index = 0
+		while used_space < available_space and expandable_items:
+			index = index % len(expandable_items)
+
+			expander = expandable_items[index]
+			old_width = expander.height
+			expander.height += 1
+			if old_width == expander.height:
+				expandable_items.pop(index)
+			else:
+				used_space += 1
+				index += 1
+
+		#print "AS/US - after",self,[o.height for o in expandable_items]
+		self._applyHeight(spacers = self.spacer[:])
+
+
+	def _getExpanders(self,vertical=True):
+		expanders = []
+		spacers = self.spacer[:]
+		for index, child in enumerate(self.children):
+			if spacers and spacers[0].index == index:
+				expanders.append( spacers.pop(0) )
+			#print self,child,child.expanding
+			if child.vexpanding and vertical:
+				expanders.append( child )
+			if child.hexpanding and not vertical:
+				expanders.append( child )
+		return expanders + spacers
+
+	def _resetSpacers(self):
+		for spacer in self.spacer:
+			spacer.size = 0
+
+class VBoxLayoutMixin(LayoutBase):
+	"""
+	A mixin class for a vertical layout. Do not use directly.
+	"""
+	def __init__(self,**kwargs):
+		super(VBoxLayoutMixin,self).__init__(**kwargs)
+
+	def resizeToContent(self, recurse = True):
+		self._resetSpacers()
+
+		max_w = self.getMaxChildrenWidth()
+		x = self.margins[0] + self.border_size
+		y = self.margins[1] + self.border_size
+		for widget in self.children:
+			widget.width = max_w
+			y += widget.height + self.padding
+
+		if self.children:
+			y -= self.padding
+
+		y += sum([spacer.min_size for spacer in self.spacer])
+
+		self.height = y + self.margins[1] + self.border_size + self._extra_border[1]
+		self.width = max_w + 2*x + self._extra_border[0]
+
+		self._applyHeight(spacers = self.spacer[:])
+		self._applyWidth()
+
+	def expandContent(self):
+		self._expandHeightSpacer()
+		if not self.hexpanding:return
+		for widget in self.children:
+			widget.width = self.width - 2*self.margins[0] - 2*self.border_size - self._extra_border[0]
+
+
+	def ydelta(self,widget):return widget.height + self.padding
+
+class HBoxLayoutMixin(LayoutBase):
+	"""
+	A mixin class for a horizontal layout. Do not use directly.
+	"""
+	def __init__(self,**kwargs):
+		super(HBoxLayoutMixin,self).__init__(**kwargs)
+
+	def resizeToContent(self, recurse = True):
+		self._resetSpacers()
+
+		max_h = self.getMaxChildrenHeight()
+		x = self.margins[0] + self.border_size
+		y = self.margins[1] + self.border_size
+		for widget in self.children:
+			widget.height = max_h
+			x += widget.width + self.padding
+		if self.children:
+			x -= self.padding
+		x += sum([spacer.min_size for spacer in self.spacer])
+
+		self.width = x + self.margins[0] + self._extra_border[0]
+		self.height = max_h + 2*y + self._extra_border[1]
+
+		self._applyHeight()
+		self._applyWidth(spacers = self.spacer[:])
+
+	def expandContent(self):
+		self._expandWidthSpacer()
+		if not self.vexpanding:return
+		for widget in self.children:
+			widget.height = self.height - 2*self.margins[1] - 2*self.border_size - self._extra_border[1]
+
+	def xdelta(self,widget):return widget.width + self.padding
+
+class Spacer(object):
+	""" A spacer represents expandable or fixed 'whitespace' in the GUI.
+
+	In a XML file you can get this by adding a <Spacer /> inside a VBox or
+	HBox element (Windows implicitly are VBox elements).
+
+	Attributes
+	----------
+
+	As with widgets a number of attributes can be set on a spacer (inside the XML definition).
+	
+	  - min_size: Int: The minimal size this Spacer is allowed to have.
+	  - max_size: Int: The maximal size this Spacer is allowed to have.
+	  - fixed_size: Int: Set min_size and max_size to the same vale - effectively a Fixed size spacer. 
+
+	"""
+
+	ATTRIBUTES = [
+		IntAttr('min_size'), IntAttr('size'), IntAttr('max_size'),
+		IntAttr('fixed_size'),
+	]
+
+	def __init__(self,parent=None,**kwargs):
+		self._parent = parent
+		self.min_size = 0
+		self.max_size = 1000
+		self.size = 0
+
+	def __str__(self):
+		return "Spacer(parent.name='%s')" % getattr(self._parent,'name','None')
+
+	def __repr__(self):
+		return "<Spacer(parent.name='%s') at %x>" % (getattr(self._parent,'name','None'),id(self))
+
+	def _getSize(self):
+		self.size = self._size
+		return self._size
+	def _setSize(self,size):
+		self._size = max(self.min_size, min(self.max_size,size))
+	size = property(_getSize,_setSize)
+
+	# Alias for size
+	width = property(_getSize,_setSize)
+	height = property(_getSize,_setSize)
+
+	def _setFixedSize(self,size):
+		self.min_size = self.max_size = size
+		self.size = size
+	fixed_size = property(fset=_setFixedSize)
+
+	def _isExpanding(self):
+		if self.min_size < self.max_size:
+			return 1
+		return 0
+	vexpanding = property(_isExpanding)
+	hexpanding = property(_isExpanding)
diff -r 5816ab527da8 -r 54bfd1015b35 engine/extensions/pychan/tools.py
--- a/engine/extensions/pychan/tools.py	Sat Mar 14 12:03:56 2009 +0000
+++ b/engine/extensions/pychan/tools.py	Sat Mar 14 12:13:29 2009 +0000
@@ -1,10 +1,14 @@
 # coding: utf-8
 
+"""
+Functional utilities designed for pychan use cases.
+"""
+
 import exceptions
 
 ### Functools ###
 
-def applyOnlySuitable(func,**kwargs):
+def applyOnlySuitable(func,*args,**kwargs):
 	"""
 	This nifty little function takes another function and applies it to a dictionary of
 	keyword arguments. If the supplied function does not expect one or more of the
@@ -20,11 +24,11 @@
 
 	#http://docs.python.org/lib/inspect-types.html
 	if code.co_flags & 8:
-		return func(**kwargs)
+		return func(*args,**kwargs)
 	for name,value in kwargs.items():
 		if name not in varnames:
 			del kwargs[name]
-	return func(**kwargs)
+	return func(*args,**kwargs)
 
 def callbackWithArguments(callback,*args,**kwargs):
 	"""
@@ -91,13 +95,31 @@
 			do_calls.append(name[4:])
 			del kwargs[name]
 
-	def callback(widget=None):
+	def attrSet_callback(widget=None):
 		for name,value in kwargs.items():
 			setattr(widget,name,value)
 		for method_name in do_calls:
 			method = getattr(widget,method_name)
 			method()
-	return callback
+	return attrSet_callback
+
+def chainCallbacks(*args):
+	"""
+	Chains callbacks to be called one after the other.
+	
+	Example Usage::
+	    def print_event(event=0):
+	      print event
+	    def print_widget(widget=0):
+	      print widget
+            callback = tools.chainCallbacks(doSomethingUseful, print_event, print_widget)
+	    guiElement.capture(callback)
+	"""
+	callbacks = args
+	def chain_callback(event=0,widget=0):
+		for callback in callbacks:
+			applyOnlySuitable(callback, event=event, widget=widget)
+	return chain_callback
 
 def this_is_deprecated(func,message=None):
 	if message is None:
diff -r 5816ab527da8 -r 54bfd1015b35 engine/extensions/pychan/widgets.py
--- a/engine/extensions/pychan/widgets.py	Sat Mar 14 12:03:56 2009 +0000
+++ b/engine/extensions/pychan/widgets.py	Sat Mar 14 12:13:29 2009 +0000
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 # coding: utf-8
 ### Widget/Container Base Classes ###
 
@@ -412,6 +413,8 @@
 		for name,data in dataMap.items():
 			widgetList = self.findChildren(name = name)
 			if len(widgetList) != 1:
+				if get_manager().debug:
+					self.listNamedWidgets()
 				raise RuntimeError("DistributeData can only handle widgets with unique names.")
 			widgetList[0].setData(data)
 
@@ -431,6 +434,8 @@
 		for name in widgetNames:
 			widgetList = self.findChildren(name = name)
 			if len(widgetList) != 1:
+				if get_manager().debug:
+					self.listNamedWidgets()
 				raise RuntimeError("CollectData can only handle widgets with unique names.")
 
 			dataMap[name] = widgetList[0].getData()
@@ -461,6 +466,8 @@
 		for name in widgetNames:
 			widgetList = self.findChildren(name = name)
 			if len(widgetList) != 1:
+				if get_manager().debug:
+					self.listNamedWidgets()
 				raise RuntimeError("CollectData can only handle widgets with unique names.")
 			dataList.append( widgetList[0].getData() )
 		if len(dataList) == 1: