org.eclipse.gef_3.7.2.v20111106-2020

16:44:52.630 INFO  jd.cli.Main - Decompiling org.eclipse.gef_3.7.2.v20111106-2020.jar
package org.eclipse.gef;

import java.util.List;

public abstract interface AccessibleAnchorProvider
{
  public abstract List getSourceAnchorLocations();
  
  public abstract List getTargetAnchorLocations();
}

/* Location:
 * Qualified Name:     org.eclipse.gef.AccessibleAnchorProvider
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.draw2d.AccessibleBase;
import org.eclipse.swt.accessibility.AccessibleControlEvent;
import org.eclipse.swt.accessibility.AccessibleEvent;

public abstract class AccessibleEditPart
  extends AccessibleBase
{
  public abstract void getChildCount(AccessibleControlEvent paramAccessibleControlEvent);
  
  public abstract void getChildren(AccessibleControlEvent paramAccessibleControlEvent);
  
  public void getDefaultAction(AccessibleControlEvent e) {}
  
  public void getDescription(AccessibleEvent e) {}
  
  public void getKeyboardShortcut(AccessibleEvent e) {}
  
  public void getHelp(AccessibleEvent e) {}
  
  public abstract void getName(AccessibleEvent paramAccessibleEvent);
  
  public abstract void getLocation(AccessibleControlEvent paramAccessibleControlEvent);
  
  public void getRole(AccessibleControlEvent e) {}
  
  public abstract void getState(AccessibleControlEvent paramAccessibleControlEvent);
  
  public void getValue(AccessibleControlEvent e) {}
}

/* Location:
 * Qualified Name:     org.eclipse.gef.AccessibleEditPart
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import java.util.List;

public abstract interface AccessibleHandleProvider
{
  public abstract List getAccessibleHandleLocations();
}

/* Location:
 * Qualified Name:     org.eclipse.gef.AccessibleHandleProvider
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.draw2d.geometry.Point;

public class AutoexposeHelper$Search
  implements EditPartViewer.Conditional
{
  private Point where;
  public AutoexposeHelper result;
  
  public AutoexposeHelper$Search(Point pt)
  {
    where = pt;
  }
  
  public boolean evaluate(EditPart editpart)
  {
    try {}catch (ClassNotFoundException localClassNotFoundException)
    {
      throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
    }
    result = 
      ((AutoexposeHelper)editpart.getAdapter(Class.forName("org.eclipse.gef.AutoexposeHelper")));
    if ((result != null) && (result.detect(where))) {
      return true;
    }
    result = null;
    return false;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.AutoexposeHelper.Search
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.draw2d.geometry.Point;

public abstract interface AutoexposeHelper
{
  public abstract boolean detect(Point paramPoint);
  
  public abstract boolean step(Point paramPoint);
  
  public static class Search
    implements EditPartViewer.Conditional
  {
    private Point where;
    public AutoexposeHelper result;
    
    public Search(Point pt)
    {
      where = pt;
    }
    
    public boolean evaluate(EditPart editpart)
    {
      try {}catch (ClassNotFoundException localClassNotFoundException)
      {
        throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
      }
      result = 
        ((AutoexposeHelper)editpart.getAdapter(Class.forName("org.eclipse.gef.AutoexposeHelper")));
      if ((result != null) && (result.detect(where))) {
        return true;
      }
      result = null;
      return false;
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.AutoexposeHelper
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.core.runtime.Assert;
import org.eclipse.draw2d.geometry.PrecisionRectangle;

public class CompoundSnapToHelper
  extends SnapToHelper
{
  private SnapToHelper[] delegates;
  
  public CompoundSnapToHelper(SnapToHelper[] delegates)
  {
    Assert.isTrue(delegates.length != 0);
    this.delegates = delegates;
  }
  
  protected SnapToHelper[] getDelegates()
  {
    return delegates;
  }
  
  public int snapRectangle(Request request, int snapOrientation, PrecisionRectangle baseRect, PrecisionRectangle result)
  {
    for (int i = 0; (i < getDelegates().length) && (snapOrientation != 0); i++) {
      snapOrientation = getDelegates()[i].snapRectangle(request, 
        snapOrientation, baseRect, result);
    }
    return snapOrientation;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.CompoundSnapToHelper
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

public abstract interface ConnectionEditPart
  extends GraphicalEditPart
{
  public abstract EditPart getSource();
  
  public abstract EditPart getTarget();
  
  public abstract void setSource(EditPart paramEditPart);
  
  public abstract void setTarget(EditPart paramEditPart);
}

/* Location:
 * Qualified Name:     org.eclipse.gef.ConnectionEditPart
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;

public abstract class ContextMenuProvider
  extends MenuManager
  implements IMenuListener
{
  private EditPartViewer viewer;
  
  public ContextMenuProvider(EditPartViewer viewer)
  {
    setViewer(viewer);
    addMenuListener(this);
    setRemoveAllWhenShown(true);
  }
  
  public abstract void buildContextMenu(IMenuManager paramIMenuManager);
  
  protected EditPartViewer getViewer()
  {
    return viewer;
  }
  
  public void menuAboutToShow(IMenuManager menu)
  {
    buildContextMenu(menu);
  }
  
  protected void setViewer(EditPartViewer viewer)
  {
    this.viewer = viewer;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.ContextMenuProvider
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.ui.IEditorPart;

public class DefaultEditDomain
  extends EditDomain
{
  private IEditorPart editorPart;
  
  public DefaultEditDomain(IEditorPart editorPart)
  {
    setEditorPart(editorPart);
  }
  
  public IEditorPart getEditorPart()
  {
    return editorPart;
  }
  
  protected void setEditorPart(IEditorPart editorPart)
  {
    this.editorPart = editorPart;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.DefaultEditDomain
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

public abstract interface Disposable
{
  public abstract void dispose();
}

/* Location:
 * Qualified Name:     org.eclipse.gef.Disposable
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

public abstract interface DragTracker
  extends Tool
{
  public abstract void commitDrag();
}

/* Location:
 * Qualified Name:     org.eclipse.gef.DragTracker
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.gef.palette.PaletteListener;
import org.eclipse.gef.palette.ToolEntry;
import org.eclipse.gef.ui.palette.PaletteViewer;

class EditDomain$1
  implements PaletteListener
{
  final EditDomain this$0;
  
  EditDomain$1(EditDomain paramEditDomain) {}
  
  public void activeToolChanged(PaletteViewer viewer, ToolEntry tool)
  {
    EditDomain.access$0(this$0);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.EditDomain.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import java.util.ArrayList;
import java.util.List;
import org.eclipse.gef.commands.CommandStack;
import org.eclipse.gef.palette.PaletteListener;
import org.eclipse.gef.palette.PaletteRoot;
import org.eclipse.gef.palette.ToolEntry;
import org.eclipse.gef.tools.SelectionTool;
import org.eclipse.gef.ui.palette.PaletteViewer;
import org.eclipse.swt.dnd.DragSourceEvent;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.TraverseEvent;
import org.eclipse.swt.widgets.Event;

public class EditDomain
{
  private Tool defaultTool;
  private PaletteViewer paletteViewer;
  private PaletteRoot paletteRoot;
  private Tool activeTool;
  private List viewers = new ArrayList();
  private CommandStack commandStack = new CommandStack();
  private PaletteListener paletteListener = new PaletteListener()
  {
    public void activeToolChanged(PaletteViewer viewer, ToolEntry tool)
    {
      EditDomain.this.handlePaletteToolChanged();
    }
  };
  
  public EditDomain()
  {
    loadDefaultTool();
  }
  
  public void addViewer(EditPartViewer viewer)
  {
    viewer.setEditDomain(this);
    if (!viewers.contains(viewer)) {
      viewers.add(viewer);
    }
  }
  
  public void focusGained(FocusEvent event, EditPartViewer viewer)
  {
    Tool tool = getActiveTool();
    if (tool != null) {
      tool.focusGained(event, viewer);
    }
  }
  
  public void focusLost(FocusEvent event, EditPartViewer viewer)
  {
    Tool tool = getActiveTool();
    if (tool != null) {
      tool.focusLost(event, viewer);
    }
  }
  
  public Tool getActiveTool()
  {
    return activeTool;
  }
  
  public CommandStack getCommandStack()
  {
    return commandStack;
  }
  
  public Tool getDefaultTool()
  {
    if (defaultTool == null) {
      defaultTool = new SelectionTool();
    }
    return defaultTool;
  }
  
  public PaletteViewer getPaletteViewer()
  {
    return paletteViewer;
  }
  
  private void handlePaletteToolChanged()
  {
    PaletteViewer paletteViewer = getPaletteViewer();
    if (paletteViewer != null)
    {
      ToolEntry entry = paletteViewer.getActiveTool();
      if (entry != null) {
        setActiveTool(entry.createTool());
      } else {
        setActiveTool(getDefaultTool());
      }
    }
  }
  
  public void keyDown(KeyEvent keyEvent, EditPartViewer viewer)
  {
    Tool tool = getActiveTool();
    if (tool != null) {
      tool.keyDown(keyEvent, viewer);
    }
  }
  
  public void keyTraversed(TraverseEvent traverseEvent, EditPartViewer viewer)
  {
    Tool tool = getActiveTool();
    if (tool != null) {
      tool.keyTraversed(traverseEvent, viewer);
    }
  }
  
  public void keyUp(KeyEvent keyEvent, EditPartViewer viewer)
  {
    Tool tool = getActiveTool();
    if (tool != null) {
      tool.keyUp(keyEvent, viewer);
    }
  }
  
  public void loadDefaultTool()
  {
    setActiveTool(null);
    PaletteViewer paletteViewer = getPaletteViewer();
    if ((paletteRoot != null) && (paletteViewer != null))
    {
      if (paletteRoot.getDefaultEntry() != null)
      {
        paletteViewer.setActiveTool(paletteRoot.getDefaultEntry());
        return;
      }
      paletteViewer.setActiveTool(null);
    }
    setActiveTool(getDefaultTool());
  }
  
  public void mouseDoubleClick(MouseEvent mouseEvent, EditPartViewer viewer)
  {
    Tool tool = getActiveTool();
    if (tool != null) {
      tool.mouseDoubleClick(mouseEvent, viewer);
    }
  }
  
  public void mouseDown(MouseEvent mouseEvent, EditPartViewer viewer)
  {
    Tool tool = getActiveTool();
    if (tool != null) {
      tool.mouseDown(mouseEvent, viewer);
    }
  }
  
  public void mouseDrag(MouseEvent mouseEvent, EditPartViewer viewer)
  {
    Tool tool = getActiveTool();
    if (tool != null) {
      tool.mouseDrag(mouseEvent, viewer);
    }
  }
  
  public void mouseHover(MouseEvent mouseEvent, EditPartViewer viewer)
  {
    Tool tool = getActiveTool();
    if (tool != null) {
      tool.mouseHover(mouseEvent, viewer);
    }
  }
  
  public void mouseMove(MouseEvent mouseEvent, EditPartViewer viewer)
  {
    Tool tool = getActiveTool();
    if (tool != null) {
      tool.mouseMove(mouseEvent, viewer);
    }
  }
  
  public void mouseUp(MouseEvent mouseEvent, EditPartViewer viewer)
  {
    Tool tool = getActiveTool();
    if (tool != null) {
      tool.mouseUp(mouseEvent, viewer);
    }
  }
  
  public void mouseWheelScrolled(Event event, EditPartViewer viewer)
  {
    Tool tool = getActiveTool();
    if (tool != null) {
      tool.mouseWheelScrolled(event, viewer);
    }
  }
  
  public void nativeDragFinished(DragSourceEvent event, EditPartViewer viewer)
  {
    Tool tool = getActiveTool();
    if (tool != null) {
      tool.nativeDragFinished(event, viewer);
    }
  }
  
  public void nativeDragStarted(DragSourceEvent event, EditPartViewer viewer)
  {
    Tool tool = getActiveTool();
    if (tool != null) {
      tool.nativeDragStarted(event, viewer);
    }
  }
  
  public void removeViewer(EditPartViewer viewer)
  {
    if (viewers.remove(viewer)) {
      viewer.setEditDomain(null);
    }
  }
  
  public void setCommandStack(CommandStack stack)
  {
    commandStack = stack;
  }
  
  public void setDefaultTool(Tool tool)
  {
    defaultTool = tool;
  }
  
  public void setPaletteRoot(PaletteRoot root)
  {
    if (paletteRoot == root) {
      return;
    }
    paletteRoot = root;
    if (getPaletteViewer() != null)
    {
      getPaletteViewer().setPaletteRoot(paletteRoot);
      loadDefaultTool();
    }
  }
  
  public void setPaletteViewer(PaletteViewer palette)
  {
    if (palette == paletteViewer) {
      return;
    }
    if (paletteViewer != null) {
      paletteViewer.removePaletteListener(paletteListener);
    }
    paletteViewer = palette;
    if (paletteViewer != null)
    {
      palette.addPaletteListener(paletteListener);
      if (paletteRoot != null)
      {
        paletteViewer.setPaletteRoot(paletteRoot);
        loadDefaultTool();
      }
    }
  }
  
  public void setActiveTool(Tool tool)
  {
    if (activeTool != null) {
      activeTool.deactivate();
    }
    activeTool = tool;
    if (activeTool != null)
    {
      activeTool.setEditDomain(this);
      activeTool.activate();
    }
  }
  
  public void viewerEntered(MouseEvent mouseEvent, EditPartViewer viewer)
  {
    Tool tool = getActiveTool();
    if (tool != null) {
      tool.viewerEntered(mouseEvent, viewer);
    }
  }
  
  public void viewerExited(MouseEvent mouseEvent, EditPartViewer viewer)
  {
    Tool tool = getActiveTool();
    if (tool != null) {
      tool.viewerExited(mouseEvent, viewer);
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.EditDomain
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import java.util.List;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.gef.commands.Command;

public abstract interface EditPart
  extends IAdaptable
{
  public static final int SELECTED_NONE = 0;
  public static final int SELECTED = 1;
  public static final int SELECTED_PRIMARY = 2;
  
  public abstract void activate();
  
  public abstract void addEditPartListener(EditPartListener paramEditPartListener);
  
  public abstract void addNotify();
  
  public abstract void deactivate();
  
  public abstract void eraseSourceFeedback(Request paramRequest);
  
  public abstract void eraseTargetFeedback(Request paramRequest);
  
  public abstract List getChildren();
  
  public abstract Command getCommand(Request paramRequest);
  
  public abstract DragTracker getDragTracker(Request paramRequest);
  
  public abstract EditPolicy getEditPolicy(Object paramObject);
  
  public abstract Object getModel();
  
  public abstract EditPart getParent();
  
  public abstract RootEditPart getRoot();
  
  public abstract int getSelected();
  
  public abstract EditPart getTargetEditPart(Request paramRequest);
  
  public abstract EditPartViewer getViewer();
  
  public abstract boolean hasFocus();
  
  public abstract void installEditPolicy(Object paramObject, EditPolicy paramEditPolicy);
  
  public abstract boolean isActive();
  
  public abstract boolean isSelectable();
  
  public abstract void performRequest(Request paramRequest);
  
  public abstract void refresh();
  
  public abstract void removeEditPartListener(EditPartListener paramEditPartListener);
  
  public abstract void removeEditPolicy(Object paramObject);
  
  public abstract void removeNotify();
  
  public abstract void setFocus(boolean paramBoolean);
  
  public abstract void setModel(Object paramObject);
  
  public abstract void setParent(EditPart paramEditPart);
  
  public abstract void setSelected(int paramInt);
  
  public abstract void showSourceFeedback(Request paramRequest);
  
  public abstract void showTargetFeedback(Request paramRequest);
  
  public abstract boolean understandsRequest(Request paramRequest);
}

/* Location:
 * Qualified Name:     org.eclipse.gef.EditPart
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

public abstract interface EditPartFactory
{
  public abstract EditPart createEditPart(EditPart paramEditPart, Object paramObject);
}

/* Location:
 * Qualified Name:     org.eclipse.gef.EditPartFactory
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

public class EditPartListener$Stub
  implements EditPartListener
{
  public void childAdded(EditPart child, int index) {}
  
  public void partActivated(EditPart editpart) {}
  
  public void partDeactivated(EditPart editpart) {}
  
  public void removingChild(EditPart child, int index) {}
  
  public void selectedStateChanged(EditPart part) {}
}

/* Location:
 * Qualified Name:     org.eclipse.gef.EditPartListener.Stub
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

public abstract interface EditPartListener
{
  public abstract void childAdded(EditPart paramEditPart, int paramInt);
  
  public abstract void partActivated(EditPart paramEditPart);
  
  public abstract void partDeactivated(EditPart paramEditPart);
  
  public abstract void removingChild(EditPart paramEditPart, int paramInt);
  
  public abstract void selectedStateChanged(EditPart paramEditPart);
  
  public static class Stub
    implements EditPartListener
  {
    public void childAdded(EditPart child, int index) {}
    
    public void partActivated(EditPart editpart) {}
    
    public void partDeactivated(EditPart editpart) {}
    
    public void removingChild(EditPart child, int index) {}
    
    public void selectedStateChanged(EditPart part) {}
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.EditPartListener
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

public abstract interface EditPartViewer$Conditional
{
  public abstract boolean evaluate(EditPart paramEditPart);
}

/* Location:
 * Qualified Name:     org.eclipse.gef.EditPartViewer.Conditional
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import java.beans.PropertyChangeListener;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.resource.ResourceManager;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.swt.graphics.Cursor;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;

public abstract interface EditPartViewer
  extends ISelectionProvider
{
  public abstract void addDragSourceListener(org.eclipse.gef.dnd.TransferDragSourceListener paramTransferDragSourceListener);
  
  public abstract void addDragSourceListener(org.eclipse.jface.util.TransferDragSourceListener paramTransferDragSourceListener);
  
  public abstract void addDropTargetListener(org.eclipse.gef.dnd.TransferDropTargetListener paramTransferDropTargetListener);
  
  public abstract void addDropTargetListener(org.eclipse.jface.util.TransferDropTargetListener paramTransferDropTargetListener);
  
  public abstract void addPropertyChangeListener(PropertyChangeListener paramPropertyChangeListener);
  
  public abstract void appendSelection(EditPart paramEditPart);
  
  public abstract Control createControl(Composite paramComposite);
  
  public abstract void deselect(EditPart paramEditPart);
  
  public abstract void deselectAll();
  
  public abstract EditPart findObjectAt(Point paramPoint);
  
  public abstract EditPart findObjectAtExcluding(Point paramPoint, Collection paramCollection);
  
  public abstract EditPart findObjectAtExcluding(Point paramPoint, Collection paramCollection, Conditional paramConditional);
  
  public abstract void flush();
  
  public abstract EditPart getContents();
  
  public abstract MenuManager getContextMenu();
  
  public abstract Control getControl();
  
  public abstract EditDomain getEditDomain();
  
  public abstract EditPartFactory getEditPartFactory();
  
  public abstract Map getEditPartRegistry();
  
  public abstract EditPart getFocusEditPart();
  
  public abstract KeyHandler getKeyHandler();
  
  public abstract Object getProperty(String paramString);
  
  public abstract ResourceManager getResourceManager();
  
  public abstract RootEditPart getRootEditPart();
  
  public abstract List getSelectedEditParts();
  
  public abstract ISelection getSelection();
  
  public abstract SelectionManager getSelectionManager();
  
  public abstract Map getVisualPartMap();
  
  public abstract void registerAccessibleEditPart(AccessibleEditPart paramAccessibleEditPart);
  
  /**
   * @deprecated
   */
  public abstract void removeDragSourceListener(org.eclipse.gef.dnd.TransferDragSourceListener paramTransferDragSourceListener);
  
  public abstract void removeDragSourceListener(org.eclipse.jface.util.TransferDragSourceListener paramTransferDragSourceListener);
  
  /**
   * @deprecated
   */
  public abstract void removeDropTargetListener(org.eclipse.gef.dnd.TransferDropTargetListener paramTransferDropTargetListener);
  
  public abstract void removeDropTargetListener(org.eclipse.jface.util.TransferDropTargetListener paramTransferDropTargetListener);
  
  public abstract void removePropertyChangeListener(PropertyChangeListener paramPropertyChangeListener);
  
  public abstract void reveal(EditPart paramEditPart);
  
  public abstract void select(EditPart paramEditPart);
  
  public abstract void setContents(EditPart paramEditPart);
  
  public abstract void setContents(Object paramObject);
  
  public abstract void setContextMenu(MenuManager paramMenuManager);
  
  public abstract void setControl(Control paramControl);
  
  public abstract void setCursor(Cursor paramCursor);
  
  public abstract void setEditDomain(EditDomain paramEditDomain);
  
  public abstract void setEditPartFactory(EditPartFactory paramEditPartFactory);
  
  public abstract void setFocus(EditPart paramEditPart);
  
  public abstract void setKeyHandler(KeyHandler paramKeyHandler);
  
  public abstract void setProperty(String paramString, Object paramObject);
  
  public abstract void setRootEditPart(RootEditPart paramRootEditPart);
  
  public abstract void setRouteEventsToEditDomain(boolean paramBoolean);
  
  public abstract void setSelectionManager(SelectionManager paramSelectionManager);
  
  public abstract void unregisterAccessibleEditPart(AccessibleEditPart paramAccessibleEditPart);
  
  public static abstract interface Conditional
  {
    public abstract boolean evaluate(EditPart paramEditPart);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.EditPartViewer
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.gef.commands.Command;

public abstract interface EditPolicy
{
  public static final String COMPONENT_ROLE = "ComponentEditPolicy";
  public static final String CONNECTION_ENDPOINTS_ROLE = "Connection Endpoint Policy";
  public static final String CONNECTION_BENDPOINTS_ROLE = "Connection Bendpoint Policy";
  public static final String CONNECTION_ROLE = "ConnectionEditPolicy";
  public static final String CONTAINER_ROLE = "ContainerEditPolicy";
  public static final String DIRECT_EDIT_ROLE = "DirectEditPolicy";
  public static final String GRAPHICAL_NODE_ROLE = "GraphicalNodeEditPolicy";
  public static final String LAYOUT_ROLE = "LayoutEditPolicy";
  public static final String NODE_ROLE = "NodeEditPolicy";
  public static final String PRIMARY_DRAG_ROLE = "PrimaryDrag Policy";
  public static final String SELECTION_FEEDBACK_ROLE = "Selection Feedback";
  public static final String TREE_CONTAINER_ROLE = "TreeContainerEditPolicy";
  
  public abstract void activate();
  
  public abstract void deactivate();
  
  public abstract void eraseSourceFeedback(Request paramRequest);
  
  public abstract void eraseTargetFeedback(Request paramRequest);
  
  public abstract Command getCommand(Request paramRequest);
  
  public abstract EditPart getHost();
  
  public abstract EditPart getTargetEditPart(Request paramRequest);
  
  public abstract void setHost(EditPart paramEditPart);
  
  public abstract void showSourceFeedback(Request paramRequest);
  
  public abstract void showTargetFeedback(Request paramRequest);
  
  public abstract boolean understandsRequest(Request paramRequest);
}

/* Location:
 * Qualified Name:     org.eclipse.gef.EditPolicy
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

public abstract interface ExposeHelper
{
  public abstract void exposeDescendant(EditPart paramEditPart);
}

/* Location:
 * Qualified Name:     org.eclipse.gef.ExposeHelper
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import com.ibm.icu.text.DecimalFormat;
import com.ibm.icu.text.NumberFormat;
import org.eclipse.swt.widgets.Text;

/**
 * @deprecated
 */
public final class GEF
{
  static final String TAB = "  ";
  static Text text;
  static int msgCount;
  static int tab;
  static NumberFormat formatter = new DecimalFormat();
  /**
   * @deprecated
   */
  public static boolean DebugTools = false;
  /**
   * @deprecated
   */
  public static boolean DebugEvents = false;
  /**
   * @deprecated
   */
  public static boolean DebugEditParts = false;
  /**
   * @deprecated
   */
  public static boolean DebugPainting = false;
  /**
   * @deprecated
   */
  public static boolean DebugFeedback = false;
  /**
   * @deprecated
   */
  public static boolean GlobalDebug = false;
  /**
   * @deprecated
   */
  public static boolean DebugToolStates = false;
  /**
   * @deprecated
   */
  public static boolean DebugDND = false;
  
  public static void clearConsole()
  {
    if (text == null) {
      return;
    }
    text.setText("");
  }
  
  public static void setConsole(Text textBox)
  {
    msgCount = 0;
    formatter.setMinimumIntegerDigits(2);
    formatter.setMaximumFractionDigits(0);
    text = textBox;
  }
  
  public static void debugPop()
  {
    tab -= 1;
  }
  
  public static void debugPush(String heading)
  {
    debug(heading);
    tab += 1;
  }
  
  public static void debug(String message)
  {
    String lineNumber = formatter.format(new Long(msgCount++));
    msgCount %= 100;
    String indent = "";
    for (int i = 0; i < tab; i++) {
      indent = indent + "  ";
    }
    if (text != null) {
      text.append('\n' + lineNumber + '\t' + indent + message);
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.GEF
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.gef.commands.CommandStack;
import org.eclipse.gef.internal.InternalGEFPlugin;
import org.eclipse.gef.ui.properties.UndoablePropertySheetEntry;
import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.eclipse.ui.views.properties.IPropertySheetEntry;

/**
 * @deprecated
 */
public final class GEFPlugin
  extends AbstractUIPlugin
{
  private static GEFPlugin singleton;
  
  /**
   * @deprecated
   */
  public static IPropertySheetEntry createUndoablePropertySheetEntry(CommandStack stack)
  {
    return new UndoablePropertySheetEntry(
      stack);
  }
  
  public static GEFPlugin getDefault()
  {
    if (singleton == null) {
      singleton = new GEFPlugin();
    }
    return singleton;
  }
  
  GEFPlugin()
  {
    try
    {
      start(InternalGEFPlugin.getContext());
    }
    catch (Exception exc)
    {
      throw new RuntimeException(exc);
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.GEFPlugin
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import java.util.List;
import org.eclipse.draw2d.IFigure;

public abstract interface GraphicalEditPart
  extends EditPart
{
  public abstract void addNodeListener(NodeListener paramNodeListener);
  
  public abstract IFigure getFigure();
  
  public abstract List getSourceConnections();
  
  public abstract List getTargetConnections();
  
  public abstract IFigure getContentPane();
  
  public abstract void removeNodeListener(NodeListener paramNodeListener);
  
  public abstract void setLayoutConstraint(EditPart paramEditPart, IFigure paramIFigure, Object paramObject);
}

/* Location:
 * Qualified Name:     org.eclipse.gef.GraphicalEditPart
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.draw2d.geometry.Point;

public abstract interface GraphicalViewer
  extends EditPartViewer
{
  public abstract Handle findHandleAt(Point paramPoint);
}

/* Location:
 * Qualified Name:     org.eclipse.gef.GraphicalViewer
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.draw2d.geometry.Point;

public abstract interface Handle
{
  public abstract DragTracker getDragTracker();
  
  public abstract Point getAccessibleLocation();
}

/* Location:
 * Qualified Name:     org.eclipse.gef.Handle
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import java.util.HashMap;
import java.util.Map;
import org.eclipse.jface.action.IAction;
import org.eclipse.swt.events.KeyEvent;

public class KeyHandler
{
  private Map actions;
  private KeyHandler parent;
  
  public boolean keyPressed(KeyEvent event)
  {
    if (performStroke(new KeyStroke(event, true)))
    {
      doit = false;
      return true;
    }
    return (parent != null) && (parent.keyPressed(event));
  }
  
  public boolean keyReleased(KeyEvent event)
  {
    if (performStroke(new KeyStroke(event, false))) {
      return true;
    }
    return (parent != null) && (parent.keyReleased(event));
  }
  
  private boolean performStroke(KeyStroke key)
  {
    if (actions == null) {
      return false;
    }
    IAction action = (IAction)actions.get(key);
    if (action == null) {
      return false;
    }
    if (action.isEnabled()) {
      action.run();
    }
    return true;
  }
  
  public void put(KeyStroke keystroke, IAction action)
  {
    if (actions == null) {
      actions = new HashMap();
    }
    actions.put(keystroke, action);
  }
  
  public void remove(KeyStroke keystroke)
  {
    if (actions != null) {
      actions.remove(keystroke);
    }
  }
  
  public KeyHandler setParent(KeyHandler parent)
  {
    this.parent = parent;
    return this;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.KeyHandler
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.swt.events.KeyEvent;

public class KeyStroke
{
  private int stateMask;
  private char character;
  private boolean onPressed;
  private int keyCode;
  
  public static KeyStroke getPressed(char character, int stateMask)
  {
    return new KeyStroke(character, stateMask, true);
  }
  
  public static KeyStroke getPressed(int keyCode, int stateMask)
  {
    return new KeyStroke(keyCode, stateMask, true);
  }
  
  public static KeyStroke getPressed(char character, int keyCode, int stateMask)
  {
    return new KeyStroke(character, keyCode, stateMask, true);
  }
  
  public static KeyStroke getReleased(char character, int stateMask)
  {
    return new KeyStroke(character, stateMask, false);
  }
  
  public static KeyStroke getReleased(int keyCode, int stateMask)
  {
    return new KeyStroke(keyCode, stateMask, false);
  }
  
  public static KeyStroke getReleased(char character, int keyCode, int stateMask)
  {
    return new KeyStroke(character, keyCode, stateMask, false);
  }
  
  KeyStroke(KeyEvent event, boolean pressed)
  {
    onPressed = pressed;
    stateMask = stateMask;
    character = character;
    keyCode = keyCode;
  }
  
  KeyStroke(int keyCode, int stateMask, boolean onPressed)
  {
    this.keyCode = keyCode;
    this.stateMask = stateMask;
    this.onPressed = onPressed;
  }
  
  KeyStroke(char character, int stateMask, boolean onPressed)
  {
    this.character = character;
    this.stateMask = stateMask;
    this.onPressed = onPressed;
  }
  
  KeyStroke(char character, int keyCode, int stateMask, boolean onPressed)
  {
    this.character = character;
    this.keyCode = keyCode;
    this.stateMask = stateMask;
    this.onPressed = onPressed;
  }
  
  public boolean equals(Object obj)
  {
    if ((obj instanceof KeyStroke))
    {
      KeyStroke stroke = (KeyStroke)obj;
      
      return (character == character) && (keyCode == keyCode) && (onPressed == onPressed) && (stateMask == stateMask);
    }
    return false;
  }
  
  public int hashCode()
  {
    return (stateMask + 1) * ((character ^ keyCode) + '\001') + (
    
      onPressed ? 0 : 32);
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.KeyStroke
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

public abstract interface LayerConstants
{
  public static final String PRIMARY_LAYER = "Primary Layer";
  public static final String CONNECTION_LAYER = "Connection Layer";
  public static final String GRID_LAYER = "Grid Layer";
  public static final String GUIDE_LAYER = "Guide Layer";
  public static final String HANDLE_LAYER = "Handle Layer";
  public static final String FEEDBACK_LAYER = "Feedback Layer";
  public static final String SCALED_FEEDBACK_LAYER = "Scaled Feedback Layer";
  public static final String PRINTABLE_LAYERS = "Printable Layers";
  public static final String SCALABLE_LAYERS = "Scalable Layers";
}

/* Location:
 * Qualified Name:     org.eclipse.gef.LayerConstants
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.swt.SWT;

public class MouseWheelHandler$KeyGenerator
{
  public static String getKey(int stateMask)
  {
    if ((stateMask & ((SWT.BUTTON_MASK | SWT.MODIFIER_MASK) ^ 0xFFFFFFFF)) != 0) {
      throw new IllegalArgumentException(
        "Illegal state: " + stateMask);
    }
    return "MouseWheelHandler(" + stateMask + ")";
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.MouseWheelHandler.KeyGenerator
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Event;

public abstract interface MouseWheelHandler
{
  public abstract void handleMouseWheel(Event paramEvent, EditPartViewer paramEditPartViewer);
  
  public static class KeyGenerator
  {
    public static String getKey(int stateMask)
    {
      if ((stateMask & ((SWT.BUTTON_MASK | SWT.MODIFIER_MASK) ^ 0xFFFFFFFF)) != 0) {
        throw new IllegalArgumentException(
          "Illegal state: " + stateMask);
      }
      return "MouseWheelHandler(" + stateMask + ")";
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.MouseWheelHandler
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.swt.widgets.Event;

public abstract interface MouseWheelHelper
{
  public abstract void handleMouseWheelScrolled(Event paramEvent);
}

/* Location:
 * Qualified Name:     org.eclipse.gef.MouseWheelHelper
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.gef.editparts.ZoomManager;
import org.eclipse.swt.widgets.Event;

public final class MouseWheelZoomHandler
  implements MouseWheelHandler
{
  public static final MouseWheelHandler SINGLETON = new MouseWheelZoomHandler();
  
  public void handleMouseWheel(Event event, EditPartViewer viewer)
  {
    ZoomManager zoomMgr = (ZoomManager)viewer
      .getProperty(ZoomManager.class.toString());
    if (zoomMgr != null)
    {
      if (count > 0) {
        zoomMgr.zoomIn();
      } else {
        zoomMgr.zoomOut();
      }
      doit = false;
    }
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.MouseWheelZoomHandler
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import org.eclipse.draw2d.ConnectionAnchor;

public abstract interface NodeEditPart
  extends GraphicalEditPart
{
  public abstract ConnectionAnchor getSourceConnectionAnchor(ConnectionEditPart paramConnectionEditPart);
  
  public abstract ConnectionAnchor getTargetConnectionAnchor(ConnectionEditPart paramConnectionEditPart);
  
  public abstract ConnectionAnchor getSourceConnectionAnchor(Request paramRequest);
  
  public abstract ConnectionAnchor getTargetConnectionAnchor(Request paramRequest);
}

/* Location:
 * Qualified Name:     org.eclipse.gef.NodeEditPart
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

public abstract interface NodeListener
{
  public abstract void removingSourceConnection(ConnectionEditPart paramConnectionEditPart, int paramInt);
  
  public abstract void removingTargetConnection(ConnectionEditPart paramConnectionEditPart, int paramInt);
  
  public abstract void sourceConnectionAdded(ConnectionEditPart paramConnectionEditPart, int paramInt);
  
  public abstract void targetConnectionAdded(ConnectionEditPart paramConnectionEditPart, int paramInt);
}

/* Location:
 * Qualified Name:     org.eclipse.gef.NodeListener
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

import java.util.HashMap;
import java.util.Map;

public class Request
{
  private Object type;
  private Map extendedData;
  
  public Request() {}
  
  public Request(Object type)
  {
    setType(type);
  }
  
  public Map getExtendedData()
  {
    if (extendedData == null) {
      extendedData = new HashMap();
    }
    return extendedData;
  }
  
  public Object getType()
  {
    return type;
  }
  
  public void setExtendedData(Map map)
  {
    extendedData = map;
  }
  
  public void setType(Object type)
  {
    this.type = type;
  }
}

/* Location:
 * Qualified Name:     org.eclipse.gef.Request
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package org.eclipse.gef;

public abstract interface RequestConstants
{
  public static final String REQ_CONNECTION_START = "connection start";
  public static final String REQ_CONNECTION_END = "connection end";
  public static final String REQ_RECONNECT_SOURCE = "Reconnection source";
  public static final String REQ_RECONNECT_TARGET = "Reconnection target";
  public static final String REQ_MOVE_BENDPOINT = "move bendpoint";
  public static final String REQ_CREATE_BENDPOINT = "create bendpoint";
  public static final String REQ_RESIZE = "resize";
  public static final String REQ_RESIZE_CHILDREN = "resize children";
  public static final String REQ_MOVE = "move";
  public static final String REQ_MOVE_CHILDREN = "move children";
  public static final String REQ_OPEN = "open";
  public static final String REQ_ORPHAN = "orphan";
  public static final String REQ_ORPHAN_CHILDREN = "orphan children";
  public static final String REQ_CREATE = "create child";
  public static final String REQ_ADD = "add children";
  public static final String REQ_CLONE = "clone";
  public static final String REQ_DELETE = "delete";
  public static final String REQ_DELETE_DEPENDANT = "delete dependant";
  public static final String REQ_ALIGN = "align";
  public static final String REQ_ALIGN_CHILDREN = "align children";
  publi
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2017. Infinite Loop Ltd