/******************************************************************************
 * Copyright (c) 2005 IBM Corporation and others.
 * 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:
 *    IBM Corporation - initial API and implementation 
 ****************************************************************************/
/*
 * Created on Oct 23, 2003
 *
 * To change the template for this generated file go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
package org.eclipse.gmf.runtime.gef.ui.internal.palette;

/**
 * @author melaasar
 *
 * The palette separator class implementsing <code>PaletteIdentity</code>
 */
public class PaletteSeparator
	extends org.eclipse.gef.palette.PaletteSeparator {

	/**
	 * Creates a new Palette Separator
	 * @param id
	 */
	public PaletteSeparator(String id) {
		super(id);
	}

}
