shoes-swt 4.0.0.pre2

data/spec/swt_shoes/line_spec.rb

@@ -0,0 +1,49 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Line do
+  include_context "swt app"
+
+  let(:container) { double('container', :disposed? => false).as_null_object }
+  let(:dsl) { Shoes::Line.new shoes_app, parent, point_a, point_b }
+  let(:point_a) { Shoes::Point.new(10, 100) }
+  let(:point_b) { Shoes::Point.new(300, 10) }
+
+  subject {
+    Shoes::Swt::Line.new(dsl, swt_app)
+  }
+
+  context "#initialize" do
+    it { is_expected.to be_instance_of(Shoes::Swt::Line) }
+    its(:dsl) { is_expected.to be(dsl) }
+  end
+
+  it "properly disposes" do
+    expect(subject.transform).to receive(:dispose)
+    subject.dispose
+  end
+
+  it_behaves_like "paintable"
+  it_behaves_like "updating visibility"
+  it_behaves_like "clickable backend"
+
+  it {is_expected.to respond_to :remove}
+
+  describe "painter" do
+    include_context "painter context"
+
+    let(:shape) { Shoes::Swt::Line.new(dsl, swt_app) }
+    subject { Shoes::Swt::Line::Painter.new(shape) }
+
+    before(:each) do
+      allow(dsl).to receive_messages(positioned?: true)
+    end
+
+    it_behaves_like "stroke painter"
+
+    specify "draws line" do
+      # coords as if drawn in box at (0,0)
+      expect(gc).to receive(:draw_line).with(0, 90, 290, 0)
+      subject.paint_control(event)
+    end
+  end
+end

data/spec/swt_shoes/link_segment_spec.rb

@@ -0,0 +1,120 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::LinkSegment do
+  let(:range)         { (2..10) }
+  let(:line_width)    { 20 }
+  let(:line_height)   { 14 }
+  let(:layout)        { double('swt layout', width: line_width, line_count: 10) }
+  let(:text_segment)  { double('text segment', layout: layout,
+                               element_left: 0, element_top: 0) }
+
+  subject { Shoes::Swt::LinkSegment.new(text_segment, range) }
+
+  before(:each) do
+    10.times {|i| stub_line_bounds(i)}
+  end
+
+
+  # ....................
+  context "empty link" do
+    let(:range) { (0...0) }
+
+    it "fails all bounds checks" do
+      stub_start_and_end_locations([0, 0], [10, 0])
+      expect_not_in_bounds(0, 0, 10, line_height)
+    end
+  end
+
+  # xxxxxxxxxx..........
+  it "sets bounds on single line" do
+    stub_start_and_end_locations([0, 0], [10, 0])
+
+    expect_bounded_box(0, 0, 10, line_height)
+  end
+
+  # xxxxxxxxxxxxxxxxxxxx
+  # xxxxx...............
+  it "sets bounds wrapping to second line" do
+    stub_start_and_end_locations([0, 0], [5, line_height])
+
+    expect_bounded_box(0, 0,           line_width, line_height)
+    expect_bounded_box(0, line_height, 5,          2*line_height)
+  end
+
+  # .....xxxxxxxxxxxxxxx
+  # xxxxxxxxxxxxxxxxxxxx
+  # xxxxx...............
+  it "sets bounds wrapping over three lines" do
+    stub_start_and_end_locations([5, 0], [5, 2*line_height])
+
+    expect_bounded_box(5, 0,             line_width, line_height)
+    expect_bounded_box(0, line_height,   line_width, 2*line_height)
+    expect_bounded_box(0, 2*line_height, 5,          3*line_height)
+  end
+
+  # ....................
+  # .....xxxxxxxxxx.....
+  it "sets bounds with single line beginning further down" do
+    stub_start_and_end_locations([5, line_height], [15, line_height])
+
+    expect_bounded_box(5, line_height, 15, 2*line_height)
+  end
+
+  # ....................
+  # ...............xxxxx
+  # xxxxx...............
+  it "sets bounds with two lines beginning further down" do
+    stub_start_and_end_locations([15, line_height], [5, 2*line_height])
+
+    expect_bounded_box(15, line_height,   15, 2*line_height)
+    expect_bounded_box(0,  2*line_height, 5,  3*line_height)
+  end
+
+  # ....................
+  # ...............xxxxx
+  # xxxxxxxxxxxxxxxxxxxx
+  # xxxxx...............
+  it "sets bounds with three lines beginning further down" do
+    stub_start_and_end_locations([15, line_height], [5, 3*line_height])
+
+    expect_bounded_box(15, line_height,   15,         2*line_height)
+    expect_bounded_box(0,  2*line_height, line_width, 3*line_height)
+    expect_bounded_box(0,  3*line_height, 5,          4*line_height)
+  end
+
+  def expect_bounded_box(left, top, right, bottom)
+    expect_in_bounds([left, top],    [right, top],
+                     [left, bottom], [right,bottom])
+  end
+
+  def expect_in_bounds(*points)
+    points.each do |(x,y)|
+      expect(subject.in_bounds?(x, y)).to be_truthy, "with #{x}, #{y}"
+    end
+  end
+
+  def expect_not_in_bounds(*points)
+    points.each do |(x,y)|
+      expect(subject.in_bounds?(x, y)).to be_falsey, "with #{x}, #{y}"
+    end
+  end
+
+  def stub_start_and_end_locations(first, last)
+    stub_location(range.first, first[0], first[1])
+    stub_location(range.last, last[0], last[1])
+  end
+
+  def stub_location(at, x, y)
+    allow(text_segment).to receive(:get_location).with(at, anything) { double(x: x, y: y) }
+  end
+
+  def stub_line_bounds(index)
+    allow(layout).to receive(:line_bounds).with(index) {
+      double("line #{index}",
+             x: 0,
+             y: index * line_height,
+             width: line_width,
+             height: line_height)
+    }
+  end
+end

data/spec/swt_shoes/link_spec.rb

@@ -0,0 +1,54 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Link do
+  include_context "swt app"
+
+  let(:dsl) { Shoes::Link.new shoes_app, parent, ["linky"] }
+
+  subject { Shoes::Swt::Link.new(dsl, swt_app) }
+
+  its(:dsl) {is_expected.to eq dsl}
+
+  it_behaves_like "clickable backend"
+
+  context "creating link segments" do
+    let(:bounds)       { double("bounds", height: 0) }
+    let(:inner_layout) { double("inner layout",
+                                get_line_bounds: bounds, line_count: 1,
+                                line_bounds: double(x: 0, y: 0, height: 0)) }
+    let(:layout)       { double("layout",
+                                get_location: double("position", x: 0, y: 0),
+                                element_left: 0, element_top: 0,
+                                layout: inner_layout) }
+
+    before(:each) do
+      allow(shoes_app).to receive(:add_listener)
+      allow(shoes_app).to receive(:add_clickable_element)
+
+      allow(swt_app).to receive(:clickable_elements) { [] }
+    end
+
+    it "clears existing" do
+      subject.link_segments << double("segment")
+      subject.create_links_in([])
+      expect(subject.link_segments).to be_empty
+    end
+
+    it "adds new segments" do
+      subject.create_links_in([
+                                [layout, [5..10]],
+                                [layout, [0..5]]
+                              ])
+      expect(subject.link_segments.count).to eql(2)
+    end
+
+    it "clears links" do
+      expect(swt_app).to receive(:remove_listener)
+
+      subject.create_links_in([[layout, 0..10]])
+      subject.remove
+
+      expect(subject.link_segments).to be_empty
+    end
+  end
+end

data/spec/swt_shoes/list_box_spec.rb

@@ -0,0 +1,56 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::ListBox do
+  include_context "swt app"
+
+  let(:items)  { ["Pie", "Apple", "Sand"] }
+  let(:dsl)    { double('dsl', app: shoes_app,
+                        items: items, opts: {},
+                        element_width: 200, element_height: 20).as_null_object }
+  let(:block)  { ->(){} }
+  let(:real)   { double('real', text: "", :items= => true,
+                        set_size: true, add_selection_listener: true,
+                        disposed?: false ) }
+
+  subject { Shoes::Swt::ListBox.new dsl, parent, &block }
+
+  before :each do
+    allow(parent).to receive(:real)
+    allow(::Swt::Widgets::Combo).to receive(:new) { real }
+  end
+
+  it_behaves_like "updating visibility"
+
+  it "should return nil when nothing is highlighted" do
+    expect(subject.text).to be_nil
+  end
+
+  it "should call 'items' when updating values" do
+    expect(real).to receive(:items=).with(["hello"])
+    subject.update_items(["hello"])
+  end
+
+  it "should respond to choose" do
+    expect(subject).to respond_to :choose
+  end
+
+  it "should call text= when choosing" do
+    expect(real).to receive(:text=).with "Bacon"
+    subject.choose "Bacon"
+  end
+
+  it 'sets the items on real upon initialization' do
+    subject
+    expect(real).to have_received(:items=).with(items)
+  end
+
+  describe "when the backend notifies us that the selection has changed" do
+    it "should call the change listeners" do
+      expect(dsl).to receive(:call_change_listeners)
+      expect(real).to receive(:add_selection_listener) do |&blk|
+        blk.call()
+      end
+      subject
+    end
+  end
+end

data/spec/swt_shoes/mouse_move_listener_spec.rb

@@ -0,0 +1,123 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::MouseMoveListener do
+  let(:app) {double 'SWT App', dsl: dsl_app, shell: shell,
+                    clickable_elements: clickable_elements}
+  let(:clickable_elements) {[]}
+  let(:mouse_hover_controls) {[]}
+  let(:mouse_motion) {[]}
+  let(:shell) {double 'Shell', setCursor: nil}
+  let(:dsl_app) {double('DSL App', mouse_hover_controls: mouse_hover_controls,
+                        mouse_motion: mouse_motion).as_null_object}
+  let(:x) {10}
+  let(:y) {42}
+  let(:block) {double 'Block', call: nil}
+  let(:mouse_event) {double'mouse event', x: x, y: y}
+
+  subject {Shoes::Swt::MouseMoveListener.new(app)}
+  before :each do
+    subject.mouse_move(mouse_event)
+  end
+
+  describe 'mouse position' do
+    it 'receives the correct mouse position' do
+      expect(dsl_app).to have_received(:mouse_pos=).with([x, y])
+    end
+  end
+
+  describe 'mouse motion' do
+    let(:mouse_motion) {[block]}
+
+    it 'calls the block with the position' do
+      expect(block).to have_received(:call).with(x, y)
+    end
+  end
+
+  describe 'shape control' do
+    let(:hand_cursor) {Shoes::Swt::Shoes.display.getSystemCursor(::Swt::SWT::CURSOR_HAND)}
+    let(:arrow_cursor) {Shoes::Swt::Shoes.display.getSystemCursor(::Swt::SWT::CURSOR_ARROW)}
+
+    context 'over a clickable element' do
+      let(:clickable_elements) {[double('element', visible?: true, in_bounds?: true)]}
+      it 'should set the curser hand' do
+        expect(shell).to have_received(:setCursor).with(hand_cursor)
+      end
+    end
+
+    context 'not over a clickable element' do
+      let(:clickable_elements) {[double('element', visible?: true, in_bounds?: false)]}
+      it 'should set the curser hand' do
+        expect(shell).to have_received(:setCursor).with(arrow_cursor)
+      end
+    end
+  end
+
+  describe 'hover control' do
+    let(:element) {double 'element', in_bounds?: in_bounds?, hovered?: hovered?,
+                          visible?: true, mouse_left: nil, mouse_hovered: nil}
+    let(:mouse_hover_controls) {[element]}
+
+    shared_examples_for 'does not do anything' do
+      it 'calls no hover related methods whatsoever' do
+        expect(element).not_to have_received :mouse_left
+        expect(element).not_to have_received :mouse_hovered
+      end
+    end
+
+    context 'in bounds and hovered' do
+      let(:in_bounds?) {true}
+      let(:hovered?) {true}
+
+      it_behaves_like 'does not do anything'
+    end
+
+    context 'out of bounds and not hovered' do
+      let(:in_bounds?) {false}
+      let(:hovered?) {false}
+
+      it_behaves_like 'does not do anything'
+    end
+
+    context 'in bounds and not hovered' do
+      let(:in_bounds?) {true}
+      let(:hovered?) {false}
+
+      it 'calls the hovered method' do
+        expect(element).to have_received :mouse_hovered
+      end
+    end
+
+    context 'out of bounds and hovered' do
+      let(:in_bounds?) {false}
+      let(:hovered?) {true}
+
+      it 'calls the mouse_left method' do
+        expect(element).to have_received :mouse_left
+      end
+    end
+
+    describe 'in bounds, not hovered but hidden' do
+      let(:in_bounds?) {true}
+      let(:hovered?)   {false}
+      let(:element) {double 'element', in_bounds?: in_bounds?, hovered?: hovered?,
+                            visible?: false, mouse_left: nil, mouse_hovered: nil}
+
+      it_behaves_like 'does not do anything'
+    end
+
+    describe 'with 2 elements' do
+      let(:in_bounds?) {false}
+      let(:hovered?) {true}
+
+      let(:element2) {double 'element 2', in_bounds?: true, hovered?: false,
+                             visible?: true, mouse_left: nil, mouse_hovered: nil}
+      let(:mouse_hover_controls) {[element, element2]}
+
+      it 'calls leave for element 1 before calling hover for element 2' do
+        expect(element).to receive(:mouse_left).ordered
+        expect(element2).to receive(:mouse_hovered).ordered
+        subject.mouse_move(mouse_event)
+      end
+    end
+  end
+end

data/spec/swt_shoes/oval_spec.rb

@@ -0,0 +1,51 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Oval do
+  include_context "swt app"
+
+  let(:left) { 100 }
+  let(:top) { 200 }
+  let(:width) { 300 }
+  let(:height) { 400 }
+  let(:dsl) {::Shoes::Oval.new shoes_app, parent, left, top, width, height}
+
+  subject {
+    Shoes::Swt::Oval.new(dsl, swt_app)
+  }
+
+  it_behaves_like "paintable"
+  it_behaves_like "updating visibility"
+  it_behaves_like 'clickable backend'
+
+  describe "painter" do
+    include_context "painter context"
+
+    before :each do
+      shape.absolute_left = left
+      shape.absolute_top  = top
+    end
+    let(:shape) { Shoes::Swt::Oval.new(dsl, swt_app) }
+    subject { Shoes::Swt::Oval::Painter.new(shape) }
+
+    it_behaves_like "fill painter"
+    it_behaves_like "stroke painter"
+
+    it "creates oval clipping area" do
+      double_path = double("path")
+      allow(::Swt::Path).to receive(:new) { double_path }
+      expect(double_path).to receive(:add_arc).with(left, top, width, height, 0, 360)
+      subject.clipping
+    end
+
+    it "fills" do
+      expect(gc).to receive(:fill_oval)
+      subject.paint_control(event)
+    end
+
+    specify "draws oval" do
+      expect(gc).to receive(:draw_oval).with(left+sw/2, top+sw/2, width-sw, height-sw)
+      subject.paint_control(event)
+    end
+  end
+end
+