[nikiroo-utils.git] / ui / ZoomBox.java

package be.nikiroo.utils.ui;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.DefaultComboBoxModel;
import javax.swing.Icon;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JLabel;

/**
 * A small panel that let you choose a zoom level or an actual zoom value (when
 * there is enough space to allow that).
 * 
 * @author niki
 */
public class ZoomBox extends ListenerPanel {
	private static final long serialVersionUID = 1L;

	/** The event that is fired on zoom change. */
	public static final String ZOOM_CHANGED = "zoom_changed";

	private enum ZoomLevel {
		FIT_TO_WIDTH(0, true), //
		FIT_TO_HEIGHT(0, false), //
		ACTUAL_SIZE(1, null), //
		HALF_SIZE(0.5, null), //
		DOUBLE_SIZE(2, null),//
		;

		private final double zoom;
		private final Boolean snapMode;

		private ZoomLevel(double zoom, Boolean snapMode) {
			this.zoom = zoom;
			this.snapMode = snapMode;
		}

		public double getZoom() {
			return zoom;
		}

		public Boolean getSnapToWidth() {
			return snapMode;
		}

		/**
		 * Use default values that can be understood by a human.
		 */
		@Override
		public String toString() {
			switch (this) {
			case FIT_TO_WIDTH:
				return "Fit to width";
			case FIT_TO_HEIGHT:
				return "Fit to height";
			case ACTUAL_SIZE:
				return "Actual size";
			case HALF_SIZE:
				return "Half size";
			case DOUBLE_SIZE:
				return "Double size";
			}
			return super.toString();
		}

		static ZoomLevel[] values(boolean orderedSelection) {
			if (orderedSelection) {
				return new ZoomLevel[] { //
						FIT_TO_WIDTH, //
						FIT_TO_HEIGHT, //
						ACTUAL_SIZE, //
						HALF_SIZE, //
						DOUBLE_SIZE,//
				};
			}

			return values();
		}
	}

	private boolean vertical;
	private boolean small;

	private JButton zoomIn;
	private JButton zoomOut;
	private JButton snapWidth;
	private JButton snapHeight;
	private JLabel zoomLabel;

	@SuppressWarnings("rawtypes") // JComboBox<?> is not java 1.6 compatible
	private JComboBox zoombox;

	private double zoom = 1;
	private Boolean snapMode = true;

	@SuppressWarnings("rawtypes") // JComboBox<?> not compatible java 1.6
	private DefaultComboBoxModel zoomBoxModel;

	/**
	 * Create a new {@link ZoomBox}.
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" }) // JComboBox<?> not
													// compatible java 1.6
	public ZoomBox() {
		zoomIn = new JButton();
		zoomIn.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				zoomIn(1);
			}
		});

		zoomBoxModel = new DefaultComboBoxModel(ZoomLevel.values(true));
		zoombox = new JComboBox(zoomBoxModel);
		zoombox.setEditable(true);
		zoombox.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				Object selected = zoomBoxModel.getSelectedItem();

				if (selected == null) {
					return;
				}

				if (selected instanceof ZoomLevel) {
					ZoomLevel selectedZoomLevel = (ZoomLevel) selected;
					setZoomSnapMode(selectedZoomLevel.getZoom(),
							selectedZoomLevel.getSnapToWidth());
				} else {
					String selectedString = selected.toString();
					selectedString = selectedString.trim();
					if (selectedString.endsWith("%")) {
						selectedString = selectedString
								.substring(0, selectedString.length() - 1)
								.trim();
					}

					try {
						int pc = Integer.parseInt(selectedString);
						if (pc <= 0) {
							throw new NumberFormatException("invalid");
						}

						setZoomSnapMode(pc / 100.0, null);
					} catch (NumberFormatException nfe) {
					}
				}

				fireActionPerformed(ZOOM_CHANGED);
			}
		});

		zoomOut = new JButton();
		zoomOut.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				zoomOut(1);
			}
		});

		snapWidth = new JButton();
		snapWidth.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				setSnapMode(true);
			}
		});

		snapHeight = new JButton();
		snapHeight.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				setSnapMode(false);
			}
		});

		zoomLabel = new JLabel();
		zoomLabel.setBorder(BorderFactory.createEmptyBorder(10, 10, 0, 0));

		setIcons(null, null, null, null);
		setOrientation(vertical);
	}

	/**
	 * The zoom level.
	 * <p>
	 * It usually returns 1 (default value), the value you passed yourself or 1
	 * (a snap to width or snap to height was asked by the user).
	 * <p>
	 * Will cause a fire event if needed.
	 * 
	 * @param zoom
	 *            the zoom level
	 */
	public void setZoom(double zoom) {
		if (this.zoom != zoom) {
			doSetZoom(zoom);
			fireActionPerformed(ZOOM_CHANGED);
		}
	}

	/**
	 * The snap mode (NULL means no snap mode, TRUE for snap to width, FALSE for
	 * snap to height).
	 * <p>
	 * Will cause a fire event if needed.
	 * 
	 * @param snapToWidth
	 *            the snap mode
	 */
	public void setSnapMode(Boolean snapToWidth) {
		if (this.snapMode != snapToWidth) {
			doSetSnapMode(snapToWidth);
			fireActionPerformed(ZOOM_CHANGED);
		}
	}

	/**
	 * Set both {@link ZoomBox#setZoom(double)} and
	 * {@link ZoomBox#setSnapMode(Boolean)} but fire only one change event.
	 * <p>
	 * Will cause a fire event if needed.
	 * 
	 * @param zoom
	 *            the zoom level
	 * @param snapMode
	 *            the snap mode
	 */
	public void setZoomSnapMode(double zoom, Boolean snapMode) {
		if (this.zoom != zoom || this.snapMode != snapMode) {
			doSetZoom(zoom);
			doSetSnapMode(snapMode);
			fireActionPerformed(ZOOM_CHANGED);
		}
	}

	/**
	 * The zoom level.
	 * <p>
	 * It usually returns 1 (default value), the value you passed yourself or 0
	 * (a snap to width or snap to height was asked by the user).
	 * 
	 * @return the zoom level
	 */
	public double getZoom() {
		return zoom;
	}

	/**
	 * The snap mode (NULL means no snap mode, TRUE for snap to width, FALSE for
	 * snap to height).
	 * 
	 * @return the snap mode
	 */
	public Boolean getSnapMode() {
		return snapMode;
	}

	/**
	 * Zoom in, by a certain amount in "steps".
	 * <p>
	 * Note that zoomIn(-1) is the same as zoomOut(1).
	 * 
	 * @param steps
	 *            the number of zoom steps to make, can be negative
	 */
	public void zoomIn(int steps) {
		// TODO: redo zoomIn/zoomOut correctly
		if (steps < 0) {
			zoomOut(-steps);
			return;
		}

		double newZoom = zoom;
		for (int i = 0; i < steps; i++) {
			newZoom = newZoom + (newZoom < 0.1 ? 0.01 : 0.1);
			if (newZoom > 0.1) {
				newZoom = Math.round(newZoom * 10.0) / 10.0; // snap to 10%
			} else {
				newZoom = Math.round(newZoom * 100.0) / 100.0; // snap to 1%
			}
		}

		setZoomSnapMode(newZoom, null);
		fireActionPerformed(ZOOM_CHANGED);
	}

	/**
	 * Zoom out, by a certain amount in "steps".
	 * <p>
	 * Note that zoomOut(-1) is the same as zoomIn(1).
	 * 
	 * @param steps
	 *            the number of zoom steps to make, can be negative
	 */
	public void zoomOut(int steps) {
		if (steps < 0) {
			zoomIn(-steps);
			return;
		}

		double newZoom = zoom;
		for (int i = 0; i < steps; i++) {
			newZoom = newZoom - (newZoom > 0.19 ? 0.1 : 0.01);
			if (newZoom < 0.01) {
				newZoom = 0.01;
				break;
			}

			if (newZoom > 0.1) {
				newZoom = Math.round(newZoom * 10.0) / 10.0; // snap to 10%
			} else {
				newZoom = Math.round(newZoom * 100.0) / 100.0; // snap to 1%
			}
		}

		setZoomSnapMode(newZoom, null);
		fireActionPerformed(ZOOM_CHANGED);
	}

	/**
	 * Set icons for the buttons instead of square brackets.
	 * <p>
	 * Any NULL value will make the button use square brackets again.
	 * 
	 * @param zoomIn
	 *            the icon of the button "go to first page"
	 * @param zoomOut
	 *            the icon of the button "go to previous page"
	 * @param snapWidth
	 *            the icon of the button "go to next page"
	 * @param snapHeight
	 *            the icon of the button "go to last page"
	 */
	public void setIcons(Icon zoomIn, Icon zoomOut, Icon snapWidth,
			Icon snapHeight) {
		this.zoomIn.setIcon(zoomIn);
		this.zoomIn.setText(zoomIn == null ? "+" : "");
		this.zoomOut.setIcon(zoomOut);
		this.zoomOut.setText(zoomOut == null ? "-" : "");
		this.snapWidth.setIcon(snapWidth);
		this.snapWidth.setText(snapWidth == null ? "W" : "");
		this.snapHeight.setIcon(snapHeight);
		this.snapHeight.setText(snapHeight == null ? "H" : "");
	}

	/**
	 * A smaller {@link ZoomBox} that uses buttons instead of a big combo box
	 * for the zoom modes.
	 * <p>
	 * Always small in vertical orientation.
	 * 
	 * @return TRUE if it is small
	 */
	public boolean getSmall() {
		return small;
	}

	/**
	 * A smaller {@link ZoomBox} that uses buttons instead of a big combo box
	 * for the zoom modes.
	 * <p>
	 * Always small in vertical orientation.
	 * 
	 * @param small
	 *            TRUE to set it small
	 * 
	 * @return TRUE if it changed something
	 */
	public boolean setSmall(boolean small) {
		return setUi(small, vertical);
	}

	/**
	 * The general orientation of the component.
	 * 
	 * @return TRUE for vertical orientation, FALSE for horisontal orientation
	 */
	public boolean getOrientation() {
		return vertical;
	}

	/**
	 * The general orientation of the component.
	 * 
	 * @param vertical
	 *            TRUE for vertical orientation, FALSE for horisontal
	 *            orientation
	 * 
	 * @return TRUE if it changed something
	 */
	public boolean setOrientation(boolean vertical) {
		return setUi(small, vertical);
	}

	/**
	 * Set the zoom level, no fire event.
	 * <p>
	 * It usually returns 1 (default value), the value you passed yourself or 0
	 * (a snap to width or snap to height was asked by the user).
	 * 
	 * @param zoom
	 *            the zoom level
	 */
	private void doSetZoom(double zoom) {
		if (zoom > 0) {
			String zoomStr = Integer.toString((int) Math.round(zoom * 100))
					+ " %";
			zoomLabel.setText(zoomStr);
			if (snapMode == null) {
				zoomBoxModel.setSelectedItem(zoomStr);
			}
		}

		this.zoom = zoom;
	}

	/**
	 * Set the snap mode, no fire event.
	 * 
	 * @param snapToWidth
	 *            the snap mode
	 */
	private void doSetSnapMode(Boolean snapToWidth) {
		if (snapToWidth == null) {
			String zoomStr = Integer.toString((int) Math.round(zoom * 100))
					+ " %";
			if (zoom > 0) {
				zoomBoxModel.setSelectedItem(zoomStr);
			}
		} else {
			for (ZoomLevel level : ZoomLevel.values()) {
				if (level.getSnapToWidth() == snapToWidth) {
					zoomBoxModel.setSelectedItem(level);
				}
			}
		}

		this.snapMode = snapToWidth;
	}

	private boolean setUi(boolean small, boolean vertical) {
		if (getWidth() == 0 || this.small != small
				|| this.vertical != vertical) {
			this.small = small;
			this.vertical = vertical;

			BoxLayout layout = new BoxLayout(this,
					vertical ? BoxLayout.Y_AXIS : BoxLayout.X_AXIS);
			this.removeAll();
			setLayout(layout);

			if (vertical || small) {
				this.add(zoomIn);
				this.add(snapWidth);
				this.add(snapHeight);
				this.add(zoomOut);
				this.add(zoomLabel);
			} else {
				this.add(zoomIn);
				this.add(zoombox);
				this.add(zoomOut);
			}

			this.revalidate();
			this.repaint();

			return true;
		}

		return false;
	}
}
Commit	Line	Data
	1	package be.nikiroo.utils.ui;
	2
	3	import java.awt.event.ActionEvent;
	4	import java.awt.event.ActionListener;
	5
	6	import javax.swing.BorderFactory;
	7	import javax.swing.BoxLayout;
	8	import javax.swing.DefaultComboBoxModel;
	9	import javax.swing.Icon;
	10	import javax.swing.JButton;
	11	import javax.swing.JComboBox;
	12	import javax.swing.JLabel;
	13
	14	/**
	15	* A small panel that let you choose a zoom level or an actual zoom value (when
	16	* there is enough space to allow that).
	17	*
	18	* @author niki
	19	*/
	20	public class ZoomBox extends ListenerPanel {
	21	private static final long serialVersionUID = 1L;
	22
	23	/** The event that is fired on zoom change. */
	24	public static final String ZOOM_CHANGED = "zoom_changed";
	25
	26	private enum ZoomLevel {
	27	FIT_TO_WIDTH(0, true), //
	28	FIT_TO_HEIGHT(0, false), //
	29	ACTUAL_SIZE(1, null), //
	30	HALF_SIZE(0.5, null), //
	31	DOUBLE_SIZE(2, null),//
	32	;
	33
	34	private final double zoom;
	35	private final Boolean snapMode;
	36
	37	private ZoomLevel(double zoom, Boolean snapMode) {
	38	this.zoom = zoom;
	39	this.snapMode = snapMode;
	40	}
	41
	42	public double getZoom() {
	43	return zoom;
	44	}
	45
	46	public Boolean getSnapToWidth() {
	47	return snapMode;
	48	}
	49
	50	/**
	51	* Use default values that can be understood by a human.
	52	*/
	53	@Override
	54	public String toString() {
	55	switch (this) {
	56	case FIT_TO_WIDTH:
	57	return "Fit to width";
	58	case FIT_TO_HEIGHT:
	59	return "Fit to height";
	60	case ACTUAL_SIZE:
	61	return "Actual size";
	62	case HALF_SIZE:
	63	return "Half size";
	64	case DOUBLE_SIZE:
	65	return "Double size";
	66	}
	67	return super.toString();
	68	}
	69
	70	static ZoomLevel[] values(boolean orderedSelection) {
	71	if (orderedSelection) {
	72	return new ZoomLevel[] { //
	73	FIT_TO_WIDTH, //
	74	FIT_TO_HEIGHT, //
	75	ACTUAL_SIZE, //
	76	HALF_SIZE, //
	77	DOUBLE_SIZE,//
	78	};
	79	}
	80
	81	return values();
	82	}
	83	}
	84
	85	private boolean vertical;
	86	private boolean small;
	87
	88	private JButton zoomIn;
	89	private JButton zoomOut;
	90	private JButton snapWidth;
	91	private JButton snapHeight;
	92	private JLabel zoomLabel;
	93
	94	@SuppressWarnings("rawtypes") // JComboBox<?> is not java 1.6 compatible
	95	private JComboBox zoombox;
	96
	97	private double zoom = 1;
	98	private Boolean snapMode = true;
	99
	100	@SuppressWarnings("rawtypes") // JComboBox<?> not compatible java 1.6
	101	private DefaultComboBoxModel zoomBoxModel;
	102
	103	/**
	104	* Create a new {@link ZoomBox}.
	105	*/
	106	@SuppressWarnings({ "unchecked", "rawtypes" }) // JComboBox<?> not
	107	// compatible java 1.6
	108	public ZoomBox() {
	109	zoomIn = new JButton();
	110	zoomIn.addActionListener(new ActionListener() {
	111	@Override
	112	public void actionPerformed(ActionEvent e) {
	113	zoomIn(1);
	114	}
	115	});
	116
	117	zoomBoxModel = new DefaultComboBoxModel(ZoomLevel.values(true));
	118	zoombox = new JComboBox(zoomBoxModel);
	119	zoombox.setEditable(true);
	120	zoombox.addActionListener(new ActionListener() {
	121	@Override
	122	public void actionPerformed(ActionEvent e) {
	123	Object selected = zoomBoxModel.getSelectedItem();
	124
	125	if (selected == null) {
	126	return;
	127	}
	128
	129	if (selected instanceof ZoomLevel) {
	130	ZoomLevel selectedZoomLevel = (ZoomLevel) selected;
	131	setZoomSnapMode(selectedZoomLevel.getZoom(),
	132	selectedZoomLevel.getSnapToWidth());
	133	} else {
	134	String selectedString = selected.toString();
	135	selectedString = selectedString.trim();
	136	if (selectedString.endsWith("%")) {
	137	selectedString = selectedString
	138	.substring(0, selectedString.length() - 1)
	139	.trim();
	140	}
	141
	142	try {
	143	int pc = Integer.parseInt(selectedString);
	144	if (pc <= 0) {
	145	throw new NumberFormatException("invalid");
	146	}
	147
	148	setZoomSnapMode(pc / 100.0, null);
	149	} catch (NumberFormatException nfe) {
	150	}
	151	}
	152
	153	fireActionPerformed(ZOOM_CHANGED);
	154	}
	155	});
	156
	157	zoomOut = new JButton();
	158	zoomOut.addActionListener(new ActionListener() {
	159	@Override
	160	public void actionPerformed(ActionEvent e) {
	161	zoomOut(1);
	162	}
	163	});
	164
	165	snapWidth = new JButton();
	166	snapWidth.addActionListener(new ActionListener() {
	167	@Override
	168	public void actionPerformed(ActionEvent e) {
	169	setSnapMode(true);
	170	}
	171	});
	172
	173	snapHeight = new JButton();
	174	snapHeight.addActionListener(new ActionListener() {
	175	@Override
	176	public void actionPerformed(ActionEvent e) {
	177	setSnapMode(false);
	178	}
	179	});
	180
	181	zoomLabel = new JLabel();
	182	zoomLabel.setBorder(BorderFactory.createEmptyBorder(10, 10, 0, 0));
	183
	184	setIcons(null, null, null, null);
	185	setOrientation(vertical);
	186	}
	187
	188	/**
	189	* The zoom level.
	190	* <p>
	191	* It usually returns 1 (default value), the value you passed yourself or 1
	192	* (a snap to width or snap to height was asked by the user).
	193	* <p>
	194	* Will cause a fire event if needed.
	195	*
	196	* @param zoom
	197	* the zoom level
	198	*/
	199	public void setZoom(double zoom) {
	200	if (this.zoom != zoom) {
	201	doSetZoom(zoom);
	202	fireActionPerformed(ZOOM_CHANGED);
	203	}
	204	}
	205
	206	/**
	207	* The snap mode (NULL means no snap mode, TRUE for snap to width, FALSE for
	208	* snap to height).
	209	* <p>
	210	* Will cause a fire event if needed.
	211	*
	212	* @param snapToWidth
	213	* the snap mode
	214	*/
	215	public void setSnapMode(Boolean snapToWidth) {
	216	if (this.snapMode != snapToWidth) {
	217	doSetSnapMode(snapToWidth);
	218	fireActionPerformed(ZOOM_CHANGED);
	219	}
	220	}
	221
	222	/**
	223	* Set both {@link ZoomBox#setZoom(double)} and
	224	* {@link ZoomBox#setSnapMode(Boolean)} but fire only one change event.
	225	* <p>
	226	* Will cause a fire event if needed.
	227	*
	228	* @param zoom
	229	* the zoom level
	230	* @param snapMode
	231	* the snap mode
	232	*/
	233	public void setZoomSnapMode(double zoom, Boolean snapMode) {
	234	if (this.zoom != zoom \|\| this.snapMode != snapMode) {
	235	doSetZoom(zoom);
	236	doSetSnapMode(snapMode);
	237	fireActionPerformed(ZOOM_CHANGED);
	238	}
	239	}
	240
	241	/**
	242	* The zoom level.
	243	* <p>
	244	* It usually returns 1 (default value), the value you passed yourself or 0
	245	* (a snap to width or snap to height was asked by the user).
	246	*
	247	* @return the zoom level
	248	*/
	249	public double getZoom() {
	250	return zoom;
	251	}
	252
	253	/**
	254	* The snap mode (NULL means no snap mode, TRUE for snap to width, FALSE for
	255	* snap to height).
	256	*
	257	* @return the snap mode
	258	*/
	259	public Boolean getSnapMode() {
	260	return snapMode;
	261	}
	262
	263	/**
	264	* Zoom in, by a certain amount in "steps".
	265	* <p>
	266	* Note that zoomIn(-1) is the same as zoomOut(1).
	267	*
	268	* @param steps
	269	* the number of zoom steps to make, can be negative
	270	*/
	271	public void zoomIn(int steps) {
	272	// TODO: redo zoomIn/zoomOut correctly
	273	if (steps < 0) {
	274	zoomOut(-steps);
	275	return;
	276	}
	277
	278	double newZoom = zoom;
	279	for (int i = 0; i < steps; i++) {
	280	newZoom = newZoom + (newZoom < 0.1 ? 0.01 : 0.1);
	281	if (newZoom > 0.1) {
	282	newZoom = Math.round(newZoom * 10.0) / 10.0; // snap to 10%
	283	} else {
	284	newZoom = Math.round(newZoom * 100.0) / 100.0; // snap to 1%
	285	}
	286	}
	287
	288	setZoomSnapMode(newZoom, null);
	289	fireActionPerformed(ZOOM_CHANGED);
	290	}
	291
	292	/**
	293	* Zoom out, by a certain amount in "steps".
	294	* <p>
	295	* Note that zoomOut(-1) is the same as zoomIn(1).
	296	*
	297	* @param steps
	298	* the number of zoom steps to make, can be negative
	299	*/
	300	public void zoomOut(int steps) {
	301	if (steps < 0) {
	302	zoomIn(-steps);
	303	return;
	304	}
	305
	306	double newZoom = zoom;
	307	for (int i = 0; i < steps; i++) {
	308	newZoom = newZoom - (newZoom > 0.19 ? 0.1 : 0.01);
	309	if (newZoom < 0.01) {
	310	newZoom = 0.01;
	311	break;
	312	}
	313
	314	if (newZoom > 0.1) {
	315	newZoom = Math.round(newZoom * 10.0) / 10.0; // snap to 10%
	316	} else {
	317	newZoom = Math.round(newZoom * 100.0) / 100.0; // snap to 1%
	318	}
	319	}
	320
	321	setZoomSnapMode(newZoom, null);
	322	fireActionPerformed(ZOOM_CHANGED);
	323	}
	324
	325	/**
	326	* Set icons for the buttons instead of square brackets.
	327	* <p>
	328	* Any NULL value will make the button use square brackets again.
	329	*
	330	* @param zoomIn
	331	* the icon of the button "go to first page"
	332	* @param zoomOut
	333	* the icon of the button "go to previous page"
	334	* @param snapWidth
	335	* the icon of the button "go to next page"
	336	* @param snapHeight
	337	* the icon of the button "go to last page"
	338	*/
	339	public void setIcons(Icon zoomIn, Icon zoomOut, Icon snapWidth,
	340	Icon snapHeight) {
	341	this.zoomIn.setIcon(zoomIn);
	342	this.zoomIn.setText(zoomIn == null ? "+" : "");
	343	this.zoomOut.setIcon(zoomOut);
	344	this.zoomOut.setText(zoomOut == null ? "-" : "");
	345	this.snapWidth.setIcon(snapWidth);
	346	this.snapWidth.setText(snapWidth == null ? "W" : "");
	347	this.snapHeight.setIcon(snapHeight);
	348	this.snapHeight.setText(snapHeight == null ? "H" : "");
	349	}
	350
	351	/**
	352	* A smaller {@link ZoomBox} that uses buttons instead of a big combo box
	353	* for the zoom modes.
	354	* <p>
	355	* Always small in vertical orientation.
	356	*
	357	* @return TRUE if it is small
	358	*/
	359	public boolean getSmall() {
	360	return small;
	361	}
	362
	363	/**
	364	* A smaller {@link ZoomBox} that uses buttons instead of a big combo box
	365	* for the zoom modes.
	366	* <p>
	367	* Always small in vertical orientation.
	368	*
	369	* @param small
	370	* TRUE to set it small
	371	*
	372	* @return TRUE if it changed something
	373	*/
	374	public boolean setSmall(boolean small) {
	375	return setUi(small, vertical);
	376	}
	377
	378	/**
	379	* The general orientation of the component.
	380	*
	381	* @return TRUE for vertical orientation, FALSE for horisontal orientation
	382	*/
	383	public boolean getOrientation() {
	384	return vertical;
	385	}
	386
	387	/**
	388	* The general orientation of the component.
	389	*
	390	* @param vertical
	391	* TRUE for vertical orientation, FALSE for horisontal
	392	* orientation
	393	*
	394	* @return TRUE if it changed something
	395	*/
	396	public boolean setOrientation(boolean vertical) {
	397	return setUi(small, vertical);
	398	}
	399
	400	/**
	401	* Set the zoom level, no fire event.
	402	* <p>
	403	* It usually returns 1 (default value), the value you passed yourself or 0
	404	* (a snap to width or snap to height was asked by the user).
	405	*
	406	* @param zoom
	407	* the zoom level
	408	*/
	409	private void doSetZoom(double zoom) {
	410	if (zoom > 0) {
	411	String zoomStr = Integer.toString((int) Math.round(zoom * 100))
	412	+ " %";
	413	zoomLabel.setText(zoomStr);
	414	if (snapMode == null) {
	415	zoomBoxModel.setSelectedItem(zoomStr);
	416	}
	417	}
	418
	419	this.zoom = zoom;
	420	}
	421
	422	/**
	423	* Set the snap mode, no fire event.
	424	*
	425	* @param snapToWidth
	426	* the snap mode
	427	*/
	428	private void doSetSnapMode(Boolean snapToWidth) {
	429	if (snapToWidth == null) {
	430	String zoomStr = Integer.toString((int) Math.round(zoom * 100))
	431	+ " %";
	432	if (zoom > 0) {
	433	zoomBoxModel.setSelectedItem(zoomStr);
	434	}
	435	} else {
	436	for (ZoomLevel level : ZoomLevel.values()) {
	437	if (level.getSnapToWidth() == snapToWidth) {
	438	zoomBoxModel.setSelectedItem(level);
	439	}
	440	}
	441	}
	442
	443	this.snapMode = snapToWidth;
	444	}
	445
	446	private boolean setUi(boolean small, boolean vertical) {
	447	if (getWidth() == 0 \|\| this.small != small
	448	\|\| this.vertical != vertical) {
	449	this.small = small;
	450	this.vertical = vertical;
	451
	452	BoxLayout layout = new BoxLayout(this,
	453	vertical ? BoxLayout.Y_AXIS : BoxLayout.X_AXIS);
	454	this.removeAll();
	455	setLayout(layout);
	456
	457	if (vertical \|\| small) {
	458	this.add(zoomIn);
	459	this.add(snapWidth);
	460	this.add(snapHeight);
	461	this.add(zoomOut);
	462	this.add(zoomLabel);
	463	} else {
	464	this.add(zoomIn);
	465	this.add(zoombox);
	466	this.add(zoomOut);
	467	}
	468
	469	this.revalidate();
	470	this.repaint();
	471
	472	return true;
	473	}
	474
	475	return false;
	476	}
	477	}