--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tools/editor/scripts/events/events.py	Mon Jan 11 23:34:52 2010 +0000
@@ -0,0 +1,280 @@
+# -*- coding: utf-8 -*-
+
+# ####################################################################
+#  Copyright (C) 2005-2009 by the FIFE team
+#  http://www.fifengine.de
+#  This file is part of FIFE.
+#
+#  FIFE 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.
+#
+#  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.,
+#  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+# ####################################################################
+from fife import fife
+import scripts
+from fife.fife import IKeyListener, ICommandListener, IMouseListener, LayerChangeListener, MapChangeListener, ConsoleExecuter
+from signal import Signal
+import pdb
+
+#--- Signals ---#
+onPump = Signal()
+preSave	= Signal(providing_args=["mapview"])
+postSave = Signal(providing_args=["mapview"])
+mapAdded = Signal(providing_args=["mapview"])
+preMapShown = Signal(providing_args=["mapview"])
+postMapShown = Signal(providing_args=["mapview"])
+preMapClosed = Signal(providing_args=["mapview"])
+postMapClosed = Signal(providing_args=["mapview"])
+onInstancesSelected = Signal(providing_args=["instances"])
+onObjectSelected = Signal(providing_args=["object"])
+onObjectsImported = Signal(providing_args=[])
+
+# Signals emitted by EventListener
+onQuit			= Signal(providing_args=[])
+keyPressed		= Signal(providing_args=["event"])
+keyReleased		= Signal(providing_args=["event"])
+mouseEntered	= Signal(providing_args=["event"])
+mouseExited		= Signal(providing_args=["event"])
+mousePressed	= Signal(providing_args=["event"])
+mouseReleased	= Signal(providing_args=["event"])
+mouseClicked	= Signal(providing_args=["event"])
+mouseWheelMovedUp = Signal(providing_args=["event"])
+mouseWheelMovedDown = Signal(providing_args=["event"])
+mouseMoved		= Signal(providing_args=["event"])
+mouseDragged	= Signal(providing_args=["event"])
+onLayerChanged	= Signal(providing_args=["layer", "changedInstances"])
+onInstanceCreate = Signal(providing_args=["layer", "instance"])
+onInstanceDelete = Signal(providing_args=["layer", "instance"])
+onMapChanged	= Signal(providing_args=["map", "changedLayers"])
+onLayerCreate	= Signal(providing_args=["map", "layer"])
+onLayerDelete	= Signal(providing_args=["map", "layer"])
+onToolsClick	= Signal(providing_args=[])
+onCommand		= Signal(providing_args=["command"])
+onConsoleCommand= Signal(providing_args=["command"])
+
+class KeySequence(object):
+	def __init__(self):
+		self.key = None
+		self.modifiers = {"alt":False,"ctrl":False,"shift":False,"meta":False}
+		self.signal = None
+
+class EventListener:
+	# NOTE: As FIFEdit currently covers the entire screen with widgets,
+	#		FIFE doesn't receive any mouse or key events. Therefore we have to add
+	#		mouse and key event tracking for the central widget
+	
+	def __init__(self, engine):
+		self.engine = engine
+		
+		eventmanager = self.engine.getEventManager()
+		self.keysequences = []
+		
+		self.keylistener			= _IKeyListener(engine)
+		self.mouselistener			= _IMouseListener(engine)
+		self.mapchangelistener		= _MapChangeListener(engine)
+		self.layerchangelistener	= _LayerChangeListener(engine)
+		self.commandlistener		= _ICommandListener(engine)
+		self.consoleexecuter		= _ConsoleExecuter(engine)
+		
+		self.controlPressed = False
+		self.altPressed		= False
+		self.shiftPressed	= False
+		self.metaPressed	= False
+		
+		eventmanager.addKeyListener(self.keylistener)
+		eventmanager.addCommandListener(self.commandlistener)
+		eventmanager.addMouseListener(self.mouselistener)
+		self.engine.getGuiManager().getConsole().setConsoleExecuter(self.consoleexecuter)
+		
+		keyPressed.connect(self.keyPressed)
+		keyReleased.connect(self.keyReleased)
+		
+
+	def getKeySequenceSignal(self, key, modifiers=[]):
+		# Parse modifiers
+		mods = {"alt":False,"ctrl":False,"shift":False,"meta":False}
+		for m in modifiers:
+			m = m.lower()
+			if m in mods:
+				mods[m] = True
+			else:
+				print "Unknown modifier:",m
+		
+		# Check if signal for keysequence has been created
+		for k in self.keysequences:
+			if k.key == key and k.modifiers == mods:
+				return k.signal
+				
+		# Create keysequence and signal
+		keysequence = KeySequence()
+		keysequence.key = key
+		keysequence.modifiers = mods
+		keysequence.signal = Signal(providing_args=["event"])
+		self.keysequences.append(keysequence)
+		
+		return keysequence.signal
+		
+	# IKeyListener
+	def keyPressed(self, event):
+		keyval = event.getKey().getValue()
+		keystr = event.getKey().getAsString().lower()
+		
+		self.controlPressed = event.isControlPressed()
+		self.altPressed		= event.isAltPressed()
+		self.shiftPressed	= event.isShiftPressed()
+		self.metaPressed	= event.isMetaPressed()
+		
+		if keyval in (fife.Key.LEFT_CONTROL, fife.Key.RIGHT_CONTROL):
+			self.controlPressed = True
+		elif keyval in (fife.Key.LEFT_SHIFT, fife.Key.RIGHT_SHIFT):
+			self.shiftPressed = True
+		elif keyval in (fife.Key.LEFT_ALT, fife.Key.RIGHT_ALT):
+			self.altPressed = True
+		elif keyval in (fife.Key.RIGHT_META, fife.Key.LEFT_META):
+			self.metaPressed = True
+	
+		elif keyval == fife.Key.ESCAPE:
+			scripts.editor.getEditor().quit()
+		elif keyval == fife.Key.F10:
+			self.engine.getGuiManager().getConsole().toggleShowHide()
+		elif keystr == "d":
+			pdb.set_trace()
+			
+		# Check keysequences
+		for k in self.keysequences:
+			if k.modifiers["alt"] != self.altPressed: continue
+			if k.modifiers["ctrl"] != self.controlPressed: continue
+			if k.modifiers["shift"]	!= self.shiftPressed: continue
+			if k.modifiers["meta"] != self.metaPressed: continue
+			if keyval != k.key: continue
+			k.signal.send(sender=self, event=event)
+
+	def keyReleased(self, event):
+		keyval = event.getKey().getValue()
+		
+		self.controlPressed = event.isControlPressed()
+		self.altPressed		= event.isAltPressed()
+		self.shiftPressed	= event.isShiftPressed()
+		self.metaPressed	= event.isMetaPressed()
+		
+		if keyval in (fife.Key.LEFT_CONTROL, fife.Key.RIGHT_CONTROL):
+			self.controlPressed = False
+		elif keyval in (fife.Key.LEFT_SHIFT, fife.Key.RIGHT_SHIFT):
+			self.shiftPressed = False
+		elif keyval in (fife.Key.LEFT_ALT, fife.Key.RIGHT_ALT):
+			self.altPressed = False
+		elif keyval in (fife.Key.RIGHT_META, fife.Key.LEFT_META):
+			self.metaPressed = False
+
+	
+#--- Internal sublistener classes ---#
+class _IKeyListener(IKeyListener):
+	def __init__(self, engine):
+		IKeyListener.__init__(self)
+		self.engine = engine
+		
+	# IKeyListener
+	def keyPressed(self, evt):
+		keyPressed.send(sender=self.engine, event=evt)
+
+	def keyReleased(self, evt):
+		keyReleased.send(sender=self.engine, event=evt)
+
+class _ICommandListener(ICommandListener):
+	def __init__(self, engine):
+		ICommandListener.__init__(self)
+		self.engine = engine
+		
+	# ICommandListener
+	def onCommand(self, command):
+		if command.getCommandType() == fife.CMD_QUIT_GAME:
+			scripts.editor.getEditor().quit()
+		else:
+			onCommand.send(sender=self.engine, command=command)
+		
+class _IMouseListener(IMouseListener):
+	def __init__(self, engine):
+		IMouseListener.__init__(self)
+		self.engine = engine
+		
+	# IMouseListener
+	def mouseEntered(self, evt):
+		mouseEntered.send(sender=self.engine, event=evt)
+	
+	def mouseExited(self, evt):
+		mouseExited.send(sender=self.engine, event=evt)
+	
+	def mousePressed(self, evt):
+		mousePressed.send(sender=self.engine, event=evt)
+	
+	def mouseReleased(self, evt):
+		mouseReleased.send(sender=self.engine, event=evt)
+	
+	def mouseClicked(self, evt):
+		mouseClicked.send(sender=self.engine, event=evt)
+	
+	def mouseWheelMovedUp(self, evt):
+		mouseWheelMovedUp.send(sender=self.engine, event=evt)
+	
+	def mouseWheelMovedDown(self, evt):
+		mouseWheelMovedDown.send(sender=self.engine, event=evt)
+	
+	def mouseMoved(self, evt):
+		mouseMoved.send(sender=self.engine, event=evt)
+	
+	def mouseDragged(self, evt):
+		mouseDragged.send(sender=self.engine, event=evt)
+
+class _MapChangeListener(MapChangeListener):
+	def __init__(self, engine):
+		MapChangeListener.__init__(self)
+		self.engine = engine
+		
+	# MapChangeListener
+	def onMapChanged(self, map, changedLayers):
+		onMapChanged.send(sender=self.engine, map=map, changedLayers=changedLayers)
+		
+	def onLayerCreate(self, map, layer):
+		onLayerCreate.send(sender=self.engine, map=map, layer=layer)
+		
+	def onLayerDelete(self, map, layer):
+		onLayerDelete.send(sender=self.engine, map=map, layer=layer)
+		
+class _LayerChangeListener(LayerChangeListener):
+	def __init__(self, engine):
+		LayerChangeListener.__init__(self)
+		self.engine = engine
+		
+	# LayerChangeListener
+	def onLayerChanged(self, layer, changedInstances):
+		onLayerChanged.send(sender=self.engine, layer=layer, changedInstances=changedInstances)
+		
+	def onInstanceCreate(self, layer, instance):
+		onInstanceCreate.send(sender=self.engine, layer=layer, instance=instance)
+		
+	def onInstanceDelete(self, layer, instance):
+		onInstanceDelete.send(sender=self.engine, layer=layer, instance=instance)
+		
+class _ConsoleExecuter(ConsoleExecuter):
+	def __init__(self, engine):
+		ConsoleExecuter.__init__(self)
+		self.engine = engine
+		
+	# ConsoleExecuter
+	def onToolsClick(self):
+		onToolsClick.send(sender=self.engine)
+		
+	def onConsoleCommand(self, command):
+		onConsoleCommand.send(sender=self.engine, command=command)
+		
+		
\ No newline at end of file