Module: Glimmer::SWT::StyleConstantizable

Includes:
SuperModule
Included in:
DNDProxy, SWTProxy
Defined in:
lib/glimmer/swt/style_constantizable.rb

Overview

Mixin for all proxy classes that manage style constants (e.g. SWT, DND, etc…)

Constant Summary collapse

REGEX_SYMBOL_NEGATIVITY = 
/^([^!]+)(!)?$/

Class Method Summary collapse

Class Method Details

.[](*symbols) ⇒ Object

Gets constants (e.g. SWT::CONSTANT) where constant is passed in as a lower case symbol



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 35

def [](*symbols)
  symbols = symbols.first if symbols.size == 1 && symbols.first.is_a?(Array)
  result = symbols.compact.map do |symbol|
    constant(symbol).tap do |constant_value|
      raise Glimmer::Error, symbol.to_s + error_message_invalid_style unless constant_value.is_a?(Integer)
    end
  end.reduce do |output, constant_value|
    if constant_value < 0
      output & constant_value
    else
      output | constant_value
    end
  end
  result.nil? ? constant_value_none : result
end

.constant(symbol) ⇒ Object

Returns style integer value for passed in symbol or allows passed in object to pass through (e.g. Integer). This makes is convenient to use symbols or actual style integers in Glimmer Does not raise error for invalid values. Just lets them pass as is. (look into [] operator if you want an error raised on invalid values)



56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 56

def constant(symbol)
  return symbol unless symbol.is_a?(Symbol) || symbol.is_a?(String)
  symbol_string, negative = extract_symbol_string_negativity(symbol)
  swt_constant_symbol = symbol_string.downcase == symbol_string ? symbol_string.upcase.to_sym : symbol_string.to_sym
  bit_value = constant_source_class.const_get(swt_constant_symbol)
  negative ? ~bit_value : bit_value
rescue => e
  begin
#             Glimmer::Config.logger.debug {e.full_message}
    alternative_swt_constant_symbol = constant_source_class.constants.find {|c| c.to_s.upcase == swt_constant_symbol.to_s.upcase}
    bit_value = constant_source_class.const_get(alternative_swt_constant_symbol)
    negative ? ~bit_value : bit_value
  rescue => e
#             Glimmer::Config.logger.debug {e.full_message}
    bit_value = extra_styles[swt_constant_symbol]
    if bit_value
      negative ? ~bit_value : bit_value
    else
      symbol
    end
  end
end

.constant_java_import ⇒ Object 



12
13
14
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 12

def constant_java_import
  raise 'Not implemented! Mixer must implement!'
end

.constant_source_class ⇒ Object 



16
17
18
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 16

def constant_source_class
  raise 'Not implemented! Mixer must implement!'
end

.constant_value_none ⇒ Object 



20
21
22
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 20

def constant_value_none
  raise 'Not implemented! Mixer must implement!'
end

.constantify_args(args) ⇒ Object 



100
101
102
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 100

def constantify_args(args)
  args.map {|arg| constant(arg)}
end

.deconstruct(integer) ⇒ Object

Deconstructs a style integer into symbols Useful for debugging



106
107
108
109
110
111
112
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 106

def deconstruct(integer)
  constant_source_class.constants.reduce([]) do |found, c|
    constant_value = constant_source_class.const_get(c) rescue -1
    is_found = constant_value.is_a?(Integer) && (integer & constant_value) == integer
    is_found ? found += [c] : found
  end
end

.error_message_invalid_style ⇒ Object 



29
30
31
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 29

def error_message_invalid_style
  " is an invalid #{constant_source_class.name.split(':').last} style! Please choose a style from #{constant_java_import} class constants." # TODO parameterize
end

.extra_styles ⇒ Object

hash of extra styles (i.e. new style combinations)



25
26
27
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 25

def extra_styles
  raise 'Not implemented! Mixer must implement!'
end

.extract_symbol_string_negativity(symbol) ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 79

def extract_symbol_string_negativity(symbol)
 if symbol.is_a?(Symbol) || symbol.is_a?(String)
   symbol_negativity_match = symbol.to_s.match(REGEX_SYMBOL_NEGATIVITY)
   symbol = symbol_negativity_match[1]
   negative = !!symbol_negativity_match[2]
   [symbol, negative]
 else
   negative = symbol < 0
   [symbol, negative]
 end
end

.has_constant?(symbol) ⇒ Boolean

Returns:

  • (Boolean) 


95
96
97
98
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 95

def has_constant?(symbol)
  return false unless symbol.is_a?(Symbol) || symbol.is_a?(String)
  constant(symbol).is_a?(Integer)
end

.include?(swt_constant, *symbols) ⇒ Boolean

Returns:

  • (Boolean) 


124
125
126
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 124

def include?(swt_constant, *symbols)
  swt_constant & self[symbols] == self[symbols]
end

.negative?(symbol) ⇒ Boolean

Returns:

  • (Boolean) 


91
92
93
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 91

def negative?(symbol)
  extract_symbol_string_negativity(symbol)[1]
end

.reverse_lookup(integer) ⇒ Object

Reverse engineer a style integer into a symbol Useful for debugging



116
117
118
119
120
121
122
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 116

def reverse_lookup(integer)
  constant_source_class.constants.reduce([]) do |found, c|
    constant_value = constant_source_class.const_get(c) rescue -1
    is_found = constant_value.is_a?(Integer) && integer == constant_value
    is_found ? found += [c] : found
  end
end