# SWT::Builder and SWT::TreeBuilder implementation
#--
#   The contents of this file are subject to the Mozilla Public License
#   Version 1.1 (the "License"); you may not use this file except in
#   compliance with the License. You may obtain a copy of the License at
#   http://www.mozilla.org/MPL/
#
#   Software distributed under the License is distributed on an "AS IS"
#   basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
#   License for the specific language governing rights and limitations
#   under the License.
#
#   The Initial Developer of the Original Code is Johannes Rudolph.
#   Portions created by the Initial Developer are Copyright (C) 2006
#   the Initial Developer. All Rights Reserved.
#
#   Contributor(s):
#      Johannes Rudolph <johannes_rudolph@gmail.com>

require 'java'

module SWT
  # see JRubyUtils::RubyObjectBrowser#object_tree
  def self.object_tree(o)
    require 'apps/objecttree'
    JRubyUtils::RubyObjectBrowser.object_tree o
  end

  class TreeCommand
    def initialize(parent)
      @parent=parent
    end
    def accept(child)
      child
    end
    def stacktrace
      "in #{self.class}\n#{@parent.stacktrace if @parent}"
    end
  end
  class SimpleCommand<TreeCommand
    def initialize(parent,child=nil)
      super(parent)
      @child=child
    end
    def accept(child)
      @child=child
    end
    def invoke(tree)
      @child=@child.call if @child.is_a? Proc
      raise "Link expression must evaluate to command: #{stacktrace}" unless @child
      tree=[tree] unless tree.is_a? Array
      @child.invoke tree
    end
    def to_s
      "#{self.class} (#{@child})"
    end
  end
  class ContainerTreeCommand<TreeCommand
    def initialize(parent)
      super(parent)
      @children=[]
    end
    def accept(child)
      @children << child
      child
    end
    def invoke(stack)
      @children.each { |x| x.invoke stack}
    end
    def to_s
      "#{self.class} ([#{@children.join ','}])"
    end
  end
  class ChildCommand<ContainerTreeCommand
    include_class 'org.eclipse.swt.widgets.TreeItem'
    include_class 'org.eclipse.swt.widgets.Tree'
    include_class 'org.eclipse.swt.events.TreeListener'
    def initialize(parent)
      super(parent)
    end

    def invoke(origstack)
      stack=origstack.dup
      last=origstack.last
      expand=lambda do
        res=TreeItem.new last,Builder::RealSWT::NONE
        res.setData("object",last.getData("object"))
        #puts "In Child.invoke: res:#{res.hashCode} data: #{last.getData("object").id}"
        stack.push(res)

        #puts "Stack: #{stack} last:#{stack.last.hashCode} objectid:#{stack.last.getData("object").hashCode}"
        @children.each do |x|
          x.invoke stack
        end
        stack.pop
        res
      end

      parent=origstack.last

      unless parent.is_a? TreeItem
        expand.call
        return
      end

      dummy=parent.getData("dummy")
      unless dummy
        dummy=TreeItem.new parent,Builder::RealSWT::NONE
        dummy.setText "dummy"
        parent.setData("dummy",dummy)
      end

      li=TreeListener.new
      class <<li
        def treeExpanded(e)
          @block.call e
        end
        def treeCollapsed(e)
        end
        def set_info(&block)
          @block=block
        end
      end
      li.set_info do |e|
        if e.item==parent
          unless dummy.isDisposed
            dummy.dispose
          end

          res=expand.call
          e.widget.getColumn(0).pack if e.widget.getColumnCount>0
          res.getParent.removeTreeListener li
        end
      end
      parent.getParent.addTreeListener li
    end
  end
  class LabelCommand<TreeCommand
    def initialize(parent,exp,index=0)
      super(parent)
      @exp=exp
      @index=index
    end
    def invoke(stack)
      stack.last.setText(@index,@exp.call(stack.last.getData("object")).to_s)
    end
    def to_s
      "LabelCmd (#{@exp})"
    end
  end
  class ImageCommand<TreeCommand
    include_class 'org.eclipse.swt.graphics.Image'
    def initialize(parent,exp)
      super(parent)
      @exp=exp
    end
    def invoke(stack)
      image=@exp.call stack.last.getData("object")
      image=Image.new stack.last.getDisplay, image if image.is_a? String
      raise "Image expression(#{image},#{@exp}) must be an swt image or a filename: #{stacktrace}" unless image.is_a? Image
      stack.last.setImage(image)

    end
  end
  class ObjectCommand<TreeCommand
    def initialize(parent,exp)
      super(parent)
      @exp=exp
    end
    def invoke(stack)
      lastobject=stack.last.getData("object")
      newobject=@exp.call(lastobject)
      stack.last.setData("object",newobject)
    end
  end
  class ChildrenCommand<ContainerTreeCommand
    def accept(cmd)
      @inner.accept cmd
    end
    def initialize(parent,exp)
      super(parent)
      @exp=exp
      @inner=ContainerTreeCommand.new self
    end
    def invoke(stack)
      last=stack.last.getData("object")
      coll=@exp.call(last)
      coll.each do |x|
        cmd=ChildCommand.new self
        @children << cmd
        cmd.accept(ObjectCommand.new(self,lambda{last}))
        cmd.accept(ObjectCommand.new(self,lambda{x}))
        cmd.accept(@inner)
        cmd.invoke stack
      end
    end
  end
  class ConditionalCommand<ContainerTreeCommand
    def initialize(parent,exp)
      super(parent)
      @exp=exp
    end
    def invoke(stack)
      condition=@exp.call stack.last.getData("object")
      super if condition
    end
  end

  # Used to describe Trees
  #
  # Example:
  #   SWT::Builder.go do
  #     shell "Example" do
  #       tree :horizontalFill=>true,:verticalFill=>true do
  #         child "Father" do
  #           child "Peter"
  #           child "Paul"
  #           child "Mary"
  #         end
  #       end
  #     end
  #   end
  #
  # But most of it's power lies in its 'children' and 'link' constructs:
  #
  #   kids=%w[Peter Paul Mary] # define some children
  #   SWT::Builder.go do
  #     shell "Example" do
  #       tree :horizontalFill=>true,:verticalFill=>true do # some display styles
  #         object {"Fritz"}
  #         @father=child do  # safe this tree command for later
  #           label {|object| "Father #{object}"} # we'll call him Father X
  #           children lambda{kids} do # children will evaluate the given lambda when appropriate ...
  #             label {|child| "#{child} (age:#{child.length})"} # ... and execute every child command for each child
  #             link{@father} # since every child is a maybe-father, link back to father command, see what happens...
  #           end # ... yeah, recursive reproduction
  #         end
  #       end
  #     end
  #   end
  #
  # Since every command is evaluated lazily, it's possible to construct
  # such infinite trees easily.
  #
  # See JRubyUtils::RubyObjectBrowser#object_tree for a more complex example.
  class TreeBuilder
    def initialize(&block)
      @current=ContainerTreeCommand.new nil
      instance_eval(&block)
    end
    # Command to create a new tree column in a tree table
    def column(text)
      cmd=SimpleCommand.new @current
      @current.accept cmd
      class <<cmd
        include_class 'org.eclipse.swt.widgets.TreeColumn'
        def invoke(stack)
          stack.last.setHeaderVisible true
          tc=TreeColumn.new stack.last,Builder::RealSWT::NONE
          tc.setText @name
          tc.pack
        end
        def name=(name)
          @name=name
        end
      end
      cmd.name=text
    end
    # Command which creates a new child if invoked
    def child(label=nil,&block)
      cmd=ChildCommand.new @current
      @current and @current.accept cmd
      old=@current
      @current=cmd
      label(label) if label
      instance_eval(&block) if block
      @current=old
      cmd
    end
    # Command which will set the text of a specific column
    # when invoked
    def cell(i,&block)
      @current.accept(LabelCommand.new(@current,block,i))
    end
    # Command which will set the label  of the item
    def label(labelExp=nil,&block)
      block=lambda{labelExp} if labelExp
      @current.accept(LabelCommand.new(@current,block))
    end
    # Command to set the object property of the item
    def object(&block)
      @current.accept(ObjectCommand.new(@current,block))
    end
    # Command to set the image of a tree item
    def image(&block)
      @current.accept(ImageCommand.new(@current,block))
    end
    # Link back to command used before, if the link command is
    # invoked it simply delegates to the cmd given
    def link(cmd=nil,&block)
      cmd=block unless cmd
      #puts "Creating link with cmd=#{cmd}"
      @current.accept(SimpleCommand.new(@current, cmd))
    end
    # Command which expands child items from a collection
    #
    # The collection has to be given as lambda (exp).
    # It will be invoked when the children command is invoked.
    # You may define child commands in a block, these will
    # be executed for each child of the computed collection/array.
    def children(exp,&block)
      cmd=ChildrenCommand.new @current,exp
      @current.accept cmd
      old=@current
      @current=cmd
      instance_eval(&block) if block
      @current=old
      cmd
    end
    # A shortcut command for a child without children
    def leaf(&block)
      child do
        label &block
      end
    end
    # Command which acts as a container for other commands.
    # It has no semantics on its own but just invokes it child commands.
    def container(&block)
      cmd=ContainerTreeCommand.new @current
      @current and @current.accept cmd
      old=@current
      @current=cmd
      instance_eval(&block)if block
      @current=old
      cmd
    end
    # Command that will execute only if the condition given as 'exp' evaluates
    # to a non-nil value. It will then invoke its child commands given in a block.
    def conditional(exp,&block)
      cmd=ConditionalCommand.new @current,exp
      @current.accept cmd
      old=@current
      @current=cmd
      instance_eval(&block) if block
      @current=old
      cmd
    end
    def run(tree)
      @current.invoke [tree]
    end
    def current
      @current
    end
  end

  # The heart of the SWT module: You may build GUIs with the Builder class
  #
  class Builder
    include_class 'org.eclipse.swt.widgets.Shell'
    include_class 'org.eclipse.swt.events.SelectionListener'
    include_class 'org.eclipse.swt.widgets.Group'
    include_class 'org.eclipse.swt.widgets.Text'
    include_class 'org.eclipse.swt.widgets.Label'
    include_class 'org.eclipse.swt.widgets.Button'
    include_class 'org.eclipse.swt.widgets.Tree'
    include_class 'org.eclipse.swt.widgets.Composite'
    include_class 'org.eclipse.swt.widgets.Display'
    include_class 'org.eclipse.swt.layout.GridLayout'
    include_class 'org.eclipse.swt.layout.FillLayout'
    include_class 'org.eclipse.swt.layout.GridData'
    include_class 'org.eclipse.swt.SWT' do
      'RealSWT'
    end

    # takes a block of Builder language code, builds the screen and shows it
    def self.go(&block)
      shell=Builder.new.instance_eval(&block)
      shell.pack
      shell.layout
      shell.open
      run shell
    end

    private
    def init_control(c,opts={})
      if c.getParent.getLayout.class==GridLayout
        gd=GridData.new
        opts[:colspan] and gd.horizontalSpan=opts[:colspan]
        if opts[:verticalFill]
          gd.verticalAlignment=RealSWT::FILL
          gd.grabExcessVerticalSpace=true
        end
        if opts[:horizontalFill]
          gd.horizontalAlignment=RealSWT::FILL
          gd.grabExcessHorizontalSpace=true
        end
        c.setLayoutData(gd)
      end
    end
    def init_composite(c,columns,opts={},&block)
      init_control c,opts
      gl=GridLayout.new
      gl.numColumns=columns
      c.setLayout(gl)

      if block_given?
        oldparent=@parent
        @parent=c
        instance_eval(&block)
        @parent=oldparent
      end
    end

    public
    # Create a shell (a toplevel window)
    def shell(title,columns=1,style=RealSWT::SHELL_TRIM,&block)
      res=Shell.new(Display.getDefault,style)
      res.setText title
      fl=FillLayout.new
      fl.marginHeight=5
      fl.marginWidth=5
      res.setLayout fl
      @parent=res
      container(columns,&block)
      return res
    end

    # Create an empty container (does not show anything). It's
    # only supposed for layouting elements
    def container(columns=1,opts={},&block)
      opts[:style] or opts[:style]=RealSWT::NONE
      res=Composite.new(@parent,opts[:style])
      init_composite res,columns,opts,&block
      return res
    end

    # Create a group element with the given title
    def group(title,columns=1,style=RealSWT::NONE,&block)
      res=Group.new(@parent,style)
      res.setText title
      init_composite res,columns,&block
      return res
    end

    # Create a text box. Sets the text if supplied
    def text(text=nil,style=RealSWT::BORDER)
      res=Text.new(@parent,style)
      text and res.setText text
      init_control res
      return res
    end

    # Create a label and show the text supplied.
    # You may use any form of 'labeledText', 'labeledButton'...
    def label(text,style=RealSWT::NONE)
      res=Label.new(@parent,style)
      res.setText text
      init_control res
      return res
    end

    # Create a push button with the specified text
    # If block is given this block will be called if button is pressed
    def button(text,style=RealSWT::NONE,&block)
      res=Button.new(@parent,style)
      res.setText text
      init_control res
      if block_given?
        lis=SelectionListener.new
        lis.instance_eval do
          def widgetDefaultSelected(event)
          end
          def widgetSelected (event)
            @block.call event
          end
          @block=block
        end
        res.addSelectionListener lis
      end
      return res
    end

    # Create Tree if block is given it is evaluated as TreeBuilder commands
    def tree(opts={:style=>RealSWT::BORDER},&block)
      opts[:style] or opts[:style]=RealSWT::BORDER
      res=Tree.new(@parent,opts[:style])
      init_control res,opts
      builder=TreeBuilder.new &block
      builder.run res
      res.pack
      return res
    end

    unless Builder.methods.include? :method_missing
      alias :old_method_missing method_missing
    end

    def method_missing(id,*args,&block)
      if id.to_s=~/labeled(\w+)/
        label args.shift
        method($1.downcase).call *args,&block
      else
        old_method_missing id,args,&block
      end
    end

    # A helper function for dispatching SWT events.
    # Blocks as long as the given shell is not disposed.
    def Builder.run(shell)
      d=shell.getDisplay
      while(!shell.isDisposed&&shell.isVisible) do
        while(d.readAndDispatch) do end
        d.sleep
      end
    end
  end
end