redcar-dev 0.12.17dev

data/plugins/application_swt/lib/application_swt/tab.rb

@@ -0,0 +1,84 @@
+module Redcar
+  class ApplicationSWT
+    class Tab
+      
+      attr_reader :item, :model, :notebook, :widget
+      
+      def initialize(model, notebook, position = nil)
+        @model, @notebook = model, notebook
+        create_item_widget(position || @notebook.tab_folder.item_count)
+        create_tab_widget
+        attach_listeners
+      end
+      
+      def create_item_widget(position = nil)
+        position ||= notebook.tab_folder.item_count
+        if @item
+          @item.dispose
+        end
+        @item = Swt::Custom::CTabItem.new(notebook.tab_folder, Swt::SWT::CLOSE, position)
+        set_icon(@model.icon)
+      end
+      
+      def set_icon(icon)
+        @item.image = @icon = ApplicationSWT::Icon.swt_image(icon)
+      end
+      
+      def create_tab_widget
+        @widget = Swt::Widgets::Text.new(notebook.tab_folder, Swt::SWT::MULTI)
+        @widget.text = "Example of a tab"
+        @item.control = @widget
+      end
+      
+      def dragging?
+        @dragging
+      end
+      
+      def dragging= boolean
+        @dragging = boolean
+      end
+      
+      def move_tab_widget_to_current_notebook
+        @widget.setParent(notebook.tab_folder)
+        @item.control = @widget
+      end
+
+      def move_tab_widget_to_position(position)
+        # CTabItem state
+        state_variables = [:font, :tool_tip_text, :text]
+        view_state = state_variables.collect {|var| @item.send(var)}
+        create_item_widget(position)
+        state_variables.each_with_index {|var, idx| @item.send(:"#{var}=", view_state[idx])}
+        @item.control = @widget
+        @item.image = @icon
+        @notebook.recalculate_tab_order
+        focus
+      end
+
+      def set_notebook(notebook_controller)
+        @notebook = notebook_controller
+      end
+      
+      def swt_focus_gained
+        notify_listeners(:swt_focus_gained)
+      end
+      
+      def attach_listeners
+        @model.add_listener(:focus, &method(:focus))
+        @model.add_listener(:close, &method(:close))
+        @model.add_listener(:moved, &method(:move_tab_widget_to_position))
+        @model.add_listener(:changed_icon, &method(:set_icon))
+      end
+      
+      def focus
+        @notebook.model_event_focus_tab(self)
+      end
+      
+      def close
+        @item.dispose if @item
+        @widget.dispose if @widget
+      end
+    end
+  end
+end
+

data/plugins/application_swt/lib/application_swt/toolbar.rb

@@ -0,0 +1,138 @@
+
+module Redcar
+  class ApplicationSWT
+    class ToolBar
+
+      DEFAULT_ICON = File.join(Redcar.root, %w(share icons document.png))
+
+      def self.icons
+        @icons = {
+          :new       => File.join(Redcar.icons_directory, "document-text.png"),
+          :open      => File.join(Redcar.icons_directory, "folder-open-document.png"),
+          :open_dir  => File.join(Redcar.icons_directory, "blue-folder-horizontal-open.png"),
+          :save      => File.join(Redcar.icons_directory, "disk.png"),
+          :save_as   => File.join(Redcar.icons_directory, "disk--plus.png"),
+          :undo      => File.join(Redcar.icons_directory, "arrow-circle-225-left.png"),
+          :redo      => File.join(Redcar.icons_directory, "arrow-circle-315.png"),
+          :search    => File.join(Redcar.icons_directory, "binocular.png")
+        }
+      end
+
+      def self.items
+        @items ||= Hash.new {|h,k| h[k] = []}
+      end
+
+      def self.disable_items(key_string)
+        items[key_string].each {|i| p i.text; i.enabled = false}
+      end
+
+      attr_reader :coolbar, :toolbar, :coolitem, :toolbars, :coolitems
+
+      def initialize(window, toolbar_model, options={})
+        return unless toolbar_model
+        
+        @entries = Hash.new {|h,k| h[k] = [] }
+        @toolbar = main_toolbar(window)
+        toolbar_model.each do |entry|
+          name = entry.barname || :new
+          @entries[name] << entry
+        end
+        add_entries_to_toolbar(@toolbar, @entries[:core])
+        @entries.each do |name, es|
+          next if name == :core
+          add_entries_to_toolbar(@toolbar, es)
+          sep = Swt::Widgets::ToolItem.new(@toolbar, Swt::SWT::DEFAULT)
+        end
+        @toolbar.pack unless Redcar.platform == :osx
+      end
+
+      def main_toolbar(window)
+        if Redcar.platform == :osx
+          window.shell.getToolBar
+        else
+          Swt::Widgets::ToolBar.new(window.shell, Swt::SWT::FLAT | Swt::SWT::HORIZONTAL)
+        end
+      end
+      
+      def show
+        @toolbar.set_visible(true)
+      end
+
+      def hide
+        unless @toolbar.disposed?
+          @toolbar.set_visible(false)
+          @toolbar.getItems.each {|i| i.dispose }
+          # @toolbar.dispose unless Redcar.platform == :osx
+        end
+      end
+
+      def close
+        hide
+        @result
+      end
+
+      def height
+        return 0 if Redcar.platform == :osx
+        point = @toolbar.computeSize(Swt::SWT::DEFAULT, Swt::SWT::DEFAULT, true)
+        return point.y
+      end
+
+      private
+
+      def add_entries_to_toolbar(toolbar, toolbar_model)
+        toolbar_model.each do |entry|
+          if entry.is_a?(Redcar::ToolBar::LazyToolBar)
+            toolbar_header = Swt::Widgets::ToolItem.new(toolbar, Swt::SWT::CASCADE)
+            toolbar_header.text = entry.text
+            new_toolbar = Swt::Widgets::ToolBar.new(toolbar)
+            toolbar_header.toolbar = new_toolbar
+            toolbar_header.add_arm_listener do
+              new_toolbar.get_items.each {|i| i.dispose }
+              add_entries_to_toolbar(new_toolbar, entry)
+            end
+          elsif entry.is_a?(Redcar::ToolBar)
+            new_toolbar = Swt::Widgets::ToolBar.new(toolbar)
+            add_entries_to_toolbar(new_toolbar, entry)
+          elsif entry.is_a?(Redcar::ToolBar::Item::Separator)
+            item = Swt::Widgets::ToolItem.new(toolbar, Swt::SWT::SEPARATOR)
+          elsif entry.is_a?(Redcar::ToolBar::Item)
+            item = Swt::Widgets::ToolItem.new(toolbar, Swt::SWT::PUSH)
+            item.setEnabled(true)
+            item.setImage(Swt::Graphics::Image.new(ApplicationSWT.display, ToolBar.icons[entry.icon] || entry.icon || DEFAULT_ICON ))
+            connect_command_to_item(item, entry)
+          else
+            raise "unknown object of type #{entry.class} in toolbar"
+          end
+        end
+        toolbar.pack
+      end
+
+      class SelectionListener
+        def initialize(entry)
+          @entry = entry
+        end
+
+        def widget_selected(e)
+          @entry.selected(e.stateMask != 0)
+        end
+
+        def widget_default_selected(e)
+          @entry.selected(e.stateMask != 0)
+        end
+      end
+
+      def connect_command_to_item(item, entry)
+        item.setToolTipText(entry.text)
+        item.add_selection_listener(SelectionListener.new(entry))
+        h = entry.command.add_listener(:active_changed) do |value|
+          unless item.disposed
+            item.enabled = value
+          end
+        end
+        if not entry.command.active?
+          item.enabled = false
+        end
+      end
+    end
+  end
+end

data/plugins/application_swt/lib/application_swt/toolbar/binding_translator.rb

@@ -0,0 +1,94 @@
+module Redcar
+  class ApplicationSWT
+    class ToolBar
+      module BindingTranslator
+        MODIFIERS = %w(Cmd Ctrl Alt Shift)
+        
+        def self.platform_key_string(key_specifier)
+          if key_specifier.is_a?(Hash)
+            key_string = key_specifier[Redcar.platform]
+          else
+            key_string = key_specifier
+          end
+          key_string.gsub("Escape", "")
+          key_string.gsub("Space", "")
+          key_string
+        end
+
+        def self.key(key_string)
+          value = 0
+          MODIFIERS.each do |modifier|
+            if key_string =~ /\b#{modifier}\b/
+              value += modifier_values[modifier]
+            end
+          end
+          if key_string =~ /Escape$/
+            value += Swt::SWT::ESC
+          elsif key_string =~ /Space$/
+            value += " "[0]
+          elsif key_string =~ /(F\d+)/
+            value += Swt::SWT.const_get $1
+          elsif key_string =~ /(Right|Left|Up|Down)/
+            value += Swt::SWT.const_get 'ARROW_'+$1.upcase
+          elsif key_string =~ /Tab/
+            value += Swt::SWT::TAB
+          elsif key_string =~ /Page Up$/
+            value += Swt::SWT::PAGE_UP
+          elsif key_string =~ /Page Down$/
+            value += Swt::SWT::PAGE_DOWN
+          elsif key_string =~ /Home$/
+            value += Swt::SWT::HOME
+          elsif key_string =~ /End$/
+            value += Swt::SWT::END
+          else
+            value += key_string[-1]
+          end
+        end
+        
+        def self.modifiers(key_event)
+          modifiers = []
+          modifier_values.each do |string, constant|
+            if (key_event.stateMask & constant) != 0
+              modifiers << string
+            end
+          end
+          modifiers = modifiers.sort_by {|m| MODIFIERS.index(m) }
+        end
+        
+        def self.key_string(key_event)
+          modifiers = modifiers(key_event)
+          if key_event.character == 0
+            modifiers.join("+")
+          else
+            letter = java.lang.Character.new(key_event.character).toString.upcase # key_event.keyCode)
+            if modifiers.any?
+              modifiers.join("+") << "+" << (pretty_letter(letter) || letter)
+            else
+              (pretty_letter(letter) || letter)
+            end
+          end
+        end
+        
+        def self.matches?(key_string, key_string2)
+          key_string.split("+").sort ==
+            key_string2.split("+").sort
+        end
+        
+        def self.pretty_letter(char_string)
+          {"\r" => "Return"}[char_string]
+        end
+        
+        private
+        
+        def self.modifier_values
+          {
+            "Cmd"   => Swt::SWT::COMMAND,
+            "Ctrl"  => Swt::SWT::CTRL,
+            "Alt"   => Swt::SWT::ALT,
+            "Shift" => Swt::SWT::SHIFT,
+          }
+        end
+      end
+    end
+  end
+end

data/plugins/application_swt/lib/application_swt/treebook.rb

@@ -0,0 +1,78 @@
+require 'swt/vtab_folder'
+require 'swt/vtab_item'
+
+module Redcar
+  class ApplicationSWT
+    class Treebook
+      attr_reader :tab_folder, :font
+
+      def initialize(window, model)
+        @window, @model = window, model
+        add_listeners
+        create_tree_view
+      end
+
+      def add_listeners
+        @model.add_listener(:tree_added,   &method(:tree_added))
+        @model.add_listener(:tree_removed, &method(:tree_removed))
+        @model.add_listener(:tree_focussed, &method(:tree_focussed))
+      end
+
+      def tree_added(tree)
+        i = Swt::Widgets::VTabItem.new(@tab_folder, Swt::SWT::NULL)
+        i.text = tree.tree_mirror.title
+        i.control = TreeViewSWT.new(@tab_folder, tree)
+        tree.controller = i.control
+        @tab_folder.selection = i
+      end
+
+      def tree_removed(tree)
+        tree.controller.close
+        @tab_folder.remove_item(@tab_folder.get_item(tree.tree_mirror.title))
+      end
+
+      def tree_focussed(tree)
+        item = @tab_folder.get_item(tree.tree_mirror.title)
+        @tab_folder.selection = item
+      end
+
+      def create_tree_view
+        @tab_folder = Swt::Widgets::VTabFolder.new(@window.tree_sash, Swt::SWT::NONE)
+        font_data = @tab_folder.font.font_data.first
+        font = Swt::Graphics::Font.new(
+          ApplicationSWT.display,
+          font_data.name,
+          Redcar::EditView.font_size - 1,
+          Swt::SWT::NORMAL)
+        @tab_folder.font = font
+        selected_tab_background = Redcar::ApplicationSWT.selected_tab_background
+        @tab_folder.set_selection_background(selected_tab_background.swt_colors, selected_tab_background.swt_stops, true)
+
+        unselected_tab_background = Redcar::ApplicationSWT.unselected_tab_background
+        @tab_folder.set_background(unselected_tab_background.swt_colors, unselected_tab_background.swt_stops, true)
+
+        attach_view_listeners
+
+        @tab_folder.layout
+        @window.left_composite.layout
+      end
+
+      def attach_view_listeners
+        @tab_folder.add_ctab_folder2_listener do |event|
+          # Close event
+          tab_item = event.item
+          tree_view_swt = tab_item.control
+          @model.remove_tree(tree_view_swt.model)
+        end
+
+        @tab_folder.add_selection_listener do |event|
+          # Widget selected event
+          tab_item = event.item
+          tree_view_swt = tab_item.control
+          tree = tree_view_swt.model
+          @model.focus_tree(tree)
+        end
+      end
+    end
+  end
+end

data/plugins/application_swt/lib/application_swt/window.rb

@@ -0,0 +1,419 @@
+
+module Redcar
+  class ApplicationSWT
+    class Window
+      attr_reader :shell, :window
+
+      SASH_WIDTH             = 5
+      TREEBOOK_WIDTH         = 200
+      MINIMUM_TREEBOOK_WIDTH = 0
+      VISIBLE_TREEBOOK_WIDTH = 25
+      TOOLBAR_HEIGHT         = 25
+      @toolbar_height        = 30
+
+      class ShellListener
+        include org.eclipse.swt.events.ShellListener
+
+        def initialize(controller)
+          @win = controller.window
+        end
+
+        def shell_closed(e)
+          unless Redcar.app.events.ignore?(:window_close, @win)
+            e.doit = false
+            Redcar.app.events.create(:window_close, @win)
+          end
+        end
+
+        def shell_activated(e)
+          unless Redcar.app.events.ignore?(:window_focus, @win)
+            e.doit = false
+            Redcar.app.events.create(:window_focus, @win)
+          end
+        end
+
+        def shell_deactivated(_); end
+        def shell_deiconified(_); end
+        def shell_iconified(_); end
+      end
+
+      def initialize(window)
+        @window = window
+        @notebook_handlers = Hash.new {|h,k| h[k] = []}
+        create_shell
+        create_sashes(window)
+        new_notebook(window.notebooks.first)
+        add_listeners
+        create_treebook_controller
+        reset_sash_widths
+        @treebook_unopened = true
+        set_icon
+      end
+
+      def add_listeners
+        @window.add_listener(:show,          &method(:show))
+        @window.add_listener(:refresh_menu,  &method(:refresh_menu))
+        @window.add_listener(:refresh_toolbar,  &method(:refresh_toolbar))
+        @window.add_listener(:popup_menu,    &method(:popup_menu))
+        @window.add_listener(:popup_menu_with_numbers, &method(:popup_menu_with_numbers))
+        @window.add_listener(:title_changed, &method(:title_changed))
+        @window.add_listener(:new_notebook,  &method(:new_notebook))
+        @window.add_listener(:notebook_removed,  &method(:notebook_removed))
+        @window.add_listener(:closed,        &method(:closed))
+        method = method(:notebook_orientation_changed)
+        @window.add_listener(:notebook_orientation_changed, &method)
+        @window.add_listener(:focussed,      &method(:focussed))
+        @window.add_listener(:speedbar_opened, &method(:speedbar_opened))
+        @window.add_listener(:speedbar_closed, &method(:speedbar_closed))
+        @window.add_listener(:enlarge_notebook, &method(:enlarge_notebook))
+        @window.add_listener(:reset_notebook_widths, &method(:reset_notebook_sash_widths))
+        @window.add_listener(:increase_treebook_width, &method(:increase_treebook_width))
+        @window.add_listener(:decrease_treebook_width, &method(:decrease_treebook_width))
+
+        @window.add_listener(:toggle_trees_visible, &method(:toggle_sash_widths))
+        @window.treebook.add_listener(:tree_added) do
+          if @treebook_unopened or not @window.trees_visible?
+            reset_sash_widths
+            @treebook_unopened = false
+          end
+        end
+        @window.treebook.add_listener(:tree_focussed) do |tree|
+          if @treebook_unopened or not @window.trees_visible?
+            reset_sash_widths
+            @treebook_unopened = false
+          end
+        end
+
+        @window.treebook.add_listener(:tree_removed) do
+          reset_sash_widths
+        end
+        @shell.add_key_listener(KeyListener.new(self))
+      end
+
+      def treebook_hidden?
+        treebook_width <= VISIBLE_TREEBOOK_WIDTH
+      end
+
+      def treebook_width
+        @sash.layout_data.left.offset
+      end
+
+      def default_treebook_width
+        TREEBOOK_WIDTH + SASH_WIDTH
+      end
+
+      def fullscreen
+        @shell.fullScreen()
+      end
+
+      def fullscreen=(value)
+        @shell.setFullScreen(value)
+      end
+
+      class KeyListener
+        def initialize(edit_view_swt)
+          @edit_view_swt = edit_view_swt
+        end
+
+        def key_pressed(key_event)
+          p key_event
+          if key_event.character == Swt::SWT::TAB
+            p :tab_pressedwin
+          elsif key_event.character == Swt::SWT::ESC
+            p :esc_pressedwin
+          end
+        end
+
+        def verify_key(key_event)
+          p :verkey
+          if key_event.character == Swt::SWT::TAB
+            p :tab_pressed
+            key_event.doit = false
+          end
+        end
+
+        def key_released(key_event)
+        end
+      end
+
+      def create_treebook_controller
+        treebook = @window.treebook
+        controller = ApplicationSWT::Treebook.new(
+        self,
+        treebook)
+        treebook.controller = controller
+      end
+
+      def show
+        @shell.open
+        @shell.text = window.title
+      end
+
+      def refresh_menu
+        old_menu_bar = shell.menu_bar
+        @menu_controller = ApplicationSWT::Menu.new(self, Redcar.app.main_menu(@window), Redcar.app.main_keymap, Swt::SWT::BAR)
+        shell.menu_bar = @menu_controller.menu_bar
+        old_menu_bar.dispose if old_menu_bar
+      end
+
+      def refresh_toolbar
+        if Redcar.app.show_toolbar?
+          @toolbar_controller = ApplicationSWT::ToolBar.new(self, Redcar.app.main_toolbar, Swt::SWT::HORIZONTAL | Swt::SWT::BORDER)
+          @toolbar_controller.show
+          @toolbar_height = @toolbar_controller.height.to_i
+        else
+          @toolbar_controller.hide() if @toolbar_controller
+          @toolbar_height = 0
+        end
+        reset_sash_height
+      end
+
+      def set_icon
+        shell.image = Icon.swt_image(icon_file)
+      end
+
+      def icon_file
+        if Redcar::VERSION =~ /dev$/
+          :redcar_icon_beta_dev
+        else
+          :redcar_icon_beta
+        end
+      end
+
+      def bring_to_front
+        @shell.set_minimized(false) # unminimize, just in case
+        @shell.redraw
+        if Redcar.platform == :windows
+          require File.dirname(__FILE__) + '/bring_to_front'
+          BringToFront.bring_window_to_front self.shell.handle
+        end
+        @shell.force_active # doesn't do anything, really
+        @shell.set_active
+      end
+
+      def popup_menu(menu)
+        menu.controller = ApplicationSWT::Menu.new(self, menu, nil, Swt::SWT::POP_UP)
+        menu.controller.show
+      end
+
+      def popup_menu_with_numbers(menu)
+        menu.controller = ApplicationSWT::Menu.new(self, menu, nil, Swt::SWT::POP_UP, :numbers => true)
+        menu.controller.show
+      end
+
+      def speedbar_opened(speedbar)
+        speedbar.controller = ApplicationSWT::Speedbar.new(@window, right_composite, speedbar)
+      end
+
+      def speedbar_closed(speedbar)
+        speedbar.controller.close
+      end
+
+      def title_changed(new_title)
+        @shell.text = new_title
+      end
+
+      def new_notebook(notebook_model)
+        notebook_controller = ApplicationSWT::Notebook.new(notebook_model, @notebook_sash)
+        reset_notebook_sash_widths
+      end
+
+      def notebook_removed(notebook_model)
+        notebook_controller = notebook_model.controller
+        @notebook_handlers[notebook_model].each do |h|
+          notebook_controller.remove_listener(h)
+        end
+        notebook_controller.dispose
+        reset_notebook_sash_widths
+      end
+
+      def notebook_orientation_changed(new_orientation)
+        orientation = horizontal_vertical(new_orientation)
+        @notebook_sash.setOrientation(orientation)
+      end
+
+      def focussed(_)
+        @shell.set_active
+      end
+
+      def closed(_)
+        @shell.close
+        @menu_controller.close
+        @toolbar_controller.close if @toolbar_controller
+      end
+
+      def dispose
+        @shell.dispose
+        @menu_controller.close
+        @toolbar_controller.close
+      end
+
+      attr_reader :right_composite, :left_composite, :tree_composite, :tree_layout, :tree_sash
+
+      private
+
+      def create_shell
+        @shell = Swt::Widgets::Shell.new(ApplicationSWT.display)
+        @shell.layout = Swt::Layout::FormLayout.new
+        @shell.add_shell_listener(ShellListener.new(self))
+        @shell.add_listener Swt::SWT::Resize do |e|
+          client_area = @shell.client_area
+          if client_area.width < @sash.bounds.x
+            @sash.layout_data.left = Swt::Layout::FormAttachment.new(0, client_area.width - SASH_WIDTH)
+          end
+        end
+        activate_osx_fullscreen_option
+        ApplicationSWT.register_shell(@shell)
+      end
+      
+      FULL_SCREEN_SHELL_ICON = 1 << 7
+      
+      def activate_osx_fullscreen_option
+        if Redcar.platform == :osx
+          @shell.view.window.set_collection_behavior(FULL_SCREEN_SHELL_ICON)
+        end
+      end
+      
+      def create_sashes(window_model)
+        orientation = horizontal_vertical(window_model.notebook_orientation)
+
+        @left_composite = Swt::Widgets::Composite.new(@shell, Swt::SWT::NONE)
+        @left_composite.layout = Swt::Layout::GridLayout.new(1, false).tap do |l|
+          l.verticalSpacing = 0
+          l.marginHeight = 0
+          l.horizontalSpacing = 0
+          l.marginWidth = 0
+        end
+
+        @sash = Swt::Widgets::Sash.new(@shell, Swt::SWT::VERTICAL)
+
+        @right_composite = Swt::Widgets::Composite.new(@shell, Swt::SWT::NONE)
+        @right_composite.layout = Swt::Layout::GridLayout.new(1, false).tap do |l|
+          l.verticalSpacing = 0
+          l.marginHeight = 0
+          l.horizontalSpacing = 0
+          l.marginWidth = 0
+        end
+
+        @sash.layout_data = Swt::Layout::FormData.new.tap do |d|
+          d.left = Swt::Layout::FormAttachment.new(0, 0)
+          d.top =  Swt::Layout::FormAttachment.new(0, 5 + TOOLBAR_HEIGHT)
+          d.bottom = Swt::Layout::FormAttachment.new(100, 0)
+        end
+
+        @sash.add_selection_listener do |e|
+          sash_rect = @sash.bounds
+          shell_rect = @shell.client_area
+          right = shell_rect.width - sash_rect.width - SASH_WIDTH
+          e.x = [[e.x, right].min, SASH_WIDTH].max
+          if (e.x != sash_rect.x)
+            if @window.treebook.trees.any?
+              @sash.layout_data.left = Swt::Layout::FormAttachment.new(0, e.x)
+            else
+              @sash.layout_data.left = Swt::Layout::FormAttachment.new(0, 0)
+            end
+            @shell.layout
+          end
+        end
+
+        @left_composite.layout_data = Swt::Layout::FormData.new.tap do |l|
+          l.left = Swt::Layout::FormAttachment.new(0, 5)
+          l.right = Swt::Layout::FormAttachment.new(@sash, 0)
+          l.top = Swt::Layout::FormAttachment.new(0, 5 + TOOLBAR_HEIGHT)
+          l.bottom = Swt::Layout::FormAttachment.new(100, -5)
+        end
+
+        @right_composite.layout_data = Swt::Layout::FormData.new.tap do |d|
+          d.left = Swt::Layout::FormAttachment.new(@sash, 0)
+          d.right = Swt::Layout::FormAttachment.new(100, -5)
+          d.top = Swt::Layout::FormAttachment.new(0, 5 + TOOLBAR_HEIGHT)
+          d.bottom = Swt::Layout::FormAttachment.new(100, -5)
+        end
+
+        @tree_sash = Swt::Custom::SashForm.new(@left_composite, orientation)
+        grid_data = Swt::Layout::GridData.new(Swt::Layout::GridData::FILL_BOTH)
+        @tree_sash.layout_data = grid_data
+
+        @notebook_sash = Swt::Custom::SashForm.new(@right_composite, orientation)
+        grid_data = Swt::Layout::GridData.new(Swt::Layout::GridData::FILL_BOTH)
+        @notebook_sash.layout_data = grid_data
+        @notebook_sash.sash_width = SASH_WIDTH
+      end
+
+      def horizontal_vertical(symbol)
+        case symbol
+        when :horizontal
+          Swt::SWT::HORIZONTAL
+        when :vertical
+          Swt::SWT::VERTICAL
+        end
+      end
+
+      def reset_sash_widths
+        @treebook_unopened = !@window.treebook.trees.any?
+        width = 0
+        if @window.treebook.trees.any?
+          if @treebook_open_width
+            width = @treebook_open_width
+          else
+            width = default_treebook_width
+          end
+        end
+        set_sash_widths(width)
+      end
+
+      def toggle_sash_widths
+        if treebook_hidden?
+          reset_sash_widths
+        else
+          @treebook_open_width = treebook_width
+          set_sash_widths(MINIMUM_TREEBOOK_WIDTH)
+        end
+      end
+
+      def decrease_treebook_width
+        width = treebook_width
+        unless width < MINIMUM_TREEBOOK_WIDTH + SASH_WIDTH
+          set_sash_widths(width-SASH_WIDTH)
+        end
+      end
+
+      def increase_treebook_width
+        set_sash_widths(treebook_width+SASH_WIDTH)
+      end
+
+      def set_sash_widths(offset)
+        @sash.layout_data.left = Swt::Layout::FormAttachment.new(0, offset)
+        @shell.layout
+      end
+
+      def reset_notebook_sash_widths
+        width = (100/@window.notebooks.length).to_i
+        widths = [width]*@window.notebooks.length
+        @notebook_sash.setWeights(widths.to_java(:int))
+      end
+
+      def enlarge_notebook(index=0)
+        if @window.notebooks.length > 1
+          widths = @notebook_sash.getWeights
+          small = index == 0 ? 1 : 0
+          total = widths[index] + widths[small]
+          unless widths[index]/total > 0.95
+            widths[small] = widths[small].to_i - SASH_WIDTH
+            widths[index] = widths[index].to_i + SASH_WIDTH
+            @notebook_sash.setWeights(widths.to_a.to_java(:int))
+          end
+        end
+      end
+
+      def reset_sash_height
+        @sash.layout_data.top =  Swt::Layout::FormAttachment.new(0, @toolbar_height.to_i)
+        @left_composite.layout_data.top = Swt::Layout::FormAttachment.new(0, 5 + @toolbar_height.to_i)
+        @right_composite.layout_data.top = Swt::Layout::FormAttachment.new(0, 5 + @toolbar_height.to_i)
+        @shell.layout
+        @shell.redraw
+      end
+
+    end
+  end
+end