archive/net.sourceforge.phpeclipse.quantum.sql/src/com/quantum/view/bookmark/BookmarkViewActionGroup.java

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