context 0.0.16

data/lib/Context/Context.rb

@@ -0,0 +1,146 @@
+require 'Context/KeyMap'
+require 'Context/ExecutionProxy'
+
+module Context
+
+    # The Context is the Presenter in the Model, View, Presentor (MVP)
+    # model.  It is an object that holds the logic for the UI
+    # scenario that the application is currently in.  Context is
+    # an abstract class. 
+    #
+    # A Context is made up of views, model objects and other sub-contexts.
+    # One of the views should be a UI widget container that contains all
+    # of the views for the Context.  The concrete classes should define
+    # the logic for the Context that is either called by enter()
+    # or called from one of the contained views.
+    #
+    # Note that views are usually only instantiated in createViews, which
+    # is called on enter(), not on Context creation.  However, there is
+    # no requirement for this.
+	class Context
+		attr_reader :parent, :mainView
+		attr_writer :mainView
+
+        # Create a new Context.  Takes a Bridge that is used to
+        # create the View s in using the correct namespace.	
+		def initialize(viewBridge)
+			@parent = nil
+			@mainView = nil
+			@viewBridge = viewBridge
+			@keyMap = KeyMap.new
+			@entered = false
+		end
+
+        # Creates the views for the context.  This method is called
+        # automatically by enter() and probably should not be called otherwise.
+	    # This method should be overriden by the concrete class.  It
+	    # should instantiate all the views and set @mainView
+	    def createViews
+	        # Nothing to do here
+	    end
+	    
+	    # This is intended to be private (how do I do that again?)
+	    # Just so that it doesn't create a view if it is already created
+	    def setupViews
+	        if @mainView.nil?
+	            createViews
+	        end
+	    end
+	    
+	    # Creates views and returns the main View.  This is intended
+	    # to be used by test code where entering the context executes
+	    # code and you need to know what the view will be ahead of time.
+	    # I can think of no reason to use this in production code.
+	    def peekAtView
+	        setupViews
+	        @mainView
+	    end
+
+        # Destroys the views for the context.  This method is called
+        # automatically by exit() and probably should not be called otherwise.
+	    # This method should be overriden by the concrete class.  It
+	    # should destroy all the views and set @mainView to nil
+	    def destroyViews
+	        @mainView = nil
+	    end
+	
+	    # Adds a view to the mainView
+	    # Since the mainView is intended to be a UI container that contains
+	    # all the views, this method is called by a sub-context's enter()
+	    # method to allow the parent's mainView to contain the sub-context's
+	    # views.
+		def addView(view)
+			@mainView.addView(view) unless @mainView.nil?
+		end
+		
+		# Enters the Context.  After it is called, the Context is then
+		# active and can be interacted with.  This method automatically
+		# calls createViews() and adds the mainView to the parent's view.
+		# 
+		# Usually this method will be overriden by the concrete class.
+		# However, it should be careful to call super() in the appropriate
+		# place.
+		def enter(parent)
+			@parent = parent
+			if (@parent != nil)
+			    @entered = true
+			    setupViews
+				parent.addView(@mainView) unless @mainView.nil?
+			end
+		end
+		
+		# Returns true if the context has been entered, but not exited.
+		# Returns false if the context has never been entered, or if
+		# it has been entered and then exited.
+		def isEntered?
+		    @entered
+		end
+		
+		# Exits the Context.  After it is called, the context is no longer
+		# active and can't be interacted with.  This method automatically
+		# removes the mainView from the parent's view and calls destroyViews().
+		#
+		# Usually this method will be overriden by the concrete class.
+		# However, it should be careful to call super() in the appropriate
+		# place.
+		def exit()
+		    @entered = false
+            if !@parent.nil? && !@parent.mainView.nil?
+                @parent.mainView.removeView(@mainView) unless @mainView.nil?
+            end
+            destroyViews
+		end
+		    
+		# Sets a binding for a key.
+		# Whenever a key is pressed, the context is notified.  This
+		# sets up a binding between the key and the block passed in.
+		# After that point, the block will be called everytime the
+		# key is pressed.
+		#
+		# Warning: This key binding mechanism is likely to be
+		# depracated, or at least heavily modified soon.
+		def setKeyBinding(key, &binding)
+		    a = KeyAssignment.new(key, &binding)
+		    @keyMap.add(a)
+		end
+		
+		# Returns the existing binding for a key.
+		#
+		# Warning: This key binding mechanism is likely to be
+		# depracated, or at least heavily modified soon.
+		def getKeyBinding(key)
+		    a = @keyMap.findKey(key)
+		    a.unless_nil.action
+		end
+		
+		# Called by the view to indicated that a key has been pressed.
+		# Runs the binding in the keymap, or returns nil if there
+		# isn't one.
+		#
+		# Warning: This key binding mechanism is likely to be
+		# depracated, or at least heavily modified soon.
+		def notifyKey(view, key)
+		    @keyMap.unless_nil do press(key) end
+		end
+	end
+end

data/lib/Context/EnumeratedType.rb

@@ -0,0 +1,51 @@
+module Context
+
+    # Class that holds a series of constants that act as an
+    # enumerated type.  The first ID added to the type is
+    # set to the value 0 (or at the value specified in start_at).
+    # each subsequent ID added to the type is automatically
+    # incremented 
+	class EnumeratedType
+		# Use singleton class to define class methods
+		class << self
+		    # Set the value that the first ID should start at.
+		    # Note: This must called *before* add() or symbols()
+			def start_at(n)
+				@nextValue = n
+			end
+
+            # Add a single ID to the enumerated type
+            # Usually called like:
+            #     add MY_ID
+			def add(id)
+				@nextValue ||= 0
+				const_set(id, @nextValue)
+				@nextValue += 1
+			end
+			
+			# Add a group of IDs to the enumerated type.
+			# This method takes an array.
+			# Usually called like:
+			#     symbols [ID1, ID2, ID3,...]
+			def symbols(array)
+				array.each do |id|
+					add(id)
+				end
+			end
+
+            # Returns true if the ID has been defined in the enumerated type.
+			def responds_to?(id)
+				name = id.id2name
+				return true if self.const_defined?(name)
+			end
+
+            # Retrieve the value of the ID
+            # If the ID is defined, return it's value.
+			def method_missing(id)
+				name = id.id2name
+				self.const_get(name) if self.const_defined?(name)
+			end
+		end
+	end
+end
+

data/lib/Context/ExecutionProxy.rb

@@ -0,0 +1,61 @@
+module Context
+
+    # A Proxy for carrying on conditional execution.
+    class ExecutionProxy
+        # Set the true object on which to execute and the condition to execute.
+        # NOTE: The condition is a bool.  In other words it has *already*
+        # been evaluated before we get to this point.
+        def initialize(object, cond)
+            @object = object
+            @cond = cond
+        end
+        
+        # Conditionally execute the block.  If the condition is true,
+        # execute the block.  Otherwise return the true object.
+        # NOTE: Crazy name is so that you don't have something with
+        # the same name and accidently call it with method_missing.
+        def execute_if_you_can(&block)
+            if @cond
+                @object.instance_eval(&block)
+            else
+                @object
+            end
+        end
+        
+        # Conditionally evaluate the symbol.  If the condition is true,
+        # evaluate the symbol.  Otherwise return the true object.
+        def method_missing(symbol)
+            if @cond
+                @object.instance_eval(symbol.to_s)
+            else
+                @object
+            end
+        end
+    end
+end
+
+class Object
+
+    # Execute the block if the condition is *true*.  Or if there is no
+    # block, then return the proxy object.  Usually this is so you
+    # can say something like:
+    # * object.execute_if(condition).property
+    # If the condition is *false*, execution of the block, or evaluation
+    # of the property will return the original object.
+    def execute_if(cond, &block)
+        proxy = Context::ExecutionProxy.new(self, cond)
+        # Note: Wouldn't it be nice if the following could be replaced by
+        # proxy.execute_if(!block.nil) do execute_if_you_can(&block) end
+        proxy_if_block_exists = Context::ExecutionProxy.new(proxy, !block.nil?)
+        proxy_if_block_exists.execute_if_you_can() do 
+            execute_if_you_can(&block) 
+        end
+    end
+    
+    # If the object is not nil, execute the block (or evaluate
+    # the property).  Otherwise return nil.
+    def unless_nil(&block)
+        execute_if(!nil?, &block)
+    end
+end
+

data/lib/Context/Gtk/App.rb

@@ -0,0 +1,28 @@
+require 'Context/Bridge'
+require 'Context/Context'
+require 'gtk2'
+
+module Context::Gtk
+	class App < Context::Context
+
+		attr_reader :mainContext
+
+		def initialize(namespace, context)
+			viewBridge = Context::Bridge.new(namespace)
+			super(viewBridge)
+			Gtk.init
+			@mainContext = context.new(viewBridge)
+		end
+	
+		def enter
+			super(nil)
+			@mainContext.enter(self)
+			Gtk.main
+		end
+	
+		def exit
+			super()
+			Gtk.main_quit
+		end
+	end
+end

data/lib/Context/Gtk/Key.rb

@@ -0,0 +1,54 @@
+require 'Context/Key'
+require 'gtk2'
+
+module Context::Gtk
+
+	class Key < Context::Key
+		
+		def Key::getModifierFromEvent(event)
+			case event.state
+                when 0
+                    Context::Key::Modifier::NONE
+				when Gdk::Window::CONTROL_MASK
+					Context::Key::Modifier::CONTROL
+				else
+					Context::Key::Modifier::ERROR
+			end
+		end
+		
+		def getGtkState
+			case @modifier
+				when Context::Key::Modifier::CONTROL
+					Gdk::Window::CONTROL_MASK
+				else
+				    0
+			end
+		end
+		
+		def Key::getCharacterFromEvent(event)
+            Gdk::Keyval::to_name(event.keyval)
+		end
+		
+		def getGtkKeyval
+            Gdk::Keyval::from_name(@character)
+		end
+		
+		def Key::createFromGtkEvent(event)
+			modifier = getModifierFromEvent(event)
+			character = getCharacterFromEvent(event)
+			if((modifier != Context::Key::Modifier::ERROR) && 
+               (!character.nil?))
+				Key.new(modifier, character)
+			else
+				Key.null
+			end
+		end
+		
+		def createGtkEvent
+			event = Gdk::EventKey.new(Gdk::Event::KEY_PRESS)
+			event.set_state(getGtkState)
+			event.set_keyval(getGtkKeyval)
+			event
+		end					
+	end
+end

data/lib/Context/Gtk/Widget.rb

@@ -0,0 +1,57 @@
+require 'Context/Widget'
+require 'gtk2'
+
+module Context::Gtk
+
+	class Widget < Context::Widget
+	    attr_reader :mainWindow, :expandHeight, :expandWidth
+	    attr_writer :mainWindow, :expandHeight, :expandWidth
+	    
+	    class << self
+	        # Redefine this in tests so that the widgets don't get displayed
+	        # on the screen.
+	        def inTests
+	            false
+	        end
+	    end
+	    
+	    def initialize(delegate)
+	        super(delegate)
+	        @mainWindow = nil
+	        # Packing hints for the container
+	        @expandHeight = false
+	        @expandWidth = false
+	    end
+	    
+	    def isAMainWindow
+	        @mainWindow = @delegate
+	    end
+	
+		def add(widget)
+   		    if !widget.delegate.class.ancestors.include?(Gtk::Window)
+    		    widget.mainWindow = @mainWindow
+    			@delegate.add(widget.delegate)
+    			if !Widget.inTests
+            		@delegate.show_all
+                end
+    	    else
+    	        widget.isAMainWindow
+    	        widget.delegate.set_transient_for(@mainWindow)
+    	        if !Widget.inTests
+        		    widget.delegate.show_all
+        		end
+    	    end
+		end
+
+        def remove(widget)
+            widget.mainWindow = nil
+   		    if !widget.delegate.class.ancestors.include?(Gtk::Window)   
+                @delegate.remove(widget.delegate)
+                if !Widget.inTests
+                    @delegate.show_all
+                end
+            end
+            @delegate.grab_focus
+        end
+	end
+end

data/lib/Context/Key.rb

@@ -0,0 +1,57 @@
+require 'Context/EnumeratedType'
+
+module Context
+
+    # Represents a keypress.  Each key is represented
+    # by a character and a modifier (e.g., the control
+    # key)
+    #
+    # One could argue that this doesn't deserve to be
+    # here at all.  It is possible that some UI types
+    # won't have a keyboard at all.  However given that
+    # most will operate the same way indicates that
+    # it should have some level of abstraction.  I have
+    # a feeling that this is YAGNI, though.  And as such
+    # it might disappear at any point.
+	class Key
+	    # Types of key modifiers. Currently only
+	    # control or none is supported.
+		class Modifier < EnumeratedType
+			start_at 0
+			symbols [:ERROR, :NONE, :CONTROL]
+		end
+	
+		attr_reader :modifier, :character
+		
+		def initialize(modifier, character)
+			@modifier = modifier
+			@character = character
+		end	
+		
+		# A non key that can be used as an error condition.
+		# Note: Perhaps this should be a constant???  Currently
+		# key.eql?(Key.null) will work, but key == Key.null
+		# won't.  FIXME
+		def Key.null
+			Key.new(Modifier.NONE, '\0')
+		end	
+		
+		# Returns true if the two keys have the same character and modifier.
+		def eql?(key)
+			(@modifier == key.modifier) && (@character == key.character)
+		end
+
+        # Creates a hash for the key.  This is needed for the KeyMap
+        # which is implemented as a hash.		
+		def hash
+			hashValue = @modifier.to_s
+			hashValue += @character
+			hashValue.hash
+		end
+
+        # Returns true if the key is equal to Key.null.		
+		def null?
+			eql?(Key.null)
+		end
+	end
+end