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



57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 57

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)



78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 78

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 



33
34
35
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 33

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

.constant_source_class ⇒ Object 



37
38
39
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 37

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

.constant_value_none ⇒ Object 



41
42
43
44
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 41

def constant_value_none
  # TODO instead of raising error try a convention instead like CLASSNAME::NONE by default
  raise 'Not implemented! Mixer must implement!'
end

.constantify_args(args) ⇒ Object 



122
123
124
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 122

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

.deconstruct(integer) ⇒ Object

Deconstructs a style integer into symbols Useful for debugging



128
129
130
131
132
133
134
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 128

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) == constant_value
    is_found ? found += [c] : found
  end
end

.error_message_invalid_style ⇒ Object 



51
52
53
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 51

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 composite styles (i.e. style combinations defined under new style names)



47
48
49
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 47

def extra_styles
  {}
end

.extract_symbol_string_negativity(symbol) ⇒ Object 



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

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) 


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

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) 


147
148
149
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 147

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

.negative?(symbol) ⇒ Boolean

Returns:

  • (Boolean) 


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

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



138
139
140
141
142
143
144
145
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 138

def reverse_lookup(integer)
  # TODO support looking up compound style mixes
  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