Ironic Wolf

class Screen < ScreenBase 	def native 		
OSX::NSScreen.mainScreen 	
end  	
protected       
def create!       	
self.frame = native.frame       
end   	
end

  class Screen < ScreenBase
	def native
		Qt::Application.desktop
	end
  protected
    def create
      self.frame = native.screenGeometry
    end
  end

  class Application <  ApplicationBase
    def native
      OSX::NSApplication.sharedApplication()
    end
 
    protected
    def create!; native.activateIgnoringOtherApps(true);
    def run!; native.run; end
    def dispose!
      # exception to the rule, terminate first the children an than the parent.
      super
      self.native.terminate(nil)
    end
  end

	class Application <  ApplicationBase
    def native; @app; end
 
    protected
    def create!
      @app = Qt::Application.new(ARGV)
    end
    def run!; native.exec(); end
    def dispose!
      # exception to the rule, terminate first the children an than the parent.
      super
      self.native.quit()
    end
  end

	# We reverse Cocoa's inverse coordinate style
  class FlippedView < OSX::NSView
    def isFlipped
      true
    end
  end
 
  # responds to action of NSWindow
  class WindowDelegate < OSX::NSObject
    def setTarget(target)
      @target = target
    end
 
    def windowWillClose(notification)
      @target.send :dispose
    end
  end
 
  class Window < WindowBase
    def create!
      styleMask = OSX::NSTitledWindowMask + OSX::NSClosableWindowMask +
    OSX::NSMiniaturizableWindowMask + OSX::NSResizableWindowMask
 
      @window = OSX::NSWindow.alloc.initWithContentRect_styleMask_backing_defer(
        self.frame.to_a, styleMask, OSX::NSBackingStoreBuffered, false)
 
      self.tile = self.class.properties[:title].default
      delegate = WindowDelegate.alloc.init
      delegate.setTarget self
      @window.setDelegate(delegate)
      @window.setContentView(FlippedView.alloc.initWithFrame(@window.contentView.frame))
    end
 
    def native
      @window
    end
 
protected    
 
    def child_added!(obj)
      super(obj)
      @window.contentView.addSubview(obj.native)
    end
 
    def get_title; @window.title.to_s; end
    def set_title(v); @window.setTitle(v); end
 
    def visible_changed!
      if self.visible then
        @window.makeKeyAndOrderFront(@window)
      else
        @window.orderOut(nil)
      end
    end
 
    def frame_changed!
      @window.setFrame_display(self.frame.to_a,true)
      super
    end
  end

	  class Window < WindowBase
    def native; @window; end
 
    protected
 
    def create!
     @window = Qt::Widget.new(nil)
     t = self.class.properties[:title].default
     @window.setGeometry(frame.origin.x, frame.origin.y, frame.size.width, frame.size.height)
     @window.setWindowTitle(t)
    end
 
    def dispose!; @window.delete; super; end
 
    def child_added!(obj)
      super(obj)
      obj.native.setParent(@window)
    end
 
    def get_title; @window.windowTitle.to_s; end
    def set_title(v); @window.setWindowTitle(v); end
 
    def visible_changed!
      if self.visible then
        @window.show()
      else
        @window.hide()
      end
    end
 
    def frame_changed!
      @window.setGeometry(frame.origin.x, frame.origin.y, frame.size.width, frame.size.height)
      super
    end
  end

	class ButtonDelegate < OSX::NSObject
    def setTarget(target)
      @target = target
    end
 
    def clicked(sender)
      @target.send :clicked
    end
  end
 
  class Button < ButtonBase
    def native; @ button; end
 
    def create!
      @button = OSX::NSButton.alloc.initWithFrame(self.frame.to_a)
      del = ButtonDelegate.alloc.init
      del.setTarget self
      with @button do
        setAction :clicked
        setTarget del
        setBezelStyle OSX::NSRoundedBezelStyle
      end
    end
 
    def get_title; native.title.to_s; end
    def set_title(v); native.setTitle(v); end
    def dispose!; native.release; super; end
 
    def visible_changed!(ov, v)
      native.setHidden(v) if ov != v
    end
 
    def frame_changed!
      native.setFrame(self.frame.to_a)
    end
  end

class ButtonDelegate < Qt::Widget
    slots 'perform_click()'
 
    def setTarget(obj); @target = obj; end
    def perform_click; @target.clicked; end
  end
 
  class Button < ButtonBase
    def native; @button; end
 
    protected
    def create!
      @button = Qt::PushButton.new('Button', nil)
      delegate = ButtonDelegate.new
      delegate.setTarget(self)
      Qt::Object.connect @button, SIGNAL('clicked()'), delegate, SLOT('perform_click()')
    end
 
    def get_title; native.title.to_s; end
    def set_title(v); native.setWindowTitle(v); end
    def dispose!; native.delete; super; end
    def visible_changed!(ov, v); native.setHidden(v) if ov != v; end
    def frame_changed!; native.setGeometry(*self.frame.to_a); end
 
  end

	# special case for application as it doe  #
  def application(&block)
    app = Application.instance
    with(app, &block)
    app
  end
 
   def self.define_sugar_for(*syms)
    syms.each do |sym|
      class_eval %{
        def #{sym.to_s.downcase.to_sym}(&block)
          obj = #{sym}.new(self)
          with(obj, &block)
          self.add_child(obj) if self.container?
          obj
        end
        }
    end
  end
 
 define_sugar_for :Window, :Button # :Label, :Edit

require 'inox'
include Inox
 
# Evaluates the block within the singleton instance Application
application {
 
	# creates a window and evalutes the block within its instance
	window {
 
		# set the title by method calling
		# setting the title by assignment not possible due
		# to the duality of local variables
		title 'Hello World'
 
		# evaluates the block within the instance of the property frame
		# equivalent of doing something like:
		#
		# f = self.frame
		# f.size = [200, 120]
		# f.center = parent.bounds.center
		# self.frame = f
		#
		# because f is of class Rect we need to get or assign an whole Rect
		# for the frame property to get updated. 
 
		frame {
			# assignement by method call not possible since size/center
			# are not properties
			self.size = [200, 120]
			self.center = $parent.bounds.center
		}
 
		# create a button and evaluates within its instance
		button {
			title 'Quit'
			frame {
				self.center = $parent.bounds.center
			}
 
			# callback called when button is clicked
			on_clicked { Application.instance.dispose }
		}.show
 
	}.show
}.run