secure.phpeclipse.com Git - phpeclipse.git/blob

   1 package com.quantum.view.bookmark;
   2
   3 import java.util.Iterator;
   4
   5 import com.quantum.ImageStore;
   6 import com.quantum.Messages;
   7 import com.quantum.actions.AddToQuickListAction;
   8 import com.quantum.actions.ConnectAction;
   9 import com.quantum.actions.DeleteAllRowsAction;
  10 import com.quantum.actions.DisconnectAction;
  11 import com.quantum.actions.NewBookmarkAction;
  12 import com.quantum.actions.NextSequenceAction;
  13 import com.quantum.actions.OpenQueryAction;
  14 import com.quantum.actions.PrevSequenceAction;
  15 import com.quantum.actions.RefreshBookmarkAction;
  16 import com.quantum.actions.RemoveFromQuickListAction;
  17 import com.quantum.actions.ViewTableAction;
  18 import com.quantum.actions.ViewTableDetailsAction;
  19 import com.quantum.model.Bookmark;
  20 import com.quantum.util.versioning.VersioningHelper;
  21
  22 import org.eclipse.jface.action.Action;
  23 import org.eclipse.jface.action.ActionContributionItem;
  24 import org.eclipse.jface.action.IAction;
  25 import org.eclipse.jface.action.IMenuCreator;
  26 import org.eclipse.jface.action.IMenuManager;
  27 import org.eclipse.jface.action.IToolBarManager;
  28 import org.eclipse.jface.action.Separator;
  29 import org.eclipse.jface.viewers.ISelectionProvider;
  30 import org.eclipse.jface.viewers.IStructuredSelection;
  31 import org.eclipse.swt.events.MenuAdapter;
  32 import org.eclipse.swt.events.MenuEvent;
  33 import org.eclipse.swt.widgets.Control;
  34 import org.eclipse.swt.widgets.Menu;
  35 import org.eclipse.swt.widgets.MenuItem;
  36 import org.eclipse.ui.IActionBars;
  37 import org.eclipse.ui.IViewPart;
  38 import org.eclipse.ui.IWorkbenchActionConstants;
  39 import org.eclipse.ui.actions.ActionGroup;
  40 import org.eclipse.ui.actions.ExportResourcesAction;
  41 import org.eclipse.ui.actions.SelectionListenerAction;
  42 import org.eclipse.ui.actions.SelectionProviderAction;
  43 import org.eclipse.ui.dialogs.PropertyDialogAction;
  44
  45 /**
  46  * This class manages the list of actions for the bookmark view.
  47  *
  48  * @author BC Holmes
  49  */
  50 public class BookmarkViewActionGroup extends ActionGroup
  51     implements BookmarkClipboard {
  52
  53         class SQLAction extends Action implements IMenuCreator {
  54                 public SQLAction() {
  55                         setText(Messages.getString(BookmarkViewActionGroup.class, "sqlAction.text"));
  56                         setMenuCreator(this);
  57                 }
  58                 public void dispose() {
  59                 }
  60                 public Menu getMenu(Control parent) {
  61                         return null;
  62                 }
  63                 public Menu getMenu(Menu parent) {
  64                         Menu menu = new Menu(parent);
  65                         /**
  66                          * Add listener to repopulate the menu each time
  67                          * it is shown because the list of bookmarks may have changed.
  68                          */
  69                         menu.addMenuListener(new MenuAdapter() {
  70                                 public void menuShown(MenuEvent event) {
  71                                         Menu menu = (Menu) event.widget;
  72                                         MenuItem[] items = menu.getItems();
  73                                         for (int i=0; i < items.length; i++) {
  74                                                 items[i].dispose();
  75                                         }
  76                                         fillSQLMenu(menu);
  77                                 }
  78                         });
  79                         return menu;
  80                 }
  81         }
  82
  83     private Bookmark bookmarkClipboard;
  84
  85     private Action newBookmarkAction;
  86     private Action sqlAction;
  87
  88     // bookmark node actions
  89     private SelectionListenerAction connectAction;
  90     private SelectionListenerAction disconnectAction;
  91     private SelectionListenerAction deleteAction;
  92
  93     // Query node actions
  94     private SelectionListenerAction openQueryAction;
  95
  96     // Entity node actions
  97     private SelectionListenerAction addToQuickListAction;
  98     private SelectionListenerAction removeFromQuickListAction;
  99     private SelectionListenerAction viewTableAction;
 100     private SelectionListenerAction viewTableDetailsAction;
 101
 102     private SelectionListenerAction nextSequenceAction;
 103     private SelectionListenerAction previousSequenceAction;
 104
 105
 106     private SelectionListenerAction dropAction;
 107
 108
 109     // other actions
 110     private SelectionListenerAction refreshAction;
 111     private SelectionListenerAction renameAction;
 112
 113     private ExportResourcesAction exportAction;
 114
 115
 116     private SelectionProviderAction propertiesAction;
 117
 118     private SelectionListenerAction copyAction;
 119     private SelectionListenerAction pasteAction;
 120     private SelectionListenerAction deleteAllRowsAction;
 121
 122     private IViewPart viewPart;
 123
 124     public BookmarkViewActionGroup(
 125         IViewPart viewPart, ISelectionProvider selectionProvider) {
 126         this.viewPart = viewPart;
 127
 128         this.newBookmarkAction = new NewBookmarkAction(this.viewPart);
 129
 130         // bookmark actions
 131         this.connectAction = new ConnectAction(this.viewPart);
 132         this.disconnectAction = new DisconnectAction(this.viewPart);
 133
 134         this.sqlAction = new SQLAction();
 135
 136         // entity actions
 137         this.previousSequenceAction = new PrevSequenceAction(this.viewPart);
 138         this.nextSequenceAction = new NextSequenceAction(this.viewPart);
 139         this.addToQuickListAction = new AddToQuickListAction(this.viewPart);
 140         this.removeFromQuickListAction = new RemoveFromQuickListAction(this.viewPart);
 141         this.deleteAllRowsAction = new DeleteAllRowsAction(this.viewPart);
 142         this.viewTableDetailsAction = new ViewTableDetailsAction(this.viewPart);
 143
 144         this.openQueryAction = new OpenQueryAction(this.viewPart);
 145
 146         this.viewTableAction = new ViewTableAction(this.viewPart);
 147         this.refreshAction = new RefreshBookmarkAction(this.viewPart);
 148         this.renameAction = new RenameAction(this.viewPart);
 149         this.copyAction = new CopyAction(this.viewPart, this, selectionProvider);
 150         this.pasteAction = new PasteAction(this.viewPart, this, selectionProvider);
 151         this.deleteAction = new DeleteAction(this.viewPart, selectionProvider);
 152         this.exportAction = VersioningHelper.createExportResourcesAction(
 153                         this.viewPart.getViewSite().getWorkbenchWindow());
 154         this.exportAction.setImageDescriptor(ImageStore.getImageDescriptor(ImageStore.EXPORT));
 155
 156         this.dropAction = new DropEntityAction(this.viewPart);
 157
 158         this.propertiesAction = new PropertyDialogAction(
 159             this.viewPart.getSite().getShell(), selectionProvider);
 160     }
 161
 162
 163     /**
 164      * Add all the appropriate actions to the popup menu. This method is
 165      * called whenever someone right-clicks on an object in the bookmark view.
 166      *
 167      * @see org.eclipse.ui.actions.ActionGroup#fillContextMenu(org.eclipse.jface.action.IMenuManager)
 168      */
 169     public void fillContextMenu(IMenuManager menu) {
 170
 171         menu.add(this.newBookmarkAction);
 172         menu.add(new Separator());
 173
 174         if (getStructuredSelection().size() > 0 &&
 175             isEverySelectionInstanceof(BookmarkNode.class)) {
 176
 177             addToMenu(menu, this.connectAction);
 178             addToMenu(menu, this.disconnectAction);
 179         }
 180
 181         menu.add(new Separator());
 182         menu.add(this.copyAction);
 183         // TODO: paste needs to change enablement whenever something is added
 184         //       to the clipboard
 185         addToMenu(menu, this.pasteAction);
 186         addToMenu(menu, this.deleteAction);
 187
 188         if (getStructuredSelection().size() == 1 &&
 189             isEverySelectionInstanceof(BookmarkNode.class)) {
 190
 191             addToMenu(menu, this.renameAction);
 192         }
 193
 194         menu.add(new Separator());
 195
 196         // NOTE: In Eclipse 3.0, Export is no longer a sub-class of
 197         //       SelectionListenerAction.
 198         if (this.exportAction != null) {
 199                 this.exportAction.selectionChanged(getStructuredSelection());
 200                 menu.add(this.exportAction);
 201         }
 202
 203         if (getStructuredSelection().size() == 1 &&
 204             isEverySelectionInstanceof(BookmarkNode.class)) {
 205         }
 206
 207         if (isEverySelectionInstanceof(QueryNode.class)) {
 208             if (getStructuredSelection().size() == 1) {
 209                 addToMenu(menu, this.openQueryAction);
 210             }
 211         }
 212
 213         if (getStructuredSelection().size() > 0 &&
 214             isEverySelectionInstanceof(EntityNode.class)) {
 215
 216             menu.add(new Separator());
 217
 218             if (getStructuredSelection().size() == 1) {
 219                 if (((EntityNode) getStructuredSelection().getFirstElement()).isSequence()) {
 220                     addToMenu(menu, this.nextSequenceAction);
 221                     addToMenu(menu, this.previousSequenceAction);
 222                 } else {
 223                     addToMenu(menu, this.viewTableAction);
 224                     addToMenu(menu, this.deleteAllRowsAction);
 225                     addToMenu(menu, this.viewTableDetailsAction);
 226                 }
 227             }
 228
 229             addToMenu(menu, this.addToQuickListAction);
 230             addToMenu(menu, this.removeFromQuickListAction);
 231
 232             if (getStructuredSelection().size() == 1) {
 233                 menu.add(new Separator());
 234                 menu.add(this.sqlAction);
 235             }
 236         }
 237
 238         if (getStructuredSelection().size() == 1) {
 239             menu.add(new Separator());
 240             addToMenu(menu, this.refreshAction);
 241         }
 242
 243         createMarkerForActionsProvidedByOtherPlugins(menu);
 244
 245         if (getStructuredSelection().size() == 1) {
 246             addToMenu(menu, this.propertiesAction);
 247         }
 248     }
 249
 250     protected void fillSQLMenu(Menu parent) {
 251         if (getStructuredSelection().size() > 0 &&
 252                 isEverySelectionInstanceof(EntityNode.class)) {
 253                 addToMenu(parent, this.dropAction);
 254         }
 255     }
 256
 257     private void addToMenu(Menu menu, SelectionListenerAction action) {
 258         action.selectionChanged(getStructuredSelection());
 259                 ActionContributionItem item = new ActionContributionItem(action);
 260                 item.fill(menu, -1);
 261     }
 262
 263     private void addToMenu(IMenuManager menu, SelectionListenerAction action) {
 264         action.selectionChanged(getStructuredSelection());
 265         menu.add(action);
 266     }
 267
 268     private void addToMenu(IMenuManager menu, SelectionProviderAction action) {
 269         action.selectionChanged(getStructuredSelection());
 270         menu.add(action);
 271     }
 272
 273
 274     private IStructuredSelection getStructuredSelection() {
 275         return (IStructuredSelection) getContext().getSelection();
 276     }
 277
 278     private boolean isEverySelectionInstanceof(Class selectedClass) {
 279         boolean result = true;
 280         IStructuredSelection selection = getStructuredSelection();
 281         for (Iterator i = selection.iterator(); result && i.hasNext(); ) {
 282             Object object = i.next();
 283             result &= selectedClass.isAssignableFrom(object.getClass());
 284         }
 285
 286         return result;
 287     }
 288
 289     public IAction getOpenAction() {
 290         if (isEverySelectionInstanceof(BookmarkNode.class)) {
 291             this.connectAction.selectionChanged(getStructuredSelection());
 292             return this.connectAction.isEnabled() ? this.connectAction : null;
 293         } else if (isEverySelectionInstanceof(EntityNode.class)) {
 294             this.viewTableAction.selectionChanged(getStructuredSelection());
 295             return this.viewTableAction.isEnabled() ? this.viewTableAction : null;
 296         } else if (isEverySelectionInstanceof(QueryNode.class)) {
 297             this.openQueryAction.selectionChanged(getStructuredSelection());
 298             return this.openQueryAction.isEnabled() ? this.openQueryAction : null;
 299         } else {
 300             return null;
 301         }
 302     }
 303
 304     private void createMarkerForActionsProvidedByOtherPlugins(IMenuManager mgr) {
 305         mgr.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
 306         mgr.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS + "-end")); //$NON-NLS-1$
 307         mgr.add(new Separator());
 308     }
 309     public void fillActionBars(IActionBars actionBars) {
 310         IToolBarManager toolBar = actionBars.getToolBarManager();
 311         toolBar.add(this.newBookmarkAction);
 312
 313         actionBars.setGlobalActionHandler(IWorkbenchActionConstants.COPY, this.copyAction);
 314         actionBars.setGlobalActionHandler(IWorkbenchActionConstants.DELETE, this.deleteAction);
 315     }
 316
 317
 318     /* (non-Javadoc)
 319      * @see com.quantum.view.bookmark.BookmarkClipboard#setBookmark(com.quantum.model.Bookmark)
 320      */
 321     public void setBookmark(Bookmark bookmark) {
 322         this.bookmarkClipboard = bookmark;
 323     }
 324
 325
 326     /* (non-Javadoc)
 327      * @see com.quantum.view.bookmark.BookmarkClipboard#getBookmark()
 328      */
 329     public Bookmark getBookmark() {
 330         return this.bookmarkClipboard;
 331     }
 332 }