Java tutorial
/* * Copyright (c) 2012, 2013 Hemanta Sapkota. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * Hemanta Sapkota (laex.pearl@gmail.com) */ package com.laex.cg2d.screeneditor; import java.io.ByteArrayInputStream; import java.io.IOException; import java.lang.reflect.InvocationTargetException; import java.util.EventObject; import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IResource; import org.eclipse.core.resources.IResourceChangeEvent; import org.eclipse.core.resources.IResourceChangeListener; import org.eclipse.core.resources.IResourceDelta; import org.eclipse.core.resources.IResourceDeltaVisitor; import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.ISafeRunnable; import org.eclipse.core.runtime.NullProgressMonitor; import org.eclipse.draw2d.LayeredPane; import org.eclipse.draw2d.ScalableFreeformLayeredPane; import org.eclipse.draw2d.geometry.Dimension; import org.eclipse.gef.ContextMenuProvider; import org.eclipse.gef.DefaultEditDomain; import org.eclipse.gef.EditPartViewer; import org.eclipse.gef.GraphicalViewer; import org.eclipse.gef.LayerConstants; import org.eclipse.gef.MouseWheelHandler; import org.eclipse.gef.MouseWheelZoomHandler; import org.eclipse.gef.Request; import org.eclipse.gef.SnapToGeometry; import org.eclipse.gef.SnapToGrid; import org.eclipse.gef.commands.CompoundCommand; import org.eclipse.gef.dnd.AbstractTransferDropTargetListener; import org.eclipse.gef.dnd.TemplateTransferDragSourceListener; import org.eclipse.gef.editparts.ScalableFreeformRootEditPart; import org.eclipse.gef.editparts.ZoomListener; import org.eclipse.gef.editparts.ZoomManager; import org.eclipse.gef.palette.PaletteRoot; import org.eclipse.gef.requests.CreateRequest; import org.eclipse.gef.ui.palette.PaletteViewer; import org.eclipse.gef.ui.palette.PaletteViewerProvider; import org.eclipse.gef.ui.parts.ContentOutlinePage; import org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette; import org.eclipse.gef.ui.parts.GraphicalViewerKeyHandler; import org.eclipse.gef.ui.parts.TreeViewer; import org.eclipse.jface.dialogs.ProgressMonitorDialog; import org.eclipse.jface.operation.IRunnableWithProgress; import org.eclipse.jface.util.SafeRunnable; import org.eclipse.swt.SWT; import org.eclipse.swt.dnd.DND; import org.eclipse.swt.dnd.DropTargetEvent; import org.eclipse.swt.dnd.TextTransfer; import org.eclipse.swt.dnd.Transfer; import org.eclipse.swt.events.DisposeEvent; import org.eclipse.swt.events.DisposeListener; import org.eclipse.swt.graphics.Color; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Control; import org.eclipse.ui.IEditorInput; import org.eclipse.ui.IEditorPart; import org.eclipse.ui.IFileEditorInput; import org.eclipse.ui.IViewPart; import org.eclipse.ui.PlatformUI; import org.eclipse.ui.part.FileEditorInput; import org.eclipse.ui.views.contentoutline.IContentOutlinePage; import com.badlogic.gdx.math.Rectangle; import com.laex.cg2d.model.DNDFileTransfer; import com.laex.cg2d.model.EntityManager; import com.laex.cg2d.model.EntityResourceChangeListener; import com.laex.cg2d.model.EntityResourceChangeListener.EntityChangeListener; import com.laex.cg2d.model.ILayerManager; import com.laex.cg2d.model.IScreenEditorState; import com.laex.cg2d.model.IScreenPropertyManager; import com.laex.cg2d.model.ScreenModel.CGScreenModel; import com.laex.cg2d.model.ScreenModel.CGScreenPreferences; import com.laex.cg2d.model.adapter.ColorAdapter; import com.laex.cg2d.model.model.EditorShapeType; import com.laex.cg2d.model.model.Entity; import com.laex.cg2d.model.model.GameModel; import com.laex.cg2d.model.model.Joint; import com.laex.cg2d.model.model.Layer; import com.laex.cg2d.model.model.ModelValidatorFactory; import com.laex.cg2d.model.model.Shape; import com.laex.cg2d.screeneditor.commands.LayerAddCommand; import com.laex.cg2d.screeneditor.commands.LayerChangeOrderCommand; import com.laex.cg2d.screeneditor.commands.LayerChangePropertiesCommand; import com.laex.cg2d.screeneditor.commands.LayerRemoveCommand; import com.laex.cg2d.screeneditor.commands.ShapeCreateCommand; import com.laex.cg2d.screeneditor.commands.ShapeDeleteCommand; import com.laex.cg2d.screeneditor.commands.ShapeDeleteCommand.DeleteCommandType; import com.laex.cg2d.screeneditor.editparts.CardEditPart; import com.laex.cg2d.screeneditor.editparts.ScreenEditPartFactory; import com.laex.cg2d.screeneditor.editparts.tree.LayerOutlineTreeEPFactory; import com.laex.cg2d.screeneditor.editparts.tree.ScreenTreeEPFactory; import com.laex.cg2d.screeneditor.model.CGScreenModelAdapter; import com.laex.cg2d.screeneditor.model.ScreenModelAdapter; import com.laex.cg2d.screeneditor.model.ShapeAdapter; import com.laex.cg2d.screeneditor.model.ShapeCopier; import com.laex.cg2d.screeneditor.palette.ScreenEditorPaletteFactory; import com.laex.cg2d.screeneditor.palette.ShapeCreationFactory; import com.laex.cg2d.screeneditor.palette.ShapeCreationInfo; import com.laex.cg2d.screeneditor.views.IScreenDisposeListener; import com.laex.cg2d.screeneditor.views.LayerOutlineViewPart; import com.laex.cg2d.screeneditor.views.LayersViewPart; /** * The Class ScreenEditor. */ public class ScreenEditor extends GraphicalEditorWithFlyoutPalette implements ILayerManager, IScreenPropertyManager, IScreenEditorState { /** The Constant ID. */ public static final String ID = "com.laex.cg2d.screeneditor.ScreenEditor"; /** The palette model. */ private static PaletteRoot PALETTE_MODEL; /** The Constant CARD_LAYER. */ private static final String CARD_LAYER = "Card Layer"; /** The card layer. */ private ScalableFreeformLayeredPane cardLayer; /** The scalable root edit part. */ private ScalableFreeformRootEditPart scalableRootEditPart; /** The resource listener. */ private EntityResourceChangeListener resourceListener = new EntityResourceChangeListener(); /** The model. */ private GameModel model; /** The grid state. */ private boolean gridState = true; /** The card height. */ private int x, y, cardWidthh, cardHeight; /** The card bg color. */ private Color cardBgColor; /** * ScreenOutineView. General outline view that shows all the editparts in the * screen viewer. * * @author hemantasapkota * */ class ScreenOutlineView extends ContentOutlinePage { /** * Instantiates a new screen outline view. * * @param viewer * the viewer */ public ScreenOutlineView(EditPartViewer viewer) { super(viewer); } /* * (non-Javadoc) * * @see * org.eclipse.gef.ui.parts.ContentOutlinePage#createControl(org.eclipse * .swt.widgets.Composite) */ @Override public void createControl(Composite parent) { getViewer().createControl(parent); getViewer().setEditDomain(getEditDomain()); getViewer().setEditPartFactory(new ScreenTreeEPFactory()); getSelectionSynchronizer().addViewer(getViewer()); getViewer().setContents(getModel()); } /* * (non-Javadoc) * * @see org.eclipse.ui.part.Page#dispose() */ @Override public void dispose() { getSelectionSynchronizer().removeViewer(getViewer()); } /* * (non-Javadoc) * * @see org.eclipse.gef.ui.parts.ContentOutlinePage#getControl() */ @Override public Control getControl() { return getViewer().getControl(); } } /** * LayerOutlineView. Shows the list of layers.Auto selects the appropriate * layer when an edit part is selected. * * @author hemantasapkota * */ public class LayerOutlineView extends ScreenOutlineView { /** * Instantiates a new layer outline view. * * @param viewer * the viewer */ public LayerOutlineView(EditPartViewer viewer) { super(viewer); } /* * (non-Javadoc) * * @see * com.laex.cg2d.screeneditor.ScreenEditor.ScreenOutlineView#createControl * (org.eclipse.swt.widgets.Composite) */ @Override public void createControl(Composite parent) { getViewer().createControl(parent); getViewer().setEditDomain(getEditDomain()); getViewer().setEditPartFactory(new LayerOutlineTreeEPFactory()); getSelectionSynchronizer().addViewer(getViewer()); getViewer().setContents(getModel()); } /* * (non-Javadoc) * * @see com.laex.cg2d.screeneditor.ScreenEditor.ScreenOutlineView#dispose() */ @Override public void dispose() { getSelectionSynchronizer().removeViewer(getViewer()); } /* * (non-Javadoc) * * @see * com.laex.cg2d.screeneditor.ScreenEditor.ScreenOutlineView#getControl() */ @Override public Control getControl() { return getViewer().getControl(); } } /** * Instantiates a new screen editor. */ public ScreenEditor() { setEditDomain(new DefaultEditDomain(this)); } /* * (non-Javadoc) * * @see org.eclipse.gef.ui.parts.GraphicalEditor#createActions() */ @Override protected void createActions() { super.createActions(); } /* * (non-Javadoc) * * @see org.eclipse.gef.ui.parts.GraphicalEditor#configureGraphicalViewer() */ protected void configureGraphicalViewer() { GraphicalViewer viewer = getGraphicalViewer(); viewer.setEditPartFactory(new ScreenEditPartFactory()); viewer.setEditDomain(getEditDomain()); scalableRootEditPart = getScalableFreeFormRootEditPart(); getGraphicalViewer().setRootEditPart(scalableRootEditPart); toggleGrid(); setGridDimension(16, 16); // Zoom manager for now setupZoomManager(); // configure the context menu provider ContextMenuProvider cmProvider = new ScreenEditorContextMenuProvider(viewer, getActionRegistry()); viewer.setContextMenu(cmProvider); getSite().registerContextMenu(cmProvider, viewer); GraphicalViewerKeyHandler keyHandler = new GraphicalViewerKeyHandler(viewer); viewer.setKeyHandler(keyHandler); // Notify other views of this viewer's disposal getGraphicalViewer().getControl().addDisposeListener(new DisposeListener() { @Override public void widgetDisposed(DisposeEvent e) { IViewPart vp = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage() .findView(LayersViewPart.ID); if (vp != null) { IScreenDisposeListener isdp = (IScreenDisposeListener) vp; isdp.screenDisposed(); } } }); super.configureGraphicalViewer(); } /** * Setup zoom manager. */ private void setupZoomManager() { ZoomManager manager = (ZoomManager) getGraphicalViewer().getProperty(ZoomManager.class.toString()); manager.addZoomListener(new ZoomListener() { @Override public void zoomChanged(double zoom) { updateCardLayerZoom(zoom); } }); manager.setZoom(1); // Scroll-wheel Zoom getGraphicalViewer().setProperty(MouseWheelHandler.KeyGenerator.getKey(SWT.MOD1), MouseWheelZoomHandler.SINGLETON); } /** * Gets the scalable free form root edit part. * * @return the scalable free form root edit part */ private ScalableFreeformRootEditPart getScalableFreeFormRootEditPart() { ScalableFreeformRootEditPart rep = new ScalableFreeformRootEditPart() { @Override protected void createLayers(LayeredPane layeredPane) { cardLayer = new ScalableFreeformLayeredPane(); layeredPane.addLayerBefore(cardLayer, CARD_LAYER, LayerConstants.GRID_LAYER); updateCardLayer(x, y, cardWidthh, cardHeight, cardBgColor); super.createLayers(layeredPane); /* Create Joint Anchor Layer after other layers are created */ } }; super.configureGraphicalViewer(); return rep; } /** * Sets the grid dimension. * * @param width * the width * @param height * the height */ public void setGridDimension(int width, int height) { getGraphicalViewer().setProperty(SnapToGrid.PROPERTY_GRID_SPACING, new Dimension(width, height)); } /** * Gets the grid state. * * @return the grid state */ public boolean getGridState() { return (Boolean) getGraphicalViewer().getProperty(SnapToGrid.PROPERTY_GRID_VISIBLE); } /* * (non-Javadoc) * * @see * org.eclipse.gef.ui.parts.GraphicalEditor#commandStackChanged(java.util. * EventObject) */ public void commandStackChanged(EventObject event) { firePropertyChange(IEditorPart.PROP_DIRTY); super.commandStackChanged(event); } /* * (non-Javadoc) * * @see org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette# * createPaletteViewerProvider() */ protected PaletteViewerProvider createPaletteViewerProvider() { return new PaletteViewerProvider(getEditDomain()) { protected void configurePaletteViewer(PaletteViewer viewer) { super.configurePaletteViewer(viewer); viewer.addDragSourceListener(new TemplateTransferDragSourceListener(viewer)); } }; } /* * (non-Javadoc) * * @see * org.eclipse.ui.part.EditorPart#doSave(org.eclipse.core.runtime.IProgressMonitor * ) */ public void doSave(IProgressMonitor monitor) { try { IFile file = ((FileEditorInput) getEditorInput()).getFile(); performSave(file, monitor); } catch (CoreException ce) { Activator.log(ce); } catch (IOException e) { Activator.log(e); } } /** * Perform save. * * @param file * the file * @param monitor * the monitor * @throws CoreException * the core exception * @throws IOException * Signals that an I/O exception has occurred. */ private void performSave(IFile file, IProgressMonitor monitor) throws CoreException, IOException { // Use existing preferences file.getProject().refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor()); CGScreenPreferences screenPrefsExisting = CGScreenModel.parseFrom(file.getContents()).getScreenPrefs(); CGScreenModel cgGameModel = new CGScreenModelAdapter(model, screenPrefsExisting).asCGGameModel(); file.setContents(new ByteArrayInputStream(cgGameModel.toByteArray()), true, false, monitor); getCommandStack().markSaveLocation(); } /* * (non-Javadoc) * * @see org.eclipse.gef.ui.parts.GraphicalEditor#dispose() */ @Override public void dispose() { ResourcesPlugin.getWorkspace().removeResourceChangeListener(resourceListener); super.dispose(); } /* * (non-Javadoc) * * @see * org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette#getAdapter(java * .lang.Class) */ public Object getAdapter(Class type) { if (type == ShapeAdapter.class) { return Boolean.TRUE; } if (type == GameModel.class) { return model; } if (type == ZoomManager.class) { return getGraphicalViewer().getProperty(ZoomManager.class.toString()); } if (type == IContentOutlinePage.class) { // Screen Outline View ScreenOutlineView ov = new ScreenOutlineView(new TreeViewer()); return ov; } if (type == LayerOutlineViewPart.class) { return new LayerOutlineView(new TreeViewer()); } return super.getAdapter(type); } /** * Gets the model. * * @return the model */ public GameModel getModel() { return model; } /* * (non-Javadoc) * * @see * org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette#getPaletteRoot() */ protected PaletteRoot getPaletteRoot() { if (PALETTE_MODEL == null) { PALETTE_MODEL = ScreenEditorPaletteFactory.createPalette(); } return PALETTE_MODEL; } /* * (non-Javadoc) * * @see org.eclipse.gef.ui.parts.GraphicalEditorWithFlyoutPalette# * initializeGraphicalViewer() */ protected void initializeGraphicalViewer() { super.initializeGraphicalViewer(); GraphicalViewer viewer = getGraphicalViewer(); viewer.setContents(getModel().getDiagram()); // listen for dropped parts viewer.addDropTargetListener(new AbstractTransferDropTargetListener(viewer) { private ShapeCreationInfo creationInfo; @Override public boolean isEnabled(DropTargetEvent event) { boolean isCurrentLayerLocked = getModel().getDiagram().isCurrentLayerLocked(); return !isCurrentLayerLocked; } @Override protected Request createTargetRequest() { CreateRequest cr = new CreateRequest(); cr.setFactory(new ShapeCreationFactory(creationInfo)); return cr; } @Override protected void updateTargetRequest() { ((CreateRequest) getTargetRequest()).setLocation(getDropLocation()); } @Override protected void handleDragOver() { getCurrentEvent().detail = DND.DROP_COPY; super.handleDragOver(); } @Override protected void handleDrop() { switch (DNDFileTransfer.transferType) { case TEXTURE: creationInfo = new ShapeCreationInfo.Builder().setBackgroundResourceFile(DNDFileTransfer.file) .setEditorShapeType(EditorShapeType.BACKGROUND_SHAPE).build(); break; case ENTITY: creationInfo = new ShapeCreationInfo.Builder().setEditorShapeType(EditorShapeType.ENTITY_SHAPE) .setEntityResourceFile(DNDFileTransfer.entityResourceFile).build(); break; case NONE: break; default: break; } super.handleDrop(); } @Override public Transfer getTransfer() { return TextTransfer.getInstance(); } }); } /* * (non-Javadoc) * * @see org.eclipse.gef.ui.parts.GraphicalEditor#isSaveAsAllowed() */ public boolean isSaveAsAllowed() { return false; } /** * Close editor. */ private void closeEditor() { getSite().getShell().getDisplay().asyncExec(new Runnable() { @Override public void run() { getSite().getPage().closeEditor(ScreenEditor.this, false); } }); } /* * (non-Javadoc) * * @see org.eclipse.ui.part.EditorPart#setInput(org.eclipse.ui.IEditorInput) */ protected void setInput(final IEditorInput input) { setupResChangeListenerForDelete(input.getName()); try { setupEntityResourceListener(input); loadScreenModel(input); } catch (CoreException e) { Activator.log(e); } catch (IOException e) { Activator.log(e); } catch (InvocationTargetException e) { Activator.log(e); } catch (InterruptedException e) { Activator.log(e); } super.setInput(input); } /** * Load screen model. * * @param input the input * @throws CoreException the core exception * @throws IOException Signals that an I/O exception has occurred. * @throws InvocationTargetException the invocation target exception * @throws InterruptedException the interrupted exception */ private void loadScreenModel(final IEditorInput input) throws CoreException, IOException, InvocationTargetException, InterruptedException { final IFile file = ((IFileEditorInput) input).getFile(); ProgressMonitorDialog pmd = new ProgressMonitorDialog(getSite().getShell()); pmd.run(false, false, new IRunnableWithProgress() { @Override public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException { try { monitor.beginTask("Parse screen model", 1); CGScreenModel cgGameModel = CGScreenModel.parseFrom(file.getContents()); model = ScreenModelAdapter.asGameModel(cgGameModel); monitor.worked(1); x = cgGameModel.getScreenPrefs().getCardPrefs().getCardNoX(); y = cgGameModel.getScreenPrefs().getCardPrefs().getCardNoY(); cardWidthh = cgGameModel.getScreenPrefs().getCardPrefs().getCardWidth(); cardHeight = cgGameModel.getScreenPrefs().getCardPrefs().getCardHeight(); cardBgColor = ColorAdapter.swtColor(cgGameModel.getScreenPrefs().getBackgroundColor()); monitor.done(); } catch (IOException e) { Activator.log(e); } catch (CoreException e) { Activator.log(e); } } }); /* Go Ahead and activate the edit parts. */ setPartName(file.getProject().getName() + "/" + file.getName()); } /** * Sets the up res change listener for delete. * * @param resName the new up res change listener for delete */ private void setupResChangeListenerForDelete(final String resName) { ResourcesPlugin.getWorkspace().addResourceChangeListener(new IResourceChangeListener() { @Override public void resourceChanged(IResourceChangeEvent event) { if (event.getType() == IResourceChangeEvent.POST_CHANGE) { try { event.getDelta().accept(new IResourceDeltaVisitor() { @Override public boolean visit(IResourceDelta delta) throws CoreException { if (delta.getKind() == IResourceDelta.REMOVED) { if (resName.equals(delta.getResource().getName())) { closeEditor(); } } return true; } }); } catch (CoreException e) { Activator.log(e); } } } }, IResourceChangeEvent.POST_CHANGE | IResourceChangeEvent.PRE_DELETE); } /** * Sets the up entity resource listener. * * @param input the new up entity resource listener * @throws CoreException the core exception */ private void setupEntityResourceListener(final IEditorInput input) throws CoreException { ResourcesPlugin.getWorkspace().addResourceChangeListener(resourceListener, IResourceChangeEvent.POST_CHANGE | IResourceChangeEvent.PRE_DELETE); // if there are any changes in the entities, load em up in the editor resourceListener.addEntityChangeListener(new EntityChangeListener() { @Override public void entityChanged(final IResource resource) { /* * It is important to execute pallete creation safely because it * accesses GEF UI thread */ SafeRunnable.run(new ISafeRunnable() { @Override public void run() throws Exception { // Check if the resource is valid entity or not. String entityPath = resource.getFullPath().toOSString(); Entity e = EntityManager.entityManager().findEntity(entityPath); boolean isValid = ModelValidatorFactory.getValidator(Entity.class, e).isValid(); if (!isValid) { removeDeletedOrInvalidEntities(resource); return; } /* * Recompute the frame for entities that might have changed * Essentially, were re-creating a new shape by copying the old one. * Following are the considerations for this: 1. The id for the new * shape should be same as the old one 2. The rectagle bounds for * the new shape should reflect the new image */ CompoundCommand cc = new CompoundCommand(); for (Shape sh : model.getDiagram().getChildren()) { if (!sh.getEditorShapeType().isEntity()) { continue; } boolean isEntityUsed = entityPath.equals(sh.getEntityResourceFile().getResourceFile()); if (isEntityUsed) { ShapeCopier copier = new ShapeCopier(); Shape newShape = (Shape) copier.copy(sh); newShape.setId(sh.getId()); /* We use the same id */ /* update bounds */ Rectangle r = newShape.getBounds(); r.setWidth(e.getDefaultFrame().getBounds().width); r.setHeight(e.getDefaultFrame().getBounds().height); newShape.setBounds(r); /* end update bounds */ ShapeDeleteCommand sdc = new ShapeDeleteCommand(model.getDiagram(), sh, DeleteCommandType.NON_UNDOABLE); ShapeCreateCommand scc = new ShapeCreateCommand(newShape, model.getDiagram()); cc.add(sdc); cc.add(scc); } } getCommandStack().execute(cc); } @Override public void handleException(Throwable exception) { exception.printStackTrace(); } }); } @Override public void entityRemoved(final IResource resource) { /* * Important: entity Removed is called in resource listener. Resource * listener might be run in whatever thread it was triggered in. So in * order to remove the entities from the pallette, we need to asyncExec * deletion. This will prevent invalid thread access error. */ getSite().getShell().getDisplay().asyncExec(new Runnable() { @Override public void run() { removeDeletedOrInvalidEntities(resource); /* Also remove this entity from the map */ EntityManager.entityManager().removeEntity(resource.getFullPath().toOSString()); } }); } }); } /* * (non-Javadoc) * * @see * com.laex.cg2d.shared.ILayerManager#addLayer(com.laex.cg2d.shared.model. * Layer) */ @Override public void addLayer(Layer newLayer) { getEditDomain().getCommandStack().execute(new LayerAddCommand(newLayer, getModel().getDiagram())); } /* * (non-Javadoc) * * @see * com.laex.cg2d.shared.ILayerManager#changeLayerProperties(com.laex.cg2d. * shared.model.Layer) */ @Override public void changeLayerProperties(Layer newLayer) { getEditDomain().getCommandStack() .execute(new LayerChangePropertiesCommand(newLayer, getModel().getDiagram())); } /* * (non-Javadoc) * * @see * com.laex.cg2d.shared.ILayerManager#changeLayerOrder(com.laex.cg2d.shared * .model.Layer[]) */ @Override public void changeLayerOrder(Layer[] orderedLayers) { getEditDomain().getCommandStack() .execute(new LayerChangeOrderCommand(getModel().getDiagram(), orderedLayers)); } /* * (non-Javadoc) * * @see * com.laex.cg2d.shared.ILayerManager#removeLayer(com.laex.cg2d.shared.model * .Layer) */ @Override public void removeLayer(Layer layer) { getEditDomain().getCommandStack().execute(new LayerRemoveCommand(layer, getModel().getDiagram())); } /* * (non-Javadoc) * * @see com.laex.cg2d.model.ILayerManager#removeAll() */ @Override public void removeAllLayers() { CompoundCommand cc = new CompoundCommand(); for (Layer l : getModel().getDiagram().getLayers()) { LayerRemoveCommand lrc = new LayerRemoveCommand(l, getModel().getDiagram()); cc.add(lrc); } getEditDomain().getCommandStack().execute(cc); } /* * (non-Javadoc) * * @see com.laex.cg2d.shared.ILayerManager#updateCardLayer(int, int, int, int) */ @Override public void updateCardLayer(int noX, int noY, int cardWidth, int cardHeight, Color bgColor) { cardLayer.removeAll(); for (int i = 0; i < noY; i++) { for (int j = 0; j < noX; j++) { CardEditPart cep = new CardEditPart(j, i, cardWidth, cardHeight, bgColor); cardLayer.add(cep.getFigure()); } } } /* * (non-Javadoc) * * @see com.laex.cg2d.shared.ILayerManager#updateCardLayerZoom(double) */ @Override public void updateCardLayerZoom(double zoom) { cardLayer.setScale(zoom); } /** * Use the command stack and delete commands to remove the entities. * * @param resource * the resource */ private void removeDeletedOrInvalidEntities(final IResource resource) { // Remove the deleted entites from the screen CompoundCommand cc = new CompoundCommand(); for (Shape s : model.getDiagram().getChildren()) { if (s.getEditorShapeType().isEntity()) { String entResFile = s.getEntityResourceFile().getResourceFile(); String resFile = resource.getFullPath().toOSString(); if (entResFile.equals(resFile)) { ShapeDeleteCommand sdc = new ShapeDeleteCommand(model.getDiagram(), s, DeleteCommandType.NON_UNDOABLE); cc.add(sdc); } } } if (!cc.isEmpty()) getCommandStack().execute(cc); } /* * (non-Javadoc) * * @see * com.laex.cg2d.shared.IScreenPropertyManager#updateScreenProperties(java * .util.Map) */ @Override public void updateScreenProperties(CGScreenPreferences screenPrefs) { IFile file = ((FileEditorInput) getEditorInput()).getFile(); try { CGScreenModel cgGameModel = new CGScreenModelAdapter(model, screenPrefs).asCGGameModel(); file.setContents(new ByteArrayInputStream(cgGameModel.toByteArray()), true, false, null); getCommandStack().markSaveLocation(); } catch (CoreException e) { Activator.log(e); } } /* * (non-Javadoc) * * @see com.laex.cg2d.shared.ILayerManager#getNewLayerId() */ @Override public int getNewLayerId() { if (model.getDiagram().getLayers().isEmpty()) { return 1; } int id = model.getDiagram().getLayers().size() + 1; return id; } /* * (non-Javadoc) * * @see com.laex.cg2d.shared.ILayerManager#getCurrentLayer() */ @Override public Layer getCurrentLayer() { for (Layer layer : model.getDiagram().getLayers()) { if (layer.isCurrent()) { return layer; } } return null; } /* * (non-Javadoc) * * @see com.laex.cg2d.shared.ILayerManager#layerCount() */ @Override public int layerCount() { return getModel().getDiagram().getLayers().size(); } /* * (non-Javadoc) * * @see com.laex.cg2d.shared.ILayerManager#getLayerAt(int) */ @Override public Layer getLayerAt(int index) { return (Layer) getModel().getDiagram().getLayers().toArray()[index]; } /* * (non-Javadoc) * * @see com.laex.cg2d.model.IScreenEditorState#toggleGrid() */ @Override public void toggleGrid() { gridState = !gridState; getGraphicalViewer().setProperty(SnapToGeometry.PROPERTY_SNAP_ENABLED, true); getGraphicalViewer().setProperty(SnapToGrid.PROPERTY_GRID_ENABLED, gridState); getGraphicalViewer().setProperty(SnapToGrid.PROPERTY_GRID_VISIBLE, gridState); } /* (non-Javadoc) * @see com.laex.cg2d.model.IScreenEditorState#toggleJointLayer(com.laex.cg2d.model.model.Joint) */ @Override public void toggleJointLayer(Joint joint) { } }