Class: Glimmer::SWT::Custom::Shape

Inherits:
Object
  • Object
show all
Includes:
Properties
Defined in:
lib/glimmer/swt/custom/shape/arc.rb,
lib/glimmer/swt/custom/shape/line.rb,
lib/glimmer/swt/custom/shape/oval.rb,
lib/glimmer/swt/custom/shape/path.rb,
lib/glimmer/swt/custom/shape/quad.rb,
lib/glimmer/swt/custom/shape/text.rb,
lib/glimmer/swt/custom/shape/cubic.rb,
lib/glimmer/swt/custom/shape/focus.rb,
lib/glimmer/swt/custom/shape/image.rb,
lib/glimmer/swt/custom/shape/point.rb,
lib/glimmer/swt/custom/shape/polygon.rb,
lib/glimmer/swt/custom/shape/polyline.rb,
lib/glimmer/swt/custom/shape/rectangle.rb,
lib/glimmer/swt/custom/shape/path_segment.rb,
lib/glimmer/swt/custom/shape.rb

Overview

Represents a shape (graphics) to be drawn on a control/widget/canvas/display That is because Shape is drawn on a parent as graphics and doesn’t have an SWT widget for itself

Direct Known Subclasses

Arc, Focus, Image, Line, Oval, Path, Point, Polygon, Polyline, Rectangle, Text

Defined Under Namespace

Modules: PathSegment Classes: Arc, Cubic, Focus, Image, Line, Oval, Path, Point, Polygon, Polyline, Quad, Rectangle, Text

Constant Summary collapse

String = 
Text

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Properties

attribute_getter, #attribute_getter, attribute_setter, #attribute_setter, normalized_attribute, #normalized_attribute, ruby_attribute_getter, #ruby_attribute_setter, ruby_attribute_setter

Constructor Details

#initialize(parent, keyword, *args, &property_block) ⇒ Shape

Returns a new instance of Shape.



133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/glimmer/swt/custom/shape.rb', line 133

def initialize(parent, keyword, *args, &property_block)
  @parent = parent
  @drawable = @parent.is_a?(Drawable) ? @parent : @parent.drawable
  @name = keyword
  @options = self.class.arg_options(args, extract: true)
  @method_name = self.class.method_name(keyword, @options) unless keyword.to_s == 'shape'
  @args = args
  @properties = {}
  @shapes = [] # nested shapes
  @options.reject {|key, value| %w[fill gradient round].include?(key.to_s)}.each do |property, property_args|
    @properties[property] = property_args
  end
  @parent.add_shape(self)
  post_add_content if property_block.nil?
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name, *args, &block) ⇒ Object 



486
487
488
489
490
491
492
493
494
 
# File 'lib/glimmer/swt/custom/shape.rb', line 486

def method_missing(method_name, *args, &block)
  if method_name.to_s.end_with?('=')
    set_attribute(method_name, *args)
  elsif has_attribute?(method_name)
    get_attribute(method_name)
  else
    super
  end
end

Instance Attribute Details

#args ⇒ Object (readonly)

Returns the value of attribute args.



130
131
132
 
# File 'lib/glimmer/swt/custom/shape.rb', line 130

def args
  @args
end

#drawable ⇒ Object (readonly)

Returns the value of attribute drawable.



130
131
132
 
# File 'lib/glimmer/swt/custom/shape.rb', line 130

def drawable
  @drawable
end

#extent ⇒ Object

Returns the value of attribute extent.



131
132
133
 
# File 'lib/glimmer/swt/custom/shape.rb', line 131

def extent
  @extent
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



130
131
132
 
# File 'lib/glimmer/swt/custom/shape.rb', line 130

def name
  @name
end

#options ⇒ Object (readonly)

Returns the value of attribute options.



130
131
132
 
# File 'lib/glimmer/swt/custom/shape.rb', line 130

def options
  @options
end

#parent ⇒ Object (readonly)

Returns the value of attribute parent.



130
131
132
 
# File 'lib/glimmer/swt/custom/shape.rb', line 130

def parent
  @parent
end

#properties ⇒ Object (readonly)

Returns the value of attribute properties.



130
131
132
 
# File 'lib/glimmer/swt/custom/shape.rb', line 130

def properties
  @properties
end

#shapes ⇒ Object (readonly)

Returns the value of attribute shapes.



130
131
132
 
# File 'lib/glimmer/swt/custom/shape.rb', line 130

def shapes
  @shapes
end

Class Method Details

.arg_options(args, extract: false) ⇒ Object 



95
96
97
98
99
 
# File 'lib/glimmer/swt/custom/shape.rb', line 95

def arg_options(args, extract: false)
  arg_options_method = extract ? :pop : :last
  options = args.send(arg_options_method) if args.last.is_a?(Hash)
  options.nil? ? {} : options.symbolize_keys
end

.create(parent, keyword, *args, &property_block) ⇒ Object 



66
67
68
69
70
71
72
73
 
# File 'lib/glimmer/swt/custom/shape.rb', line 66

def create(parent, keyword, *args, &property_block)
  potential_shape_class_name = keyword.to_s.camelcase(:upper).to_sym
  if constants.include?(potential_shape_class_name)
    const_get(potential_shape_class_name).new(parent, keyword, *args, &property_block)
  else
    new(parent, keyword, *args, &property_block)
  end
end

.flyweight_method_names ⇒ Object 



113
114
115
 
# File 'lib/glimmer/swt/custom/shape.rb', line 113

def flyweight_method_names
  @flyweight_method_names ||= {}
end

.flyweight_patterns ⇒ Object 



125
126
127
 
# File 'lib/glimmer/swt/custom/shape.rb', line 125

def flyweight_patterns
  @flyweight_patterns ||= {}
end

.gc_instance_methods ⇒ Object 



81
82
83
 
# File 'lib/glimmer/swt/custom/shape.rb', line 81

def gc_instance_methods
  @gc_instance_methods ||= org.eclipse.swt.graphics.GC.instance_methods.map(&:to_s)
end

.keywords ⇒ Object 



85
86
87
88
89
90
91
92
93
 
# File 'lib/glimmer/swt/custom/shape.rb', line 85

def keywords
  @keywords ||= gc_instance_methods.select do |method_name|
    !method_name.end_with?('=') && (method_name.start_with?('draw_') || method_name.start_with?('fill_'))
  end.reject do |method_name|
    gc_instance_methods.include?("#{method_name}=") || gc_instance_methods.include?("set_#{method_name}")
  end.map do |method_name|
    method_name.gsub(/(draw|fill|gradient|round)_/, '')
  end.uniq.compact.to_a
end

.method_name(keyword, method_arg_options) ⇒ Object 



101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/glimmer/swt/custom/shape.rb', line 101

def method_name(keyword, method_arg_options)
  keyword = keyword.to_s
  method_arg_options = method_arg_options.select {|key, value| %w[fill gradient round].include?(key.to_s)}
  unless flyweight_method_names.keys.include?([keyword, method_arg_options])
    gradient = 'Gradient' if method_arg_options[:gradient]
    round = 'Round' if method_arg_options[:round]
    gc_instance_method_name_prefix = !['polyline', 'point', 'image', 'focus'].include?(keyword) && (method_arg_options[:fill] || method_arg_options[:gradient]) ? 'fill' : 'draw'
    flyweight_method_names[[keyword, method_arg_options]] = "#{gc_instance_method_name_prefix}#{gradient}#{round}#{keyword.capitalize}"
  end
  flyweight_method_names[[keyword, method_arg_options]]
end

.pattern(*args) ⇒ Object 



117
118
119
120
121
122
123
 
# File 'lib/glimmer/swt/custom/shape.rb', line 117

def pattern(*args)
  found_pattern = flyweight_patterns[args]
  if found_pattern.nil? || found_pattern.is_disposed
    found_pattern = flyweight_patterns[args] = org.eclipse.swt.graphics.Pattern.new(*args)
  end
  found_pattern
end

.valid?(parent, keyword, *args, &block) ⇒ Boolean

Returns:

  • (Boolean) 


75
76
77
78
79
 
# File 'lib/glimmer/swt/custom/shape.rb', line 75

def valid?(parent, keyword, *args, &block)
  return true if keyword.to_s == 'shape'
  gc_instance_methods.include?(method_name(keyword, arg_options(args))) ||
    constants.include?(keyword.to_s.camelcase(:upper).to_sym)
end

Instance Method Details

#absolute_x ⇒ Object 



896
897
898
899
900
901
902
903
 
# File 'lib/glimmer/swt/custom/shape.rb', line 896

def absolute_x
  x = calculated_x
  if parent.is_a?(Shape)
    parent.absolute_x + x
  else
    x
  end
end

#absolute_y ⇒ Object 



905
906
907
908
909
910
911
912
 
# File 'lib/glimmer/swt/custom/shape.rb', line 905

def absolute_y
  y = calculated_y
  if parent.is_a?(Shape)
    parent.absolute_y + y
  else
    y
  end
end

#add_shape(shape) ⇒ Object 



149
150
151
152
 
# File 'lib/glimmer/swt/custom/shape.rb', line 149

def add_shape(shape)
  @shapes << shape
  calculated_args_changed_for_defaults!
end

#all_parent_properties ⇒ Object 



564
565
566
567
568
569
570
571
572
573
 
# File 'lib/glimmer/swt/custom/shape.rb', line 564

def all_parent_properties
  # TODO consider providing a converted property version of this ready for consumption
  @all_parent_properties ||= parent_shape_composites.reverse.reduce({}) do |all_properties, parent_shape|
    parent_properties = parent_shape.properties
    parent_properties.each do |property, args|
      parent_properties[property] = apply_property_arg_conversions(property, args)
    end
    all_properties.merge(parent_properties)
  end
end

#amend_method_name_options_based_on_properties! ⇒ Object 



388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
 
# File 'lib/glimmer/swt/custom/shape.rb', line 388

def amend_method_name_options_based_on_properties!
  @original_method_name = @method_name
  return if @name == 'point'
  if @name != 'text' && @name != 'string' && has_some_background? && !has_some_foreground?
    @options[:fill] = true
  elsif !has_some_background? && has_some_foreground?
    @options[:fill] = false
  elsif @name == 'rectangle' && has_some_background? && has_some_foreground?
    @options[:fill] = true
    @options[:gradient] = true
  end
  if @name == 'rectangle' && @args.size > 4 && @args.last.is_a?(Numeric)
    @options[:round] = true
  end
  @method_name = self.class.method_name(@name, @options)
end

#apply_property_arg_conversions(property, args) ⇒ Object 



252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
 
# File 'lib/glimmer/swt/custom/shape.rb', line 252

def apply_property_arg_conversions(property, args)
  method_name = attribute_setter(property)
  args = args.dup
  the_java_method = org.eclipse.swt.graphics.GC.java_class.declared_instance_methods.detect {|m| m.name == method_name}
  return args if the_java_method.nil?
  if the_java_method.parameter_types.first == org.eclipse.swt.graphics.Color.java_class && args.first.is_a?(org.eclipse.swt.graphics.RGB)
    args[0] = [args[0].red, args[0].green, args[0].blue]
  end
  if ['setBackground', 'setForeground'].include?(method_name.to_s) && args.first.is_a?(Array)
    args[0] = ColorProxy.new(args[0])
  end
  if method_name.to_s == 'setLineDash' && args.size > 1
    args[0] = args.dup
    args[1..-1] = []
  end
  if method_name.to_s == 'setAntialias' && [nil, true, false].include?(args.first)
    args[0] = case args.first
    when true
      args[0] = :on
    when false
      args[0] = :off
    when nil
      args[0] = :default
    end
  end
  if args.first.is_a?(Symbol) || args.first.is_a?(::String)
    if the_java_method.parameter_types.first == org.eclipse.swt.graphics.Color.java_class
      args[0] = ColorProxy.new(args[0])
    end
    if method_name.to_s == 'setLineStyle'
      args[0] = "line_#{args[0]}" if !args[0].to_s.downcase.start_with?('line_')
    end
    if the_java_method.parameter_types.first == Java::int.java_class
      args[0] = SWTProxy.constant(args[0])
    end
  end
  if args.first.is_a?(ColorProxy)
    args[0] = args[0].swt_color
  end
  if (args.first.is_a?(Hash) || args.first.is_a?(org.eclipse.swt.graphics.FontData)) && the_java_method.parameter_types.first == org.eclipse.swt.graphics.Font.java_class
    args[0] = FontProxy.new(args[0])
  end
  if args.first.is_a?(FontProxy)
    args[0] = args[0].swt_font
  end
  if args.first.is_a?(TransformProxy)
    args[0] = args[0].swt_transform
  end
  if ['setBackgroundPattern', 'setForegroundPattern'].include?(method_name.to_s)
    @drawable.requires_shape_disposal = true
    args = args.first if args.first.is_a?(Array)
    args.each_with_index do |arg, i|
      arg = ColorProxy.new(arg.red, arg.green, arg.blue) if arg.is_a?(org.eclipse.swt.graphics.RGB)
      arg = ColorProxy.new(arg) if arg.is_a?(Symbol) || arg.is_a?(::String)
      arg = arg.swt_color if arg.is_a?(ColorProxy)
      args[i] = arg
    end
    @pattern_args ||= {}
    pattern_type = method_name.to_s.match(/set(.+)Pattern/)[1]
    if args.first.is_a?(Pattern)
      new_args = @pattern_args[pattern_type]
    else
      new_args = args.first.is_a?(Display) ? args : ([DisplayProxy.instance.swt_display] + args)
      @pattern_args[pattern_type] = new_args.dup
    end
    args[0] = pattern(*new_args, type: pattern_type)
    args[1..-1] = []
  end
  args
end

#apply_shape_arg_conversions! ⇒ Object 



323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
 
# File 'lib/glimmer/swt/custom/shape.rb', line 323

def apply_shape_arg_conversions!
  if @args.size > 1 && (['polygon', 'polyline'].include?(@name))
    @args[0] = @args.dup
    @args[1..-1] = []
  end
  if @name == 'image'
    if @args.first.is_a?(::String)
      @args[0] = ImageProxy.new(@args[0])
    end
    if @args.first.is_a?(ImageProxy)
      @image = @args[0] = @args[0].swt_image
    end
    if @args.first.nil?
      @image = nil
    end
  end
  if @name == 'text'
    if @args[3].is_a?(Symbol) || @args[3].is_a?(::String)
      @args[3] = [@args[3]]
    end
    if @args[3].is_a?(Array)
      if @args[3].size == 1 && @args[3].first.is_a?(Array)
        @args[3] = @args[3].first
      end
      @args[3] = SWTProxy[*@args[3]]
    end
  end
end

#apply_shape_arg_defaults! ⇒ Object 



352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
 
# File 'lib/glimmer/swt/custom/shape.rb', line 352

def apply_shape_arg_defaults!
  if current_parameter_name?(:dest_x) && dest_x.nil?
    self.dest_x = :default
  elsif parameter_name?(:x) && x.nil?
    self.x = :default
  end
  if current_parameter_name?(:dest_y) && dest_y.nil?
    self.dest_y = :default
  elsif parameter_name?(:y) && y.nil?
    self.y = :default
  end
  self.width = :default if current_parameter_name?(:width) && width.nil?
  self.height = :default if current_parameter_name?(:height) && height.nil?
  if @name.include?('rectangle') && round? && @args.size.between?(4, 5)
    (6 - @args.size).times {@args << 60}
  elsif @name.include?('rectangle') && gradient? && @args.size == 4
    set_attribute('vertical', true, redraw: false)
  elsif (@name.include?('text') || @name.include?('string')) && !@properties.keys.map(&:to_s).include?('background') && @args.size < 4
    set_attribute('is_transparent', true, redraw: false)
  end
  if @name.include?('image')
    @drawable.requires_shape_disposal = true
  end
end

#background_pattern_args ⇒ Object 



519
520
521
 
# File 'lib/glimmer/swt/custom/shape.rb', line 519

def background_pattern_args
  pattern_args(type: 'background')
end

#bounds ⇒ Object

The bounding box top-left x, y, width, height in absolute positioning



173
174
175
 
# File 'lib/glimmer/swt/custom/shape.rb', line 173

def bounds
  org.eclipse.swt.graphics.Rectangle.new(absolute_x, absolute_y, calculated_width, calculated_height)
end

#calculate_paint_args! ⇒ Object 



921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
 
# File 'lib/glimmer/swt/custom/shape.rb', line 921

def calculate_paint_args!
  unless @calculated_paint_args
    if @name == 'pixel'
      @name = 'point'
      # optimized performance calculation for pixel points
      if !@properties[:foreground].is_a?(org.eclipse.swt.graphics.Color)
        if @properties[:foreground].is_a?(Array)
          @properties[:foreground] = ColorProxy.new(@properties[:foreground], ensure_bounds: false)
        end
        if @properties[:foreground].is_a?(Symbol) || @properties[:foreground].is_a?(::String)
         @properties[:foreground] = ColorProxy.new(@properties[:foreground], ensure_bounds: false)
        end
        if @properties[:foreground].is_a?(ColorProxy)
          @properties[:foreground] = @properties[:foreground].swt_color
        end
      end
    else
      @properties['background'] = [@drawable.background] if fill? && !has_some_background?
      @properties['foreground'] = [@drawable.foreground] if @drawable.respond_to?(:foreground) && draw? && !has_some_foreground?
      # TODO regarding alpha, make sure to reset it to parent stored alpha once we allow setting shape properties on parents directly without shapes
      @properties['alpha'] ||= [255]
      @properties['font'] = [@drawable.font] if @drawable.respond_to?(:font) && draw? && !@properties.keys.map(&:to_s).include?('font')
      # TODO regarding transform, make sure to reset it to parent stored transform once we allow setting shape properties on parents directly without shapes
      # Also do that with all future-added properties
      @properties['transform'] = [nil] if @drawable.respond_to?(:transform) && !@properties.keys.map(&:to_s).include?('transform')
      @properties.each do |property, args|
        @properties[property] = apply_property_arg_conversions(property, args)
      end
      apply_shape_arg_conversions!
      apply_shape_arg_defaults!
      tolerate_shape_extra_args!
      @calculated_paint_args = true
    end
  end
end

#calculated_args ⇒ Object

args translated to absolute coordinates



678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
 
# File 'lib/glimmer/swt/custom/shape.rb', line 678

def calculated_args
  return @args if !default_x? && !default_y? && !default_width? && !default_height? && parent.is_a?(Drawable)
  # Note: Must set x and move_by because not all shapes have a real x and some must translate all their points with move_by
  # TODO change that by setting a bounding box for all shapes with a calculated top-left x, y and
  # a setter that does the moving inside them instead so that I could rely on absolute_x and absolute_y
  # here to get the job done of calculating absolute args
  @perform_redraw = false
  original_x = nil
  original_y = nil
  original_width = nil
  original_height = nil
  if parent.is_a?(Shape)
    @parent_absolute_x = parent.absolute_x
    @parent_absolute_y = parent.absolute_y
  end
  if default_width?
    original_width = width
    self.width = default_width + width_delta
  end
  if default_height?
    original_height = height
    self.height = default_height + height_delta
  end
  if max_width?
    original_width = width
    self.width = max_width + width_delta
  end
  if max_height?
    original_height = height
    self.height = max_height + height_delta
  end
  if default_x?
    original_x = x
    self.x = default_x + default_x_delta
  end
  if default_y?
    original_y = y
    self.y = default_y + default_y_delta
  end
  if parent.is_a?(Shape)
    move_by(@parent_absolute_x, @parent_absolute_y)
    result_args = @args.clone
    move_by(-1*@parent_absolute_x, -1*@parent_absolute_y)
  else
    result_args = @args.clone
  end
  if original_x
    self.x = original_x
  end
  if original_y
    self.y = original_y
  end
  if original_width
    self.width = original_width
  end
  if original_height
    self.height = original_height
  end
  @perform_redraw = true
  result_args
end

#calculated_args? ⇒ Boolean

Returns:

  • (Boolean) 


673
674
675
 
# File 'lib/glimmer/swt/custom/shape.rb', line 673

def calculated_args?
  !!@calculated_args
end

#calculated_args_changed!(children: true) ⇒ Object 



655
656
657
658
659
 
# File 'lib/glimmer/swt/custom/shape.rb', line 655

def calculated_args_changed!(children: true)
  # TODO add a children: true option to enable setting to false to avoid recalculating children args
  @calculated_args = nil
  shapes.each(&:calculated_args_changed!) if children
end

#calculated_args_changed_for_defaults! ⇒ Object 



661
662
663
664
665
666
667
668
669
670
671
 
# File 'lib/glimmer/swt/custom/shape.rb', line 661

def calculated_args_changed_for_defaults!
  has_default_dimensions = default_width? || default_height?
  parent_calculated_args_changed_for_defaults = has_default_dimensions
  @calculated_args = nil if default_x? || default_y? || has_default_dimensions
  if has_default_dimensions && parent.is_a?(Shape)
    parent.calculated_args_changed_for_defaults!
  elsif @content_added && !drawable.is_disposed
    # TODO consider optimizing in the future if needed by ensuring one redraw for all parents in the hierarchy at the end instead of doing one per parent that needs it
    drawable.redraw if !@painting && !drawable.is_a?(ImageProxy)
  end
end

#calculated_height ⇒ Object 



837
838
839
840
841
842
 
# File 'lib/glimmer/swt/custom/shape.rb', line 837

def calculated_height
  result_height = height
  result_height = (default_height + height_delta) if default_height?
  result_height = (max_height + height_delta) if max_height?
  result_height
end

#calculated_width ⇒ Object 



830
831
832
833
834
835
 
# File 'lib/glimmer/swt/custom/shape.rb', line 830

def calculated_width
  result_width = width
  result_width = (default_width + width_delta) if default_width?
  result_width = (max_width + width_delta) if max_width?
  result_width
end

#calculated_x ⇒ Object 



884
885
886
887
888
 
# File 'lib/glimmer/swt/custom/shape.rb', line 884

def calculated_x
  result = default_x? ? default_x : self.x
  result += default_x_delta
  result
end

#calculated_y ⇒ Object 



890
891
892
893
894
 
# File 'lib/glimmer/swt/custom/shape.rb', line 890

def calculated_y
  result = default_y? ? default_y : self.y
  result += default_y_delta
  result
end

#contain?(x, y) ⇒ Boolean

Returns if shape contains a point Subclasses (like polygon) may override to indicate if a point x,y coordinates falls inside the shape some shapes may choose to provide a fuzz factor to make usage of this method for mouse clicking more user friendly

Returns:

  • (Boolean) 


194
195
196
197
 
# File 'lib/glimmer/swt/custom/shape.rb', line 194

def contain?(x, y)
  # assume a rectangular filled shape by default (works for several shapes like image, text, and focus)
  x.between?(self.absolute_x, self.absolute_x + calculated_width) && y.between?(self.absolute_y, self.absolute_y + calculated_height)
end

#content(&block) ⇒ Object 



229
230
231
232
233
234
 
# File 'lib/glimmer/swt/custom/shape.rb', line 229

def content(&block)
  Glimmer::SWT::DisplayProxy.instance.auto_exec do
    Glimmer::DSL::Engine.add_content(self, Glimmer::DSL::SWT::ShapeExpression.new, @name, &block)
    calculated_args_changed!(children: false)
  end
end

#current_parameter_name?(attribute_name) ⇒ Boolean

Returns:

  • (Boolean) 


424
425
426
 
# File 'lib/glimmer/swt/custom/shape.rb', line 424

def current_parameter_name?(attribute_name)
  parameter_names.include?(attribute_name.to_s.to_sym)
end

#default_height ⇒ Object 



802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
 
# File 'lib/glimmer/swt/custom/shape.rb', line 802

def default_height
  # TODO consider caching
  y_ends = shapes.map do |shape|
    if shape.max_height?
      0
    else
      shape_height = shape.calculated_height.to_f
      shape_y = shape.default_y? ? 0 : shape.y.to_f
      shape_y + shape_height
    end
  end
  if shapes.size == 1 && shapes.first.max_height?
    self.parent.size.y
  else
    y_ends.max.to_f
  end
end

#default_height? ⇒ Boolean

Returns:

  • (Boolean) 


756
757
758
759
760
 
# File 'lib/glimmer/swt/custom/shape.rb', line 756

def default_height?
  return false unless current_parameter_name?(:height)
  height = self.height
  (height.nil? || height == :default || height == 'default' || (height.is_a?(Array) && (height.first.to_s == :default || height.first.to_s == 'default')))
end

#default_width ⇒ Object 



784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
 
# File 'lib/glimmer/swt/custom/shape.rb', line 784

def default_width
  # TODO consider caching
  x_ends = shapes.map do |shape|
    if shape.max_width?
      0
    else
      shape_width = shape.calculated_width.to_f
      shape_x = shape.default_x? ? 0 : shape.x.to_f
      shape_x + shape_width
    end
  end
  if shapes.size == 1 && shapes.first.max_width?
    self.parent.size.x
  else
    x_ends.max.to_f
  end
end

#default_width? ⇒ Boolean

Returns:

  • (Boolean) 


750
751
752
753
754
 
# File 'lib/glimmer/swt/custom/shape.rb', line 750

def default_width?
  return false unless current_parameter_name?(:width)
  width = self.width
  (width.nil? || width == :default || width == 'default' || (width.is_a?(Array) && (width.first.to_s == :default || width.first.to_s == 'default')))
end

#default_x ⇒ Object 



772
773
774
775
776
 
# File 'lib/glimmer/swt/custom/shape.rb', line 772

def default_x
  result = ((parent.size.x - size.x) / 2)
  result += parent.bounds.x - parent.absolute_x if parent.is_a?(Shape) && parent.irregular?
  result
end

#default_x? ⇒ Boolean

Returns:

  • (Boolean) 


740
741
742
743
 
# File 'lib/glimmer/swt/custom/shape.rb', line 740

def default_x?
  current_parameter_name?(:x) and
    (x.nil? || x.to_s == 'default' || (x.is_a?(Array) && x.first.to_s == 'default'))
end

#default_x_delta ⇒ Object 



844
845
846
847
 
# File 'lib/glimmer/swt/custom/shape.rb', line 844

def default_x_delta
  return 0 unless default_x? && x.is_a?(Array)
  x[1].to_f
end

#default_x_delta=(delta) ⇒ Object 



864
865
866
867
 
# File 'lib/glimmer/swt/custom/shape.rb', line 864

def default_x_delta=(delta)
  return unless default_x?
  self.x = [:default, delta]
end

#default_y ⇒ Object 



778
779
780
781
782
 
# File 'lib/glimmer/swt/custom/shape.rb', line 778

def default_y
  result = ((parent.size.y - size.y) / 2)
  result += parent.bounds.y - parent.absolute_y if parent.is_a?(Shape) && parent.irregular?
  result
end

#default_y? ⇒ Boolean

Returns:

  • (Boolean) 


745
746
747
748
 
# File 'lib/glimmer/swt/custom/shape.rb', line 745

def default_y?
  current_parameter_name?(:y) and
    (y.nil? || y.to_s == 'default' || (y.is_a?(Array) && y.first.to_s == 'default'))
end

#default_y_delta ⇒ Object 



849
850
851
852
 
# File 'lib/glimmer/swt/custom/shape.rb', line 849

def default_y_delta
  return 0 unless default_y? && y.is_a?(Array)
  y[1].to_f
end

#default_y_delta=(delta) ⇒ Object 



869
870
871
872
 
# File 'lib/glimmer/swt/custom/shape.rb', line 869

def default_y_delta=(delta)
  return unless default_y?
  self.y = [:default, delta]
end

#dispose(dispose_images: true, dispose_patterns: true, redraw: true) ⇒ Object 



527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
 
# File 'lib/glimmer/swt/custom/shape.rb', line 527

def dispose(dispose_images: true, dispose_patterns: true, redraw: true)
  shapes.each { |shape| shape.is_a?(Shape::Path) && shape.dispose }
  if dispose_patterns
    @background_pattern&.dispose
    @background_pattern = nil
    @foreground_pattern&.dispose
    @foreground_pattern = nil
  end
  if dispose_images
    @image&.dispose
    @image = nil
  end
  @parent.shapes.delete(self)
  drawable.redraw if redraw && !drawable.is_a?(ImageProxy)
end

#draw? ⇒ Boolean Also known as: drawn?

Returns:

  • (Boolean) 


154
155
156
 
# File 'lib/glimmer/swt/custom/shape.rb', line 154

def draw?
  !fill?
end

#ensure_extent(paint_event) ⇒ Object 



626
627
628
629
630
631
632
633
634
635
636
637
638
639
 
# File 'lib/glimmer/swt/custom/shape.rb', line 626

def ensure_extent(paint_event)
  old_extent = @extent
  if ['text', 'string'].include?(@name)
    extent_args = [string]
    extent_flags = SWTProxy[:draw_transparent] if current_parameter_name?(:is_transparent) && is_transparent
    extent_flags = flags if current_parameter_name?(:flags)
    extent_args << extent_flags unless extent_flags.nil?
    self.extent = paint_event.gc.send("#{@name}Extent", *extent_args)
  end
  if !@extent.nil? && (old_extent&.x != @extent&.x || old_extent&.y != @extent&.y)
    calculated_args_changed!
    parent.calculated_args_changed_for_defaults! if parent.is_a?(Shape)
  end
end

#expanded_shapes ⇒ Object 



641
642
643
644
645
646
647
648
649
 
# File 'lib/glimmer/swt/custom/shape.rb', line 641

def expanded_shapes
  if shapes.to_a.any?
    shapes.map do |shape|
      [shape] + shape.expanded_shapes
    end.flatten
  else
    []
  end
end

#fill? ⇒ Boolean Also known as: filled?

Returns:

  • (Boolean) 


159
160
161
 
# File 'lib/glimmer/swt/custom/shape.rb', line 159

def fill?
  @options[:fill]
end

#foreground_pattern_args ⇒ Object 



523
524
525
 
# File 'lib/glimmer/swt/custom/shape.rb', line 523

def foreground_pattern_args
  pattern_args(type: 'foreground')
end

#get_attribute(attribute_name) ⇒ Object 



475
476
477
478
479
480
481
482
483
484
 
# File 'lib/glimmer/swt/custom/shape.rb', line 475

def get_attribute(attribute_name)
  if parameter_name?(attribute_name)
    arg_index = parameter_index(attribute_name)
    @args[arg_index] if arg_index
  elsif (respond_to?(attribute_name, super: true) and respond_to?(ruby_attribute_setter(attribute_name), super: true))
    self.send(attribute_name)
  else
    @properties.symbolize_keys[attribute_name.to_s.to_sym]
  end
end

#gradient? ⇒ Boolean

Returns:

  • (Boolean) 


164
165
166
 
# File 'lib/glimmer/swt/custom/shape.rb', line 164

def gradient?
  @options[:gradient]
end

#has_attribute?(attribute_name, *args) ⇒ Boolean

Returns:

  • (Boolean) 


436
437
438
439
440
 
# File 'lib/glimmer/swt/custom/shape.rb', line 436

def has_attribute?(attribute_name, *args)
  self.class.gc_instance_methods.include?(attribute_setter(attribute_name)) or
    parameter_name?(attribute_name) or
    (respond_to?(attribute_name, super: true) and respond_to?(ruby_attribute_setter(attribute_name), super: true))
end

#has_some_background? ⇒ Boolean

Returns:

  • (Boolean) 


236
237
238
 
# File 'lib/glimmer/swt/custom/shape.rb', line 236

def has_some_background?
  @properties.keys.map(&:to_s).include?('background') || @properties.keys.map(&:to_s).include?('background_pattern')
end

#has_some_foreground? ⇒ Boolean

Returns:

  • (Boolean) 


240
241
242
 
# File 'lib/glimmer/swt/custom/shape.rb', line 240

def has_some_foreground?
  @properties.keys.map(&:to_s).include?('foreground') || @properties.keys.map(&:to_s).include?('foreground_pattern')
end

#height_delta ⇒ Object 



859
860
861
862
 
# File 'lib/glimmer/swt/custom/shape.rb', line 859

def height_delta
  return 0 unless default_height? && height.is_a?(Array)
  height[1].to_f
end

#height_delta=(delta) ⇒ Object 



879
880
881
882
 
# File 'lib/glimmer/swt/custom/shape.rb', line 879

def height_delta=(delta)
  return unless default_height?
  self.height = [:default, delta]
end

#include?(x, y) ⇒ Boolean

Returns if shape includes a point. When the shape is filled, this is the same as contain. When the shape is drawn, it only returns true if the point lies on the edge (boundary/border) Subclasses (like polygon) may override to indicate if a point x,y coordinates falls on the edge of a drawn shape or inside a filled shape some shapes may choose to provide a fuzz factor to make usage of this method for mouse clicking more user friendly

Returns:

  • (Boolean) 


202
203
204
205
 
# File 'lib/glimmer/swt/custom/shape.rb', line 202

def include?(x, y)
  # assume a rectangular shape by default
  contain?(x, y)
end

#inspect ⇒ Object

Overriding inspect to avoid printing very long shape hierarchies



915
916
917
918
919
 
# File 'lib/glimmer/swt/custom/shape.rb', line 915

def inspect
  "#<#{self.class.name}:0x#{self.hash.to_s(16)} args=#{@args.inspect}, properties=#{@properties.inspect}}>"
rescue => e
  "#<#{self.class.name}:0x#{self.hash.to_s(16)}"
end

#irregular? ⇒ Boolean

Indicates if a shape’s x, y, width, height differ from its bounds calculation (e.g. arc / polygon)

Returns:

  • (Boolean) 


208
209
210
 
# File 'lib/glimmer/swt/custom/shape.rb', line 208

def irregular?
  false
end

#location ⇒ Object

The bounding box top-left x and y



178
179
180
 
# File 'lib/glimmer/swt/custom/shape.rb', line 178

def location
  org.eclipse.swt.graphics.Point.new(bounds.x, bounds.y)
end

#location_parameter_names ⇒ Object

subclasses may override to specify location parameter names if different from x and y (e.g. all polygon points are location parameters) used in calculating movement changes



412
413
414
 
# File 'lib/glimmer/swt/custom/shape.rb', line 412

def location_parameter_names
  [:x, :y]
end

#max_height ⇒ Object 



825
826
827
828
 
# File 'lib/glimmer/swt/custom/shape.rb', line 825

def max_height
  # consider caching
  parent.is_a?(Drawable) ? parent.size.y : parent.calculated_height
end

#max_height? ⇒ Boolean

Returns:

  • (Boolean) 


767
768
769
770
 
# File 'lib/glimmer/swt/custom/shape.rb', line 767

def max_height?
  current_parameter_name?(:height) and
    (height.nil? || height.to_s == 'max' || (height.is_a?(Array) && height.first.to_s == 'max'))
end

#max_width ⇒ Object 



820
821
822
823
 
# File 'lib/glimmer/swt/custom/shape.rb', line 820

def max_width
  # consider caching
  parent.is_a?(Drawable) ? parent.size.x : parent.calculated_width
end

#max_width? ⇒ Boolean

Returns:

  • (Boolean) 


762
763
764
765
 
# File 'lib/glimmer/swt/custom/shape.rb', line 762

def max_width?
  current_parameter_name?(:width) and
    (width.nil? || width.to_s == 'max' || (width.is_a?(Array) && width.first.to_s == 'max'))
end

#move_by(x_delta, y_delta) ⇒ Object

moves by x delta and y delta. Subclasses must implement provdies a default implementation that assumes moving x and y is sufficient by default (not for polygons though, which must override)



214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/glimmer/swt/custom/shape.rb', line 214

def move_by(x_delta, y_delta)
  if respond_to?(:x) && respond_to?(:y) && respond_to?(:x=) && respond_to?(:y=)
    if default_x?
      self.default_x_delta += x_delta
    else
      self.x += x_delta
    end
    if default_y?
      self.default_y_delta += y_delta
    else
      self.y += y_delta
    end
  end
end

#paint(paint_event) ⇒ Object 



575
576
577
578
579
580
581
582
583
584
 
# File 'lib/glimmer/swt/custom/shape.rb', line 575

def paint(paint_event)
  paint_children(paint_event) if default_width? || default_height?
  paint_self(paint_event)
  # re-paint children from scratch in the special case of pre-calculating parent width/height to re-center within new parent dimensions
  shapes.each(&:calculated_args_changed!) if default_width? || default_height?
  paint_children(paint_event)
rescue => e
  Glimmer::Config.logger.error {"Error encountered in painting shape (#{self.inspect}) with calculated args (#{@calculated_args}) and args (#{@args})"}
  Glimmer::Config.logger.error {e.full_message}
end

#paint_children(paint_event) ⇒ Object 



620
621
622
623
624
 
# File 'lib/glimmer/swt/custom/shape.rb', line 620

def paint_children(paint_event)
  shapes.to_a.each do |shape|
    shape.paint(paint_event)
  end
end

#paint_self(paint_event) ⇒ Object 



586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
 
# File 'lib/glimmer/swt/custom/shape.rb', line 586

def paint_self(paint_event)
  @painting = true
  unless shape_composite?
    calculate_paint_args!
    @original_gc_properties = {} # this stores GC properties before making calls to updates TODO avoid using in pixel graphics
    @original_properties = @properties # this stores original shape attributes like background/foreground/font
    @properties.merge(all_parent_properties).each do |property, args|
      method_name = attribute_setter(property)
      @original_gc_properties[method_name] = paint_event.gc.send(method_name.sub('set', 'get')) rescue nil
      paint_event.gc.send(method_name, *args)
      if property == 'transform' && args.first.is_a?(TransformProxy)
        args.first.swt_transform.dispose
      end
    end
    ensure_extent(paint_event)
  end
  if !@calculated_args || parent_shape_absolute_location_changed?
    @calculated_args = calculated_args
  end
  unless shape_composite?
    # paint unless parent's calculated args are not calculated yet, meaning it is about to get painted and trigger a paint on this child anyways
    paint_event.gc.send(@method_name, *@calculated_args) unless (parent.is_a?(Shape) && !parent.calculated_args?)
    @original_gc_properties.each do |method_name, value|
      paint_event.gc.send(method_name, value)
    end
  end
  @painting = false
rescue => e
  Glimmer::Config.logger.error {"Error encountered in painting shape (#{self.inspect}) with method (#{@method_name}) calculated args (#{@calculated_args}) and args (#{@args})"}
  Glimmer::Config.logger.error {e.full_message}
ensure
  @painting = false
end

#parameter_index(attribute_name) ⇒ Object 



428
429
430
 
# File 'lib/glimmer/swt/custom/shape.rb', line 428

def parameter_index(attribute_name)
  parameter_names.index(attribute_name.to_s.to_sym)
end

#parameter_name?(attribute_name) ⇒ Boolean

Returns:

  • (Boolean) 


420
421
422
 
# File 'lib/glimmer/swt/custom/shape.rb', line 420

def parameter_name?(attribute_name)
  possible_parameter_names.map(&:to_s).include?(ruby_attribute_getter(attribute_name))
end

#parameter_names ⇒ Object

parameter names for arguments to pass to SWT GC.xyz method for rendering shape (e.g. draw_image(image, x, y) yields :image, :x, :y parameter names)



406
407
408
 
# File 'lib/glimmer/swt/custom/shape.rb', line 406

def parameter_names
  [:x, :y, :width, :height]
end

#parent_shape_absolute_location_changed? ⇒ Boolean

Returns:

  • (Boolean) 


651
652
653
 
# File 'lib/glimmer/swt/custom/shape.rb', line 651

def parent_shape_absolute_location_changed?
  (parent.is_a?(Shape) && (parent.absolute_x != @parent_absolute_x || parent.absolute_y != @parent_absolute_y))
end

#parent_shape_composites ⇒ Object

ordered from closest to farthest parent



560
561
562
 
# File 'lib/glimmer/swt/custom/shape.rb', line 560

def parent_shape_composites
  parent_shapes.select(&:shape_composite?)
end

#parent_shapes ⇒ Object

ordered from closest to farthest parent



549
550
551
552
553
554
555
556
557
 
# File 'lib/glimmer/swt/custom/shape.rb', line 549

def parent_shapes
  current_parent = parent
  the_parent_shapes = []
  until current_parent.is_a?(Drawable)
    the_parent_shapes << current_parent
    current_parent = current_parent.parent
  end
  the_parent_shapes
end

#pattern(*args, type: nil) ⇒ Object 



506
507
508
509
510
511
512
513
 
# File 'lib/glimmer/swt/custom/shape.rb', line 506

def pattern(*args, type: nil)
  instance_variable_name = "@#{type}_pattern"
  the_pattern = instance_variable_get(instance_variable_name)
  if the_pattern.nil? || the_pattern.is_disposed
    the_pattern = self.class.pattern(*args)
  end
  the_pattern
end

#pattern_args(type: nil) ⇒ Object 



515
516
517
 
# File 'lib/glimmer/swt/custom/shape.rb', line 515

def pattern_args(type: nil)
  @pattern_args && @pattern_args[type.to_s.capitalize]
end

#possible_parameter_names ⇒ Object 



416
417
418
 
# File 'lib/glimmer/swt/custom/shape.rb', line 416

def possible_parameter_names
  parameter_names
end

#post_add_content ⇒ Object 



244
245
246
247
248
249
250
 
# File 'lib/glimmer/swt/custom/shape.rb', line 244

def post_add_content
  amend_method_name_options_based_on_properties!
  if !@content_added || @method_name != @original_method_name
    @drawable.setup_shape_painting unless @drawable.is_a?(ImageProxy)
    @content_added = true
  end
end

#respond_to?(method_name, *args, &block) ⇒ Boolean

Returns:

  • (Boolean) 


496
497
498
499
500
501
502
503
504
 
# File 'lib/glimmer/swt/custom/shape.rb', line 496

def respond_to?(method_name, *args, &block)
  options = args.last if args.last.is_a?(Hash)
  super_invocation = options && options[:super]
  if !super_invocation && has_attribute?(method_name)
    true
  else
    super
  end
end

#round? ⇒ Boolean

Returns:

  • (Boolean) 


168
169
170
 
# File 'lib/glimmer/swt/custom/shape.rb', line 168

def round?
  @options[:round]
end

#set_attribute(attribute_name, *args) ⇒ Object 



442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
 
# File 'lib/glimmer/swt/custom/shape.rb', line 442

def set_attribute(attribute_name, *args)
  options = args.last if args.last.is_a?(Hash)
  args.pop if !options.nil? && !options[:redraw].nil?
  perform_redraw = @perform_redraw
  perform_redraw = options[:redraw] if perform_redraw.nil? && !options.nil?
  perform_redraw = true if perform_redraw.nil?
  if parameter_name?(attribute_name)
    set_parameter_attribute(attribute_name, *args)
  elsif (respond_to?(attribute_name, super: true) and respond_to?(ruby_attribute_setter(attribute_name), super: true))
    self.send(ruby_attribute_setter(attribute_name), *args)
  else
    @properties[ruby_attribute_getter(attribute_name)] = args
  end
  if @content_added && perform_redraw && !drawable.is_disposed
    @calculated_paint_args = false
    if is_a?(PathSegment)
      root_path&.calculated_path_args = @calculated_path_args = false
      calculated_args_changed!
      root_path&.calculated_args_changed!
    end
    attribute_name = ruby_attribute_getter(attribute_name)
    if location_parameter_names.map(&:to_s).include?(attribute_name)
      @calculated_args = nil
      parent.calculated_args_changed_for_defaults! if parent.is_a?(Shape)
    end
    if ['width', 'height'].include?(attribute_name)
      calculated_args_changed_for_defaults!
    end
    # TODO consider redrawing an image proxy's gc in the future
    drawable.redraw unless drawable.is_a?(ImageProxy)
  end
end

#set_parameter_attribute(attribute_name, *args) ⇒ Object 



432
433
434
 
# File 'lib/glimmer/swt/custom/shape.rb', line 432

def set_parameter_attribute(attribute_name, *args)
  @args[parameter_index(ruby_attribute_getter(attribute_name))] = args.size == 1 ? args.first : args
end

#shape_composite? ⇒ Boolean

Indicate if this is a shape composite (meaning a shape bag that just contains nested shapes, but doesn’t render anything of its own)

Returns:

  • (Boolean) 


544
545
546
 
# File 'lib/glimmer/swt/custom/shape.rb', line 544

def shape_composite?
  @name == 'shape'
end

#size ⇒ Object

The bounding box width and height (as a Point object with x being width and y being height)



183
184
185
 
# File 'lib/glimmer/swt/custom/shape.rb', line 183

def size
  org.eclipse.swt.graphics.Point.new(calculated_width, calculated_height)
end

#tolerate_shape_extra_args! ⇒ Object

Tolerates shape extra args added by user by mistake (e.g. happens when switching from round rectangle to a standard one without removing all extra args)



379
380
381
382
383
384
385
386
 
# File 'lib/glimmer/swt/custom/shape.rb', line 379

def tolerate_shape_extra_args!
  the_java_method_arg_count = org.eclipse.swt.graphics.GC.java_class.declared_instance_methods.select do |m|
    m.name == @method_name.camelcase(:lower)
  end.map(&:parameter_types).map(&:size).max
  if the_java_method_arg_count && @args.to_a.size > the_java_method_arg_count
    @args[the_java_method_arg_count..-1] = []
  end
end

#width_delta ⇒ Object 



854
855
856
857
 
# File 'lib/glimmer/swt/custom/shape.rb', line 854

def width_delta
  return 0 unless default_width? && width.is_a?(Array)
  width[1].to_f
end

#width_delta=(delta) ⇒ Object 



874
875
876
877
 
# File 'lib/glimmer/swt/custom/shape.rb', line 874

def width_delta=(delta)
  return unless default_width?
  self.width = [:default, delta]
end