ironnails 0.0.1

data/lib/ironnails/view/view.rb

@@ -0,0 +1,190 @@
+module IronNails
+
+  module View
+
+    # encapsulates what IronNails sees as a view.
+    # That is the xaml proxy and some meta data for
+    # IronNails.
+    class View
+
+      include IronNails::Logging::ClassLogger
+      include IronNails::Core::Observable
+      extend Forwardable
+
+      def_delegators :@proxy, :add_control, :add_command, :add_timer, :invoke, :get_property, :play_storyboard, :stop_storyboard
+
+      # gets or sets the name of this view
+      attr_accessor :name
+
+      # gets or sets the element name on the canvas for this view
+      attr_accessor :element_name
+
+      # gets or sets the xaml proxy that is associated with this view
+      attr_accessor :proxy
+
+      # gets or sets the parent of this view
+      attr_accessor :parent
+
+      # gets or sets the name of the component that will contain this view
+      attr_accessor :container
+
+      # gets or sets the name of the controller this view is associated with
+      attr_accessor :controller
+
+      # gets the flag that indicates if this view needs to be initialized or not
+      attr_reader :loaded
+
+      # gets the collection of children for this view
+      attr_reader :children
+
+      def initialize(options)
+        options.each do |k, v|
+          if k == :view_name
+            @name = v
+          else
+            instance_variable_set "@#{k}", v
+          end
+        end
+        @element_name ||= name
+        @children = []
+      end
+
+      def added?
+        @added
+      end
+
+      # indicates whether we initialized this view already or not
+      def loaded?
+        @loaded
+      end
+
+      # indicates whether this view has to be rendered inside a component
+      def has_container?
+        !container.nil?
+      end
+
+      # indicates whether this view has to set its datacontext in order to function
+      def sets_datacontext?
+        !has_parent? || !!@sets_datacontext
+      end
+
+      # indicates whether this view has a parent
+      def has_parent?
+        !parent.nil?
+      end
+
+      # adds this view to a component in an existing view
+      def add_control(target, control_proxy)
+        proxy.add_control(target, control_proxy)
+        self
+      end
+
+      def dispatcher
+        proxy.instance.dispatcher
+      end
+
+      # loads this view into memory and adds the children if needed
+      def load(mode = :complete)
+        unless @loaded || mode == :reload
+          self.proxy = XamlProxy.load(name)
+          proxy.instance.name = element_name.to_s.to_clr_string if has_parent?
+          @loaded = true
+          #notify_observers :loaded, self
+        end
+        if has_container? && has_parent? && mode == :complete && !added?
+          parent.add_control(container, proxy)
+          @added = true
+        end
+        children.each { |cv| cv.load }
+        logger.debug("loaded view #{name}", IRONNAILS_FRAMEWORKNAME)
+        self
+      end
+
+      # sets the data context of this view
+      def data_context=(value)
+        self.proxy.data_context = value
+      end
+
+      # configures and then shows the window
+      def show
+        configure
+        self.proxy.show
+      end
+
+      # configures and then returns an instance of the loaded view
+      def instance
+        configure
+        proxy.instance
+      end
+
+      # configures the view, it loads it and then triggers the observers for further configuration
+      def configure
+        load
+        notify_observers :configuring, self
+      end
+
+      # adds a child view definition to this view.
+      def add_child(options)
+        child = children.find { |vw| vw.name == options[:name] }
+        children.delete(child) unless child.nil?
+        children << View.new(options.merge(:parent => self, :controller => controller))
+        logger.debug("added child view (#{options[:name]} to #{name})", IRONNAILS_FRAMEWORKNAME)
+        self
+      end
+
+      # returns whether this child view is alread contained by this view or not
+      def has_child?(view)
+        children.any? { |vw| vw == view }
+      end
+
+#      # adds a command to this view
+#      def add_command(cmd)
+#        proxy.add_command cmd
+#      end
+#      
+#      # adds a timer to this view
+#      def add_timer(cmd)
+#        proxy.add_timer cmd
+#      end
+
+      # executes the code block on the view
+      def on_proxy(&b)
+        load
+        #proxy.instance_eval(&b)
+        b.call proxy
+      end
+
+#      def invoke(target, method)
+#        proxy.invoke target, method
+#      end
+
+      # indicates whether this view has a data context set already or not
+      def has_datacontext?
+        !proxy.nil? && !proxy.instance.data_context.nil?
+      end
+
+      def find(view_name)
+        return self if name == view_name.to_sym || view_name.nil?
+        children.find { |cv| cv.name == view_name }
+      end
+
+      # equality comparer for easier selection
+      def ==(view)
+        view.respond_to?(:name) ? self.name == view.name : self.name = view.to_sym
+      end
+
+      alias_method :===, :==
+      alias_method :equals, :==
+
+      # sorting comparer for ordering lists
+      def <=>(view)
+        self.name <=> command.view.name
+      end
+
+      alias_method :compare_to, :<=>
+
+    end
+
+  end
+
+end

data/lib/ironnails/view/view_model.rb

@@ -0,0 +1,45 @@
+module IronNails
+
+  module View
+
+    # The base class for view models in an IronNails application.
+    module ViewModelMixin
+
+      include IronNails::Logging::ClassLogger
+
+      def __view_model_name_
+        self.class.demodulize.underscore
+      end
+
+      # adds a model for the view in the dictionary
+      def add_model(k, v)
+        unless self.respond_to?(k) && self.respond_to?(:"#{k}=")
+          logger.debug "adding object to the view model #{k}", IRONNAILS_FRAMEWORKNAME
+          self.class.send :attr_accessor, k
+        end
+        self.send :"#{k}=", v
+      end
+
+      alias_method :set_model, :add_model
+
+      # configures a command appropriately on the view.
+      # for an EventCommand it will pass it to the view and the view will attach the
+      # appropriate events
+      # for a TimedCommand it will create a timer in the view proxy object
+      # for a BehaviorCommand it will add the appropriate delegate command to the 
+      # Commands dictionary on the ViewModel class
+      def add_command(cmd)
+        dc = cmd.to_clr_command
+        cmd_name = cmd.name.to_s
+        unless self.respond_to?(cmd_name.to_sym) && self.respond_to?(:"#{cmd_name}=")
+          logger.debug "adding command to the view model #{cmd_name}", IRONNAILS_FRAMEWORKNAME
+          self.class.send :attr_accessor, cmd_name.to_sym
+        end
+        self.send :"#{cmd_name}=", dc
+      end
+
+    end
+
+  end
+
+end

data/lib/ironnails/view/xaml_proxy.rb

@@ -0,0 +1,226 @@
+module IronNails
+
+  module View
+
+    module Extensions
+
+      module ThreadingSupport
+
+        def on_ui_thread(element=:instance, &b)
+          send(element).dispatcher.begin_invoke(DispatcherPriority.normal, Action.new(&b))
+        end
+
+        # Schedules this command to execute on a different thread 
+        # and schedules the update of the view on the UI thread. 
+        def on_new_thread(request, &b)
+          cb = WaitCallback.new do
+            begin
+              # b.call
+              blk = lambda { |obj| b.call }
+              instance.dispatcher.begin_invoke(DispatcherPriority.normal, Action.of(System::Object).new(&blk), request.call )
+            rescue Exception => e
+              logger.error "#{e.message}"
+              MessageBox.Show("There was a problem. #{e.message}")
+            end
+          end
+          ThreadPool.queue_user_work_item cb
+        end
+
+      end
+
+      module CommandSupport
+
+        include IronNails::View::Extensions::ThreadingSupport
+
+        def execute_command(command)
+          unless command.asynchronous?
+            command.execute
+          else
+            on_new_thread(lambda { command.execute }) { command.refresh_view }
+          end
+        end
+
+      end
+
+      module TimerSupport
+
+        include IronNails::View::Extensions::CommandSupport
+
+        def add_timer(command)
+          command.view = self
+          @attached = false
+          instance_variable_set "@#{command.timer_name}", DispatcherTimer.new
+          ti = get_timer_for command
+          ti.interval = command.interval.to_timespan
+        end
+
+        def start_timer(command)
+          ti = get_timer_for command
+          ti.tick do
+            execute_command command if command.can_execute?
+          end unless attached?
+          @attached = true
+          ti.start
+        end
+
+        def attached?
+          !!@attached
+        end
+
+        def stop_timer(command)
+          ti = get_timer_for command
+          ti.stop
+        end
+
+        private
+
+        def get_timer_for(command)
+          instance_variable_get "@#{command.timer_name}"
+        end
+
+      end
+
+      module EventSupport
+
+        include IronNails::View::Extensions::CommandSupport
+
+        # Adds the specified +command+ to this view
+        def add_command(command)
+          command.view = self
+          ele = (command.affinity || command.element).to_sym
+          send(command.element.to_sym).send(command.trigger.to_sym) do
+            on_ui_thread(ele) do
+              execute_command command
+            end if command.can_execute?
+          end
+        end
+
+      end
+
+      module SubViewSupport
+
+        #        def add_sub_view(command)
+        #          command.view = self
+        #          command.execute if command.can_execute?
+        #        end
+
+        # Adds a subview to the current view.
+        def add_control(target, view)
+          parent = send(target)
+          vw = view.respond_to?(:instance) ? view.instance : view
+          if parent.respond_to? :content=
+            parent.content = vw
+          elsif parent.respond_to? :children
+            parent.children.add vw
+          end
+        end
+
+      end
+
+    end
+
+    # The IronNails::View::XamlProxy class wraps a xaml file and brings it alive
+    class XamlProxy
+
+      include IronNails::Logging::ClassLogger
+      include IronNails::View::Extensions::EventSupport
+      include IronNails::View::Extensions::TimerSupport
+      include IronNails::View::Extensions::SubViewSupport
+      include IronNails::Core::Observable
+
+      # gets or sets the name of the view
+      attr_accessor :view_name
+
+      # gets the instance of the view
+      attr_reader :instance
+
+      # gets or sets the extension for the view file. 
+      # defaults to xaml
+      attr_accessor :view_extension
+
+      # gets the path to the view file
+      attr_reader :view_path
+
+      def initialize(name)
+        @view_name = name
+        @view_extension = ".xaml"
+      end
+
+      # loads the view into the instance variable
+      def load_view
+        @instance = XamlReader.load_from_path view_path if File.exists? view_path
+        @instance = view_name.to_s.classify.new if @instance.nil?
+        @instance
+      end
+
+      # returns the path to the file for the current view.
+      # this is the file we'll be the proxy for
+      def view_path
+        path = "#{IRONNAILS_VIEWS_ROOT}/#{view_name}#{view_extension}"
+        @view_path = path unless @view_path == path
+        @view_path
+      end
+
+      def visibility=(visi)
+        instance.visibility = visi.to_sym.to_visibility if instance.respond_to?(:visibility)
+      end
+
+      # shows the proxied view
+      def show
+        WpfApplication.current.has_main_window? ? instance.show : instance
+      end
+
+      def invoke(element, method, *args, &b)
+        instance.send(element.to_sym).send(method.to_sym, *args, &b)
+      end
+
+      def get_property(element, method, *args, &b)
+        send(element.to_sym).send(method.to_sym, *args, &b)
+      end
+
+      def play_storyboard(storyboard_name)
+        storyboard = instance.resources[storyboard_name.to_s.to_clr_string]
+        storyboard.begin instance unless storyboard.nil?
+      end
+
+      def stop_storyboard(storyboard_name)
+        storyboard = instance.resources[storyboard_name.to_s.to_clr_string]
+        storyboard.stop instance unless storyboard.nil?
+      end
+
+      # tells this proxy to render itself with the changed information
+      def refresh
+        @instance.refresh
+      end
+
+      def method_missing(sym, *args, &blk)
+        # First we check if we can find a named control
+        # When we can't find a control we'll check if we can find
+        # a method on the view instance by that name, if that is the 
+        # case we will call that method otherwise we'll return the control 
+        # if we found one. When no method or control could be found we 
+        # delegate to the default behavior
+        obj = @instance.find_name(sym.to_s.to_clr_string)
+        nmsym = sym.to_s.camelize.to_sym
+        if @instance.respond_to?(nmsym) && obj.nil?
+          @instance.send sym, *args, &blk
+        else
+          obj.nil? ? super : obj
+        end
+      end
+
+      class << self
+
+        # creates an instance of the view specified by the +view_name+
+        def load(view_name)
+          vw = new view_name.to_s
+          vw.load_view
+          vw
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/ironnails/view.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/view/xaml_proxy'
+require File.dirname(__FILE__) + '/view/view'
+require File.dirname(__FILE__) + '/view/collections'
+require File.dirname(__FILE__) + '/view/commands'
+require File.dirname(__FILE__) + '/view/view_model'

data/lib/ironnails/wpf.rb

@@ -0,0 +1,113 @@
+module IronNails
+
+  module Wpf
+    module Builders
+      def name_collector
+        @___name_collector_
+      end
+
+      def [](name)
+        name_collector[name]
+      end
+
+      def inject_names(obj)
+        name_collector.each_pair { |k, v| obj.instance_variable_set("@#{k}".to_sym, v) }
+      end
+
+      def evaluate_properties(obj, args, &b)
+        obj.instance_variable_set(:@___name_collector_, name_collector)
+
+        args.each_pair do |k, v|
+          if k == :name
+            name_collector[v] = obj
+          end
+          if k == :binding
+            binding = Binding.new
+            binding.path = PropertyPath.new v[:property_name]
+            binding.source = v[:target]||self;
+            binding.mode = v[:mode]
+            obj.set_binding(v[:property], binding);
+            obj.owner = v[:target]||self
+          else
+            obj.send :"#{k.to_s}=", v
+          end
+        end
+
+        if obj.respond_to? :name
+          name_collector[obj.name] = obj unless obj.name.nil?
+        end
+
+        obj
+      end
+
+      def add_object_to_name_collector(collection, obj, args = {}, &b)
+        obj = evaluate_properties(obj, args, &b)
+        obj.instance_eval(&b) unless b.nil?
+        collection.add obj
+        obj
+      end
+
+      def add_class_to_name_collector(collection, klass, args = {}, &b)
+        obj = evaluate_properties(klass.new, args, &b)
+        obj.instance_eval(&b) unless b.nil?
+        collection.add obj
+        obj
+      end
+
+      def assign_to_name_collector(property, klass, args = {}, &b)
+        obj = evaluate_properties(klass.new, args, &b)
+        obj.instance_eval(&b) unless b.nil?
+        self.send property, obj
+        obj
+      end
+    end
+
+    def self.build(klass, args = {}, &b)
+      obj = klass.new
+      obj.instance_variable_set(:@___name_collector_, {})
+
+      args.each_pair do |k, v|
+        if k == :name
+          obj.name_collector[v] = obj
+        end
+        obj.send :"#{k.to_s}=", v
+      end
+
+      obj.instance_eval(&b) if b != nil
+      obj
+    end
+  end
+end
+
+class System::Windows::Data::Binding
+  alias_method :old_mode=, :mode=
+
+  def mode=(value)
+    self.old_mode = value.to_binding_mode
+  end
+end
+
+
+class Panel
+  include IronNails::Wpf::Builders
+
+  def add(klass, args = {}, &b)
+    add_class_to_name_collector(children, klass, args, &b)
+  end
+
+  def add_name(name, obj)
+    name_collector[name] = obj
+  end
+
+  def add_obj(obj)
+    add_object_to_name_collector(children, obj)
+  end
+
+  alias_method :old_background=, :background=
+
+  def background=(color)
+    self.old_background = color.to_brush
+  end
+end
+
+

data/lib/ironnails/wpf_application.rb

@@ -0,0 +1,30 @@
+class WpfApplication < System::Windows::Application
+
+  include IronNails::Logging::ClassLogger
+
+  attr_reader :nails_engine
+
+  def initialize(&b)
+    logger.debug "Starting application", IRONNAILS_FRAMEWORKNAME
+    @nails_engine = NailsEngine.new
+    #@nails_engine = TestViewManager.new
+    controller = instance_eval &b
+    nails_engine.register_controller controller
+    nails_engine.show_initial_window controller do |view_instance|
+      @main_window = view_instance
+      run view_instance
+    end
+  end
+
+  def has_main_window?
+    @main_window.nil?
+  end
+
+  def set_skin(name)
+    self.resources.merged_dictionaries.add load_skin(name)
+  end
+
+  def load_skin(name)
+    XamlReader.load_from_path "#{IRONNAILS_ROOT}/skins/#{name}.xaml"
+  end
+end

data/lib/ironnails.rb

@@ -0,0 +1,68 @@
+begin
+  require 'logger'
+  require 'fileutils'
+  require 'forwardable'
+rescue LoadError => e
+  msg = "It looks like you tried to load the application without passing the"
+  msg << " library paths to IronRuby.\n"
+  msg << "You can fix that by passing the following switch to ir\n(replace C:\\tools\\ruby and c:\\tools\\ironruby with the paths for your configuration):\n"
+  msg << "ir -I 'C:\\tools\\ironruby\\libs;C:\\tools\\ruby\\lib\\ruby\\site_ruby\\1.8;C:\\tools\\ruby\\lib\\ruby\\1.8'\n"
+  msg << "or you could change the first line of the rake file (Rakefile.rb) to reflect your configuration\n"
+  raise LoadError.new(msg)
+end
+
+IRONNAILS_ROOT = "#{File.dirname(__FILE__)}/../.." unless defined?(IRONNAILS_ROOT)
+IRONNAILS_VIEWS_ROOT = "#{IRONNAILS_ROOT}/app/views" unless defined? IRONNAILS_VIEWS_ROOT
+IRONNAILS_ENV = (ENV['IRONNAILS_ENV'] || 'development').dup unless defined?(IRONNAILS_ENV)
+IRONNAILS_FRAMEWORKNAME = "IronNails Framework" unless defined?(IRONNAILS_FRAMEWORKNAME)
+
+nails_vendor_lib = File.join(IRONNAILS_ROOT, "vendor/ironnails")
+$:.unshift nails_vendor_lib if File.exist? nails_vendor_lib
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+%w(app/views app/helpers app/converters app/controllers app/models lib bin).each do |pth|
+  $:.unshift File.join(IRONNAILS_ROOT, pth)
+end
+
+# load .NET libraries
+require 'System'
+require 'WindowsBase'
+require 'PresentationCore'
+require 'PresentationFramework'
+require 'System.Windows.Forms'
+require 'System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'
+require 'System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'
+require 'WindowsBase, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35'
+require 'System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'
+require 'PresentationFramework.Aero, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35'
+require 'System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'
+require 'System.Net, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'
+require 'System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35'
+require 'System.Windows.Presentation, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'
+require 'UIAutomationProvider, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35'
+require 'System.Security, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a'
+require "System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
+
+# load IronNails static CLR helpers
+require 'ironnails/bin/IronNails.Library.dll'
+lst = System::Collections::Generic::List.of(System::String).new
+$:.each {|pth| lst.add pth.to_clr_string }
+IronNails::Library::DlrHelper.load_paths = lst
+IronNails::Library::DlrHelper.app_root = IRONNAILS_ROOT
+
+# load IronRuby files of the IronNails framework
+require 'ironnails/version'
+require 'ironnails/logger'
+require 'ironnails/config/configuration'
+require 'ironnails/config/initializer'
+require 'ironnails/security/secure_string'
+require 'ironnails/core_ext'
+require 'ironnails/errors'
+require 'ironnails/observable'
+require 'ironnails/iron_xml'
+require 'ironnails/view'
+require 'ironnails/models'
+require 'ironnails/controller'
+require 'ironnails/nails_engine'
+require 'ironnails/wpf_application'
+