context 0.0.16 → 0.0.22

data/lib/Context/Log.rb

@@ -0,0 +1,10 @@
+module Context
+
+    # Implements some rudimentary logging for context.
+    # This is basically just to output warnings.
+    class Log
+         def Log::warning(system, message)
+             $stderr.print("WARNING #{system}: #{message}\n")
+         end
+    end
+end

data/lib/Context/Publisher.rb

@@ -0,0 +1,108 @@
+module Context
+
+    # Publisher implements an observer pattern.
+    # An object creates a Publisher, using itself as the source.
+    # It can then publish to several different streams.  Observers can
+    # subscribe to a stream.  When the stream for an observer
+    # is updated, a method on each observer, named <stream>Updated(),
+    # is called. The source is passed to this method.
+    # In Context, Publishers are usually used to notify Contexts
+    # when model objects have been updated (and hence the view
+    # needs to change).
+    class Publisher
+        attr_reader :source
+
+        # Create a Publisher with the source as the source object.
+        def initialize(source)
+            @source = source
+            @streamSubscribers = {}
+            @blocked = false
+        end
+        
+        # Subscribe an observer to a stream.  The stream must be
+        # a string.  It is allowable to observe to streams that
+        # don't exist.  The observer *must* implement
+        # <stream>Updated(source).  For example if in a method
+        # of class A I write: 
+        #      publisher.subscribe(self, "hello")
+        # then A *must* implement the method helloUpdated(source)
+        # otherwise the program will crash when the stream
+        # is publish.
+        def subscribe(observer, stream)
+            if @streamSubscribers.has_key?(stream)
+                observers = @streamSubscribers[stream]
+                if !observers.find do |x|
+                        x == observer
+                    end
+                    observers.push(observer)
+                end
+            else
+                @streamSubscribers[stream] = [observer]
+            end
+        end
+        
+        # Unsubscribe an observer from the stream.
+        # Remove the observer from the list of objects
+        # that are subscribed to the stream.
+        # Very Important Note: If you don't unsubscribe
+        # from a publisher at the end of the lifetime
+        # of your object, the publisher will retain
+        # a reference to the object.  This means it will
+        # continue to exist until the publisher is destroyed.
+        # This could potentially cause problems in your code.
+        # *Always* unsubscribe from a Publisher when you are
+        # finished with the object.
+        def unsubscribe(observer, stream)
+            if @streamSubscribers.has_key?(stream)
+                observers = @streamSubscribers[stream]
+                observers.delete(observer)
+            end
+        end
+        
+        # Publish to the observers that the stream has been updated.
+        # This is usually called by the source object, but it
+        # doesn't have to be.  The source object can also be changed
+        # (it defaults to the source in the Publisher).  This is
+        # useful if a source is publishing on behalf of another object
+        # (essentially acting as a mediator).
+        def update(stream, source=@source)
+            if blocked?
+                return
+            end
+            if @streamSubscribers.has_key?(stream)
+                @streamSubscribers[stream].each do |subscriber|
+                    eval("subscriber." + stream + "Updated(source)")
+                end
+            end
+        end
+
+        # Returns true if the publisher is blocked.
+        # A blocked publisher will not publish, even if
+        # update() is called.
+        def blocked?
+            @blocked
+        end
+        
+        # Block a publisher from publishing.  A blocked publisher
+        # will not publish to observers, even if update() is
+        # called.  This is useful for when you know that the
+        # source is being updated a lot and you only want to
+        # signal it at the end (for instance when you are loading
+        # a file).
+        # Important Note: block() and unblock() are not counted.
+        # No matter how many times you call block(), the first
+        # unblock() will unblock it.
+        def block
+            @blocked = true
+        end
+        
+        # Unblock a publisher so that it may continue to publish.
+        # Important Note: block() and unblock() are not counted.
+        # No matter how many times you call block(), the first
+        # unblock() will unblock it.
+        def unblock
+            @blocked = false
+        end
+    end
+
+end

data/lib/Context/Spec.rb

@@ -0,0 +1,8 @@
+# This is simply a handy way to predefine Context::Spec so that
+# I don't have to indent things like crazy elsewhere.
+# Suppose I can potentially put useful things here someday.
+
+module Context
+    module Spec
+    end
+end

data/lib/Context/Version.rb

@@ -1,5 +1,5 @@
 module Context
 
-	VERSION = "0.0.16"
+	VERSION = "0.0.22"
 
 end

data/lib/Context/View.rb

@@ -12,38 +12,39 @@ module Context
 			if(myWidget != nil)
 				newWidget = view.getWidget()
 				if !newWidget.nil?
-    				myWidget.add(newWidget)
-    				newWidget.addedTo(myWidget)
+    				myWidget.addToThisWidget(newWidget)
+    				newWidget.widgetWasAddedTo(myWidget)
     		    end
 			end
+            view.viewAddedTo(self)
 		end
+        
+        # Override this method to do something when your view has been
+        # added to another view.  Most useful for adding subviews
+        def viewAddedTo(parent)
+        end
 
         def removeView(view)
+            view.removingViewFrom(self)
             myWidget = getWidget()
             if(myWidget != nil)
                 oldWidget = view.getWidget()
                 if !oldWidget.nil?
-                    myWidget.remove(oldWidget)
-                    oldWidget.removedFrom(myWidget)
+                    myWidget.removeFromThisWidget(oldWidget)
+                    oldWidget.widgetWasRemovedFrom(myWidget)
                 end
             end
         end
-		
-		# Concrete classes should override this method
-		def open
-		end
-		
-		# Concrete classes should override this method
-		def close
-		end
 
+        # Override this method to do something when your view being
+        # removed from another view.  Most useful for removing subviews
+        def removingViewFrom(parent)
+        end
+		
 		# Concrete classes should override this method
 		def getWidget
 			return nil
 		end
 
-		def notifyKey(widget, key)
-			@context.notifyKey(self, key)
-		end
 	end
 end

data/lib/Context/Views/Gtk/PageView.rb

@@ -1,46 +1,26 @@
 require 'Context/Views/PageView'
-require 'Context/Gtk/Key'
 require 'Context/Gtk/Widget'
+require 'Context/Views/Gtk/Widgets/MainWindow'
 require 'gtk2'
 
 module Context::Gtk
 
 	class PageView < Context::PageView
 	
-		class MainWindow < Gtk::Window
-			def initialize(title, view)
-				super(title)
-				@view = view
-				connectSignals unless @view.nil?
-			end
-			
-			def connectSignals
-				signal_connect('destroy') do
-					closeView
-				end
-			end
-
-			def closeView
-				@view.close
-			end
-        end
-		
 		attr_reader :mainWindow
 	
 		def initialize(context, title="No Title")
 			super(context)
 			@mainWindow = MainWindow.new(title, self)
 			@mainWindow.set_default_size(600, 400)
-			@widget = Context::Gtk::Widget.new(@mainWindow)
 		end
 		
 		def open
-			@mainWindow.show_all
-			@mainWindow.grab_focus
+            @mainWindow.open
 		end
 				
 		def getWidget
-			@widget
+			@mainWindow
 		end
 		
 		def emitDestroyEvent

data/lib/Context/Views/Gtk/Widgets/MainWindow.rb

@@ -0,0 +1,70 @@
+require 'gtk2'
+
+module Context::Gtk
+
+    # A Gtk widget representing a main window.
+    # It is simply a Gtk::Window into which you can add new widgets.
+    # You must implement the following methods on the view that
+    # you pass to initialize:
+    #
+    #     close() -- closes the view.
+    class MainWindow < Gtk::Window
+        include Context::Gtk::Widget
+        # Create a main window with a given title corresponding to
+        # a Context::View.
+        def initialize(title, view)
+            super(title)
+            @view = view
+            setupWidget
+            isAMainWindow
+            @closed = false
+            connectSignals unless @view.nil?
+        end
+
+        # Connect the Gtk signals we care about.
+        def connectSignals
+            signal_connect('destroy') do
+                if !@closed
+                    closeView
+                end
+            end
+            signal_connect('delete-event') do
+                if !@closed
+                    closeView
+                end
+                true
+            end
+        end
+        
+        # Explicitly destroy the window through the code rather
+        # than having the window destroyed by pressing the close
+        # button.
+        def explicitDestroy
+            @closed = true
+            self.destroy
+        end
+        
+        # Close the view. This is called when the destroy
+        # signal has been emitted.
+        # Note: the View *must* implement close()
+        def closeView
+            @view.close
+        end
+
+        # Context::Gtk::Widget requirements
+
+        # Add a widget to this window.  
+        # Note that Gtk::Windows can only add a single item.
+        # If you want to add more items, you will have to make
+        # another widget (like a table or a vbox) and add it to
+        # this one.
+        def gtkAddWidget(widget)
+            add(widget)
+        end
+
+        # Remove the contained widget from this window
+        def gtkRemoveWidget(widget)
+            remove(widget)
+        end
+    end
+end

data/lib/Context/Views/Gtk/Widgets/VBox.rb

@@ -0,0 +1,29 @@
+require 'Context/Gtk/Widget'
+require 'gtk2'
+
+module Context::Gtk
+
+    # Container class for making vertical lists of widgets.
+    # The primary purpose of this class is to create a container
+    # that respects the packing hints in the Widget mixin.
+    # Something tells me that needing this class means 
+    # something is screwed up somewhere...
+    class VBox < Gtk::VBox
+        include Context::Gtk::Widget
+
+        def initialize
+            super
+            setupWidget
+        end
+        
+        def gtkAddWidget(widget)
+            pack_start(widget,
+                       widget.expandWidgetHeight?, 
+                       widget.expandWidgetWidth?)
+        end
+        
+        def gtkRemoveWidget(widget)
+            remove(widget)
+        end
+    end
+end    

data/lib/Context/Widget.rb

@@ -1,40 +1,31 @@
 module Context
+    # This is the Widget mixin for Context.  If you wish to be able
+    # to add to, add, or remove a widget inside a View using context,
+    # this mixin must be included.  This is an abstract mixin.  The
+    # methods do nothing.  They should be overriden in the concrete
+    # mixins.  Please see Context::Gtk::Widget for an example.
+	module Widget
 
-	class Widget
+        # This method creates any instance variables that you might have.
+        def setupWidget
+        end
 	
-		attr_reader :delegate
-	
-		def initialize(delegate)
-			@delegate = delegate
+		# Use this widget as a container for the passed widget
+		def addToThisWidget(widget)
 		end
-		
+
+        # Remove the passed widget from this object.
+		def removeFromThisWidget(widget)
+		end
+
 		# This method is called after the widget has been
 		# successfully added to another widget
-		def addedTo(widget)
-			# This is an abstract method, the child classes should
-			# implement this		    
+		def widgetWasAddedTo(widget)
 		end
 		
 		# This method is called after the widget has been
 		# successfully removed from another widget
-		def removedFrom(widget)
-			# This is an abstract method, the child classes should
-			# implement this		    
-		end
-		
-		# Use this widget as a container for the passed widget
-		def add(widget)
-			# This is an abstract method, the child classes should
-			# implement this
-		end
-	
-		def remove(widget)
-			# This is an abstract method, the child classes should
-			# implement this
-		end
-
-		def eql?(widget)
-			@delegate.eql?(widget.delegate)
+		def widgetWasRemovedFrom(widget)
 		end
 	end
 end

data/spec/Context/Bridge_spec.rb

@@ -1,36 +1,35 @@
+require 'Context/Spec'
 require 'Context/Bridge'
 
-module Other
-    module Special
-        class Fun
-        end
+module Context::Spec::BridgeStory
 
-        class In
+    module Other
+        module Special
+            class Fun
+            end
+            
+            class In
+            end
         end
     end
-end
 
-module Context::Special
-    class Fun
+    module Special
+        class Fun
+        end
     end
-end
 
-module Context
     class Fun
     end
-end
-
-module Excluded
-    class Sun
-    end    
-end
-
-module Context
+    
+    module Excluded
+        class Sun
+        end    
+    end
 
-	describe Bridge do
+	describe Context::Bridge do
 
 		it "should reference classes in the namespace provided" do
-			bridge = Bridge.new([Special, Other::Special])
+			bridge = Context::Bridge.new([Special, Other::Special])
 			
 			bridge.Fun.should be(Special::Fun)
 			bridge.In.should be(Other::Special::In)