shoes 3.0.1 → 4.0.0.pre1

data/spec/swt_shoes/link_segment_spec.rb

@@ -0,0 +1,103 @@
+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(:fitted_layout) { double('fitted layout', layout: layout,
+                               element_left: 0, element_top: 0) }
+
+  subject { Shoes::Swt::LinkSegment.new(fitted_layout, range) }
+
+  before(:each) do
+    10.times {|i| stub_line_bounds(i)}
+  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_true, "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)
+    fitted_layout.stub(:get_location).with(at, anything) { double(x: x, y: y) }
+  end
+
+  def stub_line_bounds(index)
+    layout.stub(: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,59 @@
+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) }
+
+  it "marks itself clickable" do
+    expect(swt_app).to receive(:add_listener)
+    expect(swt_app).to receive(:add_clickable_element)
+
+    subject
+  end
+
+  its(:dsl) {should eq dsl}
+
+  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
+      shoes_app.stub(:add_listener)
+      shoes_app.stub(:add_clickable_element)
+
+      swt_app.stub(: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
+      # One remove call each for mouse down, mouse up
+      expect(swt_app).to receive(:remove_listener).twice
+
+      subject.create_links_in([[layout, 0..10]])
+      subject.clear
+
+      expect(subject.link_segments).to be_empty
+    end
+  end
+end

data/spec/swt_shoes/list_box_spec.rb

@@ -0,0 +1,51 @@
+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: "",
+                        set_size: true, add_selection_listener: true,
+                        disposed?: false) }
+
+  subject { Shoes::Swt::ListBox.new dsl, parent, &block }
+
+  before :each do
+    parent.stub(:real)
+    ::Swt::Widgets::Combo.stub(:new) { real }
+  end
+
+  it_behaves_like "togglable"
+
+  it "should return nil when nothing is highlighted" do
+    subject.text.should be_nil
+  end
+
+  it "should call 'items' when updating values" do
+    real.should_receive(:items=).with(["hello"])
+    subject.update_items(["hello"])
+  end
+
+  it "should respond to choose" do
+    subject.should respond_to :choose
+  end
+
+  it "should call text= when choosing" do
+    real.should_receive(:text=).with "Bacon"
+    subject.choose "Bacon"
+  end
+
+  describe "when the backend notifies us that the selection has changed" do
+    it "should call the change listeners" do
+      dsl.should_receive(:call_change_listeners)
+      real.should_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,129 @@
+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', 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', 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?,
+                          hover_proc: element_hover, leave_proc: element_leave,
+                          mouse_left: nil, mouse_hovered: nil}
+    let(:element_hover) {double 'element hover', call: nil}
+    let(:element_leave) {double 'element leave', call: 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
+        expect(element_hover).not_to have_received :call
+        expect(element_leave).not_to have_received :call
+      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 hover block' do
+        expect(element_hover).to have_received :call
+      end
+
+      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 leave block' do
+        expect(element_leave).to have_received :call
+      end
+
+      it 'calls the mouse_left method' do
+        expect(element).to have_received :mouse_left
+      end
+    end
+
+    describe 'with 2 elements' do
+      let(:in_bounds?) {false}
+      let(:hovered?) {true}
+
+      let(:element2) {double 'element 2', in_bounds?: true, hovered?: false,
+                             hover_proc: element2_hover, leave_proc: nil,
+                             mouse_left: nil, mouse_hovered: nil}
+      let(:element2_hover) {double 'element 2 hover', call: nil}
+      let(:mouse_hover_controls) {[element, element2]}
+
+      it 'calls leave for element 1 before calling hover for element 2' do
+        expect(element_leave).to receive(:call).ordered
+        expect(element2_hover).to receive(:call).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 "togglable"
+  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")
+      ::Swt::Path.stub(:new) { double_path }
+      double_path.should_receive(:add_arc).with(left, top, width, height, 0, 360)
+      subject.clipping
+    end
+
+    it "fills" do
+      gc.should_receive(:fill_oval)
+      subject.paint_control(event)
+    end
+
+    specify "draws oval" do
+      gc.should_receive(:draw_oval).with(left+sw/2, top+sw/2, width-sw, height-sw)
+      subject.paint_control(event)
+    end
+  end
+end
+

data/spec/swt_shoes/progress_spec.rb

@@ -0,0 +1,44 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Progress do
+  include_context "swt app"
+
+  let(:text) { "TEXT" }
+  let(:dsl) { double('dsl', app: shoes_app).as_null_object }
+  let(:real) { double('real', disposed?: false, :disposed? => false).as_null_object }
+
+  subject { Shoes::Swt::Progress.new dsl, parent }
+
+  before :each do
+    parent.stub(:real)
+    ::Swt::Widgets::ProgressBar.stub(:new) { real }
+  end
+
+  it_behaves_like "movable element"
+  it_behaves_like "togglable"
+
+  it "should have a method called fraction=" do
+    subject.should respond_to :fraction=
+  end
+
+  it "should multiply the value by 100 when calling real.selection" do
+    real.should_receive(:selection=).and_return(55)
+    subject.fraction = 0.55
+  end
+
+  it "should round up correctly" do
+    real.should_receive(:selection=).and_return(100)
+    subject.fraction = 0.999
+  end
+
+  context "with disposed real element" do
+    before :each do
+      real.stub(:disposed?) { true }
+    end
+
+    it "shouldn't set selection" do
+      real.should_not_receive(:selection=)
+      subject.fraction = 0.55
+    end
+  end
+end

data/spec/swt_shoes/radio_group_spec.rb

@@ -0,0 +1,73 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::RadioGroup do
+  let(:name) { "Group Name" }
+  let(:real) { double('real', add_selection_listener: true, remove_selection_listener: true).as_null_object }
+  let(:radio) { double('radio', real: real) }
+
+  subject { Shoes::Swt::RadioGroup.new name }
+
+  describe "#initialize" do
+    it "sets name" do
+      subject.name.should == "Group Name"
+    end
+  end
+
+  describe "#add" do
+    it "monitors selection" do
+      real.should_receive(:add_selection_listener) 
+      subject.add(radio)
+    end
+
+    describe 'after adding a button' do
+      before :each do
+         subject.add radio
+      end
+
+      it "only one button is added" do
+        subject.length.should == 1
+      end
+
+      it "the correct button is added" do
+        subject.include?(radio).should == true
+      end
+    end
+  end
+
+  describe "#remove" do
+    before :each do
+      subject.add(radio)
+    end
+
+    it "stops monitoring selection" do
+      real.should_receive(:remove_selection_listener)
+      subject.remove(radio)
+    end
+
+    it "removes one button" do
+      subject.remove(radio)
+      subject.length.should == 0
+    end
+  end
+
+  describe "#select_only_one_radio_in_group" do
+    let(:real_selected) { double('real').as_null_object }
+    let(:radio_selected) { double('radio', real: real_selected) }
+    before :each do
+      subject.add(radio)
+      subject.add(radio_selected)
+    end
+    after :each do 
+      subject.select_only_one_radio_in_group(radio_selected) 
+    end
+
+    it "turns on the selected radio" do
+      real_selected.should_receive(:set_selection).with(true) 
+    end
+
+    it "turns off the non-selected radios" do
+      real.should_receive(:set_selection).with(false)
+    end
+  end
+
+end