cpartwork.java

this is best wamp jkbkgnkldjkb jkfbjdksgkjl bjkgsbkjfdb gjdsblkj gbfkjsd

		// make sure the fusioned picture is up to date
		fusionLayers();
		clipboard = new CPClip(new CPColorBmp(fusion, sel), sel.left, sel.top);
	}

	public void pasteClipboard(boolean createUndo) {
		if (clipboard != null) {
			pasteClip(createUndo, clipboard);
		}
	}

	public void pasteClip(boolean createUndo, CPClip clip) {
		if (createUndo) {
			addUndo(new CPUndoPaste(clip, getActiveLayerNb(), getSelection()));
		}

		// FIXME: redundant code, should use AddLayer's code??
		CPLayer newLayer = new CPLayer(width, height);
		newLayer.name = getDefaultLayerName();
		layers.add(activeLayer + 1, newLayer);
		setActiveLayer(activeLayer + 1);

		CPRect r = clip.bmp.getSize();
		int x, y;
		if (r.isInside(getSize())) {
			x = clip.x;
			y = clip.y;
		} else {
			x = (width - clip.bmp.width) / 2;
			y = (height - clip.bmp.height) / 2;
		}

		curLayer.pasteBitmap(clip.bmp, x, y);
		emptySelection();

		invalidateFusion();
		callListenersLayerChange();
	}

	// ////////////////////////////////////////////////////
	// Miscellaneous functions

	public String getDefaultLayerName() {
		String prefix = "Layer ";
		int highestLayerNb = 0;
		for (CPLayer l : layers) {
			if (l.name.matches("^" + prefix + "[0-9]+$")) {
				highestLayerNb = Math.max(highestLayerNb, Integer.parseInt(l.name.substring(prefix.length())));
			}
		}
		return prefix + (highestLayerNb + 1);
	}

	public boolean hasAlpha() {
		return fusion.hasAlpha();
	}

	// ////////////////////////////////////////////////////
	// Undo classes

	class CPUndoPaint extends CPUndo {

		int layer;
		CPRect rect;
		int[] data;

		public CPUndoPaint() {
			layer = getActiveLayerNb();
			rect = new CPRect(undoArea);

			data = undoBuffer.copyRectXOR(curLayer, rect);
			undoArea.makeEmpty();
		}

		public void undo() {
			getLayer(layer).setRectXOR(data, rect);
			invalidateFusion(rect);
		}

		public void redo() {
			getLayer(layer).setRectXOR(data, rect);
			invalidateFusion(rect);
		}

		public long getMemoryUsed(boolean undone, Object param) {
			return data.length * 4;
		}
	}

	class CPUndoLayerVisible extends CPUndo {

		int layer;
		boolean oldVis, newVis;

		public CPUndoLayerVisible(int layer, boolean oldVis, boolean newVis) {
			this.layer = layer;
			this.oldVis = oldVis;
			this.newVis = newVis;
		}

		public void redo() {
			getLayer(layer).visible = newVis;
			invalidateFusion();
			callListenersLayerChange();
		}

		public void undo() {
			getLayer(layer).visible = oldVis;
			invalidateFusion();
			callListenersLayerChange();
		}

		public boolean merge(CPUndo u) {
			if (u instanceof CPUndoLayerVisible && layer == ((CPUndoLayerVisible) u).layer) {
				newVis = ((CPUndoLayerVisible) u).newVis;
				return true;
			}
			return false;
		}

		public boolean noChange() {
			return oldVis == newVis;
		}
	}

	class CPUndoAddLayer extends CPUndo {

		int layer;

		public CPUndoAddLayer(int layer) {
			this.layer = layer;
		}

		public void undo() {
			layers.remove(layer + 1);
			setActiveLayer(layer);
			invalidateFusion();
			callListenersLayerChange();
		}

		public void redo() {
			CPLayer newLayer = new CPLayer(width, height);
			newLayer.name = getDefaultLayerName();
			layers.add(layer + 1, newLayer);

			setActiveLayer(layer + 1);
			invalidateFusion();
			callListenersLayerChange();
		}
	}

	class CPUndoDuplicateLayer extends CPUndo {

		int layer;

		public CPUndoDuplicateLayer(int layer) {
			this.layer = layer;
		}

		public void undo() {
			layers.remove(layer + 1);
			setActiveLayer(layer);
			invalidateFusion();
			callListenersLayerChange();
		}

		public void redo() {
			String copySuffix = " Copy";

			CPLayer newLayer = new CPLayer(width, height);
			newLayer.copyFrom(layers.elementAt(layer));
			if (!newLayer.name.endsWith(copySuffix)) {
				newLayer.name += copySuffix;
			}
			layers.add(layer + 1, newLayer);

			setActiveLayer(layer + 1);
			invalidateFusion();
			callListenersLayerChange();
		}
	}

	class CPUndoRemoveLayer extends CPUndo {

		int layer;
		CPLayer layerObj;

		public CPUndoRemoveLayer(int layer, CPLayer layerObj) {
			this.layer = layer;
			this.layerObj = layerObj;
		}

		public void undo() {
			layers.add(layer, layerObj);
			setActiveLayer(layer);
			invalidateFusion();
			callListenersLayerChange();
		}

		public void redo() {
			layers.remove(layer);
			setActiveLayer(layer < layers.size() ? layer : layer - 1);
			invalidateFusion();
			callListenersLayerChange();
		}

		public long getMemoryUsed(boolean undone, Object param) {
			return undone ? 0 : width * height * 4;
		}

	}

	class CPUndoMergeDownLayer extends CPUndo {

		int layer;
		CPLayer layerBottom, layerTop;

		public CPUndoMergeDownLayer(int layer) {
			this.layer = layer;
			layerBottom = new CPLayer(width, height);
			layerBottom.copyFrom(layers.elementAt(layer - 1));
			layerTop = layers.elementAt(layer);
		}

		public void undo() {
			layers.elementAt(layer - 1).copyFrom(layerBottom);
			layers.add(layer, layerTop);
			setActiveLayer(layer);

			layerBottom = layerTop = null;

			invalidateFusion();
			callListenersLayerChange();
		}

		public void redo() {
			layerBottom = new CPLayer(width, height);
			layerBottom.copyFrom(layers.elementAt(layer - 1));
			layerTop = layers.elementAt(layer);

			setActiveLayer(layer);
			mergeDown(false);
		}

		public long getMemoryUsed(boolean undone, Object param) {
			return undone ? 0 : width * height * 4 * 2;
		}
	}

	class CPUndoMergeAllLayers extends CPUndo {

		Vector<CPLayer> oldLayers;
		int oldActiveLayer;

		public CPUndoMergeAllLayers() {
			oldLayers = (Vector<CPLayer>) layers.clone();
			oldActiveLayer = getActiveLayerNb();
		}

		public void undo() {
			layers = (Vector<CPLayer>) oldLayers.clone();
			setActiveLayer(oldActiveLayer);

			invalidateFusion();
			callListenersLayerChange();
		}

		public void redo() {
			mergeAllLayers(false);
		}

		public long getMemoryUsed(boolean undone, Object param) {
			return undone ? 0 : oldLayers.size() * width * height * 4;
		}
	}

	class CPUndoMoveLayer extends CPUndo {

		int from, to;

		public CPUndoMoveLayer(int from, int to) {
			this.from = from;
			this.to = to;
		}

		public void undo() {
			if (to <= from) {
				moveLayerReal(to, from + 1);
			} else {
				moveLayerReal(to - 1, from);
			}
		}

		public void redo() {
			moveLayerReal(from, to);
		}
	}

	class CPUndoLayerAlpha extends CPUndo {

		int layer;
		int from, to;

		public CPUndoLayerAlpha(int layer, int alpha) {
			this.from = getLayer(layer).getAlpha();
			this.to = alpha;
			this.layer = layer;
		}

		public void undo() {
			getLayer(layer).setAlpha(from);
			invalidateFusion();
			callListenersLayerChange();
		}

		public void redo() {
			getLayer(layer).setAlpha(to);
			invalidateFusion();
			callListenersLayerChange();
		}

		public boolean merge(CPUndo u) {
			if (u instanceof CPUndoLayerAlpha && layer == ((CPUndoLayerAlpha) u).layer) {
				to = ((CPUndoLayerAlpha) u).to;
				return true;
			}
			return false;
		}

		public boolean noChange() {
			return from == to;
		}
	}

	class CPUndoLayerMode extends CPUndo {

		int layer;
		int from, to;

		public CPUndoLayerMode(int layer, int mode) {
			this.from = getLayer(layer).getBlendMode();
			this.to = mode;
			this.layer = layer;
		}

		public void undo() {
			getLayer(layer).setBlendMode(from);
			invalidateFusion();
			callListenersLayerChange();
		}

		public void redo() {
			getLayer(layer).setBlendMode(to);
			invalidateFusion();
			callListenersLayerChange();
		}

		public boolean merge(CPUndo u) {
			if (u instanceof CPUndoLayerMode && layer == ((CPUndoLayerMode) u).layer) {
				to = ((CPUndoLayerMode) u).to;
				return true;
			}
			return false;
		}

		public boolean noChange() {
			return from == to;
		}
	}

	class CPUndoLayerRename extends CPUndo {

		int layer;
		String from, to;

		public CPUndoLayerRename(int layer, String name) {
			this.from = getLayer(layer).name;
			this.to = name;
			this.layer = layer;
		}

		public void undo() {
			getLayer(layer).name = from;
			callListenersLayerChange();
		}

		public void redo() {
			getLayer(layer).name = to;
			callListenersLayerChange();
		}

		public boolean merge(CPUndo u) {
			if (u instanceof CPUndoLayerRename && layer == ((CPUndoLayerRename) u).layer) {
				to = ((CPUndoLayerRename) u).to;
				return true;
			}
			return false;
		}

		public boolean noChange() {
			return from.equals(to);
		}
	}

	class CPUndoRectangleSelection extends CPUndo {

		CPRect from, to;

		public CPUndoRectangleSelection(CPRect from, CPRect to) {
			this.from = (CPRect) from.clone();
			this.to = (CPRect) to.clone();
		}

		public void undo() {
			setSelection(from);
		}

		public void redo() {
			setSelection(to);
		}

		public boolean merge(CPUndo u) {
			return false;
		}

		public boolean noChange() {
			return from.equals(to);
		}
	}

	// used to encapsulate multiple undo operation as one
	class CPMultiUndo extends CPUndo {

		CPUndo[] undoes;

		public CPMultiUndo(CPUndo[] undoes) {
			this.undoes = undoes;
		}

		public void undo() {
			for (int i = undoes.length - 1; i >= 0; i--) {
				undoes[i].undo();
			}
		}

		public void redo() {
			for (int i = 0; i < undoes.length; i++) {
				undoes[i].redo();
			}
		}

		public boolean merge(CPUndo u) {
			return false;
		}

		public boolean noChange() {
			boolean noChange = true;
			for (int i = 0; i < undoes.length; i++) {
				noChange = noChange && undoes[i].noChange();
			}
			return noChange;
		}

		public long getMemoryUsed(boolean undone, Object param) {
			long total = 0;
			for (CPUndo undo : undoes) {
				total += undo.getMemoryUsed(undone, param);
			}
			return total;
		}
	}

	class CPUndoCut extends CPUndo {

		CPColorBmp bmp;
		int x, y, layer;
		CPRect selection;

		public CPUndoCut(CPColorBmp bmp, int x, int y, int layerNb, CPRect selection) {
			this.bmp = bmp;
			this.x = x;
			this.y = y;
			this.layer = layerNb;
			this.selection = (CPRect) selection.clone();
		}

		public void undo() {
			setActiveLayer(layer);
			curLayer.pasteBitmap(clipboard.bmp, x, y);
			setSelection(selection);
			invalidateFusion();
		}

		public void redo() {
			setActiveLayer(layer);
			CPRect r = bmp.getSize();
			r.translate(x, y);
			curLayer.clear(r, 0);
			emptySelection();
			invalidateFusion();
		}

		public long getMemoryUsed(boolean undone, Object param) {
			return bmp == param ? 0 : bmp.width * bmp.height * 4;
		}
	}

	class CPUndoPaste extends CPUndo {

		CPClip clip;
		int layer;
		CPRect selection;

		public CPUndoPaste(CPClip clip, int layerNb, CPRect selection) {
			this.clip = clip;
			this.layer = layerNb;
			this.selection = (CPRect) selection.clone();
		}

		public void undo() {
			layers.remove(layer + 1);
			setActiveLayer(layer);
			setSelection(selection);

			invalidateFusion();
			callListenersLayerChange();
		}

		public void redo() {
			setActiveLayer(layer);
			pasteClip(false, clip);
		}

		public long getMemoryUsed(boolean undone, Object param) {
			return clip.bmp == param ? 0 : clip.bmp.width * clip.bmp.height * 4;
		}

	}

}