redcar-dev 0.12.17dev

data/plugins/application_swt/lib/swt/graphics_utils.rb

@@ -0,0 +1,193 @@
+module Swt
+  class GraphicsUtils
+    import org.eclipse.swt.SWT
+    import org.eclipse.swt.widgets.Display
+    import org.eclipse.swt.graphics.FontMetrics
+    import org.eclipse.swt.graphics.GC
+    import org.eclipse.swt.graphics.Image
+    import org.eclipse.swt.graphics.ImageData
+    import org.eclipse.swt.graphics.Point
+    import org.eclipse.swt.graphics.Rectangle
+
+    ##
+    # Draws text vertically (rotates plus or minus 90 degrees). Uses the current
+    # font, color, and background.
+    # <dl>
+    # <dt><b>Styles: </b></dt>
+    # <dd>UP, DOWN</dd>
+    # </dl>
+    #
+    # @param string the text to draw
+    # @param x the x coordinate of the top left corner of the drawing rectangle
+    # @param y the y coordinate of the top left corner of the drawing rectangle
+    # @param gc the GC on which to draw the text
+    # @param style the style (SWT.UP or SWT.DOWN)
+    #          <p>
+    #          Note: Only one of the style UP or DOWN may be specified.
+    #          </p>
+    #
+    def self.draw_vertical_text(string, x, y, gc, style)
+      display = Display.current
+
+      fm = gc.font_metrics
+      pt = gc.text_extent(string)
+
+      string_image = Image.new(display, pt.x, pt.y)
+      string_gc = GC.new(string_image)
+
+      string_gc.foreground = gc.foreground
+      string_gc.background = gc.background
+      string_gc.font = gc.font
+      string_gc.draw_text(string, 0, 0)
+
+      draw_vertical_image(string_image, x, y, gc, style)
+
+      string_gc.dispose
+      string_image.dispose
+    end
+
+    ##
+    # Draws an image vertically (rotates plus or minus 90 degrees)
+    # <dl>
+    # <dt><b>Styles: </b></dt>
+    # <dd>UP, DOWN</dd>
+    # </dl>
+    #
+    # @param image the image to draw
+    # @param x the x coordinate of the top left corner of the drawing rectangle
+    # @param y the y coordinate of the top left corner of the drawing rectangle
+    # @param gc the GC on which to draw the image
+    # @param style the style (SWT.UP or SWT.DOWN)
+    #          <p>
+    #          Note: Only one of the style UP or DOWN may be specified.
+    #          </p>
+    #
+    def self.draw_vertical_image(image, x, y, gc, style)
+      display = Display.current
+
+      sd = image.image_data
+      dd = ImageData.new(sd.height, sd.width, sd.depth, sd.palette)
+      up = (style == SWT::UP)
+
+      # Transform all pixels
+      sd.width.times do |sx|
+        sd.height.times do |sy|
+          dx = up ? sy : sd.height - sy - 1
+          dy = up ? sd.width - sx - 1 : sx
+          dd.set_pixel(dx, dy, sd.get_pixel(sx, sy))
+        end
+      end
+
+      vertical = Image.new(display, dd)
+      gc.draw_image(vertical, x, y)
+      vertical.dispose
+    end
+
+    ##
+    # Creates an image containing the specified text, rotated either plus or minus
+    # 90 degrees.
+    # <dl>
+    # <dt><b>Styles: </b></dt>
+    # <dd>UP, DOWN</dd>
+    # </dl>
+    #
+    # @param text the text to rotate
+    # @param font the font to use
+    # @param foreground the color or pattern for the text
+    # @param background the background color or pattern
+    # @param style direction to rotate (up or down)
+    # @param optional options hash for padding
+    # @return Image
+    #         <p>
+    #         Note: Only one of the style UP or DOWN may be specified.
+    #         </p>
+    #
+    def self.create_rotated_text(text, font, foreground, background, style, options = {})
+      options = {:padding_x => 16, :padding_y => 4}.merge(options)
+
+      display = Display.current
+
+      gc = GC.new(display)
+      gc.font = font
+
+      fm = gc.font_metrics
+      pt = gc.text_extent(text)
+      extent = Rectangle.new(0, 0, pt.x + options[:padding_x], pt.y + options[:padding_y])
+      gc.dispose
+
+      string_image = Image.new(display, extent.width, extent.height)
+
+      gc = GC.new(string_image)
+
+      gc.font = font
+      gc.foreground = foreground
+      gc.background = background
+
+      # Do customization
+      yield(gc, extent) if block_given?
+
+      gc.draw_text(text, options[:padding_x] / 2, options[:padding_y] / 2, true)
+
+      image = create_rotated_image(string_image, style)
+      gc.dispose
+      string_image.dispose
+      return image
+    end
+
+    ##
+    # Creates a rotated image (plus or minus 90 degrees)
+    # <dl>
+    # <dt><b>Styles: </b></dt>
+    # <dd>UP, DOWN</dd>
+    # </dl>
+    #
+    # @param image the image to rotate
+    # @param style direction to rotate (up or down)
+    # @return Image
+    #         <p>
+    #         Note: Only one of the style UP or DOWN may be specified.
+    #         </p>
+    #
+    def self.create_rotated_image(image, style)
+      display = Display.current
+
+      sd = image.image_data
+      dd = ImageData.new(sd.height, sd.width, sd.depth, sd.palette)
+
+      up = (style == SWT::UP)
+
+      sd.width.times do |sx|
+        sd.height.times do |sy|
+          dx = up ? sy : sd.height - sy - 1
+          dy = up ? sd.width - sx - 1 : sx
+          dd.set_pixel(dx, dy, sd.get_pixel(sx, sy))
+        end
+      end
+
+      return Image.new(display, dd)
+    end
+
+    def self.pixel_location_at_offset(offset)
+      edit_view = Redcar::EditView.focussed_tab_edit_view
+      if edit_view
+        text_widget = edit_view.controller.mate_text.viewer.get_text_widget
+        location    = text_widget.get_location_at_offset(offset)
+        x, y = location.x, location.y
+        widget_offset = text_widget.to_display(0,0)
+        x += widget_offset.x
+        y += widget_offset.y
+        [x,y]
+      end
+    end
+
+    def self.below_pixel_location_at_offset(offset)
+      x, y = GraphicsUtils.pixel_location_at_offset(offset)
+      if x and y
+        edit_view = Redcar::EditView.focussed_tab_edit_view
+        text_widget = edit_view.controller.mate_text.viewer.get_text_widget
+        y += text_widget.get_line_height
+        [x, y]
+      end
+    end
+  end
+end

data/plugins/application_swt/lib/swt/vtab_folder.rb

@@ -0,0 +1,177 @@
+module Swt
+  module Widgets
+    class VTabFolder < Swt::Widgets::Composite
+      attr_accessor :tab_area, :content_area
+      attr_reader :selection_color_options, :font, :items
+
+      SelectionEvent  = Struct.new("Event", :item, :doit)
+      CTabFolderEvent = SelectionEvent
+
+      def initialize(parent, style)
+        super(parent, style | Swt::SWT::BORDER)
+        self.layout = Swt::Layout::GridLayout.new(2, false).tap do |l|
+          l.horizontalSpacing = -1
+          l.verticalSpacing = -1
+          l.marginHeight = -1
+          l.marginWidth = -1
+        end
+
+        @items = []
+        @selection_listeners = []
+        @ctab_folder2_listeners = []
+        @font = Swt::Widgets::Display.current.system_font
+
+        @tab_area = Swt::Widgets::Composite.new(self, Swt::SWT::NONE).tap do |t|
+          t.layout_data = Swt::Layout::GridData.new(Swt::Layout::GridData::FILL_VERTICAL | Swt::Layout::GridData::GRAB_VERTICAL)
+          t.layout = Swt::Layout::RowLayout.new.tap do |l|
+            l.type         = Swt::SWT::VERTICAL
+            l.spacing      = -1
+            l.wrap         = false
+            l.marginLeft   = 0
+            l.marginRight  = 0
+            l.marginTop    = 0
+            l.marginBottom = 0
+          end
+        end
+      end
+
+      def set_selection_background(colors, percents, vertical = true)
+        @selection_color_options = { :colors => colors,
+          :percents => percents.collect { |i| i / 100.0 },
+          :vertical => vertical }
+      end
+      
+      def set_background(colors, percents, vertical = true)
+        @background_color_options = { :colors => colors,
+          :percents => percents.collect { |i| i / 100.0 },
+          :vertical => vertical }
+        @tab_area.background = colors[colors.size - 1]
+      end
+
+      def add_item(tab)
+        @items << tab
+        tab.draw_label(@tab_area)
+        tab.font = @font
+        selection = tab if @items.size == 1
+        layout
+      end
+
+      def remove_item(tab)
+        return unless tab = ensure_tab(tab)
+
+        evt = create_ctab_folder_event(tab)
+        call_listeners(@ctab_folder2_listeners, evt, :method => :close, :run_blocks => true)
+        do_remove_item(tab) if evt.doit
+      end
+
+      def get_item(selector)
+        return @items[selector] if selector.respond_to? :to_int
+        return @items.detect { |i| i.text == selector } if selector.respond_to? :to_str
+        raise NotImplementedError, "Getting via Point not implemented"
+      end
+
+      def item_count
+        @items.size
+      end
+
+      def selection
+        @items.detect { |x| x.active? }
+      end
+
+      def selection=(tab)
+        tab = ensure_tab(tab)
+        return if tab.nil? or tab.active?
+
+        evt = create_selection_event(tab)
+        call_listeners(@selection_listeners, evt, :method => :widgetSelected, :run_blocks => true)
+        do_selection(tab) if evt.doit
+      end
+
+      def selection_index
+        index_of(selection)
+      end
+
+      def index_of(tab)
+        @items.index(tab)
+      end
+
+      def show_item(tab)
+        selection = tab
+      end
+
+      # Mirrors the selection-listener behaviour of CTabFolder.
+      # Additionally accepts a block as listener. If a block is passed,
+      # only widgetSelected events will be passed, not widgetDefaultSelected.
+      def add_selection_listener(listener = nil)
+        return @selection_listeners << listener if listener
+        raise ArgumentError, "Expected a listener or a block" unless block_given?
+        @selection_listeners << Proc.new
+      end
+
+      # Mirrors the CTabFolder2Listener behaviour of CTabFolder.
+      # You can also pass a a block as listener. Note that when you pass a
+      # block, only close events will be passed to it, not the minimize, maximize,
+      # restore or showList events.
+      def add_ctab_folder2_listener(listener = nil)
+        return @ctab_folder2_listeners << listener if listener
+        raise ArgumentError, "Expected a listener or a block" unless block_given?
+        @ctab_folder2_listeners << Proc.new
+      end
+
+      def font= swt_font
+        @font = swt_font
+        @items.each { |tab| tab.font = swt_font }
+      end
+
+      private
+
+      def ensure_tab(tab)
+        tab = @items[tab] if tab.respond_to? :to_int
+        tab
+      end
+
+      def do_selection(tab)
+        selection.active = false if selection
+        tab.active = true
+        relayout!
+      end
+
+      def do_remove_item(tab)
+        @items.delete(tab)
+        tab.dispose
+        selection = @items.first if tab.active?
+        relayout!
+      end
+
+      def relayout!
+        layout
+        @tab_area.layout
+      end
+
+      def create_selection_event(tab)
+        create_event(tab, SelectionEvent)
+      end
+
+      def create_ctab_folder_event(tab)
+        create_event(tab, CTabFolderEvent)
+      end
+
+      def create_event(tab, clazz)
+        clazz.new.tap do |e|
+          e.item = tab
+          e.doit = true
+        end
+      end
+
+      def call_listeners(list, evt, hash)
+        list.each do |l|
+          if hash[:run_blocks] and l.respond_to? :call
+            l[evt]
+          else
+            l.send(hash[:method], evt)
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/application_swt/lib/swt/vtab_item.rb

@@ -0,0 +1,78 @@
+require File.expand_path("../vtab_label", __FILE__)
+
+module Swt
+  module Widgets
+    class VTabItem
+      attr_accessor :text, :control
+      attr_reader :parent
+
+      def initialize(parent, style)
+        @parent = parent
+        @parent.add_item(self)
+      end
+
+      def text= title
+        @text = title
+        @label.title = title
+      end
+
+      def control= control
+        @control = control
+        @control.visible = active?
+        @control.layout_data = Swt::Layout::GridData.new.tap do |l|
+          l.horizontalAlignment = Swt::Layout::GridData::FILL
+          l.verticalAlignment = Swt::Layout::GridData::FILL
+          l.grabExcessHorizontalSpace = true
+          l.grabExcessVerticalSpace = true
+          l.exclude = active?
+        end
+      end
+
+      def draw_label(tab_area)
+        @label = VTabLabel.new(self, tab_area, Swt::SWT::NONE)
+      end
+
+      # This way up to the parent
+      def activate
+        @parent.selection = self
+      end
+
+      def active= boolean
+        @label.active = boolean
+        if @control
+          @control.visible = boolean
+          @control.layout_data.exclude = !boolean
+        end
+      end
+
+      def active?
+        @label.active
+      end
+
+      def selection_color_options
+        @parent.selection_color_options
+      end
+
+      def font= swt_font
+        @label.font = swt_font
+      end
+
+      def font
+        @label.font
+      end
+
+      def show_close= bool
+        @label.show_close = bool
+      end
+
+      def show_close
+        @label.show_close
+      end
+
+      def dispose
+        @control.dispose
+        @label.dispose
+      end
+    end
+  end
+end