/ Design Patterns / Behavioral Patterns
Also known as: Snapshot
Intent
Memento is a behavioral design pattern that lets you save and restore the previous state of an object without revealing the details of its implementation.
Problem
Imagine that you’re creating a text editor app. In addition to simple text editing, your editor can format text, insert inline images, etc.
At some point, you decided to let users undo any operations carried out on the text. This feature has become so common over the years that nowadays people expect every app to have it. For the implementation, you chose to take the direct approach. Before performing any operation, the app records the state of all objects and saves it in some storage. Later, when a user decides to revert an action, the app fetches the latest snapshot from the history and uses it to restore the state of all objects.
Before executing an operation, the app saves a snapshot of the objects’ state, which can later be used to restore objects to their previous state.
Let’s think about those state snapshots. How exactly would you produce one? You’d probably need to go over all the fields in an object and copy their values into storage. However, this would only work if the object had quite relaxed access restrictions to its contents. Unfortunately, most real objects won’t let others peek inside them that easily, hiding all significant data in private fields.
Ignore that problem for now and let’s assume that our objects behave like hippies: preferring open relations and keeping their state public. While this approach would solve the immediate problem and let you produce snapshots of objects’ states at will, it still has some serious issues. In the future, you might decide to refactor some of the editor classes, or add or remove some of the fields. Sounds easy, but this would also require chaining the classes responsible for copying the state of the affected objects.
How to make a copy of the object’s private state?
But there’s more. Let’s consider the actual “snapshots” of the editor’s state. What data does it contain? At a bare minimum, it must contain the actual text, cursor coordinates, current scroll position, etc. To make a snapshot, you’d need to collect these values and put them into some kind of container.
Most likely, you’re going to store lots of these container objects inside some list that would represent the history. Therefore the containers would probably end up being objects of one class. The class would have almost no methods, but lots of fields that mirror the editor’s state. To allow other objects to write and read data to and from a snapshot, you’d probably need to make its fields public. That would expose all the editor’s states, private or not. Other classes would become dependent on every little change to the snapshot class, which would otherwise happen within private fields and methods without affecting outer classes.
It looks like we’ve reached a dead end: you either expose all internal details of classes, making them too fragile, or restrict access to their state, making it impossible to produce snapshots. Is there any other way to implement the “undo”?
Solution
All problems that we’ve just experienced are caused by broken encapsulation. Some objects try to do more than they are supposed to. To collect the data required to perform some action, they invade the private space of other objects instead of letting these objects perform the actual action.
The Memento pattern delegates creating the state snapshots to the actual owner of that state, the originator object. Hence, instead of other objects trying to copy the editor’s state from the “outside,” the editor class itself can make the snapshot since it has full access to its own state.
The pattern suggests storing the copy of the object’s state in a special object called memento. The contents of the memento aren’t accessible to any other object except the one that produced it. Other objects must communicate with mementos using a limited interface which may allow fetching the snapshot’s metadata (creation time, the name of the performed operation, etc.), but not the original object’s state contained in the snapshot.
The originator has full access to the memento, whereas the caretaker can only access the metadata.
Such a restrictive policy lets you store mementos inside other objects, usually called caretakers. Since the caretaker works with the memento only via the limited interface, it’s not able to tamper with the state stored inside the memento. At the same time, the originator has access to all fields inside the memento, allowing it to restore its previous state at will.
In our text editor example, we can create a separate history class to act as the caretaker. A stack of mementos stored inside the caretaker will grow each time the editor is about to execute an operation. You could even render this stack within the app’s UI, displaying the history of previously performed operations to a user.
When a user triggers the undo, the history grabs the most recent memento from the stack and passes it back to the editor, requesting a roll-back. Since the editor has full access to the memento, it changes its own state with the values taken from the memento.
Structure
Implementation based on nested classes
The classic implementation of the pattern relies on support for nested classes, available in many popular programming languages (such as C++, C#, and Java).
-
The Originator class can produce snapshots of its own state, as well as restore its state from snapshots when needed.
-
The Memento is a value object that acts as a snapshot of the originator’s state. It’s a common practice to make the memento immutable and pass it the data only once, via the constructor.
-
The Caretaker knows not only “when” and “why” to capture the originator’s state, but also when the state should be restored.
A caretaker can keep track of the originator’s history by storing a stack of mementos. When the originator has to travel back in history, the caretaker fetches the topmost memento from the stack and passes it to the originator’s restoration method.
-
In this implementation, the memento class is nested inside the originator. This lets the originator access the fields and methods of the memento, even though they’re declared private. On the other hand, the caretaker has very limited access to the memento’s fields and methods, which lets it store mementos in a stack but not tamper with their state.
Implementation based on an intermediate interface
There’s an alternative implementation, suitable for programming languages that don’t support nested classes (yeah, PHP, I’m talking about you).
-
In the absence of nested classes, you can restrict access to the memento’s fields by establishing a convention that caretakers can work with a memento only through an explicitly declared intermediary interface, which would only declare methods related to the memento’s metadata.
-
On the other hand, originators can work with a memento object directly, accessing fields and methods declared in the memento class. The downside of this approach is that you need to declare all members of the memento public.
Implementation with even stricter encapsulation
There’s another implementation which is useful when you don’t want to leave even the slightest chance of other classes accessing the state of the originator through the memento.
-
This implementation allows having multiple types of originators and mementos. Each originator works with a corresponding memento class. Neither originators nor mementos expose their state to anyone.
-
Caretakers are now explicitly restricted from changing the state stored in mementos. Moreover, the caretaker class becomes independent from the originator because the restoration method is now defined in the memento class.
-
Each memento becomes linked to the originator that produced it. The originator passes itself to the memento’s constructor, along with the values of its state. Thanks to the close relationship between these classes, a memento can restore the state of its originator, given that the latter has defined the appropriate setters.
Pseudocode
In this example uses the Memento pattern alongside the Command pattern for storing snapshots of the complex text editor’s state and restoring an earlier state from these snapshots when needed.
Saving snapshots of the text editor’s state.
The command objects act as caretakers. They fetch the editor’s memento before executing operations related to commands. When a user attempts to undo the most recent command, the editor can use the memento stored in that command to revert itself to the previous state.
The memento class doesn’t declare any public fields, getters or setters. Therefore no object can alter its contents. Mementos are linked to the editor object that created them. This lets a memento restore the linked editor’s state by passing the data via setters on the editor object. Since mementos are linked to specific editor objects, you can make your app support several independent editor windows with a centralized undo stack.
// The originator holds some important data that may change over
// time. It also defines a method for saving its state inside a
// memento and another method for restoring the state from it.
class Editor is
private field text, curX, curY, selectionWidth
method setText(text) is
this.text = text
method setCursor(x, y) is
this.curX = curX
this.curY = curY
method setSelectionWidth(width) is
this.selectionWidth = width
// Saves the current state inside a memento.
method createSnapshot():Snapshot is
// Memento is an immutable object; that's why the
// originator passes its state to the memento's
// constructor parameters.
return new Snapshot(this, text, curX, curY, selectionWidth)
// The memento class stores the past state of the editor.
class Snapshot is
private field editor: Editor
private field text, curX, curY, selectionWidth
constructor Snapshot(editor, text, curX, curY, selectionWidth) is
this.editor = editor
this.text = text
this.curX = curX
this.curY = curY
this.selectionWidth = selectionWidth
// At some point, a previous state of the editor can be
// restored using a memento object.
method restore() is
editor.setText(text)
editor.setCursor(curX, curY)
editor.setSelectionWidth(selectionWidth)
// A command object can act as a caretaker. In that case, the
// command gets a memento just before it changes the
// originator's state. When undo is requested, it restores the
// originator's state from a memento.
class Command is
private field backup: Snapshot
method makeBackup() is
backup = editor.createSnapshot()
method undo() is
if (backup != null)
backup.restore()
// ...
Applicability
Use the Memento pattern when you want to produce snapshots of the object’s state to be able to restore a previous state of the object.
The Memento pattern lets you make full copies of an object’s state, including private fields, and store them separately from the object. While most people remember this pattern thanks to the “undo” use case, it’s also indispensable when dealing with transactions (i.e., if you need to roll back an operation on error).
Use the pattern when direct access to the object’s fields/getters/setters violates its encapsulation.
The Memento makes the object itself responsible for creating a snapshot of its state. No other object can read the snapshot, making the original object’s state data safe and secure.
How to Implement
-
Determine what class will play the role of the originator. It’s important to know whether the program uses one central object of this type or multiple smaller ones.
-
Create the memento class. One by one, declare a set of fields that mirror the fields declared inside the originator class.
-
Make the memento class immutable. A memento should accept the data just once, via the constructor. The class should have no setters.
-
If your programming language supports nested classes, nest the memento inside the originator. If not, extract a blank interface from the memento class and make all other objects use it to refer to the memento. You may add some metadata operations to the interface, but nothing that exposes the originator’s state.
-
Add a method for producing mementos to the originator class. The originator should pass its state to the memento via one or multiple arguments of the memento’s constructor.
The return type of the method should be of the interface you extracted in the previous step (assuming that you extracted it at all). Under the hood, the memento-producing method should work directly with the memento class.
-
Add a method for restoring the originator’s state to its class. It should accept a memento object as an argument. If you extracted an interface in the previous step, make it the type of the parameter. In this case, you need to typecast the incoming object to the mediator class, since the originator needs full access to that object.
-
The caretaker, whether it represents a command object, a history, or something entirely different, should know when to request new mementos from the originator, how to store them and when to restore the originator with a particular memento.
-
The link between caretakers and originators may be moved into the memento class. In this case, each memento must be connected to the originator that had created it. The restoration method would also move to the memento class. However, this would all make sense only if the memento class is nested into originator or the originator class provides sufficient setters for overriding its state.
Pros and Cons
- You can produce snapshots of the object’s state without violating its encapsulation.
-
You can simplify the originator’s code by letting the caretaker maintain the history of the originator’s state.
- The app might consume lots of RAM if clients create mementos too often.
- Caretakers should track the originator’s lifecycle to be able to destroy obsolete mementos.
- Most dynamic programming languages, such as PHP, Python and JavaScript, can’t guarantee that the state within the memento stays untouched.
Relations with Other Patterns
-
You can use Command and Memento together when implementing “undo”. In this case, commands are responsible for performing various operations over a target object, while mementos save the state of that object just before a command gets executed.
-
You can use Memento along with Iterator to capture the current iteration state and roll it back if necessary.
-
Sometimes Prototype can be a simpler alternative to Memento. This works if the object, the state of which you want to store in the history, is fairly straightforward and doesn’t have links to external resources, or the links are easy to re-establish.
Code Example
Memento is a behavioral design pattern that allows making snapshots of an object’s state and restoring it in future.
The Memento doesn’t compromise the internal structure of the object it works with, as well as data kept inside the snapshots.
Usage of the pattern in Java
Complexity:
Popularity:
Usage examples: The Memento’s principle can be achieved using the serialization, which is quite common in Java. While it’s not the only and the most efficient way to make snapshots of an object’s state, it still allows storing state backups while protecting the originator’s structure from other objects.
Here are some examples of the pattern in core Java libraries:
- All
java.io.Serializableimplementations can simulate the Memento. - All
javax.faces.component.StateHolderimplementations.
Shape editor and complex undo/redo
This graphical editor allows changing the color and position of the shapes on the screen. Any modification can be undone and repeated, though.
The “undo” is based on the collaboration between the Memento and Command patterns. The editor tracks a history of performed commands. Before executing any command, it makes a backup and connects it to the command object. After the execution, it pushes the executed command into history.
When a user requests the undo, the editor fetches a recent command from the history and restores the state from the backup kept inside that command. If the user requests another undo, the editor takes a following command from the history and so on.
Reverted commands are kept in history until the user makes some modifications to the shapes on the screen. This is crucial for redoing undone commands.
editor
editor/Editor.java: Editor code
package algamza.memento.example.editor;
import algamza.memento.example.commands.Command;
import algamza.memento.example.history.History;
import algamza.memento.example.history.Memento;
import algamza.memento.example.shapes.CompoundShape;
import algamza.memento.example.shapes.Shape;
import javax.swing.*;
import java.io.*;
import java.util.Base64;
public class Editor extends JComponent {
private Canvas canvas;
private CompoundShape allShapes = new CompoundShape();
private History history;
public Editor() {
canvas = new Canvas(this);
history = new History();
}
public void loadShapes(Shape... shapes) {
allShapes.clear();
allShapes.add(shapes);
canvas.refresh();
}
public CompoundShape getShapes() {
return allShapes;
}
public void execute(Command c) {
history.push(c, new Memento(this));
c.execute();
}
public void undo() {
if (history.undo())
canvas.repaint();
}
public void redo() {
if (history.redo())
canvas.repaint();
}
public String backup() {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this.allShapes);
oos.close();
return Base64.getEncoder().encodeToString(baos.toByteArray());
} catch (IOException e) {
return "";
}
}
public void restore(String state) {
try {
byte[] data = Base64.getDecoder().decode(state);
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(data));
this.allShapes = (CompoundShape) ois.readObject();
ois.close();
} catch (ClassNotFoundException e) {
System.out.print("ClassNotFoundException occurred.");
} catch (IOException e) {
System.out.print("IOException occurred.");
}
}
}
editor/Canvas.java: Canvas code
package algamza.memento.example.editor;
import algamza.memento.example.commands.ColorCommand;
import algamza.memento.example.commands.MoveCommand;
import algamza.memento.example.shapes.Shape;
import javax.swing.*;
import javax.swing.border.Border;
import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
class Canvas extends java.awt.Canvas {
private Editor editor;
private JFrame frame;
private static final int PADDING = 10;
Canvas(Editor editor) {
this.editor = editor;
createFrame();
attachKeyboardListeners();
attachMouseListeners();
refresh();
}
private void createFrame() {
frame = new JFrame();
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
frame.setLocationRelativeTo(null);
JPanel contentPanel = new JPanel();
Border padding = BorderFactory.createEmptyBorder(PADDING, PADDING, PADDING, PADDING);
contentPanel.setBorder(padding);
contentPanel.setLayout(new BoxLayout(contentPanel, BoxLayout.Y_AXIS));
frame.setContentPane(contentPanel);
contentPanel.add(new JLabel("Select and drag to move."), BorderLayout.PAGE_END);
contentPanel.add(new JLabel("Right click to change color."), BorderLayout.PAGE_END);
contentPanel.add(new JLabel("Undo: Ctrl+Z, Redo: Ctrl+R"), BorderLayout.PAGE_END);
contentPanel.add(this);
frame.setVisible(true);
contentPanel.setBackground(Color.LIGHT_GRAY);
}
private void attachKeyboardListeners() {
addKeyListener(new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
if ((e.getModifiers() & KeyEvent.CTRL_MASK) != 0) {
switch (e.getKeyCode()) {
case KeyEvent.VK_Z:
editor.undo();
break;
case KeyEvent.VK_R:
editor.redo();
break;
}
}
}
});
}
private void attachMouseListeners() {
MouseAdapter colorizer = new MouseAdapter() {
@Override
public void mousePressed(MouseEvent e) {
if (e.getButton() != MouseEvent.BUTTON3) {
return;
}
Shape target = editor.getShapes().getChildAt(e.getX(), e.getY());
if (target != null) {
editor.execute(new ColorCommand(editor, new Color((int) (Math.random() * 0x1000000))));
repaint();
}
}
};
addMouseListener(colorizer);
MouseAdapter selector = new MouseAdapter() {
@Override
public void mousePressed(MouseEvent e) {
if (e.getButton() != MouseEvent.BUTTON1) {
return;
}
Shape target = editor.getShapes().getChildAt(e.getX(), e.getY());
boolean ctrl = (e.getModifiers() & ActionEvent.CTRL_MASK) == ActionEvent.CTRL_MASK;
if (target == null) {
if (!ctrl) {
editor.getShapes().unSelect();
}
} else {
if (ctrl) {
if (target.isSelected()) {
target.unSelect();
} else {
target.select();
}
} else {
if (!target.isSelected()) {
editor.getShapes().unSelect();
}
target.select();
}
}
repaint();
}
};
addMouseListener(selector);
MouseAdapter dragger = new MouseAdapter() {
MoveCommand moveCommand;
@Override
public void mouseDragged(MouseEvent e) {
if ((e.getModifiersEx() & MouseEvent.BUTTON1_DOWN_MASK) != MouseEvent.BUTTON1_DOWN_MASK) {
return;
}
if (moveCommand == null) {
moveCommand = new MoveCommand(editor);
moveCommand.start(e.getX(), e.getY());
}
moveCommand.move(e.getX(), e.getY());
repaint();
}
@Override
public void mouseReleased(MouseEvent e) {
if (e.getButton() != MouseEvent.BUTTON1 || moveCommand == null) {
return;
}
moveCommand.stop(e.getX(), e.getY());
editor.execute(moveCommand);
this.moveCommand = null;
repaint();
}
};
addMouseListener(dragger);
addMouseMotionListener(dragger);
}
public int getWidth() {
return editor.getShapes().getX() + editor.getShapes().getWidth() + PADDING;
}
public int getHeight() {
return editor.getShapes().getY() + editor.getShapes().getHeight() + PADDING;
}
void refresh() {
this.setSize(getWidth(), getHeight());
frame.pack();
}
public void update(Graphics g) {
paint(g);
}
public void paint(Graphics graphics) {
BufferedImage buffer = new BufferedImage(this.getWidth(), this.getHeight(), BufferedImage.TYPE_INT_RGB);
Graphics2D ig2 = buffer.createGraphics();
ig2.setBackground(Color.WHITE);
ig2.clearRect(0, 0, this.getWidth(), this.getHeight());
editor.getShapes().paint(buffer.getGraphics());
graphics.drawImage(buffer, 0, 0, null);
}
}
history
history/History.java: History stores commands and mementos
package algamza.memento.example.history;
import algamza.memento.example.commands.Command;
import java.util.ArrayList;
import java.util.List;
public class History {
private List<Pair> history = new ArrayList<Pair>();
private int virtualSize = 0;
private class Pair {
Command command;
Memento memento;
Pair(Command c, Memento m) {
command = c;
memento = m;
}
private Command getCommand() {
return command;
}
private Memento getMemento() {
return memento;
}
}
public void push(Command c, Memento m) {
if (virtualSize != history.size() && virtualSize > 0) {
history = history.subList(0, virtualSize - 1);
}
history.add(new Pair(c, m));
virtualSize = history.size();
}
public boolean undo() {
Pair pair = getUndo();
if (pair == null) {
return false;
}
System.out.println("Undoing: " + pair.getCommand().getName());
pair.getMemento().restore();
return true;
}
public boolean redo() {
Pair pair = getRedo();
if (pair == null) {
return false;
}
System.out.println("Redoing: " + pair.getCommand().getName());
pair.getMemento().restore();
pair.getCommand().execute();
return true;
}
private Pair getUndo() {
if (virtualSize == 0) {
return null;
}
virtualSize = Math.max(0, virtualSize - 1);
return history.get(virtualSize);
}
private Pair getRedo() {
if (virtualSize == history.size()) {
return null;
}
virtualSize = Math.min(history.size(), virtualSize + 1);
return history.get(virtualSize - 1);
}
}
history/Memento.java: Memento class
package algamza.memento.example.history;
import algamza.memento.example.editor.Editor;
public class Memento {
private String backup;
private Editor editor;
public Memento(Editor editor) {
this.editor = editor;
this.backup = editor.backup();
}
public void restore() {
editor.restore(backup);
}
}
commands
commands/Command.java: Base command class
package algamza.memento.example.commands;
public interface Command {
String getName();
void execute();
}
commands/ColorCommand.java: Changes color of selected shape
package algamza.memento.example.commands;
import algamza.memento.example.editor.Editor;
import algamza.memento.example.shapes.Shape;
import java.awt.*;
public class ColorCommand implements Command {
private Editor editor;
private Color color;
public ColorCommand(Editor editor, Color color) {
this.editor = editor;
this.color = color;
}
@Override
public String getName() {
return "Colorize: " + color.toString();
}
@Override
public void execute() {
for (Shape child : editor.getShapes().getSelected()) {
child.setColor(color);
}
}
}
commands/MoveCommand.java: Moves selected shape
package algamza.memento.example.commands;
import algamza.memento.example.editor.Editor;
import algamza.memento.example.shapes.Shape;
public class MoveCommand implements Command {
private Editor editor;
private int startX, startY;
private int endX, endY;
public MoveCommand(Editor editor) {
this.editor = editor;
}
@Override
public String getName() {
return "Move by X:" + (endX - startX) + " Y:" + (endY - startY);
}
public void start(int x, int y) {
startX = x;
startY = y;
for (Shape child : editor.getShapes().getSelected()) {
child.drag();
}
}
public void move(int x, int y) {
for (Shape child : editor.getShapes().getSelected()) {
child.moveTo(x - startX, y - startY);
}
}
public void stop(int x, int y) {
endX = x;
endY = y;
for (Shape child : editor.getShapes().getSelected()) {
child.drop();
}
}
@Override
public void execute() {
for (Shape child : editor.getShapes().getSelected()) {
child.moveBy(endX - startX, endY - startY);
}
}
}
shapes: Various shapes
shapes/Shape.java
package algamza.memento.example.shapes;
import java.awt.*;
import java.io.Serializable;
public interface Shape extends Serializable {
int getX();
int getY();
int getWidth();
int getHeight();
void drag();
void drop();
void moveTo(int x, int y);
void moveBy(int x, int y);
boolean isInsideBounds(int x, int y);
Color getColor();
void setColor(Color color);
void select();
void unSelect();
boolean isSelected();
void paint(Graphics graphics);
}
shapes/BaseShape.java
package algamza.memento.example.shapes;
import java.awt.*;
public abstract class BaseShape implements Shape {
int x, y;
private int dx = 0, dy = 0;
private Color color;
private boolean selected = false;
BaseShape(int x, int y, Color color) {
this.x = x;
this.y = y;
this.color = color;
}
@Override
public int getX() {
return x;
}
@Override
public int getY() {
return y;
}
@Override
public int getWidth() {
return 0;
}
@Override
public int getHeight() {
return 0;
}
@Override
public void drag() {
dx = x;
dy = y;
}
@Override
public void moveTo(int x, int y) {
this.x = dx + x;
this.y = dy + y;
}
@Override
public void moveBy(int x, int y) {
this.x += x;
this.y += y;
}
@Override
public void drop() {
this.x = dx;
this.y = dy;
}
@Override
public boolean isInsideBounds(int x, int y) {
return x > getX() && x < (getX() + getWidth()) &&
y > getY() && y < (getY() + getHeight());
}
@Override
public Color getColor() {
return color;
}
@Override
public void setColor(Color color) {
this.color = color;
}
@Override
public void select() {
selected = true;
}
@Override
public void unSelect() {
selected = false;
}
@Override
public boolean isSelected() {
return selected;
}
void enableSelectionStyle(Graphics graphics) {
graphics.setColor(Color.LIGHT_GRAY);
Graphics2D g2 = (Graphics2D) graphics;
float dash1[] = {2.0f};
g2.setStroke(new BasicStroke(1.0f,
BasicStroke.CAP_BUTT,
BasicStroke.JOIN_MITER,
2.0f, dash1, 0.0f));
}
void disableSelectionStyle(Graphics graphics) {
graphics.setColor(color);
Graphics2D g2 = (Graphics2D) graphics;
g2.setStroke(new BasicStroke());
}
@Override
public void paint(Graphics graphics) {
if (isSelected()) {
enableSelectionStyle(graphics);
}
else {
disableSelectionStyle(graphics);
}
// ...
}
}
shapes/Circle.java
package algamza.memento.example.shapes;
import java.awt.*;
public class Circle extends BaseShape {
private int radius;
public Circle(int x, int y, int radius, Color color) {
super(x, y, color);
this.radius = radius;
}
@Override
public int getWidth() {
return radius * 2;
}
@Override
public int getHeight() {
return radius * 2;
}
@Override
public void paint(Graphics graphics) {
super.paint(graphics);
graphics.drawOval(x, y, getWidth() - 1, getHeight() - 1);
}
}
shapes/Dot.java
package algamza.memento.example.shapes;
import java.awt.*;
public class Dot extends BaseShape {
private final int DOT_SIZE = 3;
public Dot(int x, int y, Color color) {
super(x, y, color);
}
@Override
public int getWidth() {
return DOT_SIZE;
}
@Override
public int getHeight() {
return DOT_SIZE;
}
@Override
public void paint(Graphics graphics) {
super.paint(graphics);
graphics.fillRect(x - 1, y - 1, getWidth(), getHeight());
}
}
shapes/Rectangle.java
package algamza.memento.example.shapes;
import java.awt.*;
public class Rectangle extends BaseShape {
private int width;
private int height;
public Rectangle(int x, int y, int width, int height, Color color) {
super(x, y, color);
this.width = width;
this.height = height;
}
@Override
public int getWidth() {
return width;
}
@Override
public int getHeight() {
return height;
}
@Override
public void paint(Graphics graphics) {
super.paint(graphics);
graphics.drawRect(x, y, getWidth() - 1, getHeight() - 1);
}
}
shapes/CompoundShape.java
package algamza.memento.example.shapes;
import java.awt.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class CompoundShape extends BaseShape {
private List<Shape> children = new ArrayList<>();
public CompoundShape(Shape... components) {
super(0, 0, Color.BLACK);
add(components);
}
public void add(Shape component) {
children.add(component);
}
public void add(Shape... components) {
children.addAll(Arrays.asList(components));
}
public void remove(Shape child) {
children.remove(child);
}
public void remove(Shape... components) {
children.removeAll(Arrays.asList(components));
}
public void clear() {
children.clear();
}
@Override
public int getX() {
if (children.size() == 0) {
return 0;
}
int x = children.get(0).getX();
for (Shape child : children) {
if (child.getX() < x) {
x = child.getX();
}
}
return x;
}
@Override
public int getY() {
if (children.size() == 0) {
return 0;
}
int y = children.get(0).getY();
for (Shape child : children) {
if (child.getY() < y) {
y = child.getY();
}
}
return y;
}
@Override
public int getWidth() {
int maxWidth = 0;
int x = getX();
for (Shape child : children) {
int childsRelativeX = child.getX() - x;
int childWidth = childsRelativeX + child.getWidth();
if (childWidth > maxWidth) {
maxWidth = childWidth;
}
}
return maxWidth;
}
@Override
public int getHeight() {
int maxHeight = 0;
int y = getY();
for (Shape child : children) {
int childsRelativeY = child.getY() - y;
int childHeight = childsRelativeY + child.getHeight();
if (childHeight > maxHeight) {
maxHeight = childHeight;
}
}
return maxHeight;
}
@Override
public void drag() {
for (Shape child : children) {
child.drag();
}
}
@Override
public void drop() {
for (Shape child : children) {
child.drop();
}
}
@Override
public void moveTo(int x, int y) {
for (Shape child : children) {
child.moveTo(x, y);
}
}
@Override
public void moveBy(int x, int y) {
for (Shape child : children) {
child.moveBy(x, y);
}
}
@Override
public boolean isInsideBounds(int x, int y) {
for (Shape child : children) {
if (child.isInsideBounds(x, y)) {
return true;
}
}
return false;
}
@Override
public void setColor(Color color) {
super.setColor(color);
for (Shape child : children) {
child.setColor(color);
}
}
@Override
public void unSelect() {
super.unSelect();
for (Shape child : children) {
child.unSelect();
}
}
public Shape getChildAt(int x, int y) {
for (Shape child : children) {
if (child.isInsideBounds(x, y)) {
return child;
}
}
return null;
}
public boolean selectChildAt(int x, int y) {
Shape child = getChildAt(x,y);
if (child != null) {
child.select();
return true;
}
return false;
}
public List<Shape> getSelected() {
List<Shape> selected = new ArrayList<>();
for (Shape child : children) {
if (child.isSelected()) {
selected.add(child);
}
}
return selected;
}
@Override
public void paint(Graphics graphics) {
if (isSelected()) {
enableSelectionStyle(graphics);
graphics.drawRect(getX() - 1, getY() - 1, getWidth() + 1, getHeight() + 1);
disableSelectionStyle(graphics);
}
for (Shape child : children) {
child.paint(graphics);
}
}
}
Demo.java: Initialization code
package algamza.memento.example;
import algamza.memento.example.editor.Editor;
import algamza.memento.example.shapes.Circle;
import algamza.memento.example.shapes.CompoundShape;
import algamza.memento.example.shapes.Dot;
import algamza.memento.example.shapes.Rectangle;
import java.awt.*;
public class Demo {
public static void main(String[] args) {
Editor editor = new Editor();
editor.loadShapes(
new Circle(10, 10, 10, Color.BLUE),
new CompoundShape(
new Circle(110, 110, 50, Color.RED),
new Dot(160, 160, Color.RED)
),
new CompoundShape(
new Rectangle(250, 250, 100, 100, Color.GREEN),
new Dot(240, 240, Color.GREEN),
new Dot(240, 360, Color.GREEN),
new Dot(360, 360, Color.GREEN),
new Dot(360, 240, Color.GREEN)
)
);
}
}
OutputDemo.png: Screenshot
