shoes-swt 4.0.0.pre3 → 4.0.0.pre4

data/spec/shoes/swt/shared_examples/swt_app_context.rb

@@ -28,4 +28,3 @@ shared_context "swt app" do
                            gui: parent, x_dimension: double.as_null_object,
                            y_dimension: double.as_null_object)}
 end
-

data/spec/shoes/swt/shell_control_listener_spec.rb

@@ -6,18 +6,18 @@ describe Shoes::Swt::ShellControlListener do
   let(:resize_callbacks) {[]}
   let(:dsl_app) {double('DSL App', resize_callbacks: resize_callbacks).as_null_object}
   let(:block) {double 'Block', call: nil}
-  let(:resize_event) {double'resize_event', widget: shell}
+  let(:resize_event) {double 'resize_event', widget: shell}
   let(:real) {double('Swt Real').as_null_object}
 
   subject {Shoes::Swt::ShellControlListener.new(app)}
   before :each do
     subject.controlResized(resize_event)
   end
-  
+
   describe 'resize' do
-    let(:resize_callbacks ){[block]}
+    let(:resize_callbacks){[block]}
     it 'calls the resize block' do
-      expect(block).to have_received(:call) 
+      expect(block).to have_received(:call)
     end
   end
 end

data/spec/shoes/swt/shoes_layout_spec.rb

@@ -0,0 +1,84 @@
+require 'shoes/swt/spec_helper'
+
+describe Shoes::Swt::ShoesLayout do
+
+  subject do
+    result = Shoes::Swt::ShoesLayout.new
+    result.gui_app = gui_app
+    result
+  end
+
+  let(:gui_app)      { double('gui_app', dsl: dsl, real: real, shell: shell) }
+  let(:real)         { double('real', set_size: nil,
+                              location: location, :location= => nil) }
+  let(:size)         { double('size', height: 0, width: 0) }
+  let(:location)     { double('location', :y= => nil) }
+  let(:dsl)          { double('dsl', top_slot: top_slot,
+                              height: 100, width: 100) }
+  let(:top_slot)     { double('top_slot', contents_alignment: 0,
+                              :width= => nil, :height= => nil) }
+  let(:shell)        { double('shell', vertical_bar: vertical_bar) }
+  let(:vertical_bar) { double('vertical_bar', :increment= => nil,
+                              :visible= => nil, :maximum= => nil,
+                              :thumb= => nil, thumb: 0) }
+
+  let(:scroll_height) { dsl.height * 2 }
+
+  before do
+    allow(real).to receive(:compute_trim) do |_, _, width, height|
+      double('size', width: width, height: height)
+    end
+  end
+
+  it "sets size on real element" do
+    expect(real).to receive(:set_size).with(dsl.width, dsl.height)
+    subject.layout
+  end
+
+  it "sets height on real element to scrollable height when that's bigger" do
+    when_contents_scroll
+    expect(real).to receive(:set_size).with(dsl.width, scroll_height)
+    subject.layout
+  end
+
+  it "sets size on top slot" do
+    expect(top_slot).to receive(:width=).with(dsl.width)
+    expect(top_slot).to receive(:height=).with(dsl.height)
+    subject.layout
+  end
+
+  it "sets height on top slot to scrollable height when that's bigger" do
+    when_contents_scroll
+    expect(top_slot).to receive(:width=).with(dsl.width)
+    expect(top_slot).to receive(:height=).with(scroll_height)
+    subject.layout
+  end
+
+  it "shows scrollbar" do
+    when_contents_scroll
+    expect(vertical_bar).to receive(:visible=).with(true)
+    subject.layout
+  end
+
+  it "updates settings on scrollbar when visible" do
+    when_contents_scroll
+    [:thumb=, :maximum=, :increment=].each do |m|
+      expect(vertical_bar).to receive(m)
+    end
+    subject.layout
+  end
+
+  it "hides scrollbar" do
+    expect(vertical_bar).to receive(:visible=).with(false)
+    subject.layout
+  end
+
+  it "sets gui location when scrollbar hidden" do
+    expect(real).to receive(:location=).with(location)
+    subject.layout
+  end
+
+  def when_contents_scroll
+    allow(top_slot).to receive(:contents_alignment) { scroll_height }
+  end
+end

data/spec/shoes/swt/slot_spec.rb

@@ -21,4 +21,4 @@ describe Shoes::Swt::Slot do
       expect(content).to have_received :hide
     end
   end
-end
+end

data/spec/shoes/swt/spec_helper.rb

@@ -1,6 +1,8 @@
 require "shoes/swt"
 require "spec_helper"
 
+Shoes.load_backend("swt").initialize_backend
+
 RSpec.configure do |config|
   config.before(:each) do
     allow(Swt).to receive(:event_loop)

data/spec/shoes/swt/text_block/cursor_painter_spec.rb

@@ -3,7 +3,7 @@ require 'shoes/swt/spec_helper'
 describe Shoes::Swt::TextBlock::CursorPainter do
   include_context "swt app"
 
-  let(:dsl) { double("dsl", app: shoes_app, textcursor: textcursor, has_textcursor?: true) }
+  let(:dsl) { double("dsl", app: shoes_app, textcursor: textcursor, textcursor?: true) }
   let(:textcursor) { double("textcursor", left:0, top: 0, height: 10) }
   let(:segment_collection) { double('segment collection',
                                    cursor_height: 12,
@@ -21,7 +21,7 @@ describe Shoes::Swt::TextBlock::CursorPainter do
     end
 
     it "shouldn't do anything without text cursor" do
-      allow(dsl).to receive(:has_textcursor?) { nil}
+      allow(dsl).to receive(:textcursor?) { nil}
       subject.draw
       expect(dsl).to_not have_received(:textcursor=)
     end

data/spec/shoes/swt/text_block/fitter_spec.rb

@@ -144,18 +144,19 @@ describe Shoes::Swt::TextBlock::Fitter do
     context "to empty first segment" do
       before(:each) do
         allow(dsl).to receive_messages(containing_width: 100)
+        expect(segment).to receive(:fill_background=).with(true)
       end
 
       it "rolls to second segment when 0 remaining width" do
         allow(dsl).to receive_messages(desired_width: 0)
         segments = when_fit_at(x: 0, y: 75, next_line_start: 95)
-        expect_segments(segments, [26, 76], [1, 97])
+        expect_segments(segments, [26, 76], [1, 96])
       end
 
       it "rolls to second segment when negative remaining width" do
         allow(dsl).to receive_messages(desired_width: -1)
         segments = when_fit_at(x: 0, y: 75, next_line_start: 95)
-        expect_segments(segments, [26, 76], [1, 97])
+        expect_segments(segments, [26, 76], [1, 96])
       end
     end
 
@@ -174,13 +175,27 @@ describe Shoes::Swt::TextBlock::Fitter do
       it "bumps down a line if not at start" do
         allow(dsl).to receive_messages(element_left: 20, left: 20)
         segments = when_fit_at(x: 20, y: 75, next_line_start: 95)
-        expect_segments(segments, [20, 76], [1, 96])
+        expect_segments(segments, [20, 76], [1, 95])
       end
 
       it "if unbounded height, still bumps down properly" do
         allow(dsl).to receive_messages(absolute_top: 95, element_left: 20, left: 20, margin_left: 1)
         segments = when_fit_at(x: 20, y: 75, next_line_start: 95)
-        expect_segments(segments, [20, 76], [1, 96])
+        expect_segments(segments, [20, 76], [1, 95])
+      end
+    end
+
+    context "doesn't fit" do
+      it "with no width and unbounded height" do
+        allow(dsl).to receive_messages(desired_width: 0)
+        segments = when_fit_at(x: 0, y: 0, next_line_start: 0)
+        expect(segments).to be_empty
+      end
+
+      it "with no width and 0 height" do
+        allow(dsl).to receive_messages(desired_width: 0, containing_width: 0)
+        segments = when_fit_at(x: 0, y: 0, next_line_start: 1)
+        expect(segments).to be_empty
       end
     end
   end

data/spec/shoes/swt/text_block/painter_spec.rb

@@ -3,210 +3,36 @@ require 'shoes/swt/spec_helper'
 describe Shoes::Swt::TextBlock::Painter do
   include_context "swt app"
 
-  let(:dsl_style) { {justify: true, leading: 10, underline: "single"} }
-  let(:gui) { double("gui", dispose: nil) }
-  let(:dsl) { double("dsl", app: shoes_app, gui: gui,
-                     text: text, cursor: nil, style: dsl_style,
-                     element_width: 200, element_height: 180,
-                     element_left: 0, element_top: 10, font: "font",
-                     size: 16, margin_left: 0, margin_top: 0,
-                     text_styles: text_styles, :hidden? => false).as_null_object
-            }
-
-  let(:segment) do
-    allow(::Swt::Font).to receive(:new)       { font }
-    allow(::Swt::TextLayout).to receive(:new) { text_layout }
-    allow(::Swt::TextStyle).to receive(:new)  { style }
-
-    Shoes::Swt::TextBlock::TextSegment.new(dsl, text, 200).position_at(0, 10)
-  end
-
-  let(:text_layout) { double("text layout", text: text).as_null_object }
-
+  let(:dsl)   { double("dsl", app: shoes_app, gui: gui, hidden?: false) }
+  let(:gui)   { double("gui", dispose: nil, segments: segment_collection) }
   let(:event) { double("event").as_null_object }
-  let(:style) { double(:style).as_null_object }
-  let(:font)  { double(:font, font_data: [font_data]).as_null_object }
-  let(:font_data) { double(name: "font", height: 16.0, style: ::Swt::SWT::NORMAL) }
-
-  let(:blue) { Shoes::Color.new(0, 0, 255) }
-  let(:swt_blue) { Shoes::Swt::Color.new(blue).real}
-  let(:text_styles) {{}}
-  let(:text) {'hello world'}
+  let(:segment_collection) { double("segment collection", empty?: false) }
 
   subject { Shoes::Swt::TextBlock::Painter.new(dsl) }
 
-  before :each do
-    allow(::Swt::TextStyle).to receive(:new)  { style.as_null_object }
+  it "doesn't draw if hidden" do
+    allow(dsl).to receive(:hidden?) { true }
+    expect(segment_collection).to_not receive(:paint_control)
 
-    # Can't stub this in during initial let because of circular reference
-    # segments -> dsl -> gui -> segments...
-    allow(gui).to receive_messages(segments: [segment])
-  end
-
-  it "draws" do
-    expect(segment).to receive(:draw)
     subject.paintControl(event)
   end
 
-  it "sets justify" do
-    expect(text_layout).to receive(:justify=).with(dsl_style[:justify])
-    subject.paintControl(event)
-  end
+  it "doesn't draw no segment collection" do
+    allow(gui).to receive(:segments) { nil }
+    expect(segment_collection).to_not receive(:paint_control)
 
-  it "sets spacing" do
-    expect(text_layout).to receive(:spacing=).with(dsl_style[:leading])
     subject.paintControl(event)
   end
 
-  it "sets alignment" do
-    expect(text_layout).to receive(:alignment=).with(anything)
-    subject.paintControl(event)
-  end
+  it "doesn't draw segment collection is empty" do
+    allow(segment_collection).to receive(:empty?) { true }
+    expect(segment_collection).to_not receive(:paint_control)
 
-  it "sets text styles" do
-    expect(text_layout).to receive(:set_style).with(anything, anything, anything).at_least(1).times
     subject.paintControl(event)
   end
 
-  context "rise option" do
-    it "sets default rise value to nil" do
-      expect(style).to receive(:rise=).with(nil)
-      subject.paintControl(event)
-    end
-
-    it "sets correct rise value" do
-      dsl_style[:rise] = 10
-      expect(style).to receive(:rise=).with(10)
-
-      subject.paintControl(event)
-    end
-  end
-
-  context "underline option" do
-    it "sets default underline style to none" do
-      dsl_style.delete(:underline)
-
-      expect(style).to receive(:underline=).with(false)
-      expect(style).to receive(:underlineStyle=).with(nil)
-
-      subject.paintControl(event)
-    end
-
-    it "sets correct underline style" do
-
-      expect(style).to receive(:underline=).with(true)
-      expect(style).to receive(:underlineStyle=).with(Shoes::Swt::TextStyleFactory::UNDERLINE_STYLES["single"])
-
-      subject.paintControl(event)
-    end
-
-    it "sets underline color" do
-      dsl_style[:undercolor] = blue
-
-      expect(style).to receive(:underlineColor=).with(swt_blue)
-
-      subject.paintControl(event)
-    end
-
-    it "sets default underline color to nil" do
-      expect(style).to receive(:underlineColor=).with(nil)
-
-      subject.paintControl(event)
-    end
-  end
-
-  context "strikethrough option" do
-    it "sets default strikethrough to none" do
-      expect(style).to receive(:strikeout=).with(false)
-
-      subject.paintControl(event)
-    end
-
-    it "sets strikethrough" do
-      dsl_style[:strikethrough] = "single"
-
-      expect(style).to receive(:strikeout=).with(true)
-
-      subject.paintControl(event)
-    end
-
-    it "sets strikethrough color" do
-      dsl_style[:strikecolor] = blue
-
-      expect(style).to receive(:strikeoutColor=).with(swt_blue)
-
-      subject.paintControl(event)
-    end
-
-    it "sets default strikethrough color to nil" do
-      expect(style).to receive(:strikeoutColor=).with(nil)
-
-      subject.paintControl(event)
-    end
-  end
-
-  context "font styles" do
-    it "sets font style to bold" do
-      dsl_style[:weight] = true
-      expect(::Swt::Font).to receive(:new).with(anything, anything, anything, ::Swt::SWT::BOLD)
-      subject.paintControl(event)
-    end
-
-    it "sets font style to italic" do
-      dsl_style[:emphasis] = true
-      expect(::Swt::Font).to receive(:new).with(anything, anything, anything, ::Swt::SWT::ITALIC)
-      subject.paintControl(event)
-    end
-
-    it "sets font style to both bold and italic" do
-      dsl_style[:weight] = true
-      dsl_style[:emphasis] = true
-      expect(::Swt::Font).to receive(:new).with(anything, anything, anything, ::Swt::SWT::BOLD | ::Swt::SWT::ITALIC)
-
-      subject.paintControl(event)
-    end
-  end
-
-  context "colors" do
-    let(:black) { Shoes::Swt::Color.new(Shoes::COLORS[:black]).real }
-    let(:salmon) { Shoes::Swt::Color.new(Shoes::COLORS[:salmon]).real }
-
-    describe "stroke" do
-      it "is black by default" do
-        expect(::Swt::TextStyle).to receive(:new).with(anything, black, anything)
-        subject.paintControl(event)
-      end
-
-      it "is set with dsl_style[:stroke]" do
-        dsl_style[:stroke] = Shoes::COLORS[:salmon]
-        expect(::Swt::TextStyle).to receive(:new).with(anything, salmon, anything)
-        subject.paintControl(event)
-      end
-    end
-
-    describe "fill" do
-      it "is nil by default" do
-        expect(::Swt::TextStyle).to receive(:new).with(anything, anything, nil)
-        subject.paintControl(event)
-      end
-
-      it "is set with dsl_style[:fill]" do
-        dsl_style[:fill] = Shoes::COLORS[:salmon]
-        expect(::Swt::TextStyle).to receive(:new).with(anything, anything, salmon)
-        subject.paintControl(event)
-      end
-    end
-  end
-
-  describe 'text_styles' do
-    # this text_styles relies a lot on the internal structure of TextBlock/Painter
-    # right now, which I'm not too fond of... :)
-    let(:text_styles) {[[0...text.length, [Shoes::Span.new([text], size: 50)]]]}
-    it 'sets the font size to 50' do
-      expect(::Swt::Font).to receive(:new).
-                             with(anything, anything, 50, anything)
-
-      subject.paintControl event
-    end
+  it "paints" do
+    expect(segment_collection).to receive(:paint_control)
+    subject.paintControl(event)
   end
 end

data/spec/shoes/swt/text_block/text_segment_collection_spec.rb

@@ -5,7 +5,8 @@ describe Shoes::Swt::TextBlock::TextSegmentCollection do
 
   let(:first_segment) { create_segment("first", "first") }
   let(:second_segment) { create_segment("second", "rest") }
-  let(:dsl) { double("dsl", font: "", size: 16, style:{}) }
+  let(:dsl) { double("dsl", font: "", size: 16, style:{},
+                     text_styles: {(0..-1) => ["whatever"]}) }
 
   let(:gc) { double("gc") }
   let(:default_text_styles) {
@@ -62,7 +63,7 @@ describe Shoes::Swt::TextBlock::TextSegmentCollection do
 
         dsl_style = dsl_link.style
         default_style = default_text_styles.merge(dsl_style)
-        expected_style = default_style.merge({underline: true, stroke: ::Shoes::COLORS[:blue], fill: nil})
+        expected_style = default_style.merge(underline: true, stroke: ::Shoes::COLORS[:blue], fill: nil)
         expect(first_segment).to have_received(:set_style).with(expected_style, 0..1)
       end
 
@@ -162,7 +163,7 @@ describe Shoes::Swt::TextBlock::TextSegmentCollection do
 
       expected_style = style_with(stroke: :blue, fg: :blue)
       expect(first_segment).to have_received(:set_style).with(expected_style, 0..2)
-      expect(second_segment).to_not have_received(:set_style)
+      expect(second_segment).to_not have_received(:set_style).with(stroke: :blue)
     end
 
     it "applies segment styling in second segment" do
@@ -170,7 +171,7 @@ describe Shoes::Swt::TextBlock::TextSegmentCollection do
       subject.style_segment_ranges(styles)
 
       expected_style = style_with(stroke: :blue, fg: :blue)
-      expect(first_segment).to_not have_received(:set_style)
+      expect(first_segment).to_not have_received(:set_style).with(stroke: :blue)
       expect(second_segment).to have_received(:set_style).with(expected_style, 0..2)
     end
 
@@ -236,7 +237,11 @@ describe Shoes::Swt::TextBlock::TextSegmentCollection do
   def create_segment(name, text)
     bounds = double("bounds", x: 0, y: 0, height: 0)
     layout = double(name, text: text,
-                          line_bounds: bounds, line_count: 1)
+                    :justify= => nil, :spacing= => nil, :alignment= => nil,
+                    line_bounds: bounds, line_count: 1)
+
+
+    allow_any_instance_of(Shoes::Swt::TextFontFactory).to receive(:create_font)
 
     segment = Shoes::Swt::TextBlock::TextSegment.new(dsl, text, 1)
     segment.position_at(0, 0)