shoes 4.0.0.pre1 → 4.0.0.pre2

data/spec/swt_shoes/link_segment_spec.rb

@@ -1,103 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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