GrxItemView.java
Go to the documentation of this file.
00001 /*
00002  * Copyright (c) 2008, AIST, the University of Tokyo and General Robotix Inc.
00003  * All rights reserved. This program is made available under the terms of the
00004  * Eclipse Public License v1.0 which accompanies this distribution, and is
00005  * available at http://www.eclipse.org/legal/epl-v10.html
00006  * Contributors:
00007  * General Robotix Inc.
00008  * National Institute of Advanced Industrial Science and Technology (AIST)
00009  */
00010 /*
00011  *  GrxItemView.java
00012  *
00013  *  Copyright (C) 2007 GeneralRobotix, Inc.
00014  *  All Rights Reserved
00015  *
00016  *  @author Yuichiro Kawasumi (General Robotix, Inc.)
00017  */
00018 
00019 package com.generalrobotix.ui.view;
00020 
00021 import java.util.ArrayList;
00022 import java.util.List;
00023 import java.util.Map;
00024 import java.util.Vector;
00025 import java.util.Iterator;
00026 
00027 import org.eclipse.jface.action.Action;
00028 import org.eclipse.jface.action.MenuManager;
00029 import org.eclipse.jface.viewers.ISelection;
00030 import org.eclipse.jface.viewers.ISelectionChangedListener;
00031 import org.eclipse.jface.viewers.IStructuredSelection;
00032 import org.eclipse.jface.viewers.ITreeContentProvider;
00033 import org.eclipse.jface.viewers.IViewerLabelProvider;
00034 import org.eclipse.jface.viewers.LabelProvider;
00035 import org.eclipse.jface.viewers.SelectionChangedEvent;
00036 import org.eclipse.jface.viewers.StructuredSelection;
00037 import org.eclipse.jface.viewers.TreeViewer;
00038 import org.eclipse.jface.viewers.Viewer;
00039 import org.eclipse.jface.viewers.ViewerLabel;
00040 
00041 import org.eclipse.swt.SWT;
00042 import org.eclipse.swt.graphics.Image;
00043 import org.eclipse.swt.widgets.Composite;
00044 import org.eclipse.swt.widgets.Event;
00045 import org.eclipse.swt.widgets.Listener;
00046 import org.eclipse.swt.widgets.Tree;
00047 import org.eclipse.ui.ISharedImages;
00048 import org.eclipse.ui.PlatformUI;
00049 
00050 import com.generalrobotix.ui.GrxBaseItem;
00051 import com.generalrobotix.ui.GrxBaseView;
00052 import com.generalrobotix.ui.GrxBasePlugin;
00053 import com.generalrobotix.ui.GrxBaseViewPart;
00054 import com.generalrobotix.ui.GrxPluginManager;
00055 import com.generalrobotix.ui.grxui.Activator;
00056 import com.generalrobotix.ui.item.GrxExtraJointItem;
00057 import com.generalrobotix.ui.item.GrxHwcItem;
00058 import com.generalrobotix.ui.item.GrxLinkItem;
00059 import com.generalrobotix.ui.item.GrxModeInfoItem;
00060 import com.generalrobotix.ui.item.GrxModelItem;
00061 import com.generalrobotix.ui.item.GrxProjectItem;
00062 import com.generalrobotix.ui.item.GrxSegmentItem;
00063 import com.generalrobotix.ui.item.GrxSensorItem;
00064 import com.generalrobotix.ui.item.GrxTransformItem;
00065 import com.generalrobotix.ui.util.OrderedHashMap;
00066 
00067 @SuppressWarnings("serial")
00071 public class GrxItemView extends GrxBaseView {
00072 
00073         GrxItemViewPart vp;
00074 
00075         TreeViewer tv;
00076         MenuManager menuMgr= new MenuManager();
00077 
00078         private List<GrxBasePlugin> baseItems_ = new ArrayList<GrxBasePlugin>();
00086         @SuppressWarnings("unchecked")
00087         public GrxItemView(String name, GrxPluginManager manager, GrxBaseViewPart vp, Composite parent) {
00088                 super(name, manager, vp, parent);
00089 
00090                 tv = new TreeViewer(composite_);
00091                 tv.setContentProvider( new TreeContentProvider() );
00092                 tv.setLabelProvider( new TreeLabelProvider() );
00093 
00094                 Tree t = tv.getTree();
00095                 
00096                 // When an item is left-clicked, the item becomes "current item".
00097                 tv.addSelectionChangedListener(new ISelectionChangedListener() {
00098                            public void selectionChanged(SelectionChangedEvent event) {
00099                                    ISelection selection = event.getSelection();
00100                                         for (Object o : ((IStructuredSelection) selection).toArray() ){
00101                                                 if ( GrxBaseItem.class.isAssignableFrom(o.getClass()) ){
00102                                                         manager_.focusedItem((GrxBaseItem)o);
00103                                                 }else if(o instanceof String){
00104                                                         manager_.focusedItem(manager_.getProject());
00105                                                 }
00106                                         }
00107                            }            
00108                         });
00109                 // ダブルクリックでアイテムの選択状態をトグル
00110                 t.addListener ( SWT.DefaultSelection, new Listener () {
00111                         public void handleEvent (Event event) {
00112                                 ISelection selection = tv.getSelection();
00113                                 for (Object o : ((IStructuredSelection) selection).toArray() ){
00114                                         if ( GrxBaseItem.class.isAssignableFrom(o.getClass()) ){
00115                                                 manager_.setSelectedItem( (GrxBaseItem)o, !((GrxBaseItem)o).isSelected() );
00116                                         }
00117                                 }
00118                 }
00119         });
00120 
00121                 // 右クリックメニュー
00122                 t.setMenu(menuMgr.createContextMenu( t ));
00123                 t.addListener ( SWT.MenuDetect, new Listener () {
00124                 public void handleEvent (Event event) {
00125                         ISelection selection = tv.getSelection();
00126                         Object o = ((IStructuredSelection) selection).getFirstElement();
00127                 menuMgr.removeAll(); // とりあえずメニュー削除
00128                 
00129                 // project name
00130                 if (o instanceof String){
00131                         Vector<Action> menus = manager_.getProject().getMenu();
00132                                         for( Action a: menus){
00133                                                 menuMgr.add(a);
00134                                         }                       
00135                 }
00136                 
00137                         // アイテムのクラス
00138                         if( Class.class.isAssignableFrom( o.getClass() ) ){
00139                                 if( GrxBaseItem.class.isAssignableFrom( (Class<?>)o ) ) {
00140                                         Vector<Action> menus = manager_.getItemMenu( (Class<? extends GrxBaseItem>) o );
00141                                         for( Action a: menus){
00142                                                 menuMgr.add(a);
00143                                         }
00144                                 }
00145                         }
00146                         // アイテムのインスタンス
00147                         if( GrxBasePlugin.class.isAssignableFrom( o.getClass() ) ){
00148                                 Vector<Action> menus = ((GrxBasePlugin)o).getMenu();
00149                                 for( Action a: menus){
00150                                         menuMgr.add(a);
00151                                 }
00152                                 Vector<MenuManager> subMenus = ((GrxBasePlugin)o).getSubMenu();
00153                                 for( MenuManager m: subMenus){
00154                                         menuMgr.add(m);
00155                                 }
00156                         }
00157                 }
00158         });
00159 
00160                 // ツリーの構築
00161                 tv.setInput( manager_ );
00162 
00163         manager_.registerItemChangeListener(this, GrxBaseItem.class);
00164         setUp();
00165         }
00166 
00167         public void setUp(){
00168                 Iterator<GrxBasePlugin> it0 = baseItems_.iterator();
00169                 while(it0.hasNext())
00170                         it0.next().deleteObserver(this);
00171                 baseItems_.clear();
00172                 GrxModeInfoItem mode = manager_.getMode();
00173         Iterator<Class<? extends GrxBaseItem>> it = mode.activeItemClassList_.listIterator();
00174         while (it.hasNext()){
00175                 Class<? extends GrxBaseItem> local = (Class<? extends GrxBaseItem>)it.next();
00176                 if ( manager_.isItemVisible( local ) ){
00177                         Map<String, ?> map = (Map<String, ?>) manager_.getItemMap(local);
00178                         Iterator itI = map.values().iterator();
00179                         while(itI.hasNext()){
00180                                 GrxBaseItem baseItem = (GrxBaseItem) itI.next();
00181                                 baseItems_.add(baseItem);
00182                                 baseItem.addObserver(this);
00183                                 if(baseItem instanceof GrxModelItem){
00184                                         GrxModelItem model = (GrxModelItem)baseItem;
00185                                         GrxLinkItem root = model.rootLink();
00186                                         if (root != null){
00187                                                 addchildrenObserver(root);
00188                                         }
00189                                 }
00190                         }
00191                 }
00192         }
00193         GrxProjectItem projectItem = manager_.getProject();
00194         if(!projectItem.getObserver().contains(this))
00195                 projectItem.addObserver(this);
00196         updateTree();
00197         }
00198         
00199         private void addchildrenObserver(GrxBaseItem item){
00200                 baseItems_.add(item);
00201                 item.addObserver(this);
00202                 Vector<GrxTransformItem> children = ((GrxTransformItem)item).children_;
00203                 for(int i=0; i<children.size(); i++){
00204                         addchildrenObserver(children.get(i));
00205                 }
00206         }
00207         
00211         class TreeContentProvider implements ITreeContentProvider {
00212 
00213                 Object[] gets( Object o ) {
00214                         // root(PluginManager) -> プロジェクト名
00215                         if( o instanceof GrxPluginManager ) {
00216                                 Object[] os = { ((GrxPluginManager)o).getProjectName() };
00217                                 return os;
00218                         }
00219 
00220                         // プロジェクト名 -> アイテムのクラスのリスト
00221                         if( o instanceof String ) {
00222                         GrxModeInfoItem mode = manager_.getMode();
00223 
00224                         ArrayList<Class<? extends GrxBaseItem>> localList = new ArrayList<Class<? extends GrxBaseItem>>();
00225                         Iterator<Class<? extends GrxBaseItem>> it = mode.activeItemClassList_.listIterator();
00226                         //grxuirc.xmlの属性値grxui.mode.item.visibleを導入してvisibleがtrueのものをふるい分けして表示
00227                         while (it.hasNext()){
00228                                 Class<? extends GrxBaseItem> local = (Class<? extends GrxBaseItem>)it.next();
00229                                 if ( manager_.isItemVisible( local ) ){
00230                                         localList.add( local );
00231                                 }
00232                         }
00233                                 return localList.toArray();
00234                         }
00235 
00236                         // アイテムのクラス -> インスタンスのリスト
00237                         if( o instanceof Class ) {
00238                                 if( GrxBaseItem.class.isAssignableFrom( (Class<?>)o ) ) {
00239                                         OrderedHashMap oMap = manager_.pluginMap_.get( o);
00240                                         return oMap.values().toArray();
00241                                 }
00242                         }
00243                         // GrxModelItem -> ルートのリンクを返す
00244                         if (o instanceof GrxModelItem){
00245                                 GrxModelItem model = (GrxModelItem)o;
00246                                 if (model.rootLink() != null){
00247                                         //Object[] os = {((GrxModelItem)o).rootLink()};
00248                                         Vector<GrxExtraJointItem> extraJointList = ((GrxModelItem)o).extraJoints_;
00249                                         Object[] os = new Object[extraJointList.size() + 1];
00250                                         os[0] = ((GrxModelItem)o).rootLink();
00251                                         for(int i=0; i<extraJointList.size(); i++)
00252                                                 os[i+1] = extraJointList.get(i);                                
00253                                         return os;
00254                                 }else{
00255                                         return null;
00256                                 }
00257                         }
00258                         // GrxLinkItem -> 子供のリンク,センサ、形状を返す
00259                         if (o instanceof GrxLinkItem){
00260                                 GrxLinkItem link = (GrxLinkItem)o;
00261                                 return link.children_.toArray();
00262                         }
00263                         
00264                         // GrxLinkItem -> 子供の形状を返す
00265                         if (o instanceof GrxSegmentItem){
00266                                 GrxSegmentItem link = (GrxSegmentItem)o;
00267                                 return link.children_.toArray();
00268                         }
00269                         
00270                         // GrxSensorItem -> 子供の形状を返す
00271                         if (o instanceof GrxSensorItem){
00272                                 GrxSensorItem sensor = (GrxSensorItem)o;
00273                                 return sensor.children_.toArray();
00274                         }
00275                         
00276                         // GrxHwcItem -> 子供の形状を返す
00277                         if (o instanceof GrxHwcItem){
00278                                 GrxHwcItem hwc = (GrxHwcItem)o;
00279                                 return hwc.children_.toArray();
00280                         }
00281                         
00282                         // その他
00283                         return null;
00284                 }
00285                 public Object[] getChildren(Object parentElement) { return gets(parentElement); }
00286                 public Object getParent(Object element) { return null; }
00287                 public boolean hasChildren(Object element) {
00288                         Object[] os = gets(element);
00289                         return os != null && os.length > 0;
00290                 }
00291                 public Object[] getElements(Object inputElement) { return gets(inputElement); }
00292                 public void dispose() {}
00293                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {}
00294         }
00295 
00299         class TreeLabelProvider extends LabelProvider implements IViewerLabelProvider{
00300 
00301                 public String getText(Object object) {
00302                         // アイテムのクラス
00303                         if( object instanceof Class ) {
00304                                 if( GrxBaseItem.class.isAssignableFrom( (Class<?>) object ) ) {
00305                                         return manager_.getItemTitle( (Class<? extends GrxBaseItem>)object );
00306                                 }
00307                         // アイテムのインスタンス
00308                         }else{
00309                                 if( GrxBaseItem.class.isAssignableFrom( object.getClass() ) ) {
00310                                         return ((GrxBaseItem)object).getName();
00311                                 }
00312                         }
00313                         // Other
00314                         return object.toString();
00315                 }
00316 
00317                 public Image getImage( Object o ){
00318                         if( GrxBaseItem.class.isAssignableFrom( o.getClass() ) ) {
00319                                 if( ((GrxBaseItem)o).getIcon() == null )
00320                                         return PlatformUI.getWorkbench().getSharedImages().getImage(
00321                                                         ISharedImages.IMG_OBJ_FILE);
00322                                 return ((GrxBaseItem)o).getIcon();
00323                         }
00324                         return PlatformUI.getWorkbench().getSharedImages().getImage(
00325                     ISharedImages.IMG_OBJ_FOLDER);
00326                 }
00327                 
00328                 public void updateLabel(ViewerLabel label, Object element) {
00329                         label.setText( getText(element) );
00330                         label.setImage( getImage(element) );
00331                         if( GrxBaseItem.class.isAssignableFrom( element.getClass() ) ) {
00332                                 //選択
00333                                 if( ((GrxBaseItem)element).isSelected() ) {
00334                                         label.setForeground( Activator.getDefault().getColor("black") );
00335                                 //非選択
00336                                 } else{
00337                                         label.setForeground( Activator.getDefault().getColor("gray") );
00338                                         label.setText( "("+getText(element)+")" );
00339                                 }
00340                         }
00341                 }
00342         }
00343 
00347         public void updateTree() {
00348                 tv.refresh();
00349                 tv.expandToLevel(3);
00350         }
00351         
00352         public void update(GrxBasePlugin plugin, Object... arg) {
00353         if((String)arg[0]!="PropertyChange")
00354                 return;
00355         updateTree();
00356     }
00357         
00358         public void registerItemChange(GrxBaseItem item, int event){
00359                 switch(event){
00360                 case GrxPluginManager.ADD_ITEM:
00361                         if(!baseItems_.contains(item)){
00362                                 item.addObserver(this);
00363                                 baseItems_.add(item);
00364                         }
00365                         break;
00366                 case GrxPluginManager.REMOVE_ITEM:
00367                         if(baseItems_.contains(item)){
00368                                 item.deleteObserver(this);
00369                                 baseItems_.remove(item);
00370                         }
00371                         break;
00372                 default:
00373                         break;
00374         }
00375                 updateTree();
00376                 if(event==GrxPluginManager.FOCUSED_ITEM){
00377                         List<GrxBasePlugin> l = new ArrayList<GrxBasePlugin>();
00378                         l.add(item);
00379                         tv.setSelection(new StructuredSelection(l), true);
00380                 }
00381         }
00382         
00383         public void shutdown(){
00384                 manager_.removeItemChangeListener(this, GrxBaseItem.class);
00385                 Iterator<GrxBasePlugin> it = baseItems_.iterator();
00386                 while(it.hasNext()){
00387                         it.next().deleteObserver(this);
00388                 }
00389         manager_.getProject().deleteObserver(this);
00390         }
00391         
00392 }


openhrp3
Author(s): AIST, General Robotix Inc., Nakamura Lab of Dept. of Mechano Informatics at University of Tokyo
autogenerated on Sun Apr 2 2017 03:43:53