Show
Ignore:
Timestamp:
05/27/08 01:41:55 (5 years ago)
Author:
daisuke_m
Message:

フィルタをFilterSetとして整理。

Location:
lang/java/sabotter/trunk/src/jp/xet/eclipse/sabotter
Files:
2 added
8 modified

Legend:

Unmodified
Added
Removed
  • lang/java/sabotter/trunk/src/jp/xet/eclipse/sabotter/SabotterPlugin.java

    r11933 r12483  
    33import java.net.URL; 
    44 
     5import jp.xet.eclipse.sabotter.filters.FilterResolver; 
    56import jp.xet.eclipse.sabotter.preferences.SabotterPreference; 
    67import jp.xet.eclipse.sabotter.preferences.SabotterPreferenceImpl; 
     
    5556        private static SabotterPreference pref; 
    5657         
     58        private static FilterResolver resolver; 
     59         
    5760 
    5861        /** 
     
    7275                plugin = this; 
    7376                pref = new SabotterPreferenceImpl(); 
     77                resolver = new FilterResolver(); 
    7478        } 
    7579         
     
    8185        @Override 
    8286        public void stop(BundleContext context) throws Exception { 
     87                resolver = null; 
    8388                pref = null; 
    8489                plugin = null; 
     
    102107        public static SabotterPreference getPreference() { 
    103108                return pref; 
     109        } 
     110         
     111        public static FilterResolver getFilterResolver() { 
     112                return resolver; 
    104113        } 
    105114         
  • lang/java/sabotter/trunk/src/jp/xet/eclipse/sabotter/action/AddTabAction.java

    r11933 r12483  
    11package jp.xet.eclipse.sabotter.action; 
    22 
    3 import java.util.Set; 
    4  
     3import jp.xet.eclipse.sabotter.action.dialog.FilterSet; 
    54import jp.xet.eclipse.sabotter.filters.TimeLineFilter; 
    65import jp.xet.eclipse.sabotter.manager.TableManager; 
     
    153152                                        new SabotterKeyListener(new TableManager(viewer))); 
    154153                         
    155                         Set<TimeLineFilter> filters = tab.getFilters(); 
    156                         if (filters == null || filters.size() == 0) { 
     154                        FilterSet filterSet = tab.getFilterSet(); 
     155                        if (filterSet == null) { 
    157156                                viewer.setFilters(new TimeLineFilter[0]); 
    158157                        } else { 
    159                                 viewer.setFilters(filters.toArray(new TimeLineFilter[0])); 
     158                                viewer.setFilters(filterSet.getFilterArray()); 
    160159                        } 
    161160                        TimeLineSorter sorter = tab.getSorter(); 
  • lang/java/sabotter/trunk/src/jp/xet/eclipse/sabotter/action/FilterSettingAction.java

    r12010 r12483  
    11package jp.xet.eclipse.sabotter.action; 
    22 
    3 import java.util.Set; 
    4  
    53import jp.xet.eclipse.sabotter.action.dialog.FilterDialog; 
     4import jp.xet.eclipse.sabotter.action.dialog.FilterSet; 
    65import jp.xet.eclipse.sabotter.action.dialog.Memento; 
    7 import jp.xet.eclipse.sabotter.filters.FilterResolver; 
    8 import jp.xet.eclipse.sabotter.filters.TimeLineFilter; 
    96import jp.xet.eclipse.sabotter.views.SabotterView; 
    107import org.eclipse.jface.action.Action; 
     
    2320        private SabotterView view; 
    2421         
    25         private FilterResolver resolver; 
    26          
    2722 
    2823        /** 
     
    3429        public FilterSettingAction(SabotterView view) { 
    3530                this.view = view; 
    36                 this.resolver = new FilterResolver(); 
    3731        } 
    3832         
     
    4438        @Override 
    4539        public void run() { 
    46                 TimeLineFilter[] filters = 
    47                                 editFilter(view.getCurrentTab().getFilters()); 
    48                  
    49                 view.getCurrentTab().setFilters(filters); 
     40                FilterSet filters = editFilter(view.getCurrentTab().getFilterSet()); 
     41                view.getCurrentTab().setFilterSet(filters); 
    5042        } 
    5143         
    52         private TimeLineFilter[] editFilter(Set<TimeLineFilter> filters) { 
    53                 FilterDialog dialog = new FilterDialog(null, filters, resolver); 
     44        private FilterSet editFilter(FilterSet filterSet) { 
     45                FilterDialog dialog = new FilterDialog(null, filterSet); 
    5446                 
    5547                // 編集前のスナップショットを保存 
     
    6052                } 
    6153                 
    62                 return dialog.getFilters(); 
     54                return dialog.getFilterSet(); 
    6355        } 
    6456} 
  • lang/java/sabotter/trunk/src/jp/xet/eclipse/sabotter/action/dialog/FilterDialog.java

    r11875 r12483  
    11package jp.xet.eclipse.sabotter.action.dialog; 
    22 
    3 import java.util.HashMap; 
    4 import java.util.HashSet; 
    53import java.util.Map; 
    6 import java.util.Set; 
    74 
     5import jp.xet.eclipse.sabotter.SabotterPlugin; 
    86import jp.xet.eclipse.sabotter.filters.FilterResolver; 
    9 import jp.xet.eclipse.sabotter.filters.TimeLineFilter; 
    10  
    117import org.eclipse.core.runtime.IConfigurationElement; 
    128import org.eclipse.jface.dialogs.Dialog; 
     
    2824public class FilterDialog extends Dialog { 
    2925         
    30         public class FilterSet { 
    31                  
    32                 private Map<String, TimeLineFilter> filterMap = 
    33                                 new HashMap<String, TimeLineFilter>(); 
    34                  
    35                 private Set<String> enabledFilterIds = new HashSet<String>(); 
    36                  
    37  
    38                 /** 
    39                  * コンストラクタ。 
    40                  * @param filters 
    41                  * @category instance creation 
    42                  */ 
    43                 public FilterSet(Set<TimeLineFilter> filters) { 
    44                         for (TimeLineFilter filter : filters) { 
    45                                 String filterId = filter.getClass().getName(); 
    46                                 filterMap.put(filterId, filter); 
    47                                 enabledFilterIds.add(filterId); 
    48                         } 
    49                 } 
    50                  
    51                 /** 
    52                  * フィルタの有効/無効化を行う。 
    53                  *  
    54                  * @param filterId 
    55                  * @param enable  
    56                  */ 
    57                 public void setEnable(String filterId, boolean enable) { 
    58                         if (enable) { 
    59                                 enabledFilterIds.add(filterId); 
    60                                 if (filterMap.get(filterId) == null) { 
    61                                         filterMap.put(filterId, resolver 
    62                                                 .getFilterInstance(filterId)); 
    63                                 } 
    64                         } else { 
    65                                 enabledFilterIds.remove(filterId); 
    66                         } 
    67                 } 
    68                  
    69                 /** 
    70                  * フィルタが現在有効かどうかを調べる。 
    71                  *  
    72                  * @param filterId 
    73                  * @return 有効であれば<code>true</code> 
    74                  */ 
    75                 public boolean isEnable(String filterId) { 
    76                         return filterMap.keySet().contains(filterId); 
    77                 } 
    78                  
    79                 /** 
    80                  * 結果を取得する。 
    81                  *  
    82                  * @return フィルタの配列 
    83                  */ 
    84                 public TimeLineFilter[] getFilters() { 
    85                         Set<TimeLineFilter> result = new HashSet<TimeLineFilter>(); 
    86                         for (Map.Entry<String, TimeLineFilter> e : filterMap.entrySet()) { 
    87                                 if (enabledFilterIds.contains(e.getKey())) { 
    88                                         result.add(e.getValue()); 
    89                                 } 
    90                         } 
    91                         return result.toArray(new TimeLineFilter[0]); 
    92                 } 
    93                  
    94                 public Map<String, TimeLineFilter> getFilterMap() { 
    95                         return filterMap; 
    96                 } 
    97                  
    98                 /** 
    99                  * @param filterId 
    100                  * @return 
    101                  */ 
    102                 public TimeLineFilter getFilter(String filterId) { 
    103                         return filterMap.get(filterId); 
    104                 } 
    105                  
    106                 /** 
    107                  * @param filterId 
    108                  * @param filter 
    109                  */ 
    110                 public void setFilter(String filterId, TimeLineFilter filter) { 
    111                         filterMap.put(filterId, filter); 
    112                 } 
    113                  
    114         } 
    115          
    116  
    11726        private FilterSet filterSet; 
    118          
    119         private FilterResolver resolver; 
    120          
    121         private TimeLineFilter[] result; 
    12227         
    12328 
     
    12631         *  
    12732         * @param shell 
    128          * @param filters 
    129          * @param resolver  
     33         * @param filterSet 
    13034         */ 
    131         public FilterDialog(Shell shell, Set<TimeLineFilter> filters, 
    132                         FilterResolver resolver) { 
     35        public FilterDialog(Shell shell, FilterSet filterSet) { 
    13336                super(shell); 
    13437                setShellStyle(getShellStyle() | SWT.RESIZE); 
    135                 this.filterSet = new FilterSet(filters); 
    136                 this.resolver = resolver; 
     38                this.filterSet = filterSet; 
    13739        } 
    13840         
     
    14648                Shell shell = getShell(); 
    14749                shell.pack(); 
    148 //              shell.setSize(400, shell.getSize().y); 
    14950        } 
    15051         
     
    16263                composite.setLayoutData(new GridData(GridData.FILL_BOTH)); 
    16364                 
     65                final FilterResolver resolver = SabotterPlugin.getFilterResolver(); 
    16466                Map<String, IConfigurationElement> factoryMap = 
    16567                                resolver.getFilterFactories(); 
     
    207109        } 
    208110         
    209         /** 
    210          * Override method. 
    211          *  
    212          * @see org.eclipse.jface.dialogs.Dialog#okPressed() 
    213          */ 
    214         @Override 
    215         protected void okPressed() { 
    216                 result = filterSet.getFilters(); 
    217                 super.okPressed(); 
    218         } 
    219          
    220111        public Memento createMemento() { 
    221112                return new FilterDialogMemento(filterSet); 
     
    224115        public void setMemento(Memento memento) { 
    225116                FilterDialogMemento filterMemento = (FilterDialogMemento) memento; 
    226                 result = filterMemento.getFilters(); 
     117                filterSet = filterMemento.getFilters(); 
    227118        } 
    228119         
    229         public TimeLineFilter[] getFilters() { 
    230                 return result; 
     120        public FilterSet getFilterSet() { 
     121                return filterSet; 
    231122        } 
    232123         
  • lang/java/sabotter/trunk/src/jp/xet/eclipse/sabotter/action/dialog/FilterDialogMemento.java

    r11827 r12483  
    11package jp.xet.eclipse.sabotter.action.dialog; 
    2  
    3 import jp.xet.eclipse.sabotter.action.dialog.FilterDialog.FilterSet; 
    4 import jp.xet.eclipse.sabotter.filters.TimeLineFilter; 
    52 
    63/** 
     
    3027         * @return filters 
    3128         */ 
    32         public TimeLineFilter[] getFilters() { 
    33                 return this.filterSet.getFilterMap().values().toArray( 
    34                                 new TimeLineFilter[0]); 
     29        public FilterSet getFilters() { 
     30                return filterSet; 
    3531        } 
    3632} 
  • lang/java/sabotter/trunk/src/jp/xet/eclipse/sabotter/filters/FilterResolver.java

    r11827 r12483  
    7474         
    7575        public String getFilterName(String filterId) { 
    76                 return filterFactories.get(filterId).getAttribute(ATTR_NAME); 
     76                IConfigurationElement factory = filterFactories.get(filterId); 
     77                String name = factory.getAttribute(ATTR_NAME); 
     78                return name; 
    7779        } 
    7880         
    7981        public boolean hasSettings(String filterId) { 
    80                 return filterFactories.get(filterId).getAttribute( 
    81                                 ATTR_SETTING_DIALOG_CLASS) != null; 
     82                IConfigurationElement factory = filterFactories.get(filterId); 
     83                return factory.getAttribute(ATTR_SETTING_DIALOG_CLASS) != null; 
    8284        } 
    8385         
    8486        public FilterSettingDialog getSettingDialog(String filterId) { 
    85                 IConfigurationElement element = filterFactories.get(filterId); 
    86                 if (element == null) { 
     87                IConfigurationElement factory = filterFactories.get(filterId); 
     88                if (factory == null) { 
    8789                        return null; 
    8890                } 
    8991                try { 
    90                         return (FilterSettingDialog) element 
     92                        return (FilterSettingDialog) factory 
    9193                                .createExecutableExtension(ATTR_SETTING_DIALOG_CLASS); 
    9294                } catch (CoreException e) { 
  • lang/java/sabotter/trunk/src/jp/xet/eclipse/sabotter/views/SabotterTabModel.java

    r11897 r12483  
    22 
    33import java.util.HashMap; 
    4 import java.util.HashSet; 
    54import java.util.Map; 
    6 import java.util.Set; 
    7  
    8 import jp.xet.eclipse.sabotter.filters.SearchFilter; 
    9 import jp.xet.eclipse.sabotter.filters.TimeLineFilter; 
    10  
     5import jp.xet.eclipse.sabotter.action.dialog.FilterSet; 
    116import org.apache.commons.lang.builder.ToStringBuilder; 
    127import org.eclipse.jface.viewers.TableViewer; 
     
    3126        private String tabName; 
    3227         
    33         private Set<TimeLineFilter> filterSet = new HashSet<TimeLineFilter>(); 
     28        private FilterSet filterSet; 
    3429         
    3530        private TimeLineSorter sorter; 
     
    4742        public SabotterTabModel(String tabName) { 
    4843                this.tabName = tabName; 
     44                // FIXME ここで毎回resolver newが微妙。 
     45                this.filterSet = new FilterSet(); 
    4946        } 
    5047         
     
    8481        } 
    8582         
    86         public SearchFilter getSearchFilter() { 
    87                 SearchFilter result = null; 
    88                 for (TimeLineFilter filter : filterSet) { 
    89                         if (filter instanceof SearchFilter) { 
    90                                 result = (SearchFilter) filter; 
    91                                 break; 
    92                         } 
    93                 } 
    94                 return result; 
     83        public FilterSet getFilterSet() { 
     84                return filterSet; 
    9585        } 
    9686         
    97         public SearchFilter removeSearchFilter() { 
    98                 SearchFilter toRemove = getSearchFilter(); 
    99                 filterSet.remove(toRemove); 
    100                 viewer.setFilters(filterSet.toArray(new TimeLineFilter[0])); 
    101                 return toRemove; 
    102         } 
    103          
    104         public void addSearchFilter(SearchFilter filter) { 
    105                 if (filter == null) { 
    106                         return; 
    107                 } 
    108                 filterSet.add(filter); 
    109                 viewer.setFilters(filterSet.toArray(new TimeLineFilter[0])); 
    110         } 
    111          
    112         public Set<TimeLineFilter> getFilters() { 
    113                 if (filterSet == null) { 
    114                         filterSet = new HashSet<TimeLineFilter>(); 
    115                 } 
    116                 Set<TimeLineFilter> result = new HashSet<TimeLineFilter>(filterSet); 
    117                 result.remove(getSearchFilter()); 
    118                 return result; 
    119         } 
    120          
    121         public void setFilters(TimeLineFilter[] filters) { 
    122                 SearchFilter sf = getSearchFilter(); 
    123                 this.filterSet.clear(); 
    124                 if (filters != null) { 
    125                         for (TimeLineFilter filter : filters) { 
    126                                 this.filterSet.add(filter); 
    127                         } 
    128                 } 
    129                 this.filterSet.add(sf); 
    130                 viewer.setFilters(this.filterSet.toArray(new TimeLineFilter[0])); 
     87        public void setFilterSet(FilterSet filters) { 
     88                this.filterSet = filters; 
     89                viewer.setFilters(this.filterSet.getFilterArray()); 
    13190        } 
    13291         
  • lang/java/sabotter/trunk/src/jp/xet/eclipse/sabotter/views/SabotterView.java

    r12078 r12483  
    22 
    33import java.net.MalformedURLException; 
    4 import java.util.ArrayList; 
    54import java.util.HashMap; 
    65import java.util.HashSet; 
     
    102101        private CTabFolder tabFolder; 
    103102         
    104         /** 各タブ */ 
    105         private List<SabotterTabModel> tabs = new ArrayList<SabotterTabModel>(); 
     103        private SabotterState state = new SabotterState(); 
    106104         
    107105        private Label detailImage; 
     
    153151                                public void run() { 
    154152                                        SabotterPlugin.log(org.eclipse.core.runtime.Status.INFO, 
    155                                                         0, "Sabotter: start to add entries to table"); // $NON-NLS-1$ 
    156                                         for (SabotterTabModel tab : tabs) { 
     153                                                        0, "Sabotter: start to add " + toAdd.size() 
     154                                                                        + " entries to table"); // $NON-NLS-1$ 
     155                                        for (SabotterTabModel tab : getTabs()) { 
    157156                                                TableViewer viewer = tab.getViewer(); 
    158157                                                viewer.remove(toRemove.toArray(new SabotterEntry[0])); 
     
    203202        public SabotterView() { 
    204203                try { 
    205                         List<SabotterTabModel> tabs = loadTabState(); 
    206                         if (tabs != null) { 
    207                                 this.tabs = tabs; 
     204                        SabotterState state = loadTabState(); 
     205                        if (state != null) { 
     206                                this.state = state; 
    208207                        } 
    209208                } catch (Exception e) { 
     
    212211        } 
    213212         
    214         private List<SabotterTabModel> loadTabState() { 
     213        private SabotterState loadTabState() { 
    215214                String xml = pref.getTabState(); 
    216                 return (List<SabotterTabModel>) new XStream().fromXML(xml); 
     215                SabotterState result = null; 
     216                try { 
     217                        result = (SabotterState) new XStream().fromXML(xml); 
     218                } catch (Exception ignore) { 
     219                } 
     220                return result; 
    217221        } 
    218222         
     
    224228         */ 
    225229        public void saveTabState() { 
    226                 String xml = new XStream().toXML(tabs); 
     230                String xml = new XStream().toXML(state); 
    227231                pref.setTabState(xml); 
    228232        } 
     
    246250                setDetail((SabotterEntry) selection.getFirstElement()); 
    247251                 
    248                 for (SabotterTabModel tab : tabs) { 
     252                for (SabotterTabModel tab : getTabs()) { 
    249253                        TableViewer viewerToRefresh = tab.getViewer(); 
    250254                        viewerToRefresh.refresh(); 
     
    310314                 
    311315                txtSearch.addKeyListener(new AllTextSelectionAdapter(txtSearch)); 
    312                 // TODO refactor ダッサいなぁ。。 
    313                 // ホントはSearchFilterだけは保存しない方がいいので、復帰の必要もないのだが。。 
    314                 // 保存しちゃったからには復帰させなきゃ、ということで、こんな逃げコード。 
    315                 if (tabs.size() != 0 && tabs.get(0).getSearchFilter() != null) { 
    316                         txtSearch 
    317                                 .setText(tabs.get(0).getSearchFilter().getPatternString()); 
    318                 } 
    319316                txtSearch.addKeyListener(new FocusOnSpaceKeyListener(this, txtSearch)); 
    320317                txtSearch.addKeyListener(new KeyAdapter() { 
     
    330327                                                newSearchFilter.setPatternString(txtSearch.getText()); 
    331328                                        } 
    332                                         for (SabotterTabModel tab : tabs) { 
    333                                                 tab.removeSearchFilter(); 
    334                                                 tab.addSearchFilter(newSearchFilter); 
     329                                        for (SabotterTabModel tab : getTabs()) { 
     330                                                tab.getFilterSet().removeSearchFilter(); 
     331                                                tab.getFilterSet().setSearchFilter(newSearchFilter); 
    335332                                        } 
    336333                                } 
     
    367364                                (AddTabAction) actions.get(AddTabAction.ACTION_ID); 
    368365                 
    369                 if (tabs.isEmpty()) { 
     366                if (getTabs().isEmpty()) { 
    370367                        SabotterTabModel tab = new SabotterTabModel(Messages.tab_timeline); 
    371368                        action.registerTab(tab); 
    372369                        getTabs().add(tab); 
    373370                } else { 
    374                         for (SabotterTabModel tab : tabs) { 
     371                        for (SabotterTabModel tab : getTabs()) { 
    375372                                action.registerTab(tab); 
    376373                        } 
     
    465462                                new ReloadTimeLineAction(new SabotterListener()); 
    466463                reloadTimeLineAction.setText(Messages.action_reload_time_line); 
    467                 reloadTimeLineAction 
    468                         .setToolTipText(Messages.tooltip_reload_time_line); 
     464                reloadTimeLineAction.setToolTipText(Messages.tooltip_reload_time_line); 
    469465                reloadTimeLineAction.setImageDescriptor(imageRegistry 
    470466                        .getDescriptor(Images.BUTTON_REFRESH)); 
     
    607603                int index = tabFolder.getSelectionIndex(); 
    608604                if (index >= 0) { 
    609                         tabs.get(index).getViewer().getControl().setFocus(); 
     605                        getTabs().get(index).getViewer().getControl().setFocus(); 
    610606                } 
    611607        } 
     
    617613         */ 
    618614        public SabotterTabModel getCurrentTab() { 
    619                 return tabs.get(getCurrentTabIndex()); 
     615                return getTabs().get(getCurrentTabIndex()); 
    620616        } 
    621617         
     
    644640         */ 
    645641        public List<SabotterTabModel> getTabs() { 
    646                 return tabs; 
     642                return state.getTabs(); 
    647643        } 
    648644