Java tutorial
/* * Copyright 2010 The gwtquery plugins team. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ package gwtquery.plugins.droppable.client.gwt; import gwtquery.plugins.draggable.client.events.BeforeDragStartEvent; import gwtquery.plugins.draggable.client.events.BeforeDragStartEvent.BeforeDragStartEventHandler; import gwtquery.plugins.draggable.client.events.DragEvent; import gwtquery.plugins.draggable.client.events.DragEvent.DragEventHandler; import gwtquery.plugins.draggable.client.events.DragStartEvent; import gwtquery.plugins.draggable.client.events.DragStartEvent.DragStartEventHandler; import gwtquery.plugins.draggable.client.events.DragStopEvent; import gwtquery.plugins.draggable.client.events.DragStopEvent.DragStopEventHandler; import gwtquery.plugins.droppable.client.events.ActivateDroppableEvent.ActivateDroppableEventHandler; import gwtquery.plugins.droppable.client.events.DeactivateDroppableEvent.DeactivateDroppableEventHandler; import gwtquery.plugins.droppable.client.events.DropEvent.DropEventHandler; import gwtquery.plugins.droppable.client.events.OutDroppableEvent.OutDroppableEventHandler; import gwtquery.plugins.droppable.client.events.OverDroppableEvent.OverDroppableEventHandler; import java.util.List; import com.google.gwt.core.client.GWT; import com.google.gwt.event.shared.HandlerRegistration; import com.google.gwt.safehtml.shared.SafeHtml; import com.google.gwt.user.cellview.client.CellTable; import com.google.gwt.user.cellview.client.Column; import com.google.gwt.user.cellview.client.Header; import com.google.gwt.view.client.ProvidesKey; public class DragAndDropCellTable<T> extends CellTable<T> { /** * Resources that match the GWT standard style theme. */ public interface BasicResources extends Resources { /** * The styles used in this widget. */ @Source("gwtquery/plugins/droppable/client/gwt/DragAndDropCellTableBasic.css") Style cellTableStyle(); } public interface Resources extends com.google.gwt.user.cellview.client.CellTable.Resources { /** * The styles used in this widget. */ @Source("gwtquery/plugins/droppable/client/gwt/DragAndDropCellTable.css") Style cellTableStyle(); } /** * The default page size. */ private static final int DEFAULT_PAGESIZE = 15; private static Resources DEFAULT_RESOURCES; private static Resources getDefaultResources() { if (DEFAULT_RESOURCES == null) { DEFAULT_RESOURCES = GWT.create(Resources.class); } return DEFAULT_RESOURCES; } private DragAndDropAbstractCellTableDelegate<T> delegate; /** * Constructs a table with a default page size of 15. */ public DragAndDropCellTable() { this(DEFAULT_PAGESIZE); delegate = new DragAndDropAbstractCellTableDelegate<T>(); } /** * Constructs a table with the given page size. * * @param pageSize * the page size */ public DragAndDropCellTable(final int pageSize) { this(pageSize, getDefaultResources()); } /** * Constructs a table with the given page size and the given * {@link ProvidesKey key provider}. * * @param pageSize * the page size * @param keyProvider * an instance of ProvidesKey<T>, or null if the record object should * act as its own key */ public DragAndDropCellTable(final int pageSize, ProvidesKey<T> keyProvider) { this(pageSize, getDefaultResources(), keyProvider); } /** * Constructs a table with the given page size with the specified * {@link Resources}. * * @param pageSize * the page size * @param resources * the resources to use for this widget */ public DragAndDropCellTable(final int pageSize, Resources resources) { super(pageSize, resources); delegate = new DragAndDropAbstractCellTableDelegate<T>(); } /** * Constructs a table with the given page size, the specified * {@link Resources}, and the given key provider. * * @param pageSize * the page size * @param resources * the resources to use for this widget * @param keyProvider * an instance of ProvidesKey<T>, or null if the record object should * act as its own key */ public DragAndDropCellTable(final int pageSize, Resources resources, ProvidesKey<T> keyProvider) { super(pageSize, resources, keyProvider); delegate = new DragAndDropAbstractCellTableDelegate<T>(); } /** * Constructs a table with a default page size of 15, and the given * {@link ProvidesKey key provider}. * * @param keyProvider * an instance of ProvidesKey<T>, or null if the record object should * act as its own key */ public DragAndDropCellTable(ProvidesKey<T> keyProvider) { this(DEFAULT_PAGESIZE, getDefaultResources(), keyProvider); } public HandlerRegistration addActivateDroppableHandler(ActivateDroppableEventHandler handler) { return delegate.addActivateDroppableHandler(handler); } /** * Add a handler object that will manage the {@link BeforeDragStartEvent} * event. this kind of event is fired before the initialization of the drag * operation. */ public HandlerRegistration addBeforeDragHandler(BeforeDragStartEventHandler handler) { return delegate.addBeforeDragHandler(handler); } @Override public void insertColumn(int beforeIndex, Column<T, ?> col, Header<?> header, Header<?> footer) { super.insertColumn(beforeIndex, col, header, footer); delegate.insertColumn(beforeIndex, col); } public HandlerRegistration addDeactivateDroppableHandler(DeactivateDroppableEventHandler handler) { return delegate.addDeactivateDroppableHandler(handler); } /** * Add a handler object that will manage the {@link DragEvent} event. this * kind of event is fired during the move of the widget. */ public HandlerRegistration addDragHandler(DragEventHandler handler) { return delegate.addDragHandler(handler); } /** * Add a handler object that will manage the {@link DragStartEvent} event. * This kind of event is fired when the drag operation starts. */ public HandlerRegistration addDragStartHandler(DragStartEventHandler handler) { return delegate.addDragStartHandler(handler); } /** * Add a handler object that will manage the {@link DragStopEvent} event. This * kind of event is fired when the drag operation stops. */ public HandlerRegistration addDragStopHandler(DragStopEventHandler handler) { return delegate.addDragStopHandler(handler); } public HandlerRegistration addDropHandler(DropEventHandler handler) { return delegate.addDropHandler(handler); } public HandlerRegistration addOutDroppableHandler(OutDroppableEventHandler handler) { return delegate.addOutDroppableHandler(handler); } public HandlerRegistration addOverDroppableHandler(OverDroppableEventHandler handler) { return delegate.addOverDroppableHandler(handler); } @Override public void removeColumn(int index) { super.removeColumn(index); delegate.removeColumn(index); } @Override protected void onUnload() { delegate.cleanAllCells(getChildContainer()); super.onUnload(); } @Override protected void replaceAllChildren(List<T> values, SafeHtml html) { // first clean old cell before remove it delegate.cleanAllCells(getChildContainer()); // lets the super class replace all child super.replaceAllChildren(values, html); // make the new cell draggable or droppable delegate.addDragAndDropBehaviour(values, 0, getChildContainer()); } @Override protected void replaceChildren(List<T> values, int start, SafeHtml html) { // clean cell has being replaced int end = start + values.size(); delegate.cleanCellRange(start, end, getChildContainer()); // lets the super class replace all child super.replaceChildren(values, start, html); // make the new cell draggable or droppable delegate.addDragAndDropBehaviour(values, start, getChildContainer()); } }