shoes-swt 4.0.0.pre2

data/spec/swt_shoes/disposed_protection_spec.rb

@@ -0,0 +1,49 @@
+class Harness
+  include Shoes::Swt::DisposedProtection
+
+  def initialize(real)
+    @real = real
+  end
+end
+
+describe Shoes::Swt::DisposedProtection do
+  let(:width) { 234 }
+  let(:real_with_disposed_protection) { Harness.new(bare_real).real }
+
+  context "when real object is NOT disposed" do
+    let(:bare_real) { double("delegation object", width: width, dispose: nil, disposed?: false) }
+
+    it "delegates method" do
+      real_with_disposed_protection.width
+      expect(bare_real).to have_received(:width)
+    end
+
+    it "returns the same result as the bare real object" do
+      expect(real_with_disposed_protection.width).to eq(width)
+    end
+
+    it "disposes real object" do
+      real_with_disposed_protection.dispose
+      expect(bare_real).to have_received(:dispose)
+    end
+  end
+
+  context "when real object IS disposed" do
+    let(:bare_real) { double("delegation object", width: width, dispose: nil, disposed?: true) }
+
+    it "does NOT delegate method" do
+      real_with_disposed_protection.width
+      expect(bare_real).not_to have_received(:width)
+    end
+
+    it "returns nil" do
+      expect(real_with_disposed_protection.width).to eq(nil)
+    end
+
+    it "does NOT dispose real object" do
+      real_with_disposed_protection.dispose
+      expect(bare_real).not_to have_received(:dispose)
+    end
+  end
+end
+

data/spec/swt_shoes/flow_spec.rb

@@ -0,0 +1,36 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Flow do
+  include_context "swt app"
+
+  let(:dsl) { double('dsl', app: shoes_app,
+                     pass_coordinates?: true).as_null_object }
+  let(:real) { double('real', disposed?: false) }
+  let(:parent_real) { double('parent_real', :get_layout => "ok") }
+
+  subject { Shoes::Swt::Flow.new(dsl, parent) }
+
+  # it does not use toggle anymore and hides each element individually
+  # which means that each element takes care of what this spec specs,
+  # which we test elsewhere.
+  # Add back in when slots get an appropriate backend.
+  # #905
+  # it_behaves_like "updating visibility"
+
+  it_behaves_like "clickable backend" do
+    let(:click_block_parameters) { click_block_coordinates }
+  end
+
+  describe "#initialize" do
+    before do
+      allow(parent).to receive(:real) { parent_real }
+      allow(parent_real).to receive(:get_layout){double(top_slot: true)}
+    end
+
+    it "sets readers" do
+      expect(subject.parent).to eq parent
+      expect(subject.dsl).to eq dsl
+      expect(subject.real).to eq parent_real
+    end
+  end
+end

data/spec/swt_shoes/font_spec.rb

@@ -0,0 +1,33 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Font do
+
+  subject {Shoes::Swt::Font}
+
+  describe 'Shoes::FONTS' do
+    it 'has the FONTS array initially populared' do
+      expect(Shoes::FONTS).not_to be_empty
+    end
+
+    it 'loads the 2 shoes specific fonts' do
+      expect(Shoes::FONTS).to include("Coolvetica", "Lacuna")
+    end
+  end
+
+  describe '.add_font' do
+    it 'returns nil if no font was found' do
+      expect(subject.add_font('/non/existent/font.ttf')).to be_nil
+    end
+
+    it 'returns the font name when the font file is present' do
+      expect(subject.add_font(Shoes::FONT_DIR + 'Coolvetica.ttf')).to eq 'Coolvetica'
+    end
+
+    it 'calls the Display#load_font method' do
+      font_path = Shoes::FONT_DIR + 'Coolvetica.ttf'
+      expect(::Swt.display).to receive(:load_font).with(font_path)
+      subject.add_font font_path
+    end
+  end
+  
+end

data/spec/swt_shoes/gradient_spec.rb

@@ -0,0 +1,31 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Gradient do
+  let(:color1) { Shoes::Color.create(Shoes::COLORS[:honeydew]) }
+  let(:color2) { Shoes::Color.create(Shoes::COLORS[:salmon]) }
+  let(:dsl) { Shoes::Gradient.new(color1, color2) }
+  let(:gc) { double("gc", set_background_pattern: nil) }
+
+  subject { Shoes::Swt::Gradient.new(dsl) }
+
+  it_behaves_like "an swt pattern"
+
+  describe "#dispose" do
+    it "lets subresources do" do
+      # Prime the object's lazy colors
+      subject.apply_as_fill(gc, 10, 20, 100, 200)
+
+      expect(subject.color1).to receive(:dispose)
+      expect(subject.color2).to receive(:dispose)
+
+      subject.dispose
+    end
+  end
+
+  describe "#apply_as_fill" do
+    it "sets background" do
+      expect(gc).to receive(:set_background_pattern)
+      subject.apply_as_fill(gc, 10, 20, 100, 200)
+    end
+  end
+end

data/spec/swt_shoes/image_pattern_spec.rb

@@ -0,0 +1,35 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::ImagePattern do
+  let(:dsl)         { Shoes::ImagePattern.new("some/path/to") }
+  let(:swt_image)   { double("swt image") }
+  let(:swt_pattern) { double("swt pattern") }
+
+  subject { Shoes::Swt::ImagePattern.new(dsl) }
+
+  it_behaves_like "an swt pattern"
+
+  before do
+    allow(::Swt::Image).to receive(:new)   { swt_image }
+    allow(::Swt::Pattern).to receive(:new) { swt_pattern }
+  end
+
+  describe "#dispose" do
+    it "disposes of sub-resources" do
+      expect(swt_image).to receive(:dispose)
+      expect(swt_pattern).to receive(:dispose)
+
+      expect(subject.pattern).to_not be_nil
+      subject.dispose
+    end
+  end
+
+  describe "#apply_as_fill" do
+    let(:gc) { double("gc") }
+
+    it "sets background" do
+      expect(gc).to receive(:set_background_pattern)
+      subject.apply_as_fill(gc, 10, 20, 100, 200)
+    end
+  end
+end

data/spec/swt_shoes/image_spec.rb

@@ -0,0 +1,100 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Image do
+  include_context "swt app"
+
+  IMAGE_WIDTH = 3
+  IMAGE_HEIGHT = 1
+
+  let(:blk) { double("block") }
+  let(:dsl) { Shoes::Image.new shoes_app, parent_dsl, image, opts}
+  let(:opts) {{left: left, top: top, width: width, height: height}}
+  let(:left) { 100 }
+  let(:top) { 200 }
+  let(:height) { nil }
+  let(:width) {nil}
+  let(:image) { "spec/swt_shoes/minimal.png" }
+
+  subject {
+    allow(dsl).to receive(:file_path) { image }
+    Shoes::Swt::Image.new(dsl, parent)
+  }
+
+  it_behaves_like "paintable"
+  it_behaves_like "removable"
+  it_behaves_like "clickable backend"
+  it_behaves_like "updating visibility"
+
+  describe "paint callback" do
+    let(:event) { double("event", gc: gc) }
+    let(:gc) { double("gc", drawImage: true) }
+
+    before :each do
+      expect(swt_app).to receive(:add_paint_listener)
+    end
+
+    specify "draws image" do
+      allow(dsl).to receive_messages element_left: left, element_top: top
+      expect(gc).to receive(:drawImage).with(subject.real, 0, 0, 3, 1, left, top, 3, 1)
+      subject.painter.call(event)
+    end
+  end
+
+  describe "painting raw images" do
+    let(:image) { File.read("spec/swt_shoes/minimal.png", :mode => "rb") }
+
+    specify "loads image from raw data" do
+      subject.real.image_data.width = 3
+      subject.real.image_data.height = 1
+    end
+  end
+
+  # note the image used is 3x1 pixel big
+  describe 'dimensions' do
+
+    it 'has the given width' do
+      expect(subject.width).to eq(IMAGE_WIDTH)
+    end
+
+    it 'has the given height' do
+      expect(subject.height).to eq(IMAGE_HEIGHT)
+    end
+
+    it 'can change its width' do
+      subject.width = 7
+      expect(subject.width).to eq(7)
+    end
+
+    it 'can change its height' do
+      subject.height = 7
+      expect(subject.height).to eq(7)
+    end
+
+    describe 'with a given width' do
+      let(:width) {(IMAGE_WIDTH * 5.8).to_i}
+      it 'scales the height' do
+        expect(subject.height).to eq((IMAGE_HEIGHT * 5.8).to_i)
+      end
+    end
+
+    describe 'with a given height' do
+      let(:height) {IMAGE_HEIGHT * 4}
+
+      it 'scales the width' do
+        expect(subject.width).to eq(IMAGE_WIDTH * 4)
+      end
+    end
+
+    describe 'with a given width and height' do
+      let(:width) {1}
+      let(:height) {2}
+      it 'sets the given width' do
+        expect(subject.width).to eq(1)
+      end
+
+      it 'sets the given height' do
+        expect(subject.height).to eq(2)
+      end
+    end
+  end
+end

data/spec/swt_shoes/input_box_spec.rb

@@ -0,0 +1,116 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::InputBox do
+  include_context "swt app"
+
+  let(:dsl) { double('dsl', app: shoes_app, visible?: true, element_width: 80,
+                            element_height: 22, initial_text: 'Jay',
+                            secret?: secret,
+                            call_change_listeners: true).as_null_object }
+  let(:real) { double('real', disposed?: false, text: text,
+                      add_modify_listener: true).as_null_object }
+  let(:styles) {::Swt::SWT::SINGLE | ::Swt::SWT::BORDER}
+  let(:secret) {false}
+  let(:text) {'Some text...'}
+
+  subject { Shoes::Swt::InputBox.new dsl, parent, styles }
+
+  before :each do
+    allow(::Swt::Widgets::Text).to receive(:new) { real }
+    allow(::Swt::Widgets::Text).to receive(:text=) { real }
+  end
+
+  it_behaves_like "movable element"
+  it_behaves_like "removable native element"
+  it_behaves_like "updating visibility"
+
+  describe "#initialize" do
+    let(:event) {double 'Event', source: source}
+    let(:source) {double 'Source'}
+    it "sets text on real element" do
+      subject.text = "some text"
+      expect(real).to have_received(:text=).with("some text")
+    end
+
+    describe 'change listeners' do
+
+      it "should set up a listener that delegates change events" do
+        expect(dsl).to receive(:call_change_listeners)
+        expect(real).to receive(:add_modify_listener) do |&blk|
+          blk.call(event)
+        end
+        subject
+      end
+
+      describe 'modify block' do
+        before :each do
+          @modify_block = nil
+          expect(real).to receive(:add_modify_listener) do |&blk|
+            @modify_block = blk
+          end
+          subject
+        end
+
+        it 'normally calls the dsl change listeners' do
+          @modify_block.call event
+
+          expect(dsl).to have_received :call_change_listeners
+        end
+
+        describe 'with the same text' do
+          let(:event) {double 'Bad Event', source: source}
+          let(:source) {double 'Our source', text: text}
+          let(:text) {'Double call'}
+
+          it 'does not call the change listeners' do
+            subject.text = text
+            allow(event).to receive(:instance_of?) do |klazz|
+              klazz == Java::OrgEclipseSwtEvents::ModifyEvent
+            end
+            allow(source).to receive(:instance_of?) do |klazz|
+              klazz == Java::OrgEclipseSwtWidgets::Text
+            end
+            @modify_block.call event
+            expect(dsl).to_not have_received :call_change_listeners
+          end
+        end
+
+      end
+    end
+  end
+
+  describe 'text selections' do
+    it 'translates the highlight_text call' do
+      subject.highlight_text 4, 20
+      expect(real).to have_received(:set_selection).with(4, 20)
+    end
+
+    it 'translates the caret_to call' do
+      subject.caret_to 42
+      expect(real).to have_received(:set_selection).with(42)
+    end
+  end
+
+  describe Shoes::Swt::EditLine do
+    subject {Shoes::Swt::EditLine.new dsl, parent}
+    describe ":secret option" do
+      context "when NOT set" do
+        it "does NOT set PASSWORD style" do
+          options = Shoes::Swt::EditLine::DEFAULT_STYLES
+          allow(dsl).to receive(:secret?) { false }
+          expect(::Swt::Widgets::Text).to receive(:new).with(parent.real, options)
+          subject
+        end
+      end
+
+      context "when set" do
+        it "sets PASSWORD style" do
+          options = Shoes::Swt::EditLine::DEFAULT_STYLES | ::Swt::SWT::PASSWORD
+          allow(dsl).to receive(:secret?) { true }
+          expect(::Swt::Widgets::Text).to receive(:new).with(parent.real, options)
+          subject
+        end
+      end
+    end
+  end
+end

data/spec/swt_shoes/integration_spec.rb

@@ -0,0 +1,27 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::App do
+  before :each do
+    # The stubs that are unstubbed here occur in the spec_helper
+    # error not triggered with a stubbed flush (removing the stub overall
+    # seemed to difficult after initial try)
+    allow_any_instance_of(Shoes::Swt::App).to receive(:flush).and_call_original
+    allow(Shoes::Swt::RedrawingAspect).to receive(:new).and_call_original
+  end
+
+  it 'does not fail with just a simple para #574' do
+    app = nil
+    begin
+      expect do
+        app = Shoes.app do para 'me no fail' end
+        app.quit
+      end.not_to raise_error
+    ensure
+      # Really ugly, but we have to can't let the redrawing aspect persist out
+      # of this test run, don't really want to expose it broadly, and can't
+      # clear it during `quit` like might feel natural because of #782
+      aspect = app.instance_variable_get(:@__app__).gui.instance_variable_get(:@redrawing_aspect)
+      aspect.remove_redraws
+    end
+  end
+end

data/spec/swt_shoes/key_listener_spec.rb

@@ -0,0 +1,325 @@
+# encoding: UTF-8
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Keypress do
+  let(:app) { double('app', add_key_listener: nil, remove_key_listener: nil) }
+  let(:dsl) { double('dsl') }
+  let(:block) { proc{ |key| key} }
+  let(:key_listener) {Shoes::Swt::Keypress.new(dsl, app, &block)}
+
+  describe '.get_swt_constant' do
+    it 'gets the swt constant' do
+      expect(Shoes::Swt::KeyListener.get_swt_constant("TAB")).to eq ::Swt::SWT::TAB
+    end
+  end
+
+  describe "subclasses" do
+
+    describe "Subclass Keypress" do
+      it "adds key listener on creation" do
+        expect(app).to receive(:add_key_listener)
+        Shoes::Swt::Keypress.new dsl, app, &block
+      end
+    end
+
+    describe "Subclass Keyrelease" do
+      it "adds key listener on creation" do
+        expect(app).to receive(:add_key_listener)
+        Shoes::Swt::Keyrelease.new dsl, app, &block
+      end
+    end
+  end
+
+  it "removes the key listener from the app on remove" do
+    key_listener.remove
+    expect(app).to have_received(:remove_key_listener).with(key_listener)
+  end
+
+  CTRL = ::Swt::SWT::CTRL
+  ALT = ::Swt::SWT::ALT
+  SHIFT = ::Swt::SWT::SHIFT
+
+  subject {key_listener}
+
+  def test_character_press(character, state_modifier = 0, result_char = character)
+    expect(block).to receive(:call).with(result_char)
+    event = double  character: character.ord,
+                  stateMask: 0 | state_modifier,
+                  keyCode: character.downcase.ord
+    subject.handle_key_event(event)
+  end
+
+  def test_alt_character_press(character, state_mask_modifier = 0)
+    state_modifier = ALT | state_mask_modifier
+    result = ('alt_' + character).to_sym
+    test_character_press(character, state_modifier, result)
+  end
+
+
+  describe 'works with simple keys such as' do
+    it '"a"' do
+      test_character_press 'a'
+    end
+
+    it '"1"' do
+      test_character_press '1'
+    end
+
+    it '"$"' do
+      test_character_press '$'
+    end
+
+    it 'handles UTF-8 (œ)' do
+      test_character_press 'œ'
+    end
+  end
+
+  describe 'works with shift key pressed such as' do
+    def test_shift_character_press(character)
+      state_modifier = SHIFT
+      test_character_press(character, state_modifier)
+    end
+
+    it '"A"' do
+      test_shift_character_press "A"
+    end
+
+    it '"Z"' do
+      test_shift_character_press "Z"
+    end
+  end
+
+  describe 'works with alt key pressed such as' do
+    it ':alt_a' do
+      test_alt_character_press 'a'
+    end
+
+    it ':alt_z' do
+      test_alt_character_press 'z'
+    end
+
+    it ':alt_/' do
+      test_alt_character_press '/'
+    end
+
+    it 'works with what Macs seem to produce for opt + / (should be alt_/)' do
+      expect(block).to receive(:call).with(:'alt_/')
+      event = double  character: '÷'.ord,
+                      stateMask: ALT,
+                      keyCode: '/'.ord
+      subject.handle_key_event(event)
+    end
+  end
+
+  describe 'works with the ctrl key pressed such as' do
+    def test_ctrl_character_press(character, modifier = 0)
+      result_char = ('control_' + character).to_sym
+      expect(block).to receive(:call).with(result_char)
+      event = double character: 'something weird like \x00',
+                     stateMask: CTRL | modifier,
+                     keyCode:   character.downcase.ord
+      subject.handle_key_event(event)
+    end
+
+    it ':ctrl_a' do
+      test_ctrl_character_press 'a'
+    end
+
+    it 'ctrl_z' do
+      test_ctrl_character_press 'z'
+    end
+
+    describe 'and if we add the shift key' do
+      it ':ctrl_A' do
+        test_ctrl_character_press 'A', SHIFT
+      end
+
+      it ':ctrl_Z' do
+        test_ctrl_character_press 'Z', SHIFT
+      end
+    end
+  end
+
+  describe 'works with shift combined with alt yielding capital letters' do
+    def test_alt_shift_character_press(character)
+      test_alt_character_press(character, SHIFT)
+    end
+
+    it ':alt_A' do
+      test_alt_shift_character_press 'A'
+    end
+
+    it ':alt_Z' do
+      test_alt_shift_character_press 'Z'
+    end
+  end
+
+  describe 'only modifier keys yield nothing' do
+    def test_receive_nothing_with_modifier(modifier, last_key_press = modifier)
+      expect(block).not_to receive :call
+      event = double stateMask: modifier, keyCode: last_key_press, character: 0
+      subject.handle_key_event(event)
+    end
+
+    it 'shift' do
+      test_receive_nothing_with_modifier SHIFT
+    end
+
+    it 'alt' do
+      test_receive_nothing_with_modifier ALT
+    end
+
+    it 'control' do
+      test_receive_nothing_with_modifier CTRL
+    end
+
+    it 'shift + ctrl' do
+      test_receive_nothing_with_modifier SHIFT | CTRL, SHIFT
+    end
+
+    it 'ctrl + alt' do
+      test_receive_nothing_with_modifier CTRL | ALT, CTRL
+    end
+
+    it 'shift + ctrl + alt' do
+      test_receive_nothing_with_modifier CTRL | SHIFT | ALT, ALT
+    end
+  end
+
+  describe 'special keys' do
+
+    ARROW_LEFT = ::Swt::SWT::ARROW_LEFT
+
+    def special_key_test(code, expected, modifier = 0)
+      expect(block).to receive(:call).with(expected)
+      event = double stateMask: modifier,
+                   keyCode: code,
+                   character: 0
+      subject.handle_key_event(event)
+    end
+
+    it '"\n"' do
+      special_key_test(::Swt::SWT::CR, "\n")
+    end
+
+    it ':left' do
+      special_key_test ARROW_LEFT, :left
+    end
+
+    it ':f1' do
+      special_key_test ::Swt::SWT::F1, :f1
+    end
+
+    it ':tab' do
+      special_key_test ::Swt::SWT::TAB, :tab
+    end
+
+    it ':delete' do
+      special_key_test ::Swt::SWT::DEL, :delete
+    end
+
+    describe 'with modifier' do
+      it ':alt_left' do
+        special_key_test ARROW_LEFT, :alt_left, ALT
+      end
+
+      it ':control_left' do
+        special_key_test ARROW_LEFT, :control_left, CTRL
+      end
+
+      it ':shift_left' do
+        special_key_test ARROW_LEFT, :shift_left, SHIFT
+      end
+
+      it ':control_alt_home' do
+        special_key_test ::Swt::SWT::HOME, :control_alt_home, ALT | CTRL
+      end
+
+      it ':control_shift_home' do
+        special_key_test ::Swt::SWT::HOME,
+                         :control_shift_alt_home,
+                         ALT | CTRL | SHIFT
+      end
+    end
+  end
+
+  describe 'Mac command key' do
+    it 'fixes crash of shift option command #584' do
+      event = double 'key event', stateMask: 196608,
+                                  keyCode: 4194304,
+                                  character: "don't care atm"
+      expect {subject.handle_key_event(event)}.not_to raise_error
+    end
+  end
+
+  describe '#ignore_event?' do
+
+    let(:character) {'a'}
+    let(:event) {double 'key event',
+                        widget: widget,
+                        stateMask: 0,
+                        keyCode:  keyCode,
+                        character: character.ord }
+    let(:shell){Java::OrgEclipseSwtWidgets::Shell.new}
+    let(:style) {0}
+    let(:keyCode) {character.downcase.ord}
+
+
+    subject{key_listener.ignore_event? event}
+
+    shared_examples_for 'ignores space and enter' do
+      describe 'with a space' do
+        let(:character) {' '}
+        it {is_expected.to be_truthy}
+      end
+
+      describe 'with enter' do
+        let(:keyCode) {::Swt::SWT::CR}
+        it {is_expected.to be_truthy}
+      end
+    end
+
+    shared_examples_for 'accepts normal characters' do
+      describe 'with a normal character' do
+        let(:character) {'a'}
+        it{is_expected.to be_falsey}
+      end
+    end
+
+    context 'on a Shell' do
+      let(:widget){shell}
+      it {is_expected.to be_falsey}
+
+      describe 'even with enter' do
+        let(:keyCode) {::Swt::SWT::CR}
+        it {is_expected.to be_falsey}
+      end
+    end
+
+    context 'on a Text' do
+      let(:widget){Java::OrgEclipseSwtWidgets::Text.new(shell, style)}
+      it {is_expected.to be_truthy}
+    end
+
+    context 'on a button' do
+      let(:widget) {Java::OrgEclipseSwtWidgets::Button.new(shell, style)}
+
+      it_behaves_like 'ignores space and enter'
+      it_behaves_like 'accepts normal characters'
+    end
+
+    context 'on a Combo' do
+      let(:widget) {Java::OrgEclipseSwtWidgets::Combo.new(shell, style)}
+
+      it_behaves_like 'ignores space and enter'
+
+      describe 'with up' do
+        let(:keyCode) {::Swt::SWT::ARROW_UP}
+        it{is_expected.to be_truthy}
+      end
+
+      it_behaves_like 'accepts normal characters'
+    end
+  end
+
+end