shoes-swt 4.0.0.pre2

data/spec/swt_shoes/text_block/fitter_spec.rb

@@ -0,0 +1,213 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::TextBlock::Fitter do
+  let(:dsl) { double('dsl', parent: parent_dsl, text: "Text goes here",
+                     desired_width: 85, centered?:    false,
+                     absolute_left: 25, absolute_top: 75,
+                     element_left:  26, element_top:  76,
+                     margin_left:   1,  margin_top:   1) }
+
+  let(:parent_dsl) { double('parent_dsl', parent: grandparent_dsl,
+                            absolute_top: 0, absolute_left: 0, absolute_right: 100,
+                            width: parent_width, height: 200) }
+
+  let(:grandparent_dsl) { double('grandparent_dsl', parent: app,
+                                 width: grandparent_width) }
+
+  let(:app) { double('app', width: app_width) }
+
+  let(:parent_width)      { 100 }
+  let(:grandparent_width) { 1000 }
+  let(:app_width)         { 2000 }
+
+  let(:text_block) { double('text_block', dsl: dsl) }
+  let(:segment)    { double('segment') }
+
+  let(:current_position) { double('current_position') }
+
+  subject { Shoes::Swt::TextBlock::Fitter.new(text_block, current_position) }
+
+  before(:each) do
+    allow(Shoes::Swt::TextBlock::TextSegment).to receive(:new) { segment }
+  end
+
+  describe "determining available space" do
+    it "should offset by parent with current position" do
+      when_positioned_at(x: 15, y: 5, next_line_start: 30)
+      expect(subject.available_space).to eq([85, 24])
+    end
+
+    it "should move to next line with at very end of vertical space" do
+      when_positioned_at(x: 15, y: 5, next_line_start: 5)
+      expect(subject.available_space).to eq([85, :unbounded])
+    end
+
+    it "should move to next line when top is past the projected next line" do
+      when_positioned_at(x: 15, y: 100, next_line_start: 5)
+      expect(subject.available_space).to eq([85, :unbounded])
+    end
+
+    context "positioned outside parent" do
+      before(:each) do
+        allow(dsl).to receive(:desired_width) { -1 }
+      end
+
+      it "bumps to parent width when at end of vertical space" do
+        when_positioned_at(x: 110, y: 5, next_line_start: 5)
+        allow(dsl).to receive(:desired_width).with(grandparent_width) { 890 }
+
+        expect(subject.available_space).to eq([890, :unbounded])
+      end
+
+      it "bumps out until it fits" do
+        when_positioned_at(x:1010, y: 5, next_line_start: 5)
+        allow(dsl).to receive(:desired_width).with(app_width) { 990 }
+
+        expect(subject.available_space).to eq([990, :unbounded])
+      end
+
+      it "just gives up if it still won't fit" do
+        when_positioned_at(x:1010, y: 5, next_line_start: 5)
+        expect(subject.available_space).to eq([0, 0])
+      end
+    end
+  end
+
+  describe "finding what didn't fit" do
+    it "should tell split text by offsets and heights" do
+      segment = double('segment', line_offsets: [0, 5, 9], text: "Text Split")
+      allow(segment).to receive(:line_bounds) { double('line_bounds', height: 50)}
+
+      expect(subject.split_text(segment, 55)).to eq(["Text ", "Split"])
+    end
+
+    it "should be able to split text when too small" do
+      segment = double('segment', line_offsets: [0, 10], text: "Text Split")
+      allow(segment).to receive(:line_bounds).with(0) { double('line_bounds', height: 21)}
+      allow(segment).to receive(:line_bounds).with(1) { raise "Boom" }
+
+      expect(subject.split_text(segment, 33)).to eq(["Text Split", ""])
+    end
+  end
+
+  describe "fit it in" do
+    let(:bounds) { double('bounds', width: 100, height: 50)}
+    let(:segment) { double('segment',
+                           text: "something something", :text= => nil,
+                           line_count: 1, line_offsets:[], bounds: bounds) }
+
+    before(:each) do
+      layout = double('swt_layout', :spacing => 4, :spacing= => nil)
+      allow(segment).to receive(:position_at) { segment }
+      allow(segment).to receive(:spacing) { 4 }
+      allow(segment).to receive(:layout)  { layout }
+
+    end
+
+    context "to one segment" do
+      it "should work" do
+        segments = when_fit_at(x: 25, y: 75, next_line_start: 130)
+        expect_segments(segments, [26, 76])
+      end
+
+      it "with one line, even if height is bigger" do
+        allow(bounds).to receive_messages(width: 50)
+        segments = when_fit_at(x: 25, y: 75, next_line_start: 95)
+        expect_segments(segments, [26, 76])
+      end
+    end
+
+    context "to two segments" do
+      before(:each) do
+        allow(segment).to receive_messages(line_count: 2, line_bounds: double(height: 15))
+        allow(bounds).to receive_messages(width: 50)
+        allow(dsl).to receive_messages(containing_width: :unused)
+      end
+
+      it "should split text and overflow to second segment" do
+        with_text_split("something ", "something")
+        expect(segment).to receive(:dispose).once
+
+        segments = when_fit_at(x: 25, y: 75, next_line_start: 95)
+        expect_segments(segments, [26, 76], [1, 123])
+      end
+
+      it "should overflow all text to second segment" do
+        with_text_split("", "something something")
+        expect(segment).to receive(:dispose).once
+
+        segments = when_fit_at(x: 25, y: 75, next_line_start: 95)
+        expect_segments(segments, [26, 76], [1, 96])
+      end
+    end
+
+    context "to empty first segment" do
+      before(:each) do
+        allow(dsl).to receive_messages(containing_width: 100)
+      end
+
+      it "rolls to second segment when 0 remaining width" do
+        allow(dsl).to receive_messages(desired_width: 0)
+        segments = when_fit_at(x: 0, y: 75, next_line_start: 95)
+        expect_segments(segments, [26, 76], [1, 97])
+      end
+
+      it "rolls to second segment when negative remaining width" do
+        allow(dsl).to receive_messages(desired_width: -1)
+        segments = when_fit_at(x: 0, y: 75, next_line_start: 95)
+        expect_segments(segments, [26, 76], [1, 97])
+      end
+    end
+
+    context "to center segment" do
+      before do
+        allow(dsl).to receive_messages(centered?: true)
+        allow(dsl).to receive_messages(containing_width: 100)
+      end
+
+      it "uses full width" do
+        allow(dsl).to receive_messages(element_left: 0, left: 0)
+        segments = when_fit_at(x: 0, y: 75, next_line_start: 95)
+        expect_segments(segments, [0, 76])
+      end
+
+      it "bumps down a line if not at start" do
+        allow(dsl).to receive_messages(element_left: 20, left: 20)
+        segments = when_fit_at(x: 20, y: 75, next_line_start: 95)
+        expect_segments(segments, [20, 76], [1, 96])
+      end
+
+      it "if unbounded height, still bumps down properly" do
+        allow(dsl).to receive_messages(absolute_top: 95, element_left: 20, left: 20, margin_left: 1)
+        segments = when_fit_at(x: 20, y: 75, next_line_start: 95)
+        expect_segments(segments, [20, 76], [1, 96])
+      end
+    end
+  end
+
+  def with_text_split(first, second)
+    allow(dsl).to receive_messages(text: first + second)
+    allow(segment).to receive_messages(line_offsets: [0, first.length, first.length + second.length])
+  end
+
+  def when_positioned_at(args)
+    x = args.fetch(:x)
+    y = args.fetch(:y)
+    next_line_start = args.fetch(:next_line_start)
+
+    allow(dsl).to receive_messages(absolute_left: x, absolute_top: y)
+    allow(current_position).to receive(:next_line_start) { next_line_start }
+  end
+
+  def when_fit_at(args)
+    when_positioned_at(args)
+    subject.fit_it_in
+  end
+
+  def expect_segments(segments, *coordinates)
+    segments.each_with_index do |segment, index|
+      x, y = coordinates[index]
+      expect(segment).to have_received(:position_at).with(x, y)
+    end
+  end
+end

data/spec/swt_shoes/text_block/painter_spec.rb

@@ -0,0 +1,212 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::TextBlock::Painter do
+  include_context "swt app"
+
+  let(:dsl_style) { {justify: true, leading: 10, underline: "single"} }
+  let(:gui) { double("gui", dispose: nil) }
+  let(:dsl) { double("dsl", app: shoes_app, gui: gui,
+                     text: text, cursor: nil, style: dsl_style,
+                     element_width: 200, element_height: 180,
+                     element_left: 0, element_top: 10, font: "font",
+                     size: 16, margin_left: 0, margin_top: 0,
+                     text_styles: text_styles, :hidden? => false).as_null_object
+            }
+
+  let(:segment) do
+    allow(::Swt::Font).to receive(:new)       { font }
+    allow(::Swt::TextLayout).to receive(:new) { text_layout }
+    allow(::Swt::TextStyle).to receive(:new)  { style }
+
+    Shoes::Swt::TextBlock::TextSegment.new(dsl, text, 200).position_at(0, 10)
+  end
+
+  let(:text_layout) { double("text layout", text: text).as_null_object }
+
+  let(:event) { double("event").as_null_object }
+  let(:style) { double(:style).as_null_object }
+  let(:font)  { double(:font, font_data: [font_data]).as_null_object }
+  let(:font_data) { double(name: "font", height: 16.0, style: ::Swt::SWT::NORMAL) }
+
+  let(:blue) { Shoes::Color.new(0, 0, 255) }
+  let(:swt_blue) { Shoes::Swt::Color.new(blue).real}
+  let(:text_styles) {{}}
+  let(:text) {'hello world'}
+
+  subject { Shoes::Swt::TextBlock::Painter.new(dsl) }
+
+  before :each do
+    allow(::Swt::TextStyle).to receive(:new)  { style.as_null_object }
+
+    # Can't stub this in during initial let because of circular reference
+    # segments -> dsl -> gui -> segments...
+    allow(gui).to receive_messages(segments: [segment])
+  end
+
+  it "draws" do
+    expect(segment).to receive(:draw)
+    subject.paintControl(event)
+  end
+
+  it "sets justify" do
+    expect(text_layout).to receive(:justify=).with(dsl_style[:justify])
+    subject.paintControl(event)
+  end
+
+  it "sets spacing" do
+    expect(text_layout).to receive(:spacing=).with(dsl_style[:leading])
+    subject.paintControl(event)
+  end
+
+  it "sets alignment" do
+    expect(text_layout).to receive(:alignment=).with(anything)
+    subject.paintControl(event)
+  end
+
+  it "sets text styles" do
+    expect(text_layout).to receive(:set_style).with(anything, anything, anything).at_least(1).times
+    subject.paintControl(event)
+  end
+
+  context "rise option" do
+    it "sets default rise value to nil" do
+      expect(style).to receive(:rise=).with(nil)
+      subject.paintControl(event)
+    end
+
+    it "sets correct rise value" do
+      dsl_style[:rise] = 10
+      expect(style).to receive(:rise=).with(10)
+
+      subject.paintControl(event)
+    end
+  end
+
+  context "underline option" do
+    it "sets default underline style to none" do
+      dsl_style.delete(:underline)
+
+      expect(style).to receive(:underline=).with(false)
+      expect(style).to receive(:underlineStyle=).with(nil)
+
+      subject.paintControl(event)
+    end
+
+    it "sets correct underline style" do
+
+      expect(style).to receive(:underline=).with(true)
+      expect(style).to receive(:underlineStyle=).with(Shoes::Swt::TextStyleFactory::UNDERLINE_STYLES["single"])
+
+      subject.paintControl(event)
+    end
+
+    it "sets underline color" do
+      dsl_style[:undercolor] = blue
+
+      expect(style).to receive(:underlineColor=).with(swt_blue)
+
+      subject.paintControl(event)
+    end
+
+    it "sets default underline color to nil" do
+      expect(style).to receive(:underlineColor=).with(nil)
+
+      subject.paintControl(event)
+    end
+  end
+
+  context "strikethrough option" do
+    it "sets default strikethrough to none" do
+      expect(style).to receive(:strikeout=).with(false)
+
+      subject.paintControl(event)
+    end
+
+    it "sets strikethrough" do
+      dsl_style[:strikethrough] = "single"
+
+      expect(style).to receive(:strikeout=).with(true)
+
+      subject.paintControl(event)
+    end
+
+    it "sets strikethrough color" do
+      dsl_style[:strikecolor] = blue
+
+      expect(style).to receive(:strikeoutColor=).with(swt_blue)
+
+      subject.paintControl(event)
+    end
+
+    it "sets default strikethrough color to nil" do
+      expect(style).to receive(:strikeoutColor=).with(nil)
+
+      subject.paintControl(event)
+    end
+  end
+
+  context "font styles" do
+    it "sets font style to bold" do
+      dsl_style[:weight] = true
+      expect(::Swt::Font).to receive(:new).with(anything, anything, anything, ::Swt::SWT::BOLD)
+      subject.paintControl(event)
+    end
+
+    it "sets font style to italic" do
+      dsl_style[:emphasis] = true
+      expect(::Swt::Font).to receive(:new).with(anything, anything, anything, ::Swt::SWT::ITALIC)
+      subject.paintControl(event)
+    end
+
+    it "sets font style to both bold and italic" do
+      dsl_style[:weight] = true
+      dsl_style[:emphasis] = true
+      expect(::Swt::Font).to receive(:new).with(anything, anything, anything, ::Swt::SWT::BOLD | ::Swt::SWT::ITALIC)
+
+      subject.paintControl(event)
+    end
+  end
+
+  context "colors" do
+    let(:black) { Shoes::Swt::Color.new(Shoes::COLORS[:black]).real }
+    let(:salmon) { Shoes::Swt::Color.new(Shoes::COLORS[:salmon]).real }
+
+    describe "stroke" do
+      it "is black by default" do
+        expect(::Swt::TextStyle).to receive(:new).with(anything, black, anything)
+        subject.paintControl(event)
+      end
+
+      it "is set with dsl_style[:stroke]" do
+        dsl_style[:stroke] = Shoes::COLORS[:salmon]
+        expect(::Swt::TextStyle).to receive(:new).with(anything, salmon, anything)
+        subject.paintControl(event)
+      end
+    end
+
+    describe "fill" do
+      it "is nil by default" do
+        expect(::Swt::TextStyle).to receive(:new).with(anything, anything, nil)
+        subject.paintControl(event)
+      end
+
+      it "is set with dsl_style[:fill]" do
+        dsl_style[:fill] = Shoes::COLORS[:salmon]
+        expect(::Swt::TextStyle).to receive(:new).with(anything, anything, salmon)
+        subject.paintControl(event)
+      end
+    end
+  end
+
+  describe 'text_styles' do
+    # this text_styles relies a lot on the internal structure of TextBlock/Painter
+    # right now, which I'm not too fond of... :)
+    let(:text_styles) {[[0...text.length, [Shoes::Span.new([text], size: 50)]]]}
+    it 'sets the font size to 50' do
+      expect(::Swt::Font).to receive(:new).
+                             with(anything, anything, 50, anything)
+
+      subject.paintControl event
+    end
+  end
+end

data/spec/swt_shoes/text_block/text_font_factory_spec.rb

@@ -0,0 +1,40 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::TextFontFactory do
+  let(:font_details) {
+    {
+      :name   => "Helvetica",
+      :size   => 16,
+      :styles => [::Swt::SWT::BOLD]
+    }
+  }
+
+  subject { Shoes::Swt::TextFontFactory.new() }
+
+  it "creates a font" do
+    font = subject.create_font(font_details)
+    expect(font).not_to be(nil)
+  end
+
+  it "disposes of fonts" do
+    font = subject.create_font(font_details)
+    expect(font).to receive(:dispose)
+
+    subject.dispose
+  end
+
+  it "doesn't dispose already disposed fonts" do
+    font = subject.create_font(font_details)
+    font.dispose
+
+    expect(font).not_to receive(:dispose)
+    subject.dispose
+  end
+
+  it "reuses font instances" do
+    font1 = subject.create_font(font_details)
+    font2 = subject.create_font(font_details)
+
+    expect(font1).to be(font2)
+  end
+end