Changeset 36194

Show
Ignore:
Timestamp:
12/19/09 01:24:53 (5 years ago)
Author:
tarchan
Message:

lang/java/DesktopKit: ダブルクリックイベントのハンドラを追加

Location:
lang/java/DesktopKit/trunk/src/com/mac/tarchan/desktop
Files:
2 added
3 modified

Legend:

Unmodified
Added
Removed
  • lang/java/DesktopKit/trunk/src/com/mac/tarchan/desktop/DesktopSupport.java

    r35646 r36194  
    6565                SwingUtilities.invokeLater(new Runnable() 
    6666                { 
    67                         @Override 
    6867                        public void run() 
    6968                        { 
  • lang/java/DesktopKit/trunk/src/com/mac/tarchan/desktop/FileAttachPanel.java

    r35646 r36194  
    1212import javax.swing.JOptionPane; 
    1313import javax.swing.JTextField; 
     14import javax.swing.UIManager; 
    1415import javax.swing.filechooser.FileFilter; 
    15 import javax.swing.filechooser.FileNameExtensionFilter; 
    1616 
    1717import com.mac.tarchan.desktop.event.EventQuery; 
     
    2727 
    2828        /** ファイルダイアログ */ 
    29         JFileChooser chooser = new JFileChooser(); 
    30  
    31         /** 添付ファイル */ 
    32         File attachFile; 
     29        JFileChooser chooser; 
     30 
     31//      /** 添付ファイル */ 
     32//      File attachFile; 
    3333 
    3434        /** 
     
    3939        public FileAttachPanel(int columns) 
    4040        { 
     41                UIManager.put("FileChooser.saveButtonText", "保存");                                                      // ファイルを保存 
     42                UIManager.put("FileChooser.openButtonText", "選択");                                              // ファイルを選択 
     43                UIManager.put("FileChooser.directoryOpenButtonText", "開く");                     // ディレクトリを開く 
     44                UIManager.put("FileChooser.cancelButtonText", "キャンセル");                 // ファイル選択を取り消し 
     45                UIManager.put("FileChooser.openDialogTitleText", "ファイルを選択");                    // "ファイルを選択 
     46                chooser = new JFileChooser(); 
     47                chooser.setName("fileChooser"); 
     48 
    4149                JTextField attachField = new JTextField(columns); 
    4250                attachField.setName("attachName"); 
     
    4957 
    5058                EventQuery.ready(this).find("attachFile").click(this); 
     59//              EventQuery.ready(chooser).change(this, "change", ""); 
     60        } 
     61 
     62//      public void change(PropertyChangeEvent evt) 
     63//      { 
     64//              String propertyName = evt.getPropertyName(); 
     65//              System.out.println("change=" + evt.getPropertyName() + ", " + evt); 
     66//              if (JFileChooser.SELECTED_FILE_CHANGED_PROPERTY.equals(propertyName)) 
     67//              { 
     68//                      System.out.println("select=" + evt.getNewValue()); 
     69//                      System.out.println("deselect=" + evt.getOldValue()); 
     70//              } 
     71//      } 
     72 
     73        /** 
     74         * ファイル添付パネルを作成します。 
     75         */ 
     76        public FileAttachPanel() 
     77        { 
     78                this(0); 
    5179        } 
    5280 
     
    80108 
    81109        /** 
    82          * ファイル添付パネルを作成します。 
    83          */ 
    84         public FileAttachPanel() 
    85         { 
    86                 this(0); 
    87         } 
    88  
    89         /** 
    90110         * ファイルダイアログで添付ファイルを指定します。 
    91111         */ 
     
    93113        { 
    94114//              JFileChooser chooser = new JFileChooser(); 
     115                chooser.setCurrentDirectory(getFile()); 
    95116                int returnVal = chooser.showOpenDialog(this); 
    96117                if(returnVal == JFileChooser.APPROVE_OPTION) 
     
    118139 
    119140        /** 
    120          *  
    121          * @param message メッセージ 
    122          * @return int 
     141         * 確認ダイアログを表示します。 
     142         *  
     143         * @param message 確認内容 
     144         * @return 選択したオプションの整数値を返します。 
     145         * @see JOptionPane#YES_OPTION 
     146         * @see JOptionPane#NO_OPTION 
    123147         */ 
    124148        int confirm(String message) 
     
    140164        public void setFile(File file) 
    141165        { 
    142                 this.attachFile = file; 
    143                 EventQuery.ready(this).find("attachName").text(file.getName()); 
     166//              this.attachFile = file; 
     167//              EventQuery.ready(this).find("attachName").text(file.getName()); 
     168                EventQuery.ready(this).find("attachName").text(file.getPath()); 
     169        } 
     170 
     171        /** 
     172         * 指定されたパスを設定します。 
     173         *  
     174         * @param path パス 
     175         */ 
     176        public void setPath(String path) 
     177        { 
     178                setFile(new File(path)); 
     179        } 
     180 
     181        /** 
     182         * 設定されたファイルのパスを返します。 
     183         *  
     184         * @return パス 
     185         */ 
     186        public String getPath() 
     187        { 
     188                return EventQuery.ready(this).find("attachName").text(); 
    144189        } 
    145190 
     
    151196        public File getFile() 
    152197        { 
    153                 return attachFile; 
    154         } 
    155  
    156         /** 
    157          * 添付ファイルの絶対パスを返します。 
    158          *  
    159          * @return 文字列表現 
    160          */ 
     198//              return attachFile; 
     199                return new File(getPath()); 
     200        } 
     201 
     202        /** 
     203         * ファイル添付パネルの文字列表現を返します。 
     204         */ 
     205        @Override 
    161206        public String toString() 
    162207        { 
    163                 return attachFile != null ? attachFile.getAbsolutePath() : ""; 
     208                return String.format("[%s=%s]", getName(), getPath()); 
    164209        } 
    165210} 
  • lang/java/DesktopKit/trunk/src/com/mac/tarchan/desktop/event/EventQuery.java

    r35646 r36194  
    77import java.awt.Component; 
    88import java.awt.Container; 
     9import java.awt.ItemSelectable; 
    910import java.awt.TextComponent; 
    1011import java.awt.event.ActionListener; 
     
    1617import java.awt.event.TextListener; 
    1718import java.beans.EventHandler; 
     19import java.beans.PropertyChangeListener; 
    1820import java.util.ArrayList; 
    1921import java.util.Arrays; 
     
    3234import javax.swing.text.JTextComponent; 
    3335 
     36import org.apache.commons.logging.Log; 
     37import org.apache.commons.logging.LogFactory; 
    3438 
    3539/** 
     
    3842 * @author tarchan 
    3943 * @see <a href="http://semooh.jp/jquery/api/events/">Events - jQuery 1.3.2 日本語リファレンス</a> 
    40  * @see Component#setName(String) 
    41  * @see EventHandler#create(Class, Object, String, String, String) 
     44 * @see EventHandler 
    4245 */ 
    4346public class EventQuery 
    4447{ 
     48        private static final Log log = LogFactory.getLog(EventQuery.class); 
     49 
    4550        /** 親ノード */ 
    4651        protected EventQuery parent; 
     
    5257         * 新しい EventQuery を作成します。 
    5358         *  
    54          * @param comp コンポーネント 
    55          */ 
    56         protected EventQuery(Component... comp) 
     59         * @param child コンポーネント 
     60         */ 
     61        protected EventQuery(Component... child) 
    5762        { 
    5863//              this.comp = comp[0]; 
    5964//              list = new ArrayList<Component>(); 
    6065                list = new HashSet<Component>(); 
    61                 list.addAll(Arrays.asList(comp)); 
     66                list.addAll(Arrays.asList(child)); 
    6267        } 
    6368 
     
    6570         * 新しい EventQuery を作成します。 
    6671         *  
    67          * @param comp コンポーネント 
     72         * @param child コンポーネント 
    6873         * @return アクションファクトリー 
    6974         */ 
    70         public static EventQuery ready(Component... comp) 
    71         { 
    72                 return new EventQuery(comp); 
     75        public static EventQuery ready(Component... child) 
     76        { 
     77                return new EventQuery(child); 
    7378        } 
    7479 
     
    99104 
    100105        /** 
    101          * @param list コンポーネントのリスト 
    102          * @return コンポーネントのリスト 
     106         * リストを返します。 
     107         *  
     108         * @param list リスト 
     109         * @return リスト 
    103110         */ 
    104111        List<String> list(Collection<Component> list) 
     
    125132 
    126133//              System.out.format("find: names=%s, list=(%s), parent=%s\n", Arrays.asList(names), list(list), parent); 
     134//              EventQuery action = EventQuery.ready(comp); 
    127135                EventQuery query = new EventQuery(); 
    128136                query.parent = this; 
     
    227235         * @return 新しい EventQuery オブジェクト 
    228236         * @see #find(Class...) 
     237         * @see AbstractButton 
    229238         */ 
    230239        public EventQuery button() 
     
    238247         * @return 新しい EventQuery オブジェクト 
    239248         * @see #find(Class...) 
     249         * @see JTextComponent 
    240250         */ 
    241251        public EventQuery input() 
     
    285295         * クリックイベントのハンドラを登録します。 
    286296         *  
    287          * @param target ターゲットオブジェクト 
    288          * @return このオブジェクト 
    289          * @see ActionListener#actionPerformed(java.awt.event.ActionEvent) 
    290          * @see MouseListener#mouseClicked(java.awt.event.MouseEvent) 
    291          */ 
    292         public EventQuery click(Object target) 
    293         { 
    294 //              System.out.println("click: " + list(list)); 
    295                 for (Component child : list) 
    296                 { 
    297                         String action = child.getName(); 
    298                         if (action != null) find(action).click(target, action, null); 
    299                 } 
    300  
    301                 return this; 
    302         } 
    303  
    304         /** 
    305          * クリックイベントのハンドラを登録します。 
    306          *  
    307          * @param target ターゲットオブジェクト 
    308          * @param action メソッド名 
    309          * @return このオブジェクト 
    310          * @see ActionListener#actionPerformed(java.awt.event.ActionEvent) 
    311          * @see MouseListener#mouseClicked(java.awt.event.MouseEvent) 
    312          */ 
    313         public EventQuery click(Object target, String action) 
    314         { 
    315                 return click(target, action, null); 
    316         } 
    317  
    318         /** 
    319          * クリックイベントのハンドラを登録します。 
    320          *  
    321          * @param target ターゲットオブジェクト 
    322          * @param action メソッド名 
    323          * @param property イベントプロパティ 
     297         * @param target アクションを実行するオブジェクト 
     298         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     299         * @param property 受信イベントの読み込み可能なプロパティの完全指定された名前  
    324300         * @return このオブジェクト 
    325301         * @see ActionListener#actionPerformed(java.awt.event.ActionEvent) 
     
    353329 
    354330        /** 
     331         * クリックイベントのハンドラを登録します。 
     332         *  
     333         * @param target アクションを実行するオブジェクト 
     334         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     335         * @return このオブジェクト 
     336         * @see #click(Object, String, String) 
     337         */ 
     338        public EventQuery click(Object target, String action) 
     339        { 
     340                return click(target, action, null); 
     341        } 
     342 
     343        /** 
     344         * クリックイベントのハンドラを登録します。 
     345         *  
     346         * @param target アクションを実行するオブジェクト 
     347         * @return このオブジェクト 
     348         * @see #click(Object, String) 
     349         */ 
     350        public EventQuery click(Object target) 
     351        { 
     352//              System.out.println("click: " + list(list)); 
     353                for (Component child : list) 
     354                { 
     355                        String action = child.getName(); 
     356                        if (action != null) find(action).click(target, action); 
     357                } 
     358 
     359                return this; 
     360        } 
     361 
     362        /** 
     363         * ダブルクリックのハンドラを登録します。 
     364         *  
     365         * @param target アクションを実行するオブジェクト 
     366         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     367         * @param property 受信イベントの読み込み可能なプロパティの完全指定された名前  
     368         * @return このオブジェクト 
     369         * @see MouseListener#mouseClicked(java.awt.event.MouseEvent) 
     370         */ 
     371        public EventQuery dblclick(Object target, String action, String property) 
     372        { 
     373                log.debug("dblclick=" + list); 
     374                MouseListener mouseClicked = EventHandler.create(MouseListener.class, target, action, property, "mouseClicked"); 
     375                DoubleClickHandler dblclickHandler = new DoubleClickHandler(mouseClicked); 
     376                for (Component child : list) 
     377                { 
     378                        child.addMouseListener(dblclickHandler); 
     379                } 
     380 
     381                return this; 
     382        } 
     383 
     384        /** 
     385         * ダブルクリックのハンドラを登録します。 
     386         *  
     387         * @param target アクションを実行するオブジェクト 
     388         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     389         * @return このオブジェクト 
     390         * @see #dblclick(Object, String, String) 
     391         */ 
     392        public EventQuery dblclick(Object target, String action) 
     393        { 
     394                return dblclick(target, action, null); 
     395        } 
     396 
     397        /** 
     398         * ダブルクリックのハンドラを登録します。 
     399         *  
     400         * @param target アクションを実行するオブジェクト 
     401         * @return このオブジェクト 
     402         * @see #dblclick(Object, String) 
     403         */ 
     404        public EventQuery dblclick(Object target) 
     405        { 
     406                for (Component child : list) 
     407                { 
     408                        String action = child.getName(); 
     409                        if (action != null) find(action).dblclick(target, action); 
     410                } 
     411 
     412                return this; 
     413        } 
     414 
     415        /** 
    355416         * コンポーネントの表示/非表示を切り替えます。 
    356417         */ 
     
    374435        } 
    375436 
     437//      /** 
     438//       * コンポーネント表示イベントのハンドラを登録します。 
     439//       *  
     440//       * @param handler ハンドラ 
     441//       * @see ComponentListener#componentShown(java.awt.event.ComponentEvent) 
     442//       */ 
     443//      public void show(ComponentListener handler) 
     444//      { 
     445//              for (Component child : list) 
     446//              { 
     447//                      child.addComponentListener(handler); 
     448//              } 
     449//      } 
     450 
    376451        /** 
    377452         * コンポーネント表示イベントのハンドラを登録します。 
    378453         *  
    379          * @param handler ハンドラ 
     454         * @param target アクションを実行するオブジェクト 
     455         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     456         * @param property 受信イベントの読み込み可能なプロパティの完全指定された名前  
    380457         * @see ComponentListener#componentShown(java.awt.event.ComponentEvent) 
    381458         */ 
    382         public void show(ComponentListener handler) 
    383         { 
    384                 for (Component child : list) 
    385                 { 
    386                         child.addComponentListener(handler); 
     459        public void show(Object target, String action, String property) 
     460        { 
     461                ComponentListener componentShown = EventHandler.create(ComponentListener.class, target, action, property, "componentShown"); 
     462                for (Component child : list) 
     463                { 
     464                        child.addComponentListener(componentShown); 
    387465                } 
    388466        } 
     
    391469         * コンポーネント表示イベントのハンドラを登録します。 
    392470         *  
    393          * @param target ターゲットオブジェクト 
    394          * @param action メソッド名 
    395          * @see ComponentListener#componentShown(java.awt.event.ComponentEvent) 
     471         * @param target アクションを実行するオブジェクト 
     472         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     473         * @see #show(Object, String, String) 
    396474         */ 
    397475        public void show(Object target, String action) 
     
    401479 
    402480        /** 
    403          * コンポーネント表示イベントのハンドラを登録します。 
    404          *  
    405          * @param target ターゲットオブジェクト 
    406          * @param action メソッド名 
    407          * @param property イベントプロパティ 
    408          * @see ComponentListener#componentShown(java.awt.event.ComponentEvent) 
    409          */ 
    410         public void show(Object target, String action, String property) 
    411         { 
    412                 ComponentListener handler = EventHandler.create(ComponentListener.class, target, action, property, "componentShown"); 
    413                 show(handler); 
    414         } 
    415  
    416         /** 
    417481         * コンポーネントを隠します。 
    418482         */ 
     
    425489        } 
    426490 
     491//      /** 
     492//       * コンポーネント不可視イベントのハンドラを登録します。 
     493//       *  
     494//       * @param handler ハンドラ 
     495//       * @see ComponentListener#componentHidden(java.awt.event.ComponentEvent) 
     496//       */ 
     497//      public void hide(ComponentListener handler) 
     498//      { 
     499//              for (Component child : list) 
     500//              { 
     501//                      child.addComponentListener(handler); 
     502//              } 
     503//      } 
     504 
    427505        /** 
    428506         * コンポーネント不可視イベントのハンドラを登録します。 
    429507         *  
    430          * @param handler ハンドラ 
     508         * @param target アクションを実行するオブジェクト 
     509         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     510         * @param property 受信イベントの読み込み可能なプロパティの完全指定された名前  
    431511         * @see ComponentListener#componentHidden(java.awt.event.ComponentEvent) 
    432512         */ 
    433         public void hide(ComponentListener handler) 
    434         { 
    435                 for (Component child : list) 
    436                 { 
    437                         child.addComponentListener(handler); 
     513        public void hide(Object target, String action, String property) 
     514        { 
     515                ComponentListener componentHidden = EventHandler.create(ComponentListener.class, target, action, property, "componentHidden"); 
     516                for (Component child : list) 
     517                { 
     518                        child.addComponentListener(componentHidden); 
    438519                } 
    439520        } 
     
    442523         * コンポーネント不可視イベントのハンドラを登録します。 
    443524         *  
    444          * @param target ターゲットオブジェクト 
    445          * @param action メソッド名 
    446          * @see ComponentListener#componentHidden(java.awt.event.ComponentEvent) 
     525         * @param target アクションを実行するオブジェクト 
     526         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     527         * @see #hide(Object, String, String) 
    447528         */ 
    448529        public void hide(Object target, String action) 
     
    452533 
    453534        /** 
    454          * コンポーネント不可視イベントのハンドラを登録します。 
    455          *  
    456          * @param target ターゲットオブジェクト 
    457          * @param action メソッド名 
    458          * @param property イベントプロパティ 
    459          * @see ComponentListener#componentHidden(java.awt.event.ComponentEvent) 
    460          */ 
    461         public void hide(Object target, String action, String property) 
    462         { 
    463                 ComponentListener handler = EventHandler.create(ComponentListener.class, target, action, property, "componentHidden"); 
    464                 hide(handler); 
    465         } 
    466  
    467         /** 
    468535         * コンポーネントのサイズが変更されたとき 
    469536         *  
    470          * @param target ターゲッ 
    471          * @param action アクション 
    472          * @param property プロパティ 
     537         * @param target アクションを実行するオブジェク 
     538         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     539         * @param property 受信イベントの読み込み可能なプロパティの完全指定された名前  
    473540         * @see ComponentListener#componentResized(java.awt.event.ComponentEvent) 
    474541         */ 
    475542        public void resize(Object target, String action, String property) 
    476543        { 
    477                 ComponentListener handler = EventHandler.create(ComponentListener.class, target, action, property, "componentResized"); 
    478                 for (Component child : list) 
    479                 { 
    480                         child.addComponentListener(handler); 
     544                ComponentListener componentResized = EventHandler.create(ComponentListener.class, target, action, property, "componentResized"); 
     545                for (Component child : list) 
     546                { 
     547                        child.addComponentListener(componentResized); 
    481548                } 
    482549        } 
     
    485552         * コンポーネントが移動されたとき 
    486553         *  
    487          * @param target ターゲッ 
    488          * @param action アクション 
    489          * @param property プロパティ 
     554         * @param target アクションを実行するオブジェク 
     555         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     556         * @param property 受信イベントの読み込み可能なプロパティの完全指定された名前  
    490557         * @see ComponentListener#componentMoved(java.awt.event.ComponentEvent) 
    491558         */ 
    492559        public void move(Object target, String action, String property) 
    493560        { 
    494                 ComponentListener handler = EventHandler.create(ComponentListener.class, target, action, property, "componentMoved"); 
    495                 for (Component child : list) 
    496                 { 
    497                         child.addComponentListener(handler); 
    498                 } 
    499         } 
     561                ComponentListener componentMoved = EventHandler.create(ComponentListener.class, target, action, property, "componentMoved"); 
     562                for (Component child : list) 
     563                { 
     564                        child.addComponentListener(componentMoved); 
     565                } 
     566        } 
     567 
     568//      /** 
     569//       * コンポーネント上にマウスカーソルが乗ったときと、外れたときにイベントハンドラを実行します。 
     570//       *  
     571//       * @param handler イベントハンドラ 
     572//       * @see MouseListener#mouseEntered(java.awt.event.MouseEvent) 
     573//       * @see MouseListener#mouseExited(java.awt.event.MouseEvent) 
     574//       */ 
     575//      public void hover(MouseListener handler) 
     576//      { 
     577//              for (Component child : list) 
     578//              { 
     579//                      child.addMouseListener(handler); 
     580//              } 
     581//      } 
    500582 
    501583        /** 
    502584         * コンポーネント上にマウスカーソルが乗ったときと、外れたときにイベントハンドラを実行します。 
    503585         *  
    504          * @param handler ハンドラ 
     586         * @param target アクションを実行するオブジェクト 
     587         * @param overAction マウスカーソルが乗ったときの、ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     588         * @param outAction マウスカーソルが外れたときの、ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     589         * @param property 受信イベントの読み込み可能なプロパティの完全指定された名前  
    505590         * @see MouseListener#mouseEntered(java.awt.event.MouseEvent) 
    506591         * @see MouseListener#mouseExited(java.awt.event.MouseEvent) 
    507592         */ 
    508         public void hover(MouseListener handler) 
    509         { 
    510                 for (Component child : list) 
    511                 { 
    512                         child.addMouseListener(handler); 
     593        public void hover(Object target, String overAction, String outAction, String property) 
     594        { 
     595                MouseListener mouseEntered = EventHandler.create(MouseListener.class, target, overAction, property, "mouseEntered"); 
     596                MouseListener mouseExited = EventHandler.create(MouseListener.class, target, outAction, property, "mouseExited"); 
     597                for (Component child : list) 
     598                { 
     599                        child.addMouseListener(mouseEntered); 
     600                        child.addMouseListener(mouseExited); 
    513601                } 
    514602        } 
     
    517605         * コンポーネント上にマウスカーソルが乗ったときと、外れたときにイベントハンドラを実行します。 
    518606         *  
    519          * @param target ターゲットオブジェクト 
    520          * @param overAction 乗ったときのイベントハンドラ 
    521          * @param outAction 外れたときのイベントハンドラ 
    522          * @see MouseListener#mouseEntered(java.awt.event.MouseEvent) 
    523          * @see MouseListener#mouseExited(java.awt.event.MouseEvent) 
     607         * @param target アクションを実行するオブジェクト 
     608         * @param overAction マウスカーソルが乗ったときの、ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     609         * @param outAction マウスカーソルが外れたときの、ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     610         * @see #hover(Object, String, String, String) 
    524611         */ 
    525612        public void hover(Object target, String overAction, String outAction) 
     
    529616 
    530617        /** 
    531          * コンポーネント上にマウスカーソルが乗ったときと、外れたときにイベントハンドラを実行します。 
    532          *  
    533          * @param target ターゲットオブジェクト 
    534          * @param overAction 乗ったときのイベントハンドラ 
    535          * @param outAction 外れたときのイベントハンドラ 
    536          * @param property イベントプロパティ 
    537          * @see MouseListener#mouseEntered(java.awt.event.MouseEvent) 
    538          * @see MouseListener#mouseExited(java.awt.event.MouseEvent) 
    539          */ 
    540         public void hover(Object target, String overAction, String outAction, String property) 
    541         { 
    542                 MouseListener over = EventHandler.create(MouseListener.class, target, overAction, property, "mouseEntered"); 
    543                 MouseListener out = EventHandler.create(MouseListener.class, target, outAction, property, "mouseExited"); 
    544                 for (Component child : list) 
    545                 { 
    546                         child.addMouseListener(over); 
    547                         child.addMouseListener(out); 
     618         * フォーカスを受け取ったとき 
     619         *  
     620         * @param target アクションを実行するオブジェクト 
     621         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     622         * @param property 受信イベントの読み込み可能なプロパティの完全指定された名前  
     623         * @see FocusListener#focusGained(java.awt.event.FocusEvent) 
     624         */ 
     625        public void focus(Object target, String action, String property) 
     626        { 
     627                FocusListener handler = EventHandler.create(FocusListener.class, target, action, property, "focusGained"); 
     628                for (Component child : list) 
     629                { 
     630                        child.addFocusListener(handler); 
    548631                } 
    549632        } 
     
    552635         * コンポーネントがフォーカスを失ったときのイベントハンドラを登録します。 
    553636         *  
    554          * @param target ターゲットオブジェクト 
    555          * @param action メソッド名 
    556          * @param property イベントプロパティ 
     637         * @param target アクションを実行するオブジェクト 
     638         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     639         * @param property 受信イベントの読み込み可能なプロパティの完全指定された名前  
    557640         * @see FocusListener#focusLost(java.awt.event.FocusEvent) 
    558641         */ 
     
    567650 
    568651        /** 
    569          * フォーカスを受け取ったとき 
    570          *  
    571          * @param target ターゲット 
    572          * @param action アクション 
    573          * @param property プロパティ 
    574          * @see FocusListener#focusGained(java.awt.event.FocusEvent) 
    575          */ 
    576         public void focus(Object target, String action, String property) 
    577         { 
    578                 FocusListener handler = EventHandler.create(FocusListener.class, target, action, property, "focusGained"); 
    579                 for (Component child : list) 
    580                 { 
    581                         child.addFocusListener(handler); 
     652         * キーを押しているとき 
     653         *  
     654         * @param target アクションを実行するオブジェクト 
     655         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     656         * @param property 受信イベントの読み込み可能なプロパティの完全指定された名前  
     657         * @see KeyListener#keyPressed(java.awt.event.KeyEvent) 
     658         */ 
     659        public void keydown(Object target, String action, String property) 
     660        { 
     661                KeyListener handler = EventHandler.create(KeyListener.class, target, action, property, "keyPressed"); 
     662                for (Component child : list) 
     663                { 
     664                        child.addKeyListener(handler); 
     665                } 
     666        } 
     667 
     668        /** 
     669         * キーを離したとき 
     670         *  
     671         * @param target アクションを実行するオブジェクト 
     672         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     673         * @param property 受信イベントの読み込み可能なプロパティの完全指定された名前  
     674         * @see KeyListener#keyReleased(java.awt.event.KeyEvent) 
     675         */ 
     676        public void keyup(Object target, String action, String property) 
     677        { 
     678                KeyListener handler = EventHandler.create(KeyListener.class, target, action, property, "keyReleased"); 
     679                for (Component child : list) 
     680                { 
     681                        child.addKeyListener(handler); 
     682                } 
     683        } 
     684 
     685        /** 
     686         * キーをタイプしたとき 
     687         *  
     688         * @param target アクションを実行するオブジェクト 
     689         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     690         * @param property 受信イベントの読み込み可能なプロパティの完全指定された名前  
     691         * @see KeyListener#keyTyped(java.awt.event.KeyEvent) 
     692         */ 
     693        public void keypress(Object target, String action, String property) 
     694        { 
     695                KeyListener handler = EventHandler.create(KeyListener.class, target, action, property, "keyTyped"); 
     696                for (Component child : list) 
     697                { 
     698                        child.addKeyListener(handler); 
    582699                } 
    583700        } 
     
    607724//      } 
    608725 
    609         /** 
    610          * ダブルクリック 
    611          *  
    612          * @param target ターゲット 
    613          * @param action アクション 
    614          * @param property プロパティ 
    615          */ 
    616         public void dblclick(Object target, String action, String property) 
    617         { 
    618                 // TODO ダブルクリック 
    619         } 
    620  
    621         /** 
    622          * キーを押しているとき 
    623          *  
    624          * @param target ターゲット 
    625          * @param action アクション 
    626          * @param property プロパティ 
    627          * @see KeyListener#keyPressed(java.awt.event.KeyEvent) 
    628          */ 
    629         public void keydown(Object target, String action, String property) 
    630         { 
    631                 KeyListener handler = EventHandler.create(KeyListener.class, target, action, property, "keyPressed"); 
    632                 for (Component child : list) 
    633                 { 
    634                         child.addKeyListener(handler); 
    635                 } 
    636         } 
    637  
    638         /** 
    639          * キーを離したとき 
    640          *  
    641          * @param target ターゲット 
    642          * @param action アクション 
    643          * @param property プロパティ 
    644          * @see KeyListener#keyReleased(java.awt.event.KeyEvent) 
    645          */ 
    646         public void keyup(Object target, String action, String property) 
    647         { 
    648                 KeyListener handler = EventHandler.create(KeyListener.class, target, action, property, "keyReleased"); 
    649                 for (Component child : list) 
    650                 { 
    651                         child.addKeyListener(handler); 
    652                 } 
    653         } 
    654  
    655         /** 
    656          * キーをタイプしたとき 
    657          *  
    658          * @param target ターゲット 
    659          * @param action アクション 
    660          * @param property プロパティ 
    661          * @see KeyListener#keyTyped(java.awt.event.KeyEvent) 
    662          */ 
    663         public void keypress(Object target, String action, String property) 
    664         { 
    665                 KeyListener handler = EventHandler.create(KeyListener.class, target, action, property, "keyTyped"); 
    666                 for (Component child : list) 
    667                 { 
    668                         child.addKeyListener(handler); 
    669                 } 
    670         } 
     726//      /** 
     727//       * 入力コンポーネントの値の変更が完了したときのイベントハンドラを登録します。 
     728//       *  
     729//       * @param target 
     730//       * @param action 
     731//       * @param property 
     732//       * @see TextListener#textValueChanged(java.awt.event.TextEvent) 
     733//       */ 
     734//      public void cahnge(Object target, String action, String property) 
     735//      { 
     736//              TextListener handler = EventHandler.create(TextListener.class, target, action, property, "textValueChanged"); 
     737//              for (Component child : list) 
     738//              { 
     739//                      if (child instanceof TextComponent) 
     740//                      { 
     741//                              ((TextComponent)child).addTextListener(handler); 
     742//                      } 
     743//                      else 
     744//                      { 
     745//                              // 何もしない 
     746//                      } 
     747//              } 
     748//      } 
    671749 
    672750        /** 
     
    674752         * リストの選択範囲が変更されたとき 
    675753         *  
    676          * @param target ターゲット 
    677          * @param action アクション 
    678          * @param property プロパティ 
    679          * @return このオブジェクト 
     754         * @param target アクションを実行するオブジェクト 
     755         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     756         * @param property 受信イベントの読み込み可能なプロパティの完全指定された名前  
     757         * @return このオブジェクト 
     758         * @see TextListener#textValueChanged(java.awt.event.TextEvent) 
    680759         * @see ListSelectionListener#valueChanged(javax.swing.event.ListSelectionEvent) 
     760         * @see PropertyChangeListener#propertyChange(java.beans.PropertyChangeEvent) 
    681761         */ 
    682762        public EventQuery change(Object target, String action, String property) 
     
    684764                TextListener textValueChanged = EventHandler.create(TextListener.class, target, action, property, "textValueChanged"); 
    685765                ListSelectionListener valueChanged = EventHandler.create(ListSelectionListener.class, target, action, property, "valueChanged"); 
    686                 for (Component child : list) 
    687                 { 
     766                PropertyChangeListener propertyChange = EventHandler.create(PropertyChangeListener.class, target, action, property, "propertyChange"); 
     767                for (Component child : list) 
     768                { 
     769//                      child.addPropertyChangeListener(propertyChange); 
    688770                        if (child instanceof TextComponent) 
    689771                        { 
     
    696778                        else 
    697779                        { 
    698                                 // 何もしない 
     780                                child.addPropertyChangeListener(propertyChange); 
    699781                        } 
    700782                } 
     
    704786 
    705787        /** 
     788         * 入力コンポーネントの値の変更が完了したときのイベントハンドラを登録します。 
     789         * リストの選択範囲が変更されたとき 
     790         *  
     791         * @param target アクションを実行するオブジェクト 
     792         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     793         * @return このオブジェクト 
     794         * @see #change(Object, String, String) 
     795         */ 
     796        public EventQuery change(Object target, String action) 
     797        { 
     798                return change(target, action, null); 
     799        } 
     800 
     801        /** 
     802         * バウンドプロパティの変更時に呼び出されます。 
     803         *  
     804         * @param name 待機しているプロパティの名前。null の場合は、すべてのプロパティを待機します。 
     805         * @param target アクションを実行するオブジェクト 
     806         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     807         * @param property 受信イベントの読み込み可能なプロパティの完全指定された名前  
     808         * @return このオブジェクト 
     809         * @see PropertyChangeListener#propertyChange(java.beans.PropertyChangeEvent) 
     810         */ 
     811        public EventQuery change(String name, Object target, String action, String property) 
     812        { 
     813                PropertyChangeListener propertyChange = EventHandler.create(PropertyChangeListener.class, target, action, property, "propertyChange"); 
     814                for (Component child : list) 
     815                { 
     816                        if (name != null) 
     817                        { 
     818                                child.addPropertyChangeListener(name, propertyChange); 
     819                        } 
     820                        else 
     821                        { 
     822                                child.addPropertyChangeListener(propertyChange); 
     823                        } 
     824                } 
     825 
     826                return this; 
     827        } 
     828 
     829        /** 
    706830         * ページをめくるような動作をしたとき 
    707831         *  
    708          * @param target ターゲッ 
    709          * @param action アクション 
    710          * @param property プロパティ 
     832         * @param target アクションを実行するオブジェク 
     833         * @param action ターゲット上の書き込み可能なプロパティまたはメソッドの名前 
     834         * @param property 受信イベントの読み込み可能なプロパティの完全指定された名前  
    711835         * @return このオブジェクト 
    712836         * @see MouseListener#mousePressed(java.awt.event.MouseEvent) 
     
    781905 
    782906        /** 
     907         * int に変換します。 
     908         *  
     909         * @param def int に変換できない場合の値 
     910         * @return int に変換した値 
     911         */ 
     912        public int toInt(int def) 
     913        { 
     914                try 
     915                { 
     916                        String input = text(); 
     917                        int val = Integer.parseInt(input); 
     918                        return val; 
     919                } 
     920                catch (NumberFormatException x) 
     921                { 
     922                        return def; 
     923                } 
     924        } 
     925 
     926        /** 
    783927         * 値を取得します。 
    784928         *  
     
    810954                        else 
    811955                        { 
    812                                 String value = child.toString(); 
    813                                 map.put(name, value != null ? value : ""); 
     956//                              String value = child.toString(); 
     957//                              map.put(name, value != null ? value : ""); 
    814958                        } 
    815959                } 
     
    821965         * 最初のコンポーネントを返します。 
    822966         *  
     967         * @param <T> コンポーネントの型 
    823968         * @return コンポーネント 
    824969         */ 
    825         public Component first() 
     970        @SuppressWarnings("unchecked") 
     971        public <T extends Component> T first() 
    826972        { 
    827973                Iterator<Component> it = list.iterator(); 
    828                 return it.hasNext() ? it.next() : null; 
     974                return it.hasNext() ? (T)it.next() : null; 
     975        } 
     976 
     977        /** 
     978         * コンポーネントの配列を返します。 
     979         *  
     980         * @param <T> コンポーネントの型 
     981         * @return コンポーネントの配列 
     982         */ 
     983        @SuppressWarnings("unchecked") 
     984        public <T> T[] list() 
     985        { 
     986                ArrayList<T> sublist = new ArrayList<T>(); 
     987                for (Component child : list) 
     988                { 
     989                        try 
     990                        { 
     991                                sublist.add((T)child); 
     992                        } 
     993                        catch (Exception x) 
     994                        { 
     995                                // 何もしない 
     996                        } 
     997                } 
     998 
     999                return (T[])sublist.toArray(); 
    8291000        } 
    8301001 
     
    8461017 
    8471018                return new int[0]; 
     1019        } 
     1020 
     1021        /** 
     1022         * 選択された項目があるかどうか判定します。 
     1023         *  
     1024         * @return 選択された項目がある場合は true 
     1025         */ 
     1026        public boolean checked() 
     1027        { 
     1028                for (Component child : list) 
     1029                { 
     1030                        if (child instanceof ItemSelectable) 
     1031                        { 
     1032                                ItemSelectable itemSelectable = ((ItemSelectable)child); 
     1033                                Object[] selected = itemSelectable.getSelectedObjects(); 
     1034//                              System.out.println("checked: " + (selected != null ? Arrays.asList(selected) : null)); 
     1035                                if (selected != null) return true; 
     1036                        } 
     1037                } 
     1038 
     1039                return false; 
    8481040        } 
    8491041