Changeset 28997

Show
Ignore:
Timestamp:
01/25/09 12:23:35 (4 years ago)
Author:
isaisstillalive
Message:
  • Rich::Formatが長くなってきたのでファイル分割。
Location:
lang/ruby/ruwin
Files:
2 added
2 modified
2 copied

Legend:

Unmodified
Added
Removed

  • lang/ruby/ruwin/lib/ruwin/edit_field/rich.rb

    r28996 r28997  
    22  class EditField 
    33    class Rich < EditField 
     4      autoload :Format, "ruwin/edit_field/rich/format" 
     5       
    46      class Selection < EditField::Selection 
    57        attr_reader :format 
    … …  
    1416          sendMessage EM_GETSELTEXT, 0, result 
    1517          result 
    16         end 
    17       end 
    18        
    19       module Format 
    20         class Char 
    21           include Ruwin 
    22           include Const::EditField 
    23            
    24           def initialize control, extent_flag 
    25             @control = control 
    26             @extent_flag = extent_flag 
    27           end 
    28            
    29           { 
    30             :bold       => %w{CFM_BOLD      CFE_BOLD}, 
    31             :italic     => %w{CFM_ITALIC    CFE_ITALIC}, 
    32             :underline  => %w{CFM_UNDERLINE CFE_UNDERLINE}, 
    33             :strikeout  => %w{CFM_STRIKEOUT CFE_STRIKEOUT}, 
    34             :protected  => %w{CFM_PROTECTED CFE_PROTECTED}, 
    35           }.each do |option, (mask, effect)| 
    36             class_eval <<-"END" 
    37               def #{option}= enable 
    38                 set_char_format(#{mask}, :effects => (enable ? #{effect} : 0)) 
    39               end 
    40                
    41               def #{option} 
    42                 get_char_format(#{mask})[2]&#{effect} == #{effect} 
    43               end 
    44             END 
    45           end 
    46            
    47           { 
    48             :height     => %w{CFM_SIZE    twip}, 
    49             :offset     => %w{CFM_OFFSET  twip}, 
    50             :color      => %w{CFM_COLOR   color}, 
    51           }.each do |option, (mask, variable)| 
    52             class_eval <<-"END" 
    53               def #{option}= #{variable} 
    54                 set_char_format(#{mask}, :#{option} => #{variable}) 
    55               end 
    56             END 
    57           end 
    58            
    59           def height 
    60             SIGNEDLONG(get_char_format(CFM_SIZE)[3]) 
    61           end 
    62            
    63           def offset 
    64             SIGNEDLONG(get_char_format(CFM_OFFSET)[4]) 
    65           end 
    66            
    67           def color 
    68             get_char_format(CFM_OFFSET)[5] 
    69           end 
    70            
    71            
    72           private 
    73           CHARFORMAT = "LLLLLLCCU" 
    74            
    75           def set_char_format mask, options 
    76             @control.sendMessage EM_SETCHARFORMAT, @extent_flag, char_format(mask, options) 
    77           end 
    78            
    79           def get_char_format mask 
    80             charformat = char_format mask 
    81             @control.sendMessage EM_GETCHARFORMAT, @extent_flag, charformat 
    82             charformat.unpack CHARFORMAT 
    83           end 
    84            
    85           def char_format mask, options = {} 
    86             [ 
    87               60, 
    88               mask, 
    89               options[:effects] || 0, 
    90               options[:height]  || 0, 
    91               options[:offset]  || 0, 
    92               options[:color]   || 0, 
    93               0, 
    94               0, 
    95               0, 
    96             ].pack CHARFORMAT 
    97           end 
    9818        end 
    9919      end 

  • lang/ruby/ruwin/lib/ruwin/edit_field/rich/format.rb

    r28996 r28997  
    11module Ruwin 
    22  class EditField 
    3     class Rich < EditField 
    4       class Selection < EditField::Selection 
    5         attr_reader :format 
    6          
    7         def initialize *args 
    8           super 
    9           @format = Format::Char.new self, SCF_SELECTION 
    10         end 
    11          
    12         def string 
    13           result = "\0"*length 
    14           sendMessage EM_GETSELTEXT, 0, result 
    15           result 
    16         end 
    17       end 
    18        
     3    class Rich 
    194      module Format 
    205        class Char 
    … …  
    9883        end 
    9984      end 
    100        
    101       SELECTION_CLASS = Selection 
    102        
    103       LoadLibrary = Win32API.new("kernel32","LoadLibrary",["P"],"I") 
    104       if LoadLibrary.call("riched20") != 0 
    105         CLASS_NAME = "RICHEDIT20A" 
    106       elsif LoadLibrary.call("riched32") != 0 
    107         CLASS_NAME = "RICHEDIT" 
    108       end 
    109        
    110       property_accessor :background_color => nil, :color => nil 
    111       attr_reader :default 
    112        
    113       def initialize 
    114         super 
    115          
    116         self.background_color = @proparty[:background_color] if @proparty[:background_color] 
    117          
    118         @default = Format::Char.new self, SCF_DEFAULT 
    119         @default.color = @proparty[:color] if @proparty[:color] 
    120       end 
    121        
    122        
    123       def background_color= color 
    124         if color 
    125           sendMessage EM_SETBKGNDCOLOR, 0, color 
    126         else 
    127           sendMessage EM_SETBKGNDCOLOR, 1, 0 
    128         end 
    129       end 
    130        
    131        
    132       def wm_notify msg 
    133         hwndFrom, idFrom, code = *SWin::Application.cstruct2array(msg.lParam, "UUU") 
    134         case code 
    135         when EN_MSGFILTER 
    136           en_msgfilter msg 
    137         end 
    138       end 
    139        
    140       def en_msgfilter msg 
    141         nmhdr1, nmhdr2, nmhdr2, msg, wParam, lParam = *SWin::Application.cstruct2array(msg.lParam, "UUUUUU") 
    142         case msg 
    143         when WM_KEYDOWN 
    144           [:keydown, wParam] 
    145         end 
    146       end 
    147        
    148       class Multiline < Rich 
    149         STYLE = EditField::Multiline::STYLE 
    150       end 
    15185    end 
    15286  end 

  • lang/ruby/ruwin/test/ruwin/edit_field/rich/test_format.rb

    r28996 r28997  
    1 require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "helper")) 
     1require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "..", "helper")) 
    22require "ruwin" 
    33require "ruwin/edit_field" 
    4 require File.expand_path(File.join(File.dirname(__FILE__), "..", "testm_edit_field")) 
    5  
    6 module TestModuleEditFieldRich 
    7   include Ruwin::Const::EditField 
    8    
    9   def test_background_color_property 
    10     klass = Class.new(self.class::TARGET_CLASS) 
    11     klass.class_eval "background_color 0x010203" 
    12     control = klass.new(@window) 
    13     assert control.message_log.include?([EM_SETBKGNDCOLOR, 0, 0x010203]) 
    14   end 
    15    
    16   def test_background_color_setter 
    17     @control.background_color = 0x010203 
    18     assert_equal [[EM_SETBKGNDCOLOR, 0, 0x010203]], @control.message_log 
    19   end 
    20    
    21   def test_background_color_setter_nil 
    22     @control.background_color = nil 
    23     assert_equal [[EM_SETBKGNDCOLOR, 1, 0]], @control.message_log 
    24   end 
    25    
    26    
    27   def test_default_format 
    28     assert_kind_of Ruwin::EditField::Rich::Format::Char, @control.default 
    29     assert_same @control, @control.default.instance_variable_get(:@control) 
    30   end 
    31    
    32    
    33    
    34   def test_color_property 
    35     klass = Class.new(self.class::TARGET_CLASS) 
    36     klass.class_eval "color 0x010203" 
    37     control = klass.new(@window) 
    38      
    39     expected = control.message_log.find{|v| v[0] == EM_SETCHARFORMAT} 
    40     assert_equal EM_SETCHARFORMAT, expected[0] 
    41     assert_equal SCF_DEFAULT,      expected[1] 
    42      
    43     charformat = expected[2].unpack("LLLLLLCCU") 
    44     assert_equal 0x010203, charformat[5] 
    45   end 
    46    
    47    
    48    
    49   DummyMSG = Struct.new(:hWnd, :msg, :wParam, :lParam) 
    50    
    51   def test_wm_notify 
    52     klass = Class.new(Ruwin::EditField::Rich) 
    53     klass.class_eval <<-'END' 
    54       attr_reader :en_msgfilter_msg 
    55       def en_msgfilter msg 
    56         @en_msgfilter_msg = msg 
    57       end 
    58     END 
    59     instance = klass.new(HiddenWindow.new) 
    60      
    61     lParam = SWin::Application.arg2cstructStr("UUU", 0, 0, EN_MSGFILTER) 
    62     lParam_ptr = [lParam].pack("P").unpack("L")[0] 
    63     msg = DummyMSG.new nil, nil, nil, lParam_ptr 
    64     instance.wm_notify msg 
    65     assert_equal msg, instance.en_msgfilter_msg 
    66   end 
    67    
    68   def test_en_msgfilter 
    69     klass = Class.new(Ruwin::EditField::Rich) 
    70     instance = klass.new(HiddenWindow.new) 
    71      
    72     lParam = SWin::Application.arg2cstructStr("UUUUUU", 0, 0, 0, Ruwin::Const::Window::WM_KEYDOWN, 1, 0) 
    73     lParam_ptr = [lParam].pack("P").unpack("L")[0] 
    74     msg = DummyMSG.new nil, nil, nil, lParam_ptr 
    75     assert_equal [:keydown, 1], instance.en_msgfilter(msg) 
    76   end 
    77 end 
    78  
    79 class TestRuwinEditFieldRich < Test::Unit::TestCase 
    80   include TestModuleEditFieldSingle 
    81   include TestModuleEditFieldRich 
    82   include Ruwin::Const::EditField 
    83   TARGET_CLASS = Ruwin::EditField::Rich 
    84    
    85   def test_classname 
    86     assert_equal "RICHEDIT20A", @control.classname 
    87   end 
    88 end 
    89  
    90 class TestRuwinEditFieldRichMultiline < Test::Unit::TestCase 
    91   include TestModuleEditFieldMultiline 
    92   include TestModuleEditFieldRich 
    93   include Ruwin::Const::EditField 
    94   TARGET_CLASS = Ruwin::EditField::Rich::Multiline 
    95    
    96   def test_classname 
    97     assert_equal "RICHEDIT20A", @control.classname 
    98   end 
    99 end 
    100  
    101 class TestRuwinEditFieldRichSelection < Test::Unit::TestCase 
    102   include TestModuleEditFieldSelection 
    103   include Ruwin::Const::EditField 
    104   TARGET_CLASS = Ruwin::EditField::Rich 
    105    
    106   def test_format_bold 
    107     @selection.format.bold = true 
    108      
    109     assert_equal 1, @control.message_log.size 
    110     assert_equal EM_SETCHARFORMAT, @control.message_log[0][0] 
    111   end 
    112    
    113   def test_format_bold_without_reflection 
    114     @selection_without_reflection.format.bold = true 
    115      
    116     assert_equal 4, @control.message_log.size 
    117     assert_equal EM_GETSEL,        @control.message_log[0][0] 
    118     assert_equal EM_SETSEL,        @control.message_log[1][0] 
    119     assert_equal EM_SETCHARFORMAT, @control.message_log[2][0] 
    120     assert_equal EM_SETSEL,        @control.message_log[3][0] 
    121   end 
    122 end 
    1234 
    1245class TestRuwinEditFieldRichCharFormat < Test::Unit::TestCase 

  • lang/ruby/ruwin/test/ruwin/edit_field/test_rich.rb

    r28996 r28997  
    121121  end 
    122122end 
    123  
    124 class TestRuwinEditFieldRichCharFormat < Test::Unit::TestCase 
    125   include Ruwin::Const::EditField 
    126    
    127   def setup 
    128     @control = Ruwin::EditField::Rich.new(HiddenWindow.new) 
    129     @format = @control.default 
    130     @control.message_log.clear 
    131   end 
    132    
    133   { 
    134     :bold       => %w{CFM_BOLD      CFE_BOLD}, 
    135     :italic     => %w{CFM_ITALIC    CFE_ITALIC}, 
    136     :underline  => %w{CFM_UNDERLINE CFE_UNDERLINE}, 
    137     :strikeout  => %w{CFM_STRIKEOUT CFE_STRIKEOUT}, 
    138     :protected  => %w{CFM_PROTECTED CFE_PROTECTED}, 
    139   }.each do |option, (mask, effect)| 
    140     { 
    141       :on  => true, 
    142       :off => false, 
    143     }.each do |name, enable| 
    144       class_eval <<-"END" 
    145         def test_effects_#{option}_setter_#{name} 
    146           @format.#{option} = #{enable} 
    147            
    148           assert_equal 1, @control.message_log.size 
    149           assert_setcharformat @control.message_log.last, 1 => #{mask}, 2 => #{name == :on ? effect : 0} 
    150         end 
    151          
    152         def test_effects_#{option}_getter_#{name} 
    153           @format.#{option} = #{enable} 
    154            
    155           assert_equal #{enable}, @format.#{option} 
    156         end 
    157       END 
    158     end 
    159   end 
    160    
    161   { 
    162     :height     => %w{CFM_SIZE      3}, 
    163     :offset     => %w{CFM_OFFSET    4}, 
    164   }.each do |option, (mask, index)| 
    165     %w{20 -20}.each do |value| 
    166       class_eval <<-"END" 
    167         def test_#{option}_setter_#{value.gsub "-", "minus"} 
    168           @format.#{option} = #{value} 
    169            
    170           assert_equal 1, @control.message_log.size 
    171           assert_setcharformat @control.message_log.last, 1 => #{mask}, #{index} => #{value} 
    172         end 
    173          
    174         def test_#{option}_getter_#{value.gsub "-", "minus"} 
    175           @format.#{option} = #{value} 
    176            
    177           assert_equal #{value}, @format.#{option} 
    178         end 
    179       END 
    180     end 
    181   end 
    182    
    183   def test_color 
    184     @format.color = 0xFF9933 
    185      
    186     assert_equal 1, @control.message_log.size 
    187     assert_setcharformat @control.message_log.last, 1 => CFM_COLOR, 5 => 0xFF9933 
    188   end 
    189    
    190    
    191   def assert_setcharformat expected, options 
    192     assert_equal EM_SETCHARFORMAT, expected[0] 
    193     assert_equal SCF_DEFAULT,      expected[1] 
    194      
    195     charformat = expected[2].unpack("LLLLLLCCU") 
    196     options.each do |index, value| 
    197       assert_equal value, Ruwin::SIGNEDLONG(charformat[index]) 
    198     end 
    199   end 
    200 end