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
100
101
102
103
 
# 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}
    if symbol.to_s.size == 1 # accelerator key
      symbol.to_s.bytes.first
    else
      bit_value = extra_styles[swt_constant_symbol]
      if bit_value
        negative ? ~bit_value : bit_value
      else
        symbol
      end
    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 



126
127
128
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 126

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

.deconstruct(integer) ⇒ Object

Deconstructs a style integer into symbols Useful for debugging



132
133
134
135
136
137
138
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 132

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 



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

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) 


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

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) 


151
152
153
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 151

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

.negative?(symbol) ⇒ Boolean

Returns:

  • (Boolean) 


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

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



142
143
144
145
146
147
148
149
 
# File 'lib/glimmer/swt/style_constantizable.rb', line 142

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