/*******************************************************************************
 * Copyright (c) 2011 Laurent CARON
 * 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:
 *     Laurent CARON (laurent.caron at gmail dot com) - initial API and implementation
 *******************************************************************************/
package org.mihalis.opal.switchButton;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTException;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseTrackListener;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
import org.mihalis.opal.utils.SWTGraphicUtil;

/**
 * Instances of this class are simple switch button.
 * <dl>
 * <dt><b>Styles:</b></dt>
 * <dd>(none)</dd>
 * <dt><b>Events:</b></dt>
 * <dd>Selection</dd>
 * </dl>
 */
public class SwitchButton extends Canvas {

	/** Selection. */
	private boolean selection;

	/** Text displayed for the selected value (default = "On"). */
	private String textForSelect;

	/** Text displayed for the unselected value (default = "Off"). */
	private String textForUnselect;

	/** Text corresponding to the button (default is ""). */
	private String text;

	/**
	 * If true, display round rectangles instead of rectangles (default value is
	 * true).
	 */
	private boolean round;

	/**
	 * if not null, displays a rectangle (or a round rectangle) around the whole
	 * widget. Default value is null.
	 */
	private Color borderColor;

	/**
	 * if not null, displays a glow effect when the mouse is over the widget.
	 * Default value is null.
	 */
	private Color focusColor;

	/** Colors when the button is selected. */
	private Color selectedForegroundColor, selectedBackgroundColor;

	/** Colors when the button is not selected. */
	private Color unselectedForegroundColor, unselectedBackgroundColor;

	/** Colors for the button. */
	private Color buttonBorderColor, buttonBackgroundColor1, buttonBackgroundColor2;

	/** Gap between the button and the text (default value is 5). */
	private int gap = 5;

	/** Margin inside the button (default is 5). */
	private int insideMarginX = 5;

	/** Margin inside the button (default is 5). */
	private int insideMarginY = 5;

	/** Arc of rounded rectangles (default is 3). */
	private int arc = 3;

	/** Graphical context for this button. */
	private GC gc;

	/** List of selection listeners. */
	private final List<SelectionListener> listOfSelectionListeners;

	/** True when the mouse entered the widget. */
	private boolean mouseInside;

	/**
	 * Constructs a new instance of this class given its parent and a style
	 * value describing its behavior and appearance.
	 * <p>
	 * The style value is either one of the style constants defined in class
	 * <code>SWT</code> which is applicable to instances of this class, or must
	 * be built by <em>bitwise OR</em>'ing together (that is, using the
	 * <code>int</code> "|" operator) two or more of those <code>SWT</code>
	 * style constants. The class description lists the style constants that are
	 * applicable to the class. Style bits are also inherited from superclasses.
	 * </p>
	 *
	 * @param parent a composite control which will be the parent of the new
	 *            instance (cannot be null)
	 * @param style the style of control to construct
	 *
	 * @exception IllegalArgumentException
	 *                <ul>
	 *                <li>ERROR_NULL_ARGUMENT - if the parent is null</li>
	 *                </ul>
	 * @exception SWTException
	 *                <ul>
	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
	 *                thread that created the parent</li>
	 *                </ul>
	 *
	 */
	public SwitchButton(final Composite parent, final int style) {
		super(parent, style | SWT.DOUBLE_BUFFERED);

		selection = false;
		text = "";
		textForSelect = "On";
		textForUnselect = "Off";
		round = true;
		borderColor = null;
		focusColor = getDisplay().getSystemColor(SWT.COLOR_YELLOW);
		selectedForegroundColor = getDisplay().getSystemColor(SWT.COLOR_WHITE);
		selectedBackgroundColor = SWTGraphicUtil.getDefaultColor(this, 0, 112, 195);
		unselectedForegroundColor = getDisplay().getSystemColor(SWT.COLOR_BLACK);
		unselectedBackgroundColor = SWTGraphicUtil.getDefaultColor(this, 203, 203, 203);
		buttonBorderColor = SWTGraphicUtil.getDefaultColor(this, 96, 96, 96);
		buttonBackgroundColor1 = SWTGraphicUtil.getDefaultColor(this, 254, 254, 254);
		buttonBackgroundColor2 = SWTGraphicUtil.getDefaultColor(this, 192, 192, 192);

		listOfSelectionListeners = new ArrayList<SelectionListener>();

		addPaintListener(new PaintListener() {
			@Override
			public void paintControl(final PaintEvent event) {
				SwitchButton.this.onPaint(event);
			}
		});

		addMouseListener(new MouseAdapter() {

			/**
			 * @see org.eclipse.swt.events.MouseAdapter#mouseUp(org.eclipse.swt.events.MouseEvent)
			 */
			@Override
			public void mouseUp(final MouseEvent e) {
				if (SwitchButton.this.fireSelectionListeners(e)) {
					selection = !selection;
					SwitchButton.this.redraw();

					// notify listeners that were registered via
					// Widget#addListener
					SwitchButton.this.notifyListeners(SWT.Selection, new Event());

				}
			}

		});

		mouseInside = false;
		addMouseTrackListener(new MouseTrackListener() {

			@Override
			public void mouseHover(final MouseEvent e) {
				mouseInside = true;
				SwitchButton.this.redraw();
			}

			@Override
			public void mouseExit(final MouseEvent e) {
				mouseInside = false;
				SwitchButton.this.redraw();
			}

			@Override
			public void mouseEnter(final MouseEvent e) {
				mouseInside = true;
				SwitchButton.this.redraw();
			}
		});

	}

	/**
	 * Paint the widget.
	 *
	 * @param event paint event
	 */
	private void onPaint(final PaintEvent event) {
		final Rectangle rect = getClientArea();
		if (rect.width == 0 || rect.height == 0) {
			return;
		}
		gc = event.gc;
		gc.setAntialias(SWT.ON);

		final Point buttonSize = computeButtonSize();
		drawSwitchButton(buttonSize);
		drawText(buttonSize);

		if (borderColor != null) {
			drawBorder();
		}

	}

	/**
	 * Draw the switch button.
	 *
	 * @param buttonSize size of the button
	 */
	private void drawSwitchButton(final Point buttonSize) {
		// Draw the background of the button
		gc.setForeground(buttonBorderColor);
		if (round) {
			gc.drawRoundRectangle(2, 2, buttonSize.x, buttonSize.y, arc, arc);
		} else {
			gc.drawRectangle(2, 2, buttonSize.x, buttonSize.y);
		}

		drawRightPart(buttonSize);
		drawLeftPart(buttonSize);
		gc.setClipping(getClientArea());
		drawToggleButton(buttonSize);
	}

	/**
	 * Draw the right part of the button.
	 *
	 * @param buttonSize size of the button
	 */
	private void drawRightPart(final Point buttonSize) {
		gc.setForeground(selectedBackgroundColor);
		gc.setBackground(selectedBackgroundColor);
		gc.setClipping(3, 3, buttonSize.x / 2, buttonSize.y - 1);
		if (round) {
			gc.fillRoundRectangle(2, 2, buttonSize.x, buttonSize.y, arc, arc);
		} else {
			gc.fillRectangle(2, 2, buttonSize.x, buttonSize.y);
		}
		gc.setForeground(selectedForegroundColor);
		final Point textSize = gc.textExtent(textForSelect);
		gc.drawString(textForSelect, (buttonSize.x / 2 - textSize.x) / 2 + arc, (buttonSize.y - textSize.y) / 2 + arc);
	}

	/**
	 * Draw the left part of the button.
	 *
	 * @param buttonSize size of the button
	 */
	private void drawLeftPart(final Point buttonSize) {
		gc.setForeground(unselectedBackgroundColor);
		gc.setBackground(unselectedBackgroundColor);
		gc.setClipping(buttonSize.x / 2 + 3, 3, buttonSize.x / 2, buttonSize.y - 1);
		if (round) {
			gc.fillRoundRectangle(2, 2, buttonSize.x, buttonSize.y, arc, arc);
		} else {
			gc.fillRectangle(2, 2, buttonSize.x, buttonSize.y);
		}
		gc.setForeground(unselectedForegroundColor);
		final Point textSize = gc.textExtent(textForUnselect);

		gc.drawString(textForUnselect, buttonSize.x / 2 + (buttonSize.x / 2 - textSize.x) / 2 + arc, //
				(buttonSize.y - textSize.y) / 2 + arc);
	}

	/**
	 * Draw the toggle button.
	 *
	 * @param buttonSize size of the button
	 */
	private void drawToggleButton(final Point buttonSize) {
		gc.setForeground(buttonBackgroundColor1);
		gc.setBackground(buttonBackgroundColor2);
		if (selection) {
			gc.fillGradientRectangle(arc, arc, buttonSize.x / 2, buttonSize.y, true);
		} else {
			gc.fillGradientRectangle(buttonSize.x / 2, arc, buttonSize.x / 2 + 2, buttonSize.y - 1, true);
		}

		gc.setForeground(buttonBorderColor);
		if (selection) {
			gc.drawRoundRectangle(2, 2, buttonSize.x / 2, buttonSize.y, arc, arc);
		} else {
			gc.drawRoundRectangle(buttonSize.x / 2, 2, buttonSize.x / 2 + 2, buttonSize.y, arc, arc);
		}

		if (focusColor != null && mouseInside) {
			gc.setForeground(focusColor);
			gc.setLineWidth(2);
			if (selection) {
				gc.drawRoundRectangle(3, 3, buttonSize.x / 2, buttonSize.y - 1, 3, 3);
			} else {
				gc.drawRoundRectangle(buttonSize.x / 2 + 1, 3, buttonSize.x / 2, buttonSize.y - 2, 3, 3);
			}
			gc.setLineWidth(1);
		}

	}

	/**
	 * Compute button size.
	 *
	 * @return the button size
	 */
	private Point computeButtonSize() {
		// Compute size for the left part
		final Point sizeForLeftPart = gc.stringExtent(textForSelect);
		// Compute size for the right part
		final Point sizeForRightPart = gc.stringExtent(textForUnselect);

		// Compute whole size
		final int width = Math.max(sizeForLeftPart.x, sizeForRightPart.x) * 2 + 2 * insideMarginX;
		final int height = Math.max(sizeForLeftPart.y, sizeForRightPart.y) + 2 * insideMarginY;

		return new Point(width, height);
	}

	/**
	 * Draws the text besides the button.
	 *
	 * @param buttonSize whole size of the button
	 */
	private void drawText(final Point buttonSize) {
		gc.setForeground(getForeground());
		gc.setBackground(getBackground());

		final int widgetHeight = this.computeSize(0, 0, true).y;
		final int textHeight = gc.stringExtent(text).y;
		final int x = 2 + buttonSize.x + gap;

		gc.drawString(text, x, (widgetHeight - textHeight) / 2);
	}

	/**
	 * Draw (eventually) the border around the button.
	 */
	private void drawBorder() {
		if (borderColor == null) {
			return;
		}

		gc.setForeground(borderColor);
		final Point temp = this.computeSize(0, 0, false);
		if (round) {
			gc.drawRoundRectangle(0, 0, temp.x - 2, temp.y - 2, 3, 3);
		} else {
			gc.drawRectangle(0, 0, temp.x - 2, temp.y - 2);
		}

	}

	/**
	 * Fire the selection listeners.
	 *
	 * @param mouseEvent mouse event
	 * @return true if the selection could be changed, false otherwise
	 */
	private boolean fireSelectionListeners(final MouseEvent mouseEvent) {
		for (final SelectionListener listener : listOfSelectionListeners) {
			final Event event = new Event();

			event.button = mouseEvent.button;
			event.display = getDisplay();
			event.item = null;
			event.widget = this;
			event.data = null;
			event.time = mouseEvent.time;
			event.x = mouseEvent.x;
			event.y = mouseEvent.y;

			final SelectionEvent selEvent = new SelectionEvent(event);
			listener.widgetSelected(selEvent);
			if (!selEvent.doit) {
				return false;
			}
		}
		return true;
	}

	/**
	 * Adds the listener to the collection of listeners who will be notified
	 * when the control is selected by the user, by sending it one of the
	 * messages defined in the <code>SelectionListener</code> interface.
	 * <p>
	 * <code>widgetSelected</code> is called when the control is selected by the
	 * user. <code>widgetDefaultSelected</code> is not called.
	 * </p>
	 *
	 * @param listener the listener which should be notified
	 * @see SelectionListener
	 * @see #removeSelectionListener
	 * @see SelectionEvent
	 * @exception IllegalArgumentException <ul>
	 *                <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
	 *                </ul>
	 * @exception SWTException <ul>
	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
	 *                disposed</li>
	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
	 *                thread that created the receiver</li>
	 *                </ul>
	 */
	public void addSelectionListener(final SelectionListener listener) {
		checkWidget();
		if (listener == null) {
			SWT.error(SWT.ERROR_NULL_ARGUMENT);
		}
		listOfSelectionListeners.add(listener);
	}

	/**
	 * Removes the listener from the collection of listeners who will be
	 * notified when the control is selected by the user.
	 *
	 * @param listener the listener which should no longer be notified
	 * @see SelectionListener
	 * @see #addSelectionListener
	 * @exception IllegalArgumentException <ul>
	 *                <li>ERROR_NULL_ARGUMENT - if the listener is null</li>
	 *                </ul>
	 * @exception SWTException <ul>
	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
	 *                disposed</li>
	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
	 *                thread that created the receiver</li>
	 *                </ul>
	 */
	public void removeSelectionListener(final SelectionListener listener) {
		checkWidget();
		if (listener == null) {
			SWT.error(SWT.ERROR_NULL_ARGUMENT);
		}
		listOfSelectionListeners.remove(listener);
	}

	/**
	 * Compute size.
	 *
	 * @param wHint the w hint
	 * @param hHint the h hint
	 * @param changed the changed
	 * @return the point
	 * @see org.eclipse.swt.widgets.Composite#computeSize(int, int, boolean)
	 */
	@Override
	public Point computeSize(final int wHint, final int hHint, final boolean changed) {
		checkWidget();
		boolean disposeGC = false;
		if (gc == null || gc.isDisposed()) {
			gc = new GC(this);
			disposeGC = true;
		}

		final Point buttonSize = computeButtonSize();
		int width = buttonSize.x;
		int height = buttonSize.y;

		if (text != null && text.trim().length() > 0) {
			final Point textSize = gc.textExtent(text);
			width += textSize.x + gap + 1;
		}

		width += 4;
		height += 6;

		if (disposeGC) {
			gc.dispose();
		}

		return new Point(width, height);
	}

	/**
	 * Gets the selection.
	 *
	 * @return the selection state of the button
	 */
	public boolean getSelection() {
		checkWidget();
		return selection;
	}

	/**
	 * Sets the selection.
	 *
	 * @param selection the selection state of the button
	 */
	public void setSelection(final boolean selection) {
		checkWidget();
		this.selection = selection;
	}

	/**
	 * Gets the text displayed for the selected value (default = "On").
	 *
	 * @return the text used to display the selection
	 */
	public String getTextForSelect() {
		checkWidget();
		return textForSelect;
	}

	/**
	 * Sets the text displayed for the selected value (default = "On").
	 *
	 * @param textForSelect the text used to display the selection
	 */
	public void setTextForSelect(final String textForSelect) {
		checkWidget();
		this.textForSelect = textForSelect;
	}

	/**
	 * Gets the text displayed for the unselected value (default = "Off").
	 *
	 * @return the text used to display the unselected option
	 */
	public String getTextForUnselect() {
		checkWidget();
		return textForUnselect;
	}

	/**
	 * Sets the text displayed for the unselected value (default = "Off").
	 *
	 * @param textForUnselect the text used to display the unselected option
	 */
	public void setTextForUnselect(final String textForUnselect) {
		checkWidget();
		this.textForUnselect = textForUnselect;
	}

	/**
	 * Gets the text corresponding to the button (default is "").
	 *
	 * @return the text displayed in the widget
	 */
	public String getText() {
		checkWidget();
		return text;
	}

	/**
	 * Sets the text corresponding to the button (default is "").
	 *
	 * @param text the new text corresponding to the button (default is "")
	 */
	public void setText(final String text) {
		checkWidget();
		this.text = text;
	}

	/**
	 * Checks if is if true, display round rectangles instead of rectangles
	 * (default value is true).
	 *
	 * @return the round flag
	 */
	public boolean isRound() {
		checkWidget();
		return round;
	}

	/**
	 * Sets the if true, display round rectangles instead of rectangles (default
	 * value is true).
	 *
	 * @param round the round flag to set. If true, the widget is composed of
	 *            round rectangle instead of rectangles
	 */
	public void setRound(final boolean round) {
		checkWidget();
		this.round = round;
	}

	/**
	 * Gets the if not null, displays a rectangle (or a round rectangle) around
	 * the whole widget.
	 *
	 * @return the border's color. If null, no border is displayed
	 */
	public Color getBorderColor() {
		checkWidget();
		return borderColor;
	}

	/**
	 * Sets the if not null, displays a rectangle (or a round rectangle) around
	 * the whole widget.
	 *
	 * @param borderColor the border's color. If null, no border is displayed.
	 */
	public void setBorderColor(final Color borderColor) {
		checkWidget();
		this.borderColor = borderColor;
	}

	/**
	 * Gets the if not null, displays a glow effect when the mouse is over the
	 * widget.
	 *
	 * @return the focus color. If null, no focus effect is displayed.
	 */
	public Color getFocusColor() {
		checkWidget();
		return focusColor;
	}

	/**
	 * Sets the if not null, displays a glow effect when the mouse is over the
	 * widget.
	 *
	 * @param focusColor the focus color to set. If null, no focus effect is
	 *            displayed.
	 */
	public void setFocusColor(final Color focusColor) {
		checkWidget();
		this.focusColor = focusColor;
	}

	/**
	 * Gets the colors when the button is selected.
	 *
	 * @return the foreground color of the left part of the widget (selection is
	 *         on)
	 */
	public Color getSelectedForegroundColor() {
		checkWidget();
		return selectedForegroundColor;
	}

	/**
	 * Sets the colors when the button is selected.
	 *
	 * @param selectedForegroundColor the new colors when the button is selected
	 */
	public void setSelectedForegroundColor(final Color selectedForegroundColor) {
		checkWidget();
		this.selectedForegroundColor = selectedForegroundColor;
	}

	/**
	 * Gets the colors when the button is selected.
	 *
	 * @return the background color of the left part of the widget (selection is
	 *         on)
	 */
	public Color getSelectedBackgroundColor() {
		checkWidget();
		return selectedBackgroundColor;
	}

	/**
	 * Sets the colors when the button is selected.
	 *
	 * @param selectedBackgroundColor the new colors when the button is selected
	 */
	public void setSelectedBackgroundColor(final Color selectedBackgroundColor) {
		checkWidget();
		this.selectedBackgroundColor = selectedBackgroundColor;
	}

	/**
	 * Gets the colors when the button is not selected.
	 *
	 * @return the foreground color of the left part of the widget (selection is
	 *         on)
	 */
	public Color getUnselectedForegroundColor() {
		checkWidget();
		return unselectedForegroundColor;
	}

	/**
	 * Sets the colors when the button is not selected.
	 *
	 * @param unselectedForegroundColor the foreground color of the left part of
	 *            the widget (selection is on)
	 */
	public void setUnselectedForegroundColor(final Color unselectedForegroundColor) {
		checkWidget();
		this.unselectedForegroundColor = unselectedForegroundColor;
	}

	/**
	 * Gets the colors when the button is not selected.
	 *
	 * @return the background color of the left part of the widget (selection is
	 *         on)
	 */
	public Color getUnselectedBackgroundColor() {
		checkWidget();
		return unselectedBackgroundColor;
	}

	/**
	 * Sets the colors when the button is not selected.
	 *
	 * @param unselectedBackgroundColor the background color of the left part of
	 *            the widget (selection is on)
	 */
	public void setUnselectedBackgroundColor(final Color unselectedBackgroundColor) {
		checkWidget();
		this.unselectedBackgroundColor = unselectedBackgroundColor;
	}

	/**
	 * Gets the colors for the button.
	 *
	 * @return the border color of the switch button
	 */
	public Color getButtonBorderColor() {
		checkWidget();
		return buttonBorderColor;
	}

	/**
	 * Sets the colors for the button.
	 *
	 * @param buttonBorderColor the border color of the switch button
	 */
	public void setButtonBorderColor(final Color buttonBorderColor) {
		checkWidget();
		this.buttonBorderColor = buttonBorderColor;
	}

	/**
	 * Gets the colors for the button.
	 *
	 * @return the first color of the toggle button
	 */
	public Color getButtonBackgroundColor1() {
		checkWidget();
		return buttonBackgroundColor1;
	}

	/**
	 * Sets the colors for the button.
	 *
	 * @param buttonBackgroundColor1 the first color of the toggle button
	 */
	public void setButtonBackgroundColor1(final Color buttonBackgroundColor1) {
		checkWidget();
		this.buttonBackgroundColor1 = buttonBackgroundColor1;
	}

	/**
	 * Gets the colors for the button.
	 *
	 * @return the second color of the toggle button
	 */
	public Color getButtonBackgroundColor2() {
		checkWidget();
		return buttonBackgroundColor2;
	}

	/**
	 * Sets the colors for the button.
	 *
	 * @param buttonBackgroundColor2 the second color of the toggle button
	 */
	public void setButtonBackgroundColor2(final Color buttonBackgroundColor2) {
		checkWidget();
		this.buttonBackgroundColor2 = buttonBackgroundColor2;
	}

	/**
	 * Gets the gap between the button and the text (default value is 5).
	 *
	 * @return the gap value
	 */
	public int getGap() {
		checkWidget();
		return gap;
	}

	/**
	 * Sets the gap between the button and the text (default value is 5).
	 *
	 * @param gap the gap value to set
	 */
	public void setGap(final int gap) {
		checkWidget();
		this.gap = gap;
	}

	/**
	 * Gets the inside margin.
	 *
	 * @return the margin value
	 * @exception SWTException <ul>
	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
	 *                disposed</li>
	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
	 *                thread that created the receiver</li>
	 *                </ul>
	 */
	public Point getInsideMargin() {
		checkWidget();
		return new Point(insideMarginX, insideMarginY);
	}

	/**
	 * Sets the inside margin.
	 *
	 * @param insideMarginX the new margin value (horizontal)
	 * @param insideMarginY the new margin value (vertical)
	 * @exception SWTException <ul>
	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
	 *                disposed</li>
	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
	 *                thread that created the receiver</li>
	 *                </ul>
	 */
	public void setInsideMargin(final int insideMarginX, final int insideMarginY) {
		checkWidget();
		this.insideMarginX = insideMarginX;
		this.insideMarginY = insideMarginY;
	}

	/**
	 * Sets the inside margin.
	 *
	 * @param insideMargin the new margin value
	 * @exception SWTException <ul>
	 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been
	 *                disposed</li>
	 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the
	 *                thread that created the receiver</li>
	 *                </ul>
	 */
	public void setInsideMargin(final Point insideMargin) {
		checkWidget();
		insideMarginX = insideMargin.x;
		insideMarginY = insideMargin.y;
	}

	/**
	 * Gets the arc of rounded rectangles (default is 3).
	 *
	 * @return the arc value
	 */
	public int getArc() {
		checkWidget();
		return arc;
	}

	/**
	 * Sets the arc of rounded rectangles (default is 3).
	 *
	 * @param arc the arc value to set
	 */
	public void setArc(final int arc) {
		checkWidget();
		this.arc = arc;
	}

}