shoes-swt 4.0.0.pre2

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
+    allow(parent).to receive(:real)
+    allow(::Swt::Widgets::ProgressBar).to receive(:new) { real }
+  end
+
+  it_behaves_like "movable element"
+  it_behaves_like "updating visibility"
+
+  it "should have a method called fraction=" do
+    expect(subject).to respond_to :fraction=
+  end
+
+  it "should multiply the value by 100 when calling real.selection" do
+    expect(real).to receive(:selection=).and_return(55)
+    subject.fraction = 0.55
+  end
+
+  it "should round up correctly" do
+    expect(real).to receive(:selection=).and_return(100)
+    subject.fraction = 0.999
+  end
+
+  context "with disposed real element" do
+    before :each do
+      allow(real).to receive(:disposed?) { true }
+    end
+
+    it "shouldn't set selection" do
+      expect(real).not_to 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
+      expect(subject.name).to eq("Group Name")
+    end
+  end
+
+  describe "#add" do
+    it "monitors selection" do
+      expect(real).to 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
+        expect(subject.length).to eq(1)
+      end
+
+      it "the correct button is added" do
+        expect(subject.include?(radio)).to eq(true)
+      end
+    end
+  end
+
+  describe "#remove" do
+    before :each do
+      subject.add(radio)
+    end
+
+    it "stops monitoring selection" do
+      expect(real).to receive(:remove_selection_listener)
+      subject.remove(radio)
+    end
+
+    it "removes one button" do
+      subject.remove(radio)
+      expect(subject.length).to eq(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
+      expect(real_selected).to receive(:set_selection).with(true) 
+    end
+
+    it "turns off the non-selected radios" do
+      expect(real).to receive(:set_selection).with(false)
+    end
+  end
+
+end

data/spec/swt_shoes/radio_spec.rb

@@ -0,0 +1,56 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Radio do
+  include_context "swt app"
+
+  let(:text) { "TEXT" }
+  let(:dsl) { double('dsl', :app => shoes_app,
+                     :width= => true, :width => 100,
+                     :height= => true, :height => 200,
+                     :group => nil, :blk => block).as_null_object }
+  let(:block) { proc {} }
+  let(:real) { double('real').as_null_object }
+
+  subject { Shoes::Swt::Radio.new dsl, parent }
+
+  before :each do
+    allow(::Swt::Widgets::Button).to receive(:new) { real }
+  end
+
+  it_behaves_like "buttons"
+  it_behaves_like "movable element"
+  it_behaves_like "selectable"
+  it_behaves_like "updating visibility"
+
+  describe "#initialize" do
+    it "sets group to default" do
+      expect(subject.group).to eq(Shoes::Swt::RadioGroup::DEFAULT_RADIO_GROUP)
+    end
+  end
+
+  describe "#group=" do
+    let(:group_name) { "New Group Name" }
+    let(:radio_group) { double("radio_group").as_null_object }
+    let(:group_lookup) { double('group_lookup', :[] => radio_group).as_null_object }
+    before :each do
+      allow(Shoes::Swt::RadioGroup).to receive(:group_lookup) { group_lookup }  
+    end
+
+    it "changes the group" do
+      subject.group = group_name
+      expect(subject.group).to eq(group_name)
+    end
+
+    it "adds to the new radio group" do
+      expect(group_lookup).to receive(:[]).with group_name
+      expect(radio_group).to receive(:add).with subject
+      subject.group = group_name
+    end
+
+    it "removes from the old radio group" do
+      expect(group_lookup).to receive(:[]).with Shoes::Swt::RadioGroup::DEFAULT_RADIO_GROUP
+      expect(radio_group).to receive(:remove).with subject
+      subject.group = group_name
+    end
+  end
+end

data/spec/swt_shoes/rect_painter_spec.rb

@@ -0,0 +1,45 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::RectPainter do
+  include_context "painter context"
+
+  let(:corners) { 0 }
+  let(:app) { double('app', :real => container, :add_paint_listener => true, :dsl => dsl) }
+  let(:container) { double('container', :disposed? => false) }
+  let(:dsl) { double("dsl object", hidden: false, rotate: 0,
+                     element_left: left, element_top: top,
+                     element_width: width, element_height: height,
+                     curve: corners).as_null_object }
+  let(:left) { 55 }
+  let(:top) { 77 }
+  let(:width) { 222 }
+  let(:height) { 111 }
+  let(:shape) { Shoes::Swt::Rect.new dsl, app}
+  subject { Shoes::Swt::RectPainter.new shape }
+
+  it_behaves_like "fill painter"
+  it_behaves_like "stroke painter"
+
+  describe "square corners" do
+    let(:corners) { 0 }
+
+    it "fills rect" do
+      expect(gc).to receive(:fill_round_rectangle).with(left, top, width, height, corners*2, corners*2)
+      subject.paint_control(event)
+    end
+
+    it "draws rect" do
+      expect(gc).to receive(:draw_round_rectangle).with(left+sw/2, top+sw/2, width-sw, height-sw, corners*2, corners*2)
+      subject.paint_control(event)
+    end
+  end
+
+  describe "round corners" do
+    let(:corners) { 13 }
+
+    it "draws rect with rounded corners" do
+      expect(gc).to receive(:draw_round_rectangle).with(left+sw/2, top+sw/2, width-sw, height-sw, corners*2, corners*2)
+      subject.paint_control(event)
+    end
+  end
+end

data/spec/swt_shoes/rect_spec.rb

@@ -0,0 +1,19 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Rect do
+  include_context "swt app"
+
+  let(:left) { 55 }
+  let(:top) { 77 }
+  let(:width) { 222 }
+  let(:height) { 111 }
+  let(:dsl) {::Shoes::Rect.new shoes_app, parent, left, top, width, height}
+
+  subject {
+    Shoes::Swt::Rect.new dsl, swt_app
+  }
+
+  it_behaves_like "paintable"
+  it_behaves_like "updating visibility"
+  it_behaves_like 'clickable backend'
+end

data/spec/swt_shoes/shape_spec.rb

@@ -0,0 +1,84 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Shape do
+  include_context "swt app"
+
+  let(:dsl) { instance_double("Shoes::Shape", hidden: false, style: {}).as_null_object }
+  subject { Shoes::Swt::Shape.new dsl, swt_app }
+
+  shared_examples_for "Swt::Shape" do
+    let(:ancestors) { subject.class.ancestors.map(&:name) }
+
+    it "uses Shoes::Swt" do
+      expect(ancestors).to include('Shoes::Swt::Shape')
+      subject
+    end
+
+    its(:dsl) { is_expected.to be(dsl) }
+  end
+
+  it_behaves_like "Swt::Shape"
+  it_behaves_like "paintable"
+  it_behaves_like "removable"
+
+  it "properly disposes" do
+    expect(subject.transform).to receive(:dispose)
+    expect(subject.element).to receive(:dispose)
+    subject.dispose
+  end
+
+  describe "Swt element" do
+    let(:element) { double("element") }
+
+    before :each do
+      allow(::Swt::Path).to receive(:new) { element }
+    end
+
+    it "delegates #move_to" do
+      expect(element).to receive(:move_to).with(20, 30)
+      subject.move_to 20, 30
+    end
+
+    it "delegates #line_to" do
+      expect(element).to receive(:line_to).with(20, 30)
+      subject.line_to 20, 30
+    end
+  end
+
+  describe "moving" do
+    let(:transform) { double("transform") }
+
+    before :each do
+      allow(::Swt::Transform).to receive(:new) { transform }
+    end
+
+    it "translates position to dsl's element_left and element_top" do
+      allow(dsl).to receive(:element_left) { 20 }
+      allow(dsl).to receive(:element_top) { 30 }
+      expect(transform).to receive(:translate).with(20, 30)
+      subject.update_position
+    end
+
+  end
+
+  describe "painter" do
+    include_context "painter context"
+
+    let(:shape) { Shoes::Swt::Shape.new(dsl, swt_app) }
+    subject { Shoes::Swt::Shape::Painter.new(shape) }
+
+    it_behaves_like "stroke painter"
+    it_behaves_like "fill painter"
+    it_behaves_like "movable painter"
+
+    it "fills path" do
+      expect(gc).to receive(:fill_path)
+      subject.paint_control(event)
+    end
+
+    it "draws path" do
+      expect(gc).to receive(:draw_path)
+      subject.paint_control(event)
+    end
+  end
+end

data/spec/swt_shoes/shared_examples/button.rb

@@ -0,0 +1,21 @@
+shared_examples "buttons" do
+
+  it "calls set_focus when focus is called" do
+    expect(real).to receive(:set_focus)
+    subject.focus
+  end
+
+end
+
+# Check and Radio
+shared_examples "selectable" do
+  it "calls get_selection when checked? is called" do
+    expect(real).to receive(:get_selection)
+    subject.checked?
+  end
+
+  it "calls set_selection when checked= is called" do
+    expect(real).to receive(:set_selection).with(true)
+    subject.checked = true
+  end
+end

data/spec/swt_shoes/shared_examples/clickable.rb

@@ -0,0 +1,85 @@
+shared_examples 'clickable backend' do
+
+  before :each do
+    allow(swt_app).to receive :add_clickable_element
+    allow(swt_app).to receive :remove_listener
+    allow(swt_app).to receive(:clickable_elements).and_return(clickable_elements)
+    allow(dsl).to receive(:in_bounds?) { true }
+  end
+
+  let(:block) {clickable_block}
+  let(:clickable_elements) { double("clickable_elements", delete: nil) }
+
+  let(:clickable_block) {double 'clickable_block'}
+  let(:clickable_subject) do
+    subject.clickable clickable_block
+    subject
+  end
+
+  let(:mouse_event) {double 'mouse_event', button: 1, x: 2, y:3}
+
+  it {is_expected.to respond_to :clickable}
+
+  it 'its click_handler should not be nil' do
+    expect(clickable_subject.click_listener).not_to be_nil
+  end
+
+  # This let will be used for expectations on click parameters
+  let(:click_block_parameters)  { [dsl] }
+
+  # This is the alternate form of click parameters we can expect
+  # set click_block_parameters to this for examples with coordinate clicks
+  let(:click_block_coordinates) { [1, 2, 3] }
+
+  it 'calls the block when a click event comes in bounds' do
+    allow(dsl).to receive(:hidden?) { false }
+    expect(clickable_block).to receive(:call).with(*click_block_parameters)
+    clickable_subject.click_listener.handleEvent mouse_event
+  end
+
+  it "doesn't call the block if the object is hidden" do
+    allow(dsl).to receive(:hidden?) { true }
+    expect(clickable_block).to_not receive(:call)
+  end
+
+  describe 'interaction with the swt app object' do
+
+    def expect_added_listener_for(event)
+      click_listener = subject.click_listener
+      expect(swt_app).to have_received(:add_listener).with(event,
+                                                           click_listener)
+    end
+
+    it 'receives the add_clickable_element message' do
+      expect(swt_app).to receive(:add_clickable_element)
+      clickable_subject
+    end
+
+    it 'adds a listener for the MouseDown event' do
+      clickable_subject
+      expect_added_listener_for ::Swt::SWT::MouseDown
+    end
+
+    it 'adds the correct listener' do
+      clickable_subject
+      expect_added_listener_for ::Swt::SWT::MouseDown
+    end
+
+    it 'adds a listener for the MouseDown event when click is called' do
+      subject.click Proc.new {}
+      expect_added_listener_for ::Swt::SWT::MouseDown
+    end
+
+    it 'adds a listener for the MouseUp event when release is called' do
+      subject.release Proc.new {}
+      expect_added_listener_for ::Swt::SWT::MouseUp
+    end
+  end
+
+  it 'only hands the dsl object to the app' do
+    subject.click Proc.new {}
+    # at least is used for link - because it already triggers it in intialize
+    expect(swt_app).to have_received(:add_clickable_element).with(subject.dsl).
+                           at_least(1).times
+  end
+end

data/spec/swt_shoes/shared_examples/movable.rb

@@ -0,0 +1,36 @@
+shared_examples "movable element" do |left, top|
+
+  before :each do
+    allow(dsl).to receive_messages element_left: left, element_top: top
+  end
+
+  context "with disposed real element" do
+    before :each do
+      allow(real).to receive(:disposed?) { true }
+    end
+
+    it "doesn't delegate to real" do
+      expect(real).not_to receive(:set_location)
+      subject.update_position
+    end
+  end
+
+  context "with undisposed real element" do
+    before :each do
+      allow(real).to receive(:disposed?) { false }
+    end
+
+    it "delegates to real" do
+      expect(real).to receive(:set_location).with(left, top)
+      subject.update_position
+    end
+  end
+end
+
+shared_examples_for "movable shape" do |x, y|
+  it "redraws container" do
+    expect(container).to receive(:redraw).at_least(2).times
+    allow(dsl).to receive_messages element_left: x, element_top: y
+    subject.update_position
+  end
+end