*** empty log message ***
diff --git a/bundles/org.eclipse.swt/.classpath_gtk b/bundles/org.eclipse.swt/.classpath_gtk
index 045d19e..5a85f7b 100644
--- a/bundles/org.eclipse.swt/.classpath_gtk
+++ b/bundles/org.eclipse.swt/.classpath_gtk
@@ -9,7 +9,7 @@
<classpathentry kind="src" path="Eclipse SWT PI/common_j2se"/>
<classpathentry kind="src" path="Eclipse SWT Accessibility/emulated"/>
<classpathentry kind="src" path="Eclipse SWT Accessibility/common"/>
- <classpathentry kind="src" path="Eclipse SWT Drag and Drop/emulated"/>
+ <classpathentry kind="src" path="Eclipse SWT Drag and Drop/gtk"/>
<classpathentry kind="src" path="Eclipse SWT Drag and Drop/common"/>
<classpathentry kind="src" path="Eclipse SWT Printing/gtk"/>
<classpathentry kind="src" path="Eclipse SWT Printing/common"/>
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/ByteArrayTransfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/ByteArrayTransfer.java
new file mode 100644
index 0000000..15defa3
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/ByteArrayTransfer.java
@@ -0,0 +1,62 @@
+package org.eclipse.swt.dnd;
+
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved
+ */
+
+import org.eclipse.swt.internal.gtk.OS;
+
+/**
+ * The class <code>ByteArrayTransfer</code> provides a platform specific mechanism for transforming
+ * a Java array of bytes into a format that can be passed around in a Drag and Drop operation and vice
+ * versa.
+ *
+ * <p>This abstract class can be subclassed to provided utilities for transforming Java data types
+ * into the byte array based platform specific drag and drop data types. See TextTransfer and
+ * FileTransfer for examples. If the data you are transferring <b>does not</b> map to a byte array,
+ * you should sub-class Transfer directly and do your own mapping to the platform data types.</p>
+ */
+public abstract class ByteArrayTransfer extends Transfer {
+
+public TransferData[] getSupportedTypes(){
+ int[] types = getTypeIds();
+ TransferData[] data = new TransferData[types.length];
+ for (int i = 0; i < types.length; i++) {
+ data[i] = new TransferData();
+ data[i].type = types[i];
+ }
+ return data;
+}
+
+public boolean isSupportedType(TransferData transferData){
+ if ( transferData == null ) return false;
+ int[] types = getTypeIds();
+ for (int i = 0; i < types.length; i++) {
+ if (transferData.type == types[i]) return true;
+ }
+ return false;
+}
+
+protected void javaToNative (Object object, TransferData transferData){
+ if ((object == null) || !(object instanceof byte[]) || !(isSupportedType(transferData))) {
+ if ( transferData != null ) transferData.result = 0;
+ return;
+ }
+ byte[] buffer = (byte[])object;
+ transferData.pValue = OS.g_malloc(buffer.length);
+ OS.memmove(transferData.pValue, buffer, buffer.length);
+ transferData.length = buffer.length;
+ transferData.format = 8;
+ transferData.result = 1;
+}
+
+protected Object nativeToJava(TransferData transferData){
+ if ( !isSupportedType(transferData) || transferData.pValue == 0 ) return null;
+ int size = transferData.format * transferData.length / 8;
+ byte[] buffer = new byte[size];
+ OS.memmove(buffer, transferData.pValue, size);
+ return buffer;
+}
+
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/Clipboard.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/Clipboard.java
new file mode 100644
index 0000000..1e04065
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/Clipboard.java
@@ -0,0 +1,180 @@
+package org.eclipse.swt.dnd;
+
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved
+ */
+
+import org.eclipse.swt.*;
+import org.eclipse.swt.internal.*;
+import org.eclipse.swt.internal.gtk.GtkSelectionData;
+import org.eclipse.swt.internal.gtk.GtkTargetEntry;
+import org.eclipse.swt.internal.gtk.OS;
+import org.eclipse.swt.widgets.*;
+
+/**
+ * IMPORTANT: This class is <em>not</em> intended to be subclassed.
+ */
+public class Clipboard {
+
+ Display display;
+ Callback getFunc;
+ Callback clearFunc;
+
+ int pGtkClipboard;
+
+ /* Hold the reference for the data and transfer to be used in the callback */
+ Object[] data;
+ Transfer[] dataTypes;
+
+public Clipboard(Display display) {
+ checkSubclass ();
+ if (display == null) {
+ display = Display.getCurrent();
+ if (display == null) {
+ display = Display.getDefault();
+ }
+ }
+ if (display.getThread() != Thread.currentThread()) {
+ SWT.error(SWT.ERROR_THREAD_INVALID_ACCESS);
+ }
+ this.display = display;
+
+ //Setting callbacks
+ getFunc = new Callback( this, "getFunc", 4);
+ clearFunc = new Callback( this, "clearFunc", 2);
+
+ pGtkClipboard = OS.gtk_clipboard_get(OS.GDK_NONE);
+}
+
+int clearFunc(int clipboard,int user_data_or_owner){
+ data = null;
+ dataTypes = null;
+ return 1;
+}
+
+protected void checkSubclass () {
+ String name = getClass().getName ();
+ String validName = Clipboard.class.getName();
+ if (!validName.equals(name)) {
+ DND.error (SWT.ERROR_INVALID_SUBCLASS);
+ }
+}
+
+public void dispose () {
+ if (pGtkClipboard == 0) return;
+ if (data != null) OS.gtk_clipboard_clear(pGtkClipboard);
+ OS.g_free(pGtkClipboard);
+ pGtkClipboard = 0;
+ display = null;
+ if (getFunc != null ) getFunc.dispose();
+ getFunc = null;
+ if (clearFunc != null) clearFunc.dispose();
+ clearFunc = null;
+}
+public Object getContents(Transfer transfer) {
+ int selection_data = 0;
+ int[] typeIds = transfer.getTypeIds();
+ for (int i = 0; i < typeIds.length; i++) {
+ selection_data = OS.gtk_clipboard_wait_for_contents(pGtkClipboard, typeIds[i]);
+ if( selection_data != 0) break;
+ };
+ if (selection_data == 0) return null; // No data available for this transfer
+
+ GtkSelectionData gtkSelectionData = new GtkSelectionData(selection_data);
+ TransferData tdata = new TransferData();
+ tdata.type = gtkSelectionData.target;
+ tdata.pValue = gtkSelectionData.data;
+ tdata.length = gtkSelectionData.length;
+ tdata.format = gtkSelectionData.format;
+ Object result = transfer.nativeToJava(tdata);
+ OS.gtk_selection_data_free(selection_data);
+ return result;
+}
+
+/**
+ * This function provides the data to the clipboard.
+ * Because of the callback mechanism, the data in the clipboard
+ * will not be available when this object is disposed
+ * (just if the data was set in the clipboard by app who owns
+ * this Clipboard object)
+ */
+int getFunc( int clipboard, int selection_data, int info, int user_data_or_owner){
+ if (selection_data == 0) return 0;
+ GtkSelectionData selectionData = new GtkSelectionData(selection_data);
+ TransferData tdata = new TransferData();
+ tdata.type = selectionData.target;
+ int index = -1;
+ for (int i = 0; i < dataTypes.length; i++) {
+ if (dataTypes[i].isSupportedType(tdata)) {
+ index = i;
+ break;
+ }
+ }
+ if (index == -1) return 0;
+ dataTypes[index].javaToNative(data[index], tdata);
+ OS.gtk_selection_data_set(selection_data, tdata.type, tdata.format, tdata.pValue, tdata.length);
+ return 1;
+}
+
+public void setContents(Object[] data, Transfer[] dataTypes){
+ if (data == null || dataTypes == null || data.length != dataTypes.length) {
+ DND.error(SWT.ERROR_INVALID_ARGUMENT);
+ }
+ if (display.isDisposed() ) DND.error(DND.ERROR_CANNOT_SET_CLIPBOARD);
+ if (dataTypes.length == 0) return;
+
+ if (this.data != null) {
+ OS.gtk_clipboard_clear(pGtkClipboard);
+ }
+
+ GtkTargetEntry[] entries = new GtkTargetEntry [0];
+ for (int i = 0; i < dataTypes.length; i++) {
+ Transfer transfer = dataTypes[i];
+ int[] typeIds = transfer.getTypeIds();
+ String[] typeNames = transfer.getTypeNames();
+ for (int j = 0; j < typeIds.length; j++) {
+ GtkTargetEntry entry = new GtkTargetEntry();
+ entry.info = typeIds[j];
+ byte[] buffer = Converter.wcsToMbcs(null, typeNames[j], true);
+ int pName = OS.g_malloc(buffer.length);
+ OS.memmove(pName, buffer, buffer.length);
+ entry.target = pName;
+ GtkTargetEntry[] tmp = new GtkTargetEntry [entries.length + 1];
+ System.arraycopy(entries, 0, tmp, 0, entries.length);
+ tmp[entries.length] = entry;
+ entries = tmp;
+ }
+ }
+
+ int pTargetsList = OS.g_malloc(GtkTargetEntry.sizeof * entries.length);
+ int offset = 0;
+ for (int i = 0; i < entries.length; i++) {
+ OS.memmove(pTargetsList + offset, entries[i]);
+ offset += GtkTargetEntry.sizeof;
+ }
+
+ this.data = data;
+ this.dataTypes = dataTypes;
+
+ boolean result = OS.gtk_clipboard_set_with_data(pGtkClipboard, pTargetsList, entries.length, getFunc.getAddress(), clearFunc.getAddress(), 0);
+
+ if ( entries != null ) {
+ for (int i = 0; i < entries.length; i++) {
+ GtkTargetEntry entry = entries[i];
+ if( entry.target != 0) OS.g_free(entry.target);
+ }
+ }
+ if (pTargetsList != 0) OS.g_free(pTargetsList);
+
+ if (!result) DND.error(DND.ERROR_CANNOT_SET_CLIPBOARD);
+}
+/*
+ * Note: getAvailableTypeNames is a tool for writing a Transfer sub-class only. It should
+ * NOT be used within an application because it provides platform specfic
+ * information.
+ */
+public String[] getAvailableTypeNames() {
+ return new String[0];
+}
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/DragSource.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/DragSource.java
new file mode 100644
index 0000000..ff3cff3
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/DragSource.java
@@ -0,0 +1,392 @@
+package org.eclipse.swt.dnd;
+
+/*
+ * (c) Copyright IBM Corp. 2000, 2002.
+ * All Rights Reserved
+ */
+
+
+import org.eclipse.swt.*;
+import org.eclipse.swt.widgets.*;
+import org.eclipse.swt.internal.*;
+import org.eclipse.swt.internal.gtk.*;
+
+/**
+ *
+ * Class <code>DragSource</code> defines the source object for a drag and drop transfer.
+ *
+ * IMPORTANT: This class is <em>not</em> intended to be subclassed.
+ *
+ * <p>This class defines the following items:<ul>
+ * <li>the <code>Control</code> that the user clicks on to intiate a drag;
+ * <li>the data that will be transferred on a successful drop;
+ * <li>and the modes (move, copy, link) of transfer that are allowed.
+ * </ul></p>
+ *
+ * <p>You may have several DragSources in an application but you can only have one DragSource
+ * per Control. Data dragged from this DragSource can be dropped on a site within this application
+ * but it can also be dropped on another application such as an external Text editor.</p>
+ *
+ * <p>The application supplies the content of the data being transferred by implementing the interface
+ * <code>DragSourceListener</code> which uses the class <code>DragSourceEvent</code>.
+ * The application is required to take the appropriate action to remove the data from the drag source
+ * when a successful move operation occurs.</p>
+ *
+ * <code><pre>
+ * // Enable a label as a Drag Source
+ * Label label = new Label(shell, SWT.NONE);
+ * // This example will allow text to be dragged
+ * Transfer[] types = new Transfer[] {TextTransfer.getInstance()};
+ * // This example will allow the text to be copied or moved to the drop target
+ * int operations = DND.DROP_MOVE | DND.DROP_COPY;
+ *
+ * DragSource source = new DragSource (label, operations);
+ * source.setTransfer(types);
+ * source.addDragListener (new DragSourceListener() {
+ * public void dragStart(DragSourceEvent e) {
+ * // Only start the drag if there is actually text in the
+ * // label - this text will be what is dropped on the target.
+ * if (label.getText().length() == 0) {
+ * event.doit = false;
+ * }
+ * };
+ * public void dragSetData (DragSourceEvent event) {
+ * // A drop has been performed, so provide the data of the
+ * // requested type.
+ * // (Checking the type of the requested data is only
+ * // necessary if the drag source supports more than
+ * // one data type but is shown here as an example).
+ * if (TextTransfer.getInstance().isSupportedType(event.dataType)){
+ * event.data = label.getText();
+ * }
+ * }
+ * public void dragFinished(DragSourceEvent event) {
+ * // A Move operation has been performed so remove the data
+ * // from the source
+ * if (event.detail == DND.DROP_MOVE)
+ * label.setText("");
+ * }
+ * });
+ * </pre></code>
+ *
+ *
+ * <dl>
+ * <dt><b>Styles</b> <dd>DND.DROP_NONE, DND.DROP_COPY, DND.DROP_MOVE, DND.DROP_LINK
+ * <dt><b>Events</b> <dd>DND.DragEnd, DND.DragSetData
+ * </dl>
+ */
+public final class DragSource extends Widget {
+ Control control;
+ Transfer[] transfers;
+ Callback dragBegin;
+ Callback dragGetData;
+ Callback dragEnd;
+ int dragBeginAddress;
+ int dragGetDataAddress;
+ int dragEndAddress;
+
+ GtkTargetEntry[] targets; //Data reference to be freed
+ int targets_list; //Data reference to be freed
+
+ final int buttonMask = OS.GDK_BUTTON1_MASK | OS.GDK_BUTTON3_MASK;
+ int operations;
+
+ Listener controlListener;
+
+/**
+ * Creates a new <code>DragSource</code> to handle dragging from the specified <code>Control</code>.
+ *
+ * @param control the <code>Control</code> that the user clicks on to initiate the drag
+ *
+ * @param style the bitwise OR'ing of allowed operations; this may be a combination of any of
+ * DND.DROP_NONE, DND.DROP_COPY, DND.DROP_MOVE, DND.DROP_LINK
+ *
+ */
+public DragSource(Control control, int style) {
+ super (control, checkStyle(style));
+ this.control = control;
+
+ operations = 0;
+ if ( (style & DND.DROP_MOVE) != 0) operations |= OS.GDK_ACTION_MOVE;
+ if ( (style & DND.DROP_COPY) != 0) operations |= OS.GDK_ACTION_COPY;
+ if ( (style & DND.DROP_LINK) != 0) operations |= OS.GDK_ACTION_LINK;
+
+ // Drag Begin Callback
+ dragBegin = new Callback(this, "dragBegin", 3);
+ dragBeginAddress = dragBegin.getAddress();
+ byte[] dragBeginB = Converter.wcsToMbcs(null, "drag_begin", true);
+ OS.gtk_signal_connect(control.handle, dragBeginB, dragBeginAddress, 0);
+
+ // Drag Get Data Callback
+ dragGetData = new Callback(this, "dragGetData", 6);
+ dragGetDataAddress = dragGetData.getAddress();
+ byte[] dragGetDataB = Converter.wcsToMbcs(null, "drag_data_get", true);
+ OS.gtk_signal_connect(control.handle, dragGetDataB, dragGetDataAddress, 0);
+
+ // Drag End Callback
+ dragEnd = new Callback(this, "dragEnd", 3);
+ dragEndAddress = dragEnd.getAddress();
+ byte[] dragEndB = Converter.wcsToMbcs(null, "drag_end", true);
+ OS.gtk_signal_connect(control.handle, dragEndB, dragEndAddress, 0);
+
+
+ controlListener = new Listener(){
+ public void handleEvent(Event event){
+ DragSource.this.dispose();
+ }
+ };
+ control.addListener(SWT.Dispose, controlListener);
+ this.addListener(SWT.Dispose, new Listener(){
+ public void handleEvent(Event event){
+ DragSource.this.onDispose();
+ }
+ });
+
+}
+
+/**
+ * Adds the listener to receive events.
+ *
+ * @param listener the listener
+ *
+ * @exception SWTError
+ * <ul><li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>
+ * <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>
+ * <li>ERROR_NULL_ARGUMENT when listener is null</li></ul>
+ */
+public void addDragListener(DragSourceListener listener) {
+ if (listener == null) DND.error (SWT.ERROR_NULL_ARGUMENT);
+ DNDListener typedListener = new DNDListener (listener);
+ addListener (DND.DragStart, typedListener);
+ addListener (DND.DragEnd, typedListener);
+ addListener (DND.DragSetData, typedListener);
+}
+
+static int checkStyle (int style) {
+ if (style == SWT.NONE) return DND.DROP_MOVE;
+ return style;
+}
+
+
+int dragBegin(int widget, int context, int data){
+
+ int time = 0;
+ if(context != 0 ) {
+ GdkDragContext gdkDragContext = new GdkDragContext(context);
+ time = gdkDragContext.start_time; //BAD (ALWAYS ZERO)
+ if (time == 0) time = OS.GDK_CURRENT_TIME(); //BAD (ALWAYS ZERO)
+ }
+ DNDEvent event = new DNDEvent();
+ event.doit = true;
+ event.widget = this;
+ event.time = time;
+ notifyListeners(DND.DragStart, event);
+
+ if ( ! event.doit) {
+ OS.gdk_drag_abort(context, event.time ); //BAD (NOT WORKING)
+ }
+
+ return 1;
+}
+
+int dragEnd(int widget, int context, int data){
+ int op = DND.DROP_NONE;
+ boolean doit = true;
+ if (context != 0) {
+ GdkDragContext dragContext = new GdkDragContext (context);
+ switch (dragContext.action) {
+ case OS.GDK_ACTION_MOVE:
+ op = DND.DROP_MOVE;
+ break;
+ case OS.GDK_ACTION_COPY:
+ op = DND.DROP_COPY;
+ break;
+ case OS.GDK_ACTION_LINK:
+ op = DND.DROP_LINK;
+ break;
+ case 0: //Drag was cancel
+ doit = false;
+ break;
+ }
+ }
+
+ DNDEvent event = new DNDEvent();
+ event.widget = this;
+ event.doit = doit;
+ event.detail = op;
+ notifyListeners(DND.DragEnd, event);
+ return 1;
+}
+
+int dragGetData(int widget, int context, int selection_data, int info, int time, int data){
+ DNDEvent event = new DNDEvent();
+ event.widget = this;
+ event.time = time;
+ TransferData tdata = new TransferData ();
+ tdata.type = info;
+ event.dataType = tdata;
+
+ notifyListeners(DND.DragSetData, event);
+
+ if (event.data == null) return 0;
+
+ Transfer transfer = null;
+ for (int i = 0; i < transfers.length; i++) {
+ transfer = transfers[i];
+ if (transfer.isSupportedType(tdata)) break;
+ }
+ if (transfer == null) return 0;
+
+ if (selection_data == 0) return 0;
+ GtkSelectionData gtkSelectionData = new GtkSelectionData(selection_data);
+ if (gtkSelectionData.target == 0) return 0;
+
+ transfer.javaToNative(event.data, tdata);
+
+ OS.gtk_selection_data_set(selection_data, gtkSelectionData.target, transfer.format, tdata.pValue , tdata.length);
+
+ return 1;
+
+}
+
+public Display getDisplay () {
+ if (control == null) DND.error(SWT.ERROR_WIDGET_DISPOSED);
+ return control.getDisplay ();
+}
+
+/**
+ * Returns the list of data types that can be transferred by this DragSource.
+ *
+ * @return the list of data types that can be transferred by this DragSource
+ */
+public Transfer[] getTransfer(){
+ return transfers;
+}
+
+private void onDispose(){
+ if (dragBegin != null )
+ dragBegin.dispose();
+ dragBegin = null;
+
+ if (dragGetData != null )
+ dragGetData.dispose();
+ dragGetData = null;
+
+ if (dragEnd != null )
+ dragEnd.dispose();
+ dragEnd = null;
+
+
+ if (control != null){
+ OS.gtk_drag_source_unset(control.handle);
+ if (controlListener != null)
+ control.removeListener(SWT.Dispose, controlListener);
+ }
+
+ releaseTargets();
+ control = null;
+ controlListener = null;
+}
+
+
+private void releaseTargets(){
+
+ if ( targets != null ) {
+ for (int i = 0; i < targets.length; i++) {
+ GtkTargetEntry entry = targets[i];
+ if( entry.target != 0) OS.g_free(entry.target);
+ }
+ }
+
+ if (targets_list != 0) {
+ OS.g_free(targets_list);
+ }
+
+ targets_list = 0;
+ targets = null;
+}
+
+/**
+ * Removes the listener.
+ *
+ * @param listener the listener
+ *
+ * @exception SWTError
+ * <ul><li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>
+ * <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>
+ * <li>ERROR_NULL_ARGUMENT when listener is null</li></ul>
+ */
+public void removeDragListener(DragSourceListener listener) {
+ if (listener == null) DND.error (SWT.ERROR_NULL_ARGUMENT);
+ removeListener (DND.DragStart, listener);
+ removeListener (DND.DragEnd, listener);
+ removeListener (DND.DragSetData, listener);
+}
+
+private void setTargetList(){
+
+ if (transfers == null) return;
+ if (control == null) return;
+
+ releaseTargets();
+
+ int n_entry = 0;
+ GtkTargetEntry[] entrys = new GtkTargetEntry [n_entry];
+
+
+ Transfer[] transferAgents = transfers;
+ for (int i = 0; i < transferAgents.length; i++) {
+ Transfer transfer = transferAgents[i];
+ int[] types = transfer.getTypeIds();
+ for (int j = 0; j < types.length; j++) {
+ int type = types[j];
+ String typename = transfer.getTypeNames()[j];
+ byte[] buffer = Converter.wcsToMbcs(null, typename, true);
+ int ptr = OS.g_malloc(buffer.length);
+ OS.memmove(ptr, buffer, buffer.length);
+
+ GtkTargetEntry entry = new GtkTargetEntry();
+ entry.target = ptr;
+ entry.info = type;
+
+ GtkTargetEntry[] tmp = new GtkTargetEntry [n_entry + 1];
+ System.arraycopy(entrys, 0, tmp, 0, n_entry);
+ tmp[ n_entry ] = entry;
+ entrys = tmp;
+ n_entry++;
+ }
+ }
+
+ byte[] buffer = new byte[ GtkTargetEntry.sizeof * n_entry ];
+ byte[] tmp = new byte[ GtkTargetEntry.sizeof ];
+ for (int i = 0; i < n_entry; i++) {
+ OS.memmove(tmp, entrys[i], GtkTargetEntry.sizeof);
+ System.arraycopy(tmp, 0, buffer, i * GtkTargetEntry.sizeof, tmp.length);
+ }
+
+ int ptr = OS.g_malloc(buffer.length);
+ OS.memmove(ptr, buffer, buffer.length);
+
+ if (targets_list != 0){
+ OS.gtk_drag_source_unset(control.handle);
+ }
+
+ targets_list = ptr;
+ targets = entrys;
+
+ OS.gtk_drag_source_set(control.handle, buttonMask , targets_list, n_entry, operations );
+
+}
+
+/**
+ * Specifies the list of data types that can be transferred by this DragSource.
+ * The application must be able to provide data to match each of these types when
+ * a successful drop has occurred.
+ */
+public void setTransfer(Transfer[] transferAgents){
+ if (transferAgents == null) DND.error(SWT.ERROR_NULL_ARGUMENT);
+ this.transfers = transferAgents;
+ setTargetList();
+}
+
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/DropTarget.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/DropTarget.java
new file mode 100644
index 0000000..3cf19d4
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/DropTarget.java
@@ -0,0 +1,505 @@
+package org.eclipse.swt.dnd;
+
+/*
+ * (c) Copyright IBM Corp. 2000, 2002.
+ * All Rights Reserved
+ */
+
+import org.eclipse.swt.*;
+import org.eclipse.swt.graphics.*;
+import org.eclipse.swt.widgets.*;
+import org.eclipse.swt.internal.*;
+import org.eclipse.swt.internal.gtk.*;
+
+/**
+ *
+ * Class <code>DropTarget</code> defines the target object for a drag and drop transfer.
+ *
+ * IMPORTANT: This class is <em>not</em> intended to be subclassed.
+ *
+ * <p>This class identifies the <code>Control</code> over which the user must position the cursor
+ * in order to drop the data being transferred. It also specifies what data types can be dropped on
+ * this control and what operations can be performed. You may have several DropTragets in an
+ * application but there can only be a one to one mapping between a <code>Control</code> and a <code>DropTarget</code>.
+ * The DropTarget can receive data from within the same application or from other applications
+ * (such as text dragged from a text editor like Word).</p>
+ *
+ * <code><pre>
+ * int operations = DND.DROP_MOVE | DND.DROP_COPY | DND.DROP_LINK;
+ * Transfer[] types = new Transfer[] {TextTransfer.getInstance()};
+ * DropTarget target = new DropTarget(label, operations);
+ * target.setTransfer(types);
+ * </code></pre>
+ *
+ * <p>The application is notified of data being dragged over this control and of when a drop occurs by
+ * implementing the interface <code>DropTargetListener</code> which uses the class
+ * <code>DropTargetEvent</code>. The application can modify the type of drag being performed
+ * on this Control at any stage of the drag by modifying the <code>event.detail</code> field or the
+ * <code>event.currentDataType</code> field. When the data is dropped, it is the responsibility of
+ * the application to copy this data for its own purposes.
+ *
+ * <code><pre>
+ * target.addDropListener (new DropTargetListener() {
+ * public void dragEnter(DropTargetEvent event) {};
+ * public void dragOver(DropTargetEvent event) {};
+ * public void dragLeave(DropTargetEvent event) {};
+ * public void dragOperationChanged(DropTargetEvent event) {};
+ * public void dropAccept(DropTargetEvent event) {}
+ * public void drop(DropTargetEvent event) {
+ * // A drop has occurred, copy over the data
+ * if (event.data == null) { // no data to copy, indicate failure in event.detail
+ * event.detail = DND.DROP_NONE;
+ * return;
+ * }
+ * label.setText ((String) event.data); // data copied to label text
+ * }
+ * });
+ * </pre></code>
+ *
+ * <dl>
+ * <dt><b>Styles</b> <dd>DND.DROP_NONE, DND.DROP_COPY, DND.DROP_MOVE, DND.DROP_LINK
+ * <dt><b>Events</b> <dd>DND.DragEnter, DND.DragLeave, DND.DragOver, DND.DragOperationChanged,
+ * DND.Drop, DND.DropAccept
+ * </dl>
+ */
+public final class DropTarget extends Widget {
+
+/**
+ * Creates a new <code>DropTarget</code> to handle dropping on the specified <code>Control</code>.
+ *
+ * @param control the <code>Control</code> over which the user positions the cursor to drop data
+ *
+ * @param style the bitwise OR'ing of allowed operations; this may be a combination of any of
+ * DND.DROP_NONE, DND.DROP_COPY, DND.DROP_MOVE, DND.DROP_LINK
+ *
+ */
+ Control control;
+ boolean isEnter = true;
+ Callback dragMotion;
+ Callback dragLeave;
+ Callback dragDataReceived;
+
+ int dragMotionAddress;
+ int dragLeaveAddress;
+ int dragDataReceivedAddress;
+
+ Transfer[] transfers;
+ TransferData[] transferDatas;
+
+ GtkTargetEntry[] targets; //Data reference to be freed
+ int targets_list; //Data reference to be freed
+
+ Listener controlListener;
+
+ int lastOperation = -1; // To control operations changed events
+ int lastX, lastY; // To be used in drag leave event (callback do not provided it)
+
+ private DragUnderEffect effect;
+
+public DropTarget(Control control, int style) {
+ super(control, checkStyle(style));
+ this.control = control;
+
+ // Drag Motion Callback
+ dragMotion = new Callback(this, "dragMotion", 5);
+ dragMotionAddress = dragMotion.getAddress();
+ byte[] dragMotionB = Converter.wcsToMbcs(null, "drag_motion", true);
+ OS.gtk_signal_connect(control.handle, dragMotionB, dragMotionAddress, 0);
+
+ // Drag Leave Callback
+ dragLeave = new Callback(this, "dragLeave", 3);
+ dragLeaveAddress = dragLeave.getAddress();
+ byte[] dragLeaveB = Converter.wcsToMbcs(null, "drag_leave", true);
+ OS.gtk_signal_connect(control.handle, dragLeaveB, dragLeaveAddress, 0);
+
+ // Drag Data Received Callback
+ dragDataReceived = new Callback(this, "dragDataReceived", 7);
+ dragDataReceivedAddress = dragDataReceived.getAddress();
+ byte[] DataReceivedB = Converter.wcsToMbcs(null, "drag_data_received", true);
+ OS.gtk_signal_connect(control.handle, DataReceivedB, dragDataReceivedAddress, 0);
+
+ // Dispose listeners
+ controlListener = new Listener(){
+ public void handleEvent(Event event){
+ DropTarget.this.dispose();
+ }
+ };
+ control.addListener(SWT.Dispose, controlListener);
+ this.addListener(SWT.Dispose, new Listener(){
+ public void handleEvent(Event event){
+ DropTarget.this.onDispose();
+ }
+ });
+
+ // Drag under effect
+ if (control instanceof Tree) {
+ effect = new TreeDragUnderEffect((Tree)control);
+ } else if (control instanceof Table) {
+ effect = new TableDragUnderEffect((Table)control);
+ } else {
+ effect = new NoDragUnderEffect(control);
+ }
+}
+
+/**
+ * Adds the listener to receive events.
+ *
+ * @param listener the listener
+ *
+ * @exception SWTError
+ * <ul><li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>
+ * <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>
+ * <li>ERROR_NULL_ARGUMENT when listener is null</li></ul>
+ */
+public void addDropListener(DropTargetListener listener) {
+ if (listener == null) DND.error (SWT.ERROR_NULL_ARGUMENT);
+ DNDListener typedListener = new DNDListener (listener);
+ addListener (DND.DragEnter, typedListener);
+ addListener (DND.DragLeave, typedListener);
+ addListener (DND.DragOver, typedListener);
+ addListener (DND.DragOperationChanged, typedListener);
+ addListener (DND.Drop, typedListener);
+ addListener (DND.DropAccept, typedListener);
+}
+
+static int checkStyle (int style) {
+ if (style == SWT.NONE) return DND.DROP_MOVE;
+ return style;
+}
+
+int dragDataReceived ( int widget, int context, int x, int y, int data, int info, int time){
+ if (data == 0) return 0;
+ GtkSelectionData gtkSelectionData = new GtkSelectionData( data );
+ if (context == 0) return 0;
+ GdkDragContext dragContext = new GdkDragContext( context );
+
+ if (gtkSelectionData.data == 0) return 0;
+
+ TransferData tdata = new TransferData ();
+ tdata.type = info;
+ tdata.length = gtkSelectionData.length;
+ tdata.pValue = gtkSelectionData.data;
+
+ Point coordinates = new Point( x, y );
+ coordinates = control.toDisplay( coordinates );
+
+ int[] act = getCurrentOperation(context);
+
+ DNDEvent event = new DNDEvent();
+ event.widget = this;
+ event.x = coordinates.x;
+ event.y = coordinates.y;
+ event.time = time;
+ event.detail = act[0];
+ event.operations = act[1];
+ event.dataType = tdata;
+ event.dataTypes = new TransferData[] { tdata }; //looks bad, but the dataType cann't be changed at this step anyway
+ notifyListeners(DND.DropAccept, event);
+
+ /* NOTE: GTK do not provided a way to choose the typedata just before the drop */
+
+
+ if (event.detail == DND.DROP_NONE) {
+ OS.gtk_drag_finish(context, false, false, time); // It's Useless
+// OS.gdk_drag_abort(context, time); // can not be used in this callback (GP)
+ return 0;
+ }
+
+ Transfer transfer = null;
+ for (int i = 0; i < transfers.length; i++) {
+ transfer = transfers[i];
+ if (transfer.isSupportedType(tdata)) break;
+ }
+ if (transfer == null) return 0;
+
+ Object value = transfer.nativeToJava(tdata);
+
+ event = new DNDEvent();
+ event.widget = this;
+ event.x = coordinates.x;
+ event.y = coordinates.y;
+ event.detail = act[0];
+ event.operations = act[1];
+ event.time = time;
+ event.dataType = tdata;
+ event.data = value;
+ this.notifyListener(DND.Drop, event);
+
+ OS.gtk_drag_finish(context, true, dragContext.action == OS.GDK_ACTION_MOVE, time);
+ return 1;
+}
+
+int dragLeave ( int widget, int context, int time){
+ int[] act = getCurrentOperation(context);
+ DNDEvent event = new DNDEvent();
+ event.widget = this;
+ event.time = time;
+ event.x = lastX;
+ event.y = lastY;
+ event.dataType = getTransferData(context);
+ event.dataTypes = new TransferData[] { event.dataType }; //BAD
+ event.detail = act[0];
+ event.operations = act[1];
+ notifyListeners(DND.DragLeave, event);
+ isEnter = true;
+ return 1;
+}
+
+int dragMotion ( int widget, int context, int x, int y, int time){
+ DNDEvent event = new DNDEvent();
+ int[] act = getCurrentOperation(context);
+ Point coordinates = control.toDisplay( new Point( x, y) );
+ event.widget = this;
+ event.x = coordinates.x;
+ event.y = coordinates.y;
+ event.dataType = getTransferData(context);
+ event.dataTypes = new TransferData[] { event.dataType }; //BAD
+ event.detail = act[0];
+ event.operations = act[1];
+ event.time = time;
+ event.feedback = DND.FEEDBACK_NONE;
+
+ // to be used in dragleave
+ lastX = event.x;
+ lastY = event.y;
+
+ int type = DND.DragOver;
+ if(isEnter){
+ type = DND.DragEnter;
+ isEnter = false;
+ } else {
+ if ( lastOperation != -1 && event.detail != lastOperation ) {
+ type = DND.DragOperationChanged;
+ }
+ }
+ lastOperation = event.detail;
+
+ notifyListeners(type, event);
+
+ effect.show( event.feedback, coordinates.x, coordinates.y);
+
+ if (event.detail == DND.DROP_NONE) {
+ // Does not work properly, do not send drag_end signal for the source side
+ OS.gdk_drag_abort(context, time);
+ return 0;
+ }
+
+ return 1;
+}
+
+private int getActions(){
+ int style = getStyle();
+ int operationsDnd = 0;
+ if ( (style & DND.DROP_MOVE) != 0) operationsDnd |= OS.GDK_ACTION_MOVE;
+ if ( (style & DND.DROP_COPY) != 0) operationsDnd |= OS.GDK_ACTION_COPY;
+ if ( (style & DND.DROP_LINK) != 0) operationsDnd |= OS.GDK_ACTION_LINK;
+ return operationsDnd;
+}
+
+/**
+ * Returns the Control which is registered for this DropTarget. This is the control over which the
+ * user positions the cursor to drop the data.
+ *
+ * @return the Control which is registered for this DropTarget
+ *
+ */
+public Control getControl () {
+ return control;
+}
+
+/**
+ * @return int[] length equals 2,
+ * index 0 holds the currentAction
+ * index 1 holds a bitwise of all possible actions
+ *
+ */
+private int[] getCurrentOperation(int context){
+ if(context == 0) return new int[]{ DND.DROP_MOVE, DND.DROP_MOVE};
+ GdkDragContext dragContext = new GdkDragContext(context);
+
+ int action = DND.DROP_MOVE;
+ if(dragContext.action == OS.GDK_ACTION_COPY) action = DND.DROP_COPY;
+ if(dragContext.action == OS.GDK_ACTION_LINK) action = DND.DROP_LINK;
+
+ int actions = 0;
+ if((dragContext.actions & OS.GDK_ACTION_MOVE) != 0) actions |= DND.DROP_MOVE;
+ if((dragContext.actions & OS.GDK_ACTION_COPY) != 0) actions |= DND.DROP_COPY;
+ if((dragContext.actions & OS.GDK_ACTION_LINK) != 0) actions |= DND.DROP_LINK;
+
+ return new int[] {action, actions};
+}
+
+public Display getDisplay () {
+ if (control == null) DND.error(SWT.ERROR_WIDGET_DISPOSED);
+ return control.getDisplay ();
+}
+
+/**
+ * Returns the list of data types that can be transferred to this DropTarget.
+ *
+ * @return the list of data types that can be transferred to this DropTarget
+ *
+ */
+public Transfer[] getTransfer() {
+ return transfers;
+}
+
+private TransferData getTransferData(int context){
+ TransferData tdata = new TransferData();
+ if ( context == 0) return tdata;
+ GdkDragContext dragContext = new GdkDragContext(context);
+ int atom = OS.gtk_drag_dest_find_target(control.handle, context, 0);
+ int ptr = OS.gdk_atom_name(atom);
+ int len = OS.strlen(ptr);
+ byte[] buffer = new byte [ len ];
+ OS.memmove(buffer, ptr, len);
+ String formatname = new String ( Converter.mbcsToWcs(null, buffer) );
+ tdata.type = Transfer.registerType(formatname); // Lazy way
+ return tdata;
+}
+
+public void notifyListener (int eventType, Event event) {
+ Point coordinates = new Point(event.x, event.y);
+ coordinates = control.toControl(coordinates);
+ if (this.control instanceof Tree) {
+ event.item = ((Tree)control).getItem(coordinates);
+ }
+ if (this.control instanceof Table) {
+ event.item = ((Table)control).getItem(coordinates);
+ }
+ super.notifyListeners(eventType, event);
+}
+
+private void onDispose(){
+ if (dragMotion != null )
+ dragMotion.dispose();
+ dragMotion = null;
+
+ if (dragDataReceived != null )
+ dragDataReceived.dispose();
+ dragDataReceived = null;
+
+ if (dragLeave!= null )
+ dragLeave.dispose();
+ dragLeave = null;
+
+ if (control != null){
+ OS.gtk_drag_dest_unset(control.handle);
+ if (controlListener != null)
+ control.removeListener(SWT.Dispose, controlListener);
+ }
+
+ releaseTargets();
+ control = null;
+ controlListener = null;
+}
+
+private void releaseTargets(){
+
+ if ( targets != null ) {
+ for (int i = 0; i < targets.length; i++) {
+ GtkTargetEntry entry = targets[i];
+ if( entry.target != 0) OS.g_free(entry.target);
+ }
+ }
+
+ if (targets_list != 0) {
+ OS.g_free(targets_list);
+ }
+
+ targets_list = 0;
+ targets = null;
+}
+
+/**
+ * Removes the listener.
+ *
+ * @param listener the listener
+ *
+ * @exception SWTError
+ * <ul><li>ERROR_THREAD_INVALID_ACCESS when called from the wrong thread</li>
+ * <li>ERROR_WIDGET_DISPOSED when the widget has been disposed</li>
+ * <li>ERROR_NULL_ARGUMENT when listener is null</li></ul>
+ */
+public void removeDropListener(DropTargetListener listener) {
+ if (listener == null) DND.error (SWT.ERROR_NULL_ARGUMENT);
+ removeListener (DND.DragEnter, listener);
+ removeListener (DND.DragLeave, listener);
+ removeListener (DND.DragOver, listener);
+ removeListener (DND.DragOperationChanged, listener);
+ removeListener (DND.Drop, listener);
+ removeListener (DND.DropAccept, listener);
+}
+
+private void setTargetList(){
+
+ if (transfers == null) return;
+ if (control == null) return;
+
+ //Release previous allocates data (remember)
+
+ int n_entry = 0;
+ GtkTargetEntry[] entrys = new GtkTargetEntry [n_entry];
+
+
+ Transfer[] transferAgents = transfers;
+ for (int i = 0; i < transferAgents.length; i++) {
+ Transfer transfer = transferAgents[i];
+ int[] types = transfer.getTypeIds();
+ for (int j = 0; j < types.length; j++) {
+ int type = types[j];
+ String typename = transfer.getTypeNames()[j];
+ byte[] buffer = Converter.wcsToMbcs(null, typename, true);
+ int ptr = OS.g_malloc(buffer.length);
+ OS.memmove(ptr, buffer, buffer.length);
+
+ GtkTargetEntry entry = new GtkTargetEntry();
+ entry.target = ptr;
+ entry.info = type;
+
+ GtkTargetEntry[] tmp = new GtkTargetEntry [n_entry + 1];
+ System.arraycopy(entrys, 0, tmp, 0, n_entry);
+ tmp[ n_entry ] = entry;
+ entrys = tmp;
+ n_entry++;
+ }
+ }
+
+ byte[] buffer = new byte[ GtkTargetEntry.sizeof * n_entry ];
+ byte[] tmp = new byte[ GtkTargetEntry.sizeof ];
+ for (int i = 0; i < n_entry; i++) {
+ OS.memmove(tmp, entrys[i], GtkTargetEntry.sizeof);
+ System.arraycopy(tmp, 0, buffer, i * GtkTargetEntry.sizeof, tmp.length);
+ }
+
+ transferDatas = new TransferData[entrys.length];
+ for (int i = 0; i < transferDatas.length; i++) {
+ TransferData td = new TransferData();
+ td.type = entrys[i].target;
+ transferDatas[i] = td;
+ }
+
+ if (targets_list != 0){
+ OS.gtk_drag_dest_unset(control.handle);
+ }
+
+ targets_list = OS.g_malloc(buffer.length);
+ OS.memmove(targets_list, buffer, buffer.length);
+ targets = entrys;
+
+ OS.gtk_drag_dest_set(control.handle, OS.GTK_DEST_DEFAULT_ALL, targets_list, n_entry, getActions());
+
+}
+
+/**
+ * Specifies the list of data types that can be transferred to this DropTarget.
+ *
+ * @param transferAgents a list of Transfer objects which define the types of data that can be
+ * dropped on this target
+ */
+public void setTransfer(Transfer[] transferAgents){
+ if (transferAgents == null) DND.error(SWT.ERROR_NULL_ARGUMENT);
+ this.transfers = transferAgents;
+ setTargetList();
+}
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/FileTransfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/FileTransfer.java
new file mode 100644
index 0000000..d792b76
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/FileTransfer.java
@@ -0,0 +1,104 @@
+package org.eclipse.swt.dnd;
+
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved
+ */
+
+import org.eclipse.swt.internal.Converter;
+import org.eclipse.swt.internal.gtk.OS;
+
+/**
+ * The <code>FileTransfer</code> class is used to transfer files in a drag and drop operation.
+ */
+public class FileTransfer extends ByteArrayTransfer {
+
+ private static final FileTransfer _instance = new FileTransfer();
+ private static final String TYPENAME = "text/uri-list";
+ private static final int TYPEID = Transfer.registerType(TYPENAME);
+
+private FileTransfer() {}
+/**
+ * Returns the singleton instance of the FileTransfer class.
+ *
+ * @return the singleton instance of the FileTransfer class
+ */
+public static FileTransfer getInstance () {
+ return _instance;
+}
+/**
+ * Converts a list of filenames to a platform specific representation.
+ * <p>
+ * On a successful conversion, the transferData.result field will be set as follows:
+ * <ul>
+ * <li>Windows: OLE.S_OK
+ * <li>Motif: 0
+ * </ul>
+ * If this transfer agent is unable to perform the conversion,
+ * the transferData.result field will be set to a failure value as follows:
+ * <ul>
+ * <li>Windows: OLE.DV_E_TYMED
+ * <li>Motif: 1
+ * </ul></p>
+ *
+ * @param object a list of file names
+ * @param transferData an empty TransferData object; this object will be filled in on return
+ * with the platform specific format of the data
+ */
+public void javaToNative(Object object, TransferData transferData) {
+ if (object == null || !(object instanceof String[])) return;
+
+ // build a byte array from data
+ String[] files = (String[])object;
+
+ // create a string separated by "new lines" to represent list of files
+ String nativeFormat = "file:";
+ for (int i = 0, length = files.length; i < length; i++){
+ nativeFormat += files[i]+"\r";
+ }
+ nativeFormat += "\0";
+ // pass byte array on to super to convert to native
+ super.javaToNative(nativeFormat.getBytes(), transferData);
+}
+/**
+ * Converts a platform specific representation of a list of file names to a Java array of String.
+ *
+ * @param transferData the platform specific representation of the data that has been transferred
+ * @return a Java array of String containing a list of file names if the conversion was successful;
+ * otherwise null
+ */
+public Object nativeToJava(TransferData transferData) {
+
+ byte[] data = (byte[])super.nativeToJava(transferData);
+ if (data == null) return null;
+ String string = new String(data);
+ // parse data and convert string to array of files
+ int start = string.indexOf("file:");
+ if (start == -1) return null;
+ start += 5;
+ String[] fileNames = new String[0];
+ while (start < string.length()) {
+ int end = string.indexOf("\r", start);
+ if (end == -1) end = string.length() - 1;
+
+ String fileName = string.substring(start, end);
+ String[] newFileNames = new String[fileNames.length + 1];
+ System.arraycopy(fileNames, 0, newFileNames, 0, fileNames.length);
+ newFileNames[fileNames.length] = fileName;
+ fileNames = newFileNames;
+
+ start = string.indexOf("file:", end);
+ if (start == -1) break;
+ start += 5;
+ }
+ return fileNames;
+}
+
+protected String[] getTypeNames(){
+ return new String[]{TYPENAME};
+}
+protected int[] getTypeIds(){
+ return new int[]{TYPEID};
+}
+}
+
\ No newline at end of file
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/RTFTransfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/RTFTransfer.java
new file mode 100644
index 0000000..8baed20
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/RTFTransfer.java
@@ -0,0 +1,80 @@
+package org.eclipse.swt.dnd;
+
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved
+ */
+
+import org.eclipse.swt.internal.Converter;
+import org.eclipse.swt.internal.gtk.OS;
+
+/**
+ * The <code>RTFTransfer</code> class is used to transfer text with the RTF format
+ * in a drag and drop operation.
+ */
+public class RTFTransfer extends ByteArrayTransfer {
+
+ private static RTFTransfer _instance = new RTFTransfer();
+ private static final String TYPENAME1 = "text/rtf";
+ private static final int TYPEID1 = registerType(TYPENAME1);
+ private static final String TYPENAME2 = "TEXT/RTF";
+ private static final int TYPEID2 = registerType(TYPENAME2);
+ private static final String TYPENAME3 = "application/rtf";
+ private static final int TYPEID3 = registerType(TYPENAME3);
+
+private RTFTransfer() {
+}
+/**
+ * Returns the singleton instance of the RTFTransfer class.
+ *
+ * @return the singleton instance of the RTFTransfer class
+ */
+public static RTFTransfer getInstance () {
+ return _instance;
+}
+/**
+ * Converts a RTF-formatted Java String to a platform specific representation.
+ * <p>
+ * On a successful conversion, the transferData.result field will be set as follows:
+ * <ul>
+ * <li>Windows: OLE.S_OK
+ * <li>Motif: 0
+ * </ul>
+ * If this transfer agent is unable to perform the conversion,
+ * the transferData.result field will be set to a failure value as follows:
+ * <ul>
+ * <li>Windows: OLE.DV_E_TYMED
+ * <li>Motif: 1
+ * </ul></p>
+ *
+ * @param object a Java String containing the data to be transferred
+ * @param transferData an empty TransferData object; this object will be filled in on return
+ * with the platform specific format of the data
+ */
+public void javaToNative (Object object, TransferData transferData){
+ if (object == null || !(object instanceof String)) return;
+ byte [] buffer = Converter.wcsToMbcs (null, (String)object, true);
+ super.javaToNative(buffer, transferData);
+}
+/**
+ * Converts a platform specific representation of a string to a Java String.
+ *
+ * @param transferData the platform specific representation of the data that has been transferred
+ * @return a Java String containing the transferred data if the conversion was successful;
+ * otherwise null
+ */
+public Object nativeToJava(TransferData transferData){
+ if ( !isSupportedType(transferData) || transferData.pValue == 0 ) return null;
+ if (transferData.length <=0) transferData.length = OS.strlen(transferData.pValue);
+ byte[] buffer = (byte[]) super.nativeToJava(transferData);
+ if (buffer == null) return null;
+ char [] unicode = Converter.mbcsToWcs (null, buffer);
+ return new String (unicode);
+}
+protected String[] getTypeNames(){
+ return new String[]{TYPENAME1, TYPENAME2, TYPENAME3};
+}
+protected int[] getTypeIds(){
+ return new int[]{TYPEID1, TYPEID2, TYPEID3};
+}
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/TableDragUnderEffect.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/TableDragUnderEffect.java
new file mode 100644
index 0000000..7b9e962
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/TableDragUnderEffect.java
@@ -0,0 +1,101 @@
+package org.eclipse.swt.dnd;
+
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved
+ */
+
+import org.eclipse.swt.graphics.*;
+import org.eclipse.swt.widgets.*;
+
+class TableDragUnderEffect extends DragUnderEffect {
+ private Table table;
+ private TableItem[] selection = new TableItem[0];
+ private int currentEffect = DND.FEEDBACK_NONE;
+ private TableItem dropSelection;
+ private TableItem scrollItem;
+ private long scrollBeginTime;
+ private static final int SCROLL_HYSTERESIS = 400; // milli seconds
+ private static final int SCROLL_WIDTH = 100; // pixels
+
+TableDragUnderEffect(Table table) {
+ this.table = table;
+}
+void show(int effect, int x, int y) {
+ TableItem item = findItem(x, y);
+ if (item == null) effect = DND.FEEDBACK_NONE;
+ if (currentEffect == DND.FEEDBACK_NONE && effect != DND.FEEDBACK_NONE) {
+ selection = table.getSelection();
+ table.deselectAll();
+ }
+ scrollHover(effect, item, x, y);
+ setDragUnderEffect(effect, item);
+ if (currentEffect != DND.FEEDBACK_NONE && effect == DND.FEEDBACK_NONE) {
+ table.setSelection(selection);
+ selection = new TableItem[0];
+ }
+ currentEffect = effect;
+}
+private TableItem findItem(int x, int y){
+ if (table == null) return null;
+ Point coordinates = new Point(x, y);
+ coordinates = table.toControl(coordinates);
+ TableItem item = table.getItem(coordinates);
+ if (item != null) return item;
+
+ Rectangle area = table.getClientArea();
+ for (int x1 = area.x; x1 < area.x + area.width; x1++) {
+ coordinates = new Point(x1, y);
+ coordinates = table.toControl(coordinates);
+ item = table.getItem(coordinates);
+ if (item != null) return item;
+ }
+ return null;
+}
+private void setDragUnderEffect(int effect, TableItem item) {
+ if ((effect & DND.FEEDBACK_SELECT) != 0) {
+ setDropSelection(item);
+ return;
+ }
+ if ((currentEffect & DND.FEEDBACK_SELECT) != 0) setDropSelection(null);
+}
+private void setDropSelection (TableItem item) {
+ if (item == dropSelection) return;
+ if (dropSelection != null) table.deselectAll();
+ dropSelection = item;
+ if (dropSelection != null) table.setSelection(new TableItem[]{dropSelection});
+}
+private void scrollHover (int effect, TableItem item, int x, int y) {
+ if ((effect & DND.FEEDBACK_SCROLL) == 0) {
+ scrollBeginTime = 0;
+ scrollItem = null;
+ return;
+ }
+ if (scrollItem == item && scrollBeginTime != 0) {
+ if (System.currentTimeMillis() >= scrollBeginTime) {
+ scroll(item, x, y);
+ scrollBeginTime = 0;
+ scrollItem = null;
+ }
+ return;
+ }
+ scrollBeginTime = System.currentTimeMillis() + SCROLL_HYSTERESIS;
+ scrollItem = item;
+}
+private void scroll(TableItem item, int x, int y) {
+ if (item == null) return;
+ Point coordinates = new Point(x, y);
+ coordinates = table.toControl(coordinates);
+ Rectangle area = table.getClientArea();
+ TableItem showItem = null;
+ int itemIndex = table.indexOf(item);
+ if (coordinates.y - area.y < SCROLL_WIDTH) {
+ showItem = table.getItem(Math.max(0, itemIndex - 1));
+ } else if ((area.y + area.height - coordinates.y) < SCROLL_WIDTH) {
+ showItem = table.getItem(Math.min(table.getItemCount() - 1, itemIndex + 1));
+ }
+ if (showItem != null) {
+ table.showItem(showItem);
+ }
+}
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/TextTransfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/TextTransfer.java
new file mode 100644
index 0000000..4ee2647
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/TextTransfer.java
@@ -0,0 +1,79 @@
+package org.eclipse.swt.dnd;
+
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved
+ */
+
+import org.eclipse.swt.internal.Converter;
+import org.eclipse.swt.internal.gtk.OS;
+
+/**
+ * The <code>TextTransfer</code> class is used to transfer text in a drag and drop operation.
+ */
+public class TextTransfer extends ByteArrayTransfer {
+
+ private static TextTransfer _instance = new TextTransfer();
+ private static final String TYPENAME1 = "STRING";
+ private static final int TYPEID1 = registerType(TYPENAME1);
+ private static final String TYPENAME2 = "text/plain";
+ private static final int TYPEID2 = registerType(TYPENAME2);
+ private static final String TYPENAME3 = "text/text";
+ private static final int TYPEID3 = registerType(TYPENAME3);
+
+private TextTransfer() {
+}
+/**
+ * Returns the singleton instance of the TextTransfer class.
+ *
+ * @return the singleton instance of the TextTransfer class
+ */
+public static TextTransfer getInstance () {
+ return _instance;
+}
+/**
+ * Converts a plain text Java String to a platform specific representation.
+ * <p>
+ * On a successful conversion, the transferData.result field will be set as follows:
+ * <ul>
+ * <li>Windows: OLE.S_OK
+ * <li>Motif: 0
+ * </ul>
+ * If this transfer agent is unable to perform the conversion,
+ * the transferData.result field will be set to a failure value as follows:
+ * <ul>
+ * <li>Windows: OLE.DV_E_TYMED
+ * <li>Motif: 1
+ * </ul></p>
+ *
+ * @param object a Java String containing the data to be transferred
+ * @param transferData an empty TransferData object; this object will be filled in on return
+ * with the platform specific format of the data
+ */
+public void javaToNative (Object object, TransferData transferData){
+ if (object == null || !(object instanceof String)) return;
+ byte [] buffer = Converter.wcsToMbcs (null, (String)object, true);
+ super.javaToNative(buffer, transferData);
+}
+/**
+ * Converts a platform specific representation of a string to a Java String.
+ *
+ * @param transferData the platform specific representation of the data that has been transferred
+ * @return a Java String containing the transferred data if the conversion was successful;
+ * otherwise null
+ */
+public Object nativeToJava(TransferData transferData){
+ if ( !isSupportedType(transferData) || transferData.pValue == 0 ) return null;
+ if (transferData.length <=0) transferData.length = OS.strlen(transferData.pValue);
+ byte[] buffer = (byte[]) super.nativeToJava(transferData);
+ char [] unicode = Converter.mbcsToWcs (null, buffer);
+ return new String (unicode);
+}
+
+protected String[] getTypeNames(){
+ return new String[]{TYPENAME1, TYPENAME2, TYPENAME3};
+}
+protected int[] getTypeIds(){
+ return new int[]{TYPEID1, TYPEID2, TYPEID3};
+}
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/Transfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/Transfer.java
new file mode 100644
index 0000000..253f50e
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/Transfer.java
@@ -0,0 +1,58 @@
+package org.eclipse.swt.dnd;
+
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved
+ */
+
+import org.eclipse.swt.internal.Converter;
+import org.eclipse.swt.internal.gtk.OS;
+
+/**
+ * The class <code>Transfer</code> provides a mechanism for converting a Java object to a
+ * platform specific format that can be passed around in a Drag and Drop operation and vice versa.
+ *
+ * <p>You should only need to become familiar with this class if you are implementing
+ * a Transfer subclass and you are unable to subclass the ByteArrayTransfer class.</p>
+ */
+public abstract class Transfer {
+/**
+ * Returns a list of the data types that can be transferred using this Transfer agent.
+ *
+ * <p>Only the data type fields of the TransferData Object are filled in.</p>
+ *
+ * @return a list of the data types that can be transferred using this Transfer agent
+ */
+abstract public TransferData[] getSupportedTypes();
+/**
+ * Returns true if the transferData data type can be transferred using this Transfer agent.
+ *
+ * @param transferData a platform specific description of a data type; only the data type fields
+ * of the TransferData Object need to be filled in
+ *
+ * @return true if the transferData data type can be transferred using this Transfer agent
+ */
+abstract public boolean isSupportedType(TransferData transferData);
+abstract protected String[] getTypeNames();
+abstract protected int[] getTypeIds();
+abstract protected void javaToNative (Object object, TransferData transferData);
+abstract protected Object nativeToJava(TransferData transferData);
+/**
+ * Registers a name for a data type and returns the associated unique identifier.
+ *
+ * <p>You may register the same type more than once, the same unique identifier will be returned if the
+ * type has been previously registered.</p>
+ *
+ * <p>Note: Do <b>not</b> call this method with pre-defined Clipboard Format types such as CF_TEXT
+ * or CF_BITMAP because the pre-defined value will not be returned</p>
+ *
+ * @param formatName the name of a data type
+ *
+ * @return the unique identifier associated with this data type
+ */
+public static int registerType(String formatName){
+ if (formatName == null) return OS.GDK_NONE;
+ byte[] buffer = Converter.wcsToMbcs(null, formatName, true);
+ return OS.gdk_atom_intern(buffer, 0);
+}
+}
\ No newline at end of file
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/TransferData.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/TransferData.java
new file mode 100644
index 0000000..64a8c75
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/TransferData.java
@@ -0,0 +1,35 @@
+package org.eclipse.swt.dnd;
+
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved
+ */
+
+/**
+ * The <code>TransferData</code> class is a platform specific data structure for describing the type and the
+ * contents of data being transferred in a Drag and Drop operation.
+ *
+ * <p>As an application writer, you do not need to know anything about the specifics of TransferData. You
+ * should just pass the TransferData instances to subclass of Transfer and let the Transfer objects deal
+ * with the platform specific issues. You can ask a Transfer subclass if it can handle this data by calling
+ * TextTransfer.isSupportedType(transferData). You can get a list of the types of TransferData supported by a
+ * Transfer object by calling TextTransfer.getSupportedTypes().</p>
+ *
+ * <p>You should only need to become familiar with the fields in this class if you are implementing
+ * a Transfer subclass and you are unable to subclass the ByteArrayTransfer class.</p>
+ */
+public class TransferData {
+ /**
+ * Data Type - a pre-defined clipboard format <b>or</b> the unique identifier of a user defined format
+ * (Warning: This field is platform dependent)
+ */
+ public int type;
+
+ // attributes specific to set/get
+ int length;
+ int format;
+ int pValue;
+
+ int result;
+
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/TreeDragUnderEffect.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/TreeDragUnderEffect.java
new file mode 100644
index 0000000..9698a3a
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/gtk/org/eclipse/swt/dnd/TreeDragUnderEffect.java
@@ -0,0 +1,214 @@
+package org.eclipse.swt.dnd;
+
+/*
+ * (c) Copyright IBM Corp. 2000, 2001.
+ * All Rights Reserved
+ */
+import org.eclipse.swt.graphics.*;
+import org.eclipse.swt.widgets.*;
+import org.eclipse.swt.SWT;
+
+class TreeDragUnderEffect extends DragUnderEffect {
+
+ private Tree tree;
+ private int currentEffect = DND.FEEDBACK_NONE;
+ private TreeItem[] selection = new TreeItem[0];
+ private TreeItem dropSelection = null;
+ private TreeItem insertMark = null;
+ private boolean insertBefore = false;
+
+ private TreeItem scrollItem;
+ private long scrollBeginTime;
+ private static final int SCROLL_HYSTERESIS = 400; // milli seconds
+ private static final int SCROLL_WIDTH = 100; // pixels
+
+ private TreeItem expandItem;
+ private long expandBeginTime;
+ private static final int EXPAND_HYSTERESIS = 1000; // milli seconds
+
+TreeDragUnderEffect(Tree tree) {
+ this.tree = tree;
+}
+void show(int effect, int x, int y) {
+ effect = checkEffect(effect);
+ TreeItem item = findItem(x, y);
+ if (item == null) effect = DND.FEEDBACK_NONE;
+ if (currentEffect == DND.FEEDBACK_NONE && effect != DND.FEEDBACK_NONE) {
+ selection = tree.getSelection();
+ tree.deselectAll();
+ }
+ scrollHover(effect, item, x, y);
+ expandHover(effect, item, x, y);
+ setDragUnderEffect(effect, item);
+ if (currentEffect != DND.FEEDBACK_NONE && effect == DND.FEEDBACK_NONE) {
+ tree.setSelection(selection);
+ selection = new TreeItem[0];
+ }
+ currentEffect = effect;
+}
+private int checkEffect(int effect) {
+ // Some effects are mutually exclusive. Make sure that only one of the mutually exclusive effects has been specified.
+ int mask = DND.FEEDBACK_INSERT_AFTER | DND.FEEDBACK_INSERT_BEFORE | DND.FEEDBACK_SELECT;
+ int bits = effect & mask;
+ if (bits == DND.FEEDBACK_INSERT_AFTER || bits == DND.FEEDBACK_INSERT_BEFORE || bits == DND.FEEDBACK_SELECT) return effect;
+ return (effect & ~mask);
+}
+private TreeItem findItem(int x , int y){
+ Point coordinates = new Point(x, y);
+ coordinates = tree.toControl(coordinates);
+ Rectangle area = tree.getClientArea();
+ if (!area.contains(coordinates)) return null;
+
+ TreeItem item = tree.getItem(coordinates);
+ if (item != null) return item;
+
+ // Scan across the width of the tree.
+ for (int x1 = area.x; x1 < area.x + area.width; x1++) {
+ coordinates = new Point(x1, coordinates.y);
+ item = tree.getItem(coordinates);
+ if (item != null) return item;
+ }
+ // Check if we are just below the last item of the tree
+ coordinates = new Point(x, y);
+ coordinates = tree.toControl(coordinates);
+ if (coordinates.y > area.y + area.height - tree.getItemHeight()) {;
+ int y1 = area.y + area.height - tree.getItemHeight();
+ coordinates = new Point(coordinates.x, y1);
+
+ item = tree.getItem(coordinates);
+ if (item != null) return item;
+
+ // Scan across the width of the tree just above the bottom..
+ for (int x1 = area.x; x1 < area.x + area.width; x1++) {
+ coordinates = new Point(x1, y1);
+ item = tree.getItem(coordinates);
+ if (item != null) return item;
+ }
+ }
+ return null;
+}
+private void setDragUnderEffect(int effect, TreeItem item) {
+ if ((effect & DND.FEEDBACK_SELECT) != 0) {
+ if ((currentEffect & DND.FEEDBACK_INSERT_AFTER) != 0 ||
+ (currentEffect & DND.FEEDBACK_INSERT_BEFORE) != 0) {
+// tree.setInsertMark(null, false);
+ }
+ setDropSelection(item);
+ return;
+ }
+ if ((effect & DND.FEEDBACK_INSERT_AFTER) != 0 ||
+ (effect & DND.FEEDBACK_INSERT_BEFORE) != 0) {
+ if ((currentEffect & DND.FEEDBACK_SELECT) != 0) {
+ setDropSelection(null);
+ }
+ setInsertMark(item, (effect & DND.FEEDBACK_INSERT_BEFORE) != 0);
+ return;
+ }
+
+ setInsertMark(null, false);
+ setDropSelection(null);
+}
+private void setDropSelection (TreeItem item) {
+ if (item == dropSelection) return;
+ if (dropSelection != null) tree.deselectAll();
+ dropSelection = item;
+ if (dropSelection != null) tree.setSelection(new TreeItem[]{dropSelection});
+}
+private void setInsertMark(TreeItem item, boolean before) {
+ if (item == insertMark && before == insertBefore) return;
+ insertMark = item;
+ insertBefore = before;
+// tree.setInsertMark(item, before);
+}
+private void scrollHover (int effect, TreeItem item, int x, int y) {
+ if ((effect & DND.FEEDBACK_SCROLL) == 0) {
+ scrollBeginTime = 0;
+ scrollItem = null;
+ return;
+ }
+ if (scrollItem == item && scrollBeginTime != 0) {
+ if (System.currentTimeMillis() >= scrollBeginTime) {
+ scroll(item, x, y);
+ scrollBeginTime = 0;
+ scrollItem = null;
+ }
+ return;
+ }
+ scrollBeginTime = System.currentTimeMillis() + SCROLL_HYSTERESIS;
+ scrollItem = item;
+}
+private void scroll(TreeItem item, int x, int y) {
+ if (item == null) return;
+ Point coordinates = new Point(x, y);
+ coordinates = tree.toControl(coordinates);
+ Rectangle area = tree.getClientArea();
+ TreeItem showItem = null;
+ if (coordinates.y - area.y < SCROLL_WIDTH) {
+ showItem = getPreviousVisibleItem(item);
+ } else if ((area.y + area.height - coordinates.y) < SCROLL_WIDTH) {
+ showItem = getNextVisibleItem(item, true);
+ }
+ if (showItem != null) {
+ tree.showItem(showItem);
+ }
+}
+private void expandHover (int effect, TreeItem item, int x, int y) {
+ if ((effect & DND.FEEDBACK_EXPAND) == 0) {
+ expandBeginTime = 0;
+ expandItem = null;
+ return;
+ }
+ if (expandItem == item && expandBeginTime != 0) {
+ if (System.currentTimeMillis() >= expandBeginTime) {
+ expand(item, x, y);
+ expandBeginTime = 0;
+ expandItem = null;
+ }
+ return;
+ }
+ expandBeginTime = System.currentTimeMillis() + EXPAND_HYSTERESIS;
+ expandItem = item;
+}
+private void expand(TreeItem item, int x, int y) {
+ if (item == null || item.getExpanded()) return;
+ Event event = new Event();
+ event.x = x;
+ event.y = y;
+ event.item = item;
+ event.time = (int) System.currentTimeMillis();
+ tree.notifyListeners(SWT.Expand, event);
+ if (item.isDisposed()) return;
+ item.setExpanded(true);
+}
+private TreeItem getNextVisibleItem(TreeItem item, boolean includeChildren) {
+ // look down
+ // neccesary on the first pass only
+ if (includeChildren && item.getItemCount() > 0 && item.getExpanded()) {
+ return item.getItems()[0];
+ }
+ // look sideways
+ TreeItem parent = item.getParentItem();
+ TreeItem[] peers = (parent != null) ? parent.getItems() : tree.getItems();
+ for (int i = 0; i < peers.length - 1; i++) {
+ if (peers[i] == item) return peers[i + 1];
+ }
+ // look up
+ if (parent != null) return getNextVisibleItem(parent, false);
+ return null;
+}
+private TreeItem getPreviousVisibleItem(TreeItem item) {
+ // look sideways
+ TreeItem parent = item.getParentItem();
+ TreeItem[] peers = (parent != null) ? parent.getItems() : tree.getItems();
+ for (int i = peers.length - 1; i > 0; i--) {
+ if (peers[i] == item) {
+ TreeItem peer = peers[i-1];
+ if (!peer.getExpanded() || peer.getItemCount() == 0) return peer;
+ TreeItem[] peerItems = peer.getItems();
+ return peerItems[peerItems.length - 1];
+ }
+ }
+ // look up
+ return parent;
+}
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/ByteArrayTransfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/ByteArrayTransfer.java
index 13155b4..633c288 100755
--- a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/ByteArrayTransfer.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/ByteArrayTransfer.java
@@ -5,7 +5,7 @@
* All Rights Reserved
*/
-import org.eclipse.swt.internal.motif.*;
+import org.eclipse.swt.internal.motif.OS;
/**
* The class <code>ByteArrayTransfer</code> provides a platform specific mechanism for transforming
@@ -37,18 +37,18 @@
}
protected void javaToNative (Object object, TransferData transferData){
if ((object == null) || !(object instanceof byte[]) || !(isSupportedType(transferData))) {
- transferData.result = 0;
+ if ( transferData != null ) transferData.result = 0;
return;
}
byte[] buffer = (byte[])object;
- transferData.pValue = OS.XtMalloc(buffer.length + 1);
+ transferData.pValue = OS.XtMalloc(buffer.length);
OS.memmove(transferData.pValue, buffer, buffer.length);
transferData.length = buffer.length;
transferData.format = 8;
transferData.result = 1;
}
protected Object nativeToJava(TransferData transferData){
- if (transferData == null || transferData.pValue == 0 || !(isSupportedType(transferData))) return null;
+ if ( !(isSupportedType(transferData) || transferData.pValue == 0)) return null;
int size = transferData.format * transferData.length / 8;
byte[] buffer = new byte[size];
OS.memmove(buffer, transferData.pValue, size);
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/Clipboard.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/Clipboard.java
index 4bf7a12..a83d896 100755
--- a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/Clipboard.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/Clipboard.java
@@ -111,12 +111,9 @@
return result;
}
-public void setContents(Object[] data, Transfer[] transferAgents){
+public void setContents(Object[] data, Transfer[] dataTypes){
- if (data == null) {
- DND.error(SWT.ERROR_NOT_IMPLEMENTED);
- }
- if (transferAgents == null || data.length != transferAgents.length) {
+ if (data == null || dataTypes == null || data.length != dataTypes.length) {
DND.error(SWT.ERROR_INVALID_ARGUMENT);
}
@@ -141,15 +138,15 @@
DND.error(DND.ERROR_CANNOT_SET_CLIPBOARD);
// copy data directly over to System clipboard (not deferred)
- for (int i = 0; i < transferAgents.length; i++) {
- String[] names = transferAgents[i].getTypeNames();
+ for (int i = 0; i < dataTypes.length; i++) {
+ String[] names = dataTypes[i].getTypeNames();
for (int j = 0; j < names.length; j++) {
TransferData transferData = new TransferData();
/* Use the character encoding for the default locale */
byte[] bName = Converter.wcsToMbcs (null, names[j], false);
transferData.type = OS.XmInternAtom (xDisplay, bName, false);
- transferAgents[i].javaToNative(data[i], transferData);
+ dataTypes[i].javaToNative(data[i], transferData);
status = OS.XmClipboardFail;
if (transferData.result == 1 && transferData.format == 8){
byte[] buffer = new byte[transferData.length];
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/FileTransfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/FileTransfer.java
index 0bda4b5..f749b42 100755
--- a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/FileTransfer.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/FileTransfer.java
@@ -11,7 +11,7 @@
public class FileTransfer extends ByteArrayTransfer {
private static FileTransfer _instance = new FileTransfer();
- private static final String TYPENAME = "text/uri-list\0";
+ private static final String TYPENAME = "text/uri-list";
private static final int TYPEID = registerType(TYPENAME);
private FileTransfer() {}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/RTFTransfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/RTFTransfer.java
index f2b015d..a10e757 100755
--- a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/RTFTransfer.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/RTFTransfer.java
@@ -12,11 +12,11 @@
public class RTFTransfer extends ByteArrayTransfer {
private static RTFTransfer _instance = new RTFTransfer();
- private static final String TYPENAME1 = "text/rtf\0";
+ private static final String TYPENAME1 = "text/rtf";
private static final int TYPEID1 = registerType(TYPENAME1);
- private static final String TYPENAME2 = "TEXT/RTF\0";
+ private static final String TYPENAME2 = "TEXT/RTF";
private static final int TYPEID2 = registerType(TYPENAME2);
- private static final String TYPENAME3 = "application/rtf\0";
+ private static final String TYPENAME3 = "application/rtf";
private static final int TYPEID3 = registerType(TYPENAME3);
private RTFTransfer() {
@@ -50,9 +50,8 @@
*/
public void javaToNative (Object object, TransferData transferData){
if (object == null || !(object instanceof String)) return;
-
- String text = (String)object;
- super.javaToNative(text.getBytes(), transferData);
+ byte [] buffer = Converter.wcsToMbcs (null, (String)object, true);
+ super.javaToNative(buffer, transferData);
}
/**
* Converts a platform specific representation of a string to a Java String.
@@ -66,7 +65,8 @@
byte[] buffer = (byte[])super.nativeToJava(transferData);
if (buffer == null) return null;
// convert byte array to a string
- return new String(buffer);
+ char [] unicode = Converter.mbcsToWcs (null, buffer);
+ return new String (unicode);
}
protected String[] getTypeNames(){
return new String[]{TYPENAME1, TYPENAME2, TYPENAME3};
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/TextTransfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/TextTransfer.java
index 93fb0cf..6120790 100755
--- a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/TextTransfer.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/TextTransfer.java
@@ -11,11 +11,11 @@
public class TextTransfer extends ByteArrayTransfer {
private static TextTransfer _instance = new TextTransfer();
- private static final String TYPENAME1 = "STRING\0";
+ private static final String TYPENAME1 = "STRING";
private static final int TYPEID1 = registerType(TYPENAME1);
- private static final String TYPENAME2 = "text/plain\0";
+ private static final String TYPENAME2 = "text/plain";
private static final int TYPEID2 = registerType(TYPENAME2);
- private static final String TYPENAME3 = "text/text\0";
+ private static final String TYPENAME3 = "text/text";
private static final int TYPEID3 = registerType(TYPENAME3);
private TextTransfer() {
@@ -49,9 +49,8 @@
*/
public void javaToNative (Object object, TransferData transferData){
if (object == null || !(object instanceof String)) return;
-
- String text = (String)object;
- super.javaToNative(text.getBytes(), transferData);
+ byte [] buffer = Converter.wcsToMbcs (null, (String)object, true);
+ super.javaToNative(buffer, transferData);
}
/**
* Converts a platform specific representation of a string to a Java String.
@@ -65,7 +64,8 @@
byte[] buffer = (byte[])super.nativeToJava(transferData);
if (buffer == null) return null;
// convert byte array to a string
- return new String(buffer);
+ char [] unicode = Converter.mbcsToWcs (null, buffer);
+ return new String (unicode);
}
protected String[] getTypeNames(){
return new String[]{TYPENAME1, TYPENAME2, TYPENAME3};
diff --git a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/Transfer.java b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/Transfer.java
index adfd307..ec816ae 100755
--- a/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/Transfer.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT Drag and Drop/motif/org/eclipse/swt/dnd/Transfer.java
@@ -49,14 +49,12 @@
*
* @param formatName the name of a data type
*
- * @return the unique identifier associated with htis data type
+ * @return the unique identifier associated with this data type
*/
public static int registerType(String formatName){
-
int xDisplay = Display.getDefault().xDisplay; // using default because we don't have a particular widget
/* Use the character encoding for the default locale */
- byte[] bName = Converter.wcsToMbcs (null, formatName, false);
- int atom = OS.XmInternAtom (xDisplay, bName, false);
- return atom;
+ byte[] bName = Converter.wcsToMbcs (null, formatName, true);
+ return OS.XmInternAtom (xDisplay, bName, false);
}
}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/structs.c b/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/structs.c
index b1228fa..ecc4273 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/structs.c
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/structs.c
@@ -19,6 +19,9 @@
#include "structs.h"
/* Globals */
+GdkDragContext_FID_CACHE GdkDragContextFc;
+GtkTargetEntry_FID_CACHE GtkTargetEntryFc;
+GtkSelectionData_FID_CACHE GtkSelectionDataFc;
GdkColor_FID_CACHE GdkColorFc;
GdkEventExpose_FID_CACHE GdkEventExposeFc;
GdkFont_FID_CACHE GdkFontFc;
@@ -1502,3 +1505,125 @@
(*env)->SetIntField(env, lpObject, lpGtkCTreeRowFc->is_leaf, (jint)lpGtkCTreeRow->is_leaf);
(*env)->SetIntField(env, lpObject, lpGtkCTreeRowFc->expanded, (jint)lpGtkCTreeRow->expanded);
}
+
+void cacheGtkSelectionDataFids(JNIEnv *env, jobject lpObject, PGtkSelectionData_FID_CACHE lpCache)
+{
+ if (lpCache->cached) return;
+ lpCache->clazz = (*env)->GetObjectClass(env, lpObject);
+ lpCache->selection = (*env)->GetFieldID(env, lpCache->clazz, "selection", "I");
+ lpCache->target = (*env)->GetFieldID(env, lpCache->clazz, "target", "I");
+ lpCache->type = (*env)->GetFieldID(env, lpCache->clazz, "type", "I");
+ lpCache->format = (*env)->GetFieldID(env, lpCache->clazz, "format", "I");
+ lpCache->data = (*env)->GetFieldID(env, lpCache->clazz, "data", "I");
+ lpCache->length = (*env)->GetFieldID(env, lpCache->clazz, "length", "I");
+ lpCache->cached = 1;
+}
+
+GtkSelectionData* getGtkSelectionDataFields(JNIEnv *env, jobject lpObject, GtkSelectionData *lpStruct, PGtkSelectionData_FID_CACHE lpCache)
+{
+ if (!lpCache->cached) cacheGtkSelectionDataFids(env, lpObject, lpCache);
+ lpStruct->selection = (GdkAtom)(*env)->GetIntField(env, lpObject, lpCache->selection);
+ lpStruct->target = (GdkAtom)(*env)->GetIntField(env, lpObject, lpCache->target);
+ lpStruct->type = (GdkAtom)(*env)->GetIntField(env, lpObject, lpCache->type);
+ lpStruct->format = (*env)->GetIntField(env, lpObject, lpCache->format);
+ lpStruct->data = (guchar*)(*env)->GetIntField(env, lpObject, lpCache->data);
+ lpStruct->length = (*env)->GetIntField(env, lpObject, lpCache->length);
+ return lpStruct;
+}
+
+void setGtkSelectionDataFields(JNIEnv *env, jobject lpObject, GtkSelectionData *lpStruct, PGtkSelectionData_FID_CACHE lpCache)
+{
+ if (!lpCache->cached) cacheGtkSelectionDataFids(env, lpObject, lpCache);
+ (*env)->SetIntField(env, lpObject, lpCache->selection, (jint) lpStruct->selection);
+ (*env)->SetIntField(env, lpObject, lpCache->target, (jint)lpStruct->target);
+ (*env)->SetIntField(env, lpObject, lpCache->type, (jint)lpStruct->type);
+ (*env)->SetIntField(env, lpObject, lpCache->format, lpStruct->format);
+ (*env)->SetIntField(env, lpObject, lpCache->data, (jint)lpStruct->data);
+ (*env)->SetIntField(env, lpObject, lpCache->length, lpStruct->length);
+}
+
+void cacheGtkTargetEntryFids(JNIEnv *env, jobject lpObject, PGtkTargetEntry_FID_CACHE lpCache)
+{
+ if (lpCache->cached) return;
+ lpCache->clazz = (*env)->GetObjectClass(env, lpObject);
+ lpCache->target = (*env)->GetFieldID(env, lpCache->clazz, "target", "I");
+ lpCache->flags = (*env)->GetFieldID(env, lpCache->clazz, "flags", "I");
+ lpCache->info = (*env)->GetFieldID(env, lpCache->clazz, "info", "I");
+ lpCache->cached = 1;
+}
+
+GtkTargetEntry* getGtkTargetEntryFields(JNIEnv *env, jobject lpObject, GtkTargetEntry *lpStruct, PGtkTargetEntry_FID_CACHE lpCache)
+{
+ if (!lpCache->cached) cacheGtkTargetEntryFids(env, lpObject, lpCache);
+ lpStruct->target = (gchar*)(*env)->GetIntField(env, lpObject, lpCache->target);
+ lpStruct->flags = (*env)->GetIntField(env, lpObject, lpCache->flags);
+ lpStruct->info = (*env)->GetIntField(env, lpObject, lpCache->info);
+ return lpStruct;
+}
+
+void setGtkTargetEntryFields(JNIEnv *env, jobject lpObject, GtkTargetEntry *lpStruct, PGtkTargetEntry_FID_CACHE lpCache)
+{
+ if (!lpCache->cached) cacheGtkTargetEntryFids(env, lpObject, lpCache);
+ (*env)->SetIntField(env, lpObject, lpCache->target, (jint)lpStruct->target);
+ (*env)->SetIntField(env, lpObject, lpCache->flags, (jint)lpStruct->flags);
+ (*env)->SetIntField(env, lpObject, lpCache->info, (jint)lpStruct->info);
+}
+
+void cacheGdkDragContextFids(JNIEnv *env, jobject lpObject, PGdkDragContext_FID_CACHE lpCache)
+{
+ if (lpCache->cached) return;
+ lpCache->clazz = (*env)->GetObjectClass(env, lpObject);
+ lpCache->parent_instance$g_type_instance$g_class = (*env)->GetFieldID(env, lpCache->clazz, "parent_instance$g_type_instance$g_class", "I");
+ lpCache->parent_instance$ref_count = (*env)->GetFieldID(env, lpCache->clazz, "parent_instance$ref_count", "I");
+ lpCache->parent_instance$qdata = (*env)->GetFieldID(env, lpCache->clazz, "parent_instance$qdata", "I");
+ lpCache->protocol = (*env)->GetFieldID(env, lpCache->clazz, "protocol", "I");
+ lpCache->is_source = (*env)->GetFieldID(env, lpCache->clazz, "is_source", "Z");
+ lpCache->source_window = (*env)->GetFieldID(env, lpCache->clazz, "source_window", "I");
+ lpCache->dest_window = (*env)->GetFieldID(env, lpCache->clazz, "dest_window", "I");
+ lpCache->targets = (*env)->GetFieldID(env, lpCache->clazz, "targets", "I");
+ lpCache->actions = (*env)->GetFieldID(env, lpCache->clazz, "actions", "I");
+ lpCache->suggested_action = (*env)->GetFieldID(env, lpCache->clazz, "suggested_action", "I");
+ lpCache->action = (*env)->GetFieldID(env, lpCache->clazz, "action", "I");
+ lpCache->start_time = (*env)->GetFieldID(env, lpCache->clazz, "start_time", "I");
+ lpCache->windowing_data = (*env)->GetFieldID(env, lpCache->clazz, "windowing_data", "I");
+ lpCache->cached = 1;
+}
+
+GdkDragContext* getGdkDragContextFields(JNIEnv *env, jobject lpObject, GdkDragContext *lpStruct, PGdkDragContext_FID_CACHE lpCache)
+{
+ if (!lpCache->cached) cacheGdkDragContextFids(env, lpObject, lpCache);
+ lpStruct->parent_instance.g_type_instance.g_class = (GTypeClass*)(*env)->GetIntField(env, lpObject, lpCache->parent_instance$g_type_instance$g_class);
+ lpStruct->parent_instance.ref_count = (*env)->GetIntField(env, lpObject, lpCache->parent_instance$ref_count);
+ lpStruct->parent_instance.qdata = (GData*)(*env)->GetIntField(env, lpObject, lpCache->parent_instance$qdata);
+ lpStruct->protocol = (*env)->GetIntField(env, lpObject, lpCache->protocol);
+ lpStruct->is_source = (*env)->GetBooleanField(env, lpObject, lpCache->is_source);
+ lpStruct->source_window = (GdkWindow*)(*env)->GetIntField(env, lpObject, lpCache->source_window);
+ lpStruct->dest_window = (GdkWindow*)(*env)->GetIntField(env, lpObject, lpCache->dest_window);
+ lpStruct->targets = (GList*)(*env)->GetIntField(env, lpObject, lpCache->targets);
+ lpStruct->actions = (*env)->GetIntField(env, lpObject, lpCache->actions);
+ lpStruct->suggested_action = (*env)->GetIntField(env, lpObject, lpCache->suggested_action);
+ lpStruct->action = (*env)->GetIntField(env, lpObject, lpCache->action);
+ lpStruct->start_time = (*env)->GetIntField(env, lpObject, lpCache->start_time);
+ lpStruct->windowing_data = (gpointer)(*env)->GetIntField(env, lpObject, lpCache->windowing_data);
+ return lpStruct;
+}
+
+void setGdkDragContextFields(JNIEnv *env, jobject lpObject, GdkDragContext *lpStruct, PGdkDragContext_FID_CACHE lpCache)
+{
+ if (!lpCache->cached) cacheGdkDragContextFids(env, lpObject, lpCache);
+ (*env)->SetIntField(env, lpObject, lpCache->parent_instance$g_type_instance$g_class,(jint) lpStruct->parent_instance.g_type_instance.g_class);
+ (*env)->SetIntField(env, lpObject, lpCache->parent_instance$ref_count, lpStruct->parent_instance.ref_count);
+ (*env)->SetIntField(env, lpObject, lpCache->parent_instance$qdata, (jint) lpStruct->parent_instance.qdata);
+ (*env)->SetIntField(env, lpObject, lpCache->protocol, (jint) lpStruct->protocol);
+ (*env)->SetBooleanField(env, lpObject, lpCache->is_source, (jboolean) lpStruct->is_source);
+ (*env)->SetIntField(env, lpObject, lpCache->source_window, (jint) lpStruct->source_window);
+ (*env)->SetIntField(env, lpObject, lpCache->dest_window, (jint) lpStruct->dest_window);
+ (*env)->SetIntField(env, lpObject, lpCache->targets, (jint) lpStruct->targets);
+ (*env)->SetIntField(env, lpObject, lpCache->actions, (jint) lpStruct->actions);
+ (*env)->SetIntField(env, lpObject, lpCache->suggested_action, (jint) lpStruct->suggested_action);
+ (*env)->SetIntField(env, lpObject, lpCache->action, (jint) lpStruct->action);
+ (*env)->SetIntField(env, lpObject, lpCache->start_time, lpStruct->start_time);
+ (*env)->SetIntField(env, lpObject, lpCache->windowing_data, (jint) lpStruct->windowing_data);
+}
+
+
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/structs.h b/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/structs.h
index f3bb667..b5a9ea7 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/structs.h
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/structs.h
@@ -245,6 +245,45 @@
typedef GtkCTree_FID_CACHE *PGtkCTree_FID_CACHE;
+
+/* GtkSelectionData struct */
+typedef struct GtkSelectionData_FID_CACHE {
+ int cached;
+ jclass clazz;
+ jfieldID selection, target, type, format, data, length;
+} GtkSelectionData_FID_CACHE;
+typedef GtkSelectionData_FID_CACHE *PGtkSelectionData_FID_CACHE;
+
+void cacheGtkSelectionDataFids(JNIEnv *env, jobject lpObject, PGtkSelectionData_FID_CACHE lpCache);
+GtkSelectionData* getGtkSelectionDataFields(JNIEnv *env, jobject lpObject, GtkSelectionData *lpStruct, PGtkSelectionData_FID_CACHE lpCache);
+void setGtkSelectionDataFields(JNIEnv *env, jobject lpObject, GtkSelectionData *lpStruct, PGtkSelectionData_FID_CACHE lpCache);
+
+
+/* GtkTargetEntry struct */
+typedef struct GtkTargetEntry_FID_CACHE {
+ int cached;
+ jclass clazz;
+ jfieldID target, flags, info;
+} GtkTargetEntry_FID_CACHE;
+typedef GtkTargetEntry_FID_CACHE *PGtkTargetEntry_FID_CACHE;
+
+void cacheGtkTargetEntryFids(JNIEnv *env, jobject lpObject, PGtkTargetEntry_FID_CACHE lpCache);
+GtkTargetEntry* getGtkTargetEntryFields(JNIEnv *env, jobject lpObject, GtkTargetEntry *lpStruct, PGtkTargetEntry_FID_CACHE lpCache);
+void setGtkTargetEntryFields(JNIEnv *env, jobject lpObject, GtkTargetEntry *lpStruct, PGtkTargetEntry_FID_CACHE lpCache);
+
+/* GdkDragContext struct */
+typedef struct GdkDragContext_FID_CACHE {
+ int cached;
+ jclass clazz;
+ jfieldID parent_instance$g_type_instance$g_class, parent_instance$ref_count, parent_instance$qdata, protocol, is_source, source_window, dest_window, targets, actions, suggested_action, action, start_time, windowing_data;
+} GdkDragContext_FID_CACHE;
+typedef GdkDragContext_FID_CACHE *PGdkDragContext_FID_CACHE;
+
+void cacheGdkDragContextFids(JNIEnv *env, jobject lpObject, PGdkDragContext_FID_CACHE lpCache);
+GdkDragContext* getGdkDragContextFields(JNIEnv *env, jobject lpObject, GdkDragContext *lpStruct, PGdkDragContext_FID_CACHE lpCache);
+void setGdkDragContextFields(JNIEnv *env, jobject lpObject, GdkDragContext *lpStruct, PGdkDragContext_FID_CACHE lpCache);
+
+
/* ----------- cache function prototypes ----------- */
void cacheGdkColorFids(JNIEnv *env, jobject lpGdkColor, PGdkColor_FID_CACHE lpCache);
@@ -331,5 +370,9 @@
extern GtkRequisition_FID_CACHE GtkRequisitionFc;
extern GtkStyle_FID_CACHE GtkStyleFc;
extern GtkStyleClass_FID_CACHE GtkStyleClassFc;
+extern GtkSelectionData_FID_CACHE GtkSelectionDataFc;
+extern GtkTargetEntry_FID_CACHE GtkTargetEntryFc;
+extern GdkDragContext_FID_CACHE GdkDragContextFc;
+
#endif // INC_structs_H
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/swt-gtkwidget.c b/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/swt-gtkwidget.c
index 8cb5bab..33f2fb1 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/swt-gtkwidget.c
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/swt-gtkwidget.c
@@ -633,3 +633,216 @@
return gtk_widget_send_expose((GtkWidget*)wid, (GdkEvent*)event);
}
+/*
+ * Class: org_eclipse_swt_internal_gtk_OS
+ * Method: gtk_drag_source_set
+ * Signature: (IIIII)V
+ */
+JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_gtk_OS_gtk_1drag_1source_1set
+ (JNIEnv *env, jclass that, jint widget, jint start_button_mask, jint targets, jint n_targets, jint actions)
+{
+#ifdef DEBUG_CALL_PRINTS
+ fprintf(stderr, "gtk_drag_source_set");
+#endif
+ gtk_drag_source_set( (GtkWidget*)widget, (GdkModifierType) start_button_mask, (const GtkTargetEntry*) targets,
+ n_targets, (GdkDragAction) actions );
+
+}
+
+/*
+ * Class: org_eclipse_swt_internal_gtk_OS
+ * Method: gtk_drag_source_unset
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_gtk_OS_gtk_1drag_1source_1unset
+ (JNIEnv *env, jclass that, jint widget)
+{
+#ifdef DEBUG_CALL_PRINTS
+ fprintf(stderr, "gtk_drag_source_unset");
+#endif
+ gtk_drag_source_unset( (GtkWidget*)widget);
+}
+
+/*
+ * Class: org_eclipse_swt_internal_gtk_OS
+ * Method: gtk_selection_data_set
+ * Signature: (IIIII)V
+ */
+JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_gtk_OS_gtk_1selection_1data_1set
+ (JNIEnv *env, jclass that, jint selection_data, jint type, jint format, jint data, jint length)
+{
+#ifdef DEBUG_CALL_PRINTS
+ fprintf(stderr, "gtk_selection_data_set");
+#endif
+ gtk_selection_data_set( (GtkSelectionData*) selection_data, (GdkAtom) type, format,
+ (guchar*) data, length);
+
+}
+
+/*
+ * Class: org_eclipse_swt_internal_gtk_OS
+ * Method: gtk_drag_dest_set
+ * Signature: (IIIII)V
+ */
+JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_gtk_OS_gtk_1drag_1dest_1set
+ (JNIEnv *env, jclass that, jint widget, jint flags, jint targets, jint n_targets, jint actions)
+{
+#ifdef DEBUG_CALL_PRINTS
+ fprintf(stderr, "gtk_drag_dest_set");
+#endif
+ gtk_drag_dest_set( (GtkWidget*)widget, (GtkDestDefaults) flags, (const GtkTargetEntry*) targets,
+ n_targets, (GdkDragAction) actions );
+
+}
+
+/*
+ * Class: org_eclipse_swt_internal_gtk_OS
+ * Method: gtk_drag_dest_unset
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_gtk_OS_gtk_1drag_1dest_1unset
+ (JNIEnv *env, jclass that, jint widget)
+{
+#ifdef DEBUG_CALL_PRINTS
+ fprintf(stderr, "gtk_drag_dest_unset");
+#endif
+ gtk_drag_dest_unset( (GtkWidget*)widget );
+}
+
+/*
+ * Class: org_eclipse_swt_internal_gtk_OS
+ * Method: gtk_drag_dest_find_target
+ * Signature: (III)I
+ */
+JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_gtk_OS_gtk_1drag_1dest_1find_1target
+ (JNIEnv *env, jclass that, jint widget, jint context, jint target_list)
+{
+#ifdef DEBUG_CALL_PRINTS
+ fprintf(stderr, "gtk_drag_dest_find_target");
+#endif
+ return (jint)gtk_drag_dest_find_target( (GtkWidget*)widget , (GdkDragContext*)context, (GtkTargetList*)target_list);
+}
+
+
+
+/*
+ * Class: org_eclipse_swt_internal_gtk_OS
+ * Method: gdk_drag_abort
+ * Signature: (II)V
+ */
+JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_gtk_OS_gdk_1drag_1abort
+ (JNIEnv *env, jclass that, jint context, jint time)
+{
+#ifdef DEBUG_CALL_PRINTS
+ fprintf(stderr, "gdk_drag_abort");
+#endif
+ gdk_drag_abort( (GdkDragContext *) context, time);
+}
+
+/*
+ * Class: org_eclipse_swt_internal_gtk_OS
+ * Method: gtk_drag_finish
+ * Signature: (IBBI)V
+ */
+JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_gtk_OS_gtk_1drag_1finish
+ (JNIEnv *env, jclass that, jint context, jboolean sucess, jboolean del, jint time)
+{
+#ifdef DEBUG_CALL_PRINTS
+ fprintf(stderr, "gtk_drag_finish");
+#endif
+ gtk_drag_finish( (GdkDragContext *) context, sucess, del, time);
+}
+
+
+/*
+ * Class: org_eclipse_swt_internal_gtk_OS
+ * Method: gtk_clipboard_get
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_gtk_OS_gtk_1clipboard_1get
+ (JNIEnv *env, jclass that, jint selection)
+{
+#ifdef DEBUG_CALL_PRINTS
+ fprintf(stderr, "gtk_clipboard_get");
+#endif
+ return (jint) gtk_clipboard_get ( (GdkAtom) selection );
+}
+
+/*
+ * Class: org_eclipse_swt_internal_gtk_OS
+ * Method: gtk_clipboard_set_with_data
+ * Signature: (I)I
+ */
+JNIEXPORT jboolean JNICALL Java_org_eclipse_swt_internal_gtk_OS_gtk_1clipboard_1set_1with_1data
+ (JNIEnv *env, jclass that, jint clipboard, jint targets, jint n_targets, jint get_func, jint clear_func, jint user_data)
+{
+#ifdef DEBUG_CALL_PRINTS
+ fprintf(stderr, "gtk_clipboard_set_with_data");
+#endif
+ return gtk_clipboard_set_with_data ( (GtkClipboard*) clipboard, (GtkTargetEntry*) targets,
+ n_targets, (GtkClipboardGetFunc) get_func,
+ (GtkClipboardClearFunc) clear_func, (gpointer) user_data);
+}
+
+/*
+ * Class: org_eclipse_swt_internal_gtk_OS
+ * Method: gtk_clipboard_wait_for_contents
+ * Signature: (II)I
+ */
+JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_gtk_OS_gtk_1clipboard_1wait_1for_1contents
+ (JNIEnv *env, jclass that, jint clipboard, jint target)
+{
+#ifdef DEBUG_CALL_PRINTS
+ fprintf(stderr, "gtk_clipboard_wait_for_contents");
+#endif
+ return (jint) gtk_clipboard_wait_for_contents( (GtkClipboard*) clipboard,(GdkAtom) target);
+}
+
+
+/*
+ * Class: org_eclipse_swt_internal_gtk_OS
+ * Method: gdk_atom_name
+ * Signature: (I)I
+ */
+JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_gtk_OS_gdk_1atom_1name
+ (JNIEnv *env, jclass that, jint atom)
+{
+#ifdef DEBUG_CALL_PRINTS
+ fprintf(stderr, "gdk_atom_name");
+#endif
+ return (jint) gdk_atom_name( (GdkAtom) atom );
+}
+
+/*
+ * Class: org_eclipse_swt_internal_gtk_OS
+ * Method: gtk_selection_data_free
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_gtk_OS_gtk_1selection_1data_1free
+ (JNIEnv *env, jclass that, jint data)
+{
+#ifdef DEBUG_CALL_PRINTS
+ fprintf(stderr, "gtk_selection_data_free");
+#endif
+ gtk_selection_data_free( (GtkSelectionData*) data);
+}
+
+/*
+ * Class: org_eclipse_swt_internal_gtk_OS
+ * Method: gtk_clipboard_clear
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_gtk_OS_gtk_1clipboard_1clear
+ (JNIEnv *env, jclass that, jint clipboard)
+{
+#ifdef DEBUG_CALL_PRINTS
+ fprintf(stderr, "gtk_clipboard_clear");
+#endif
+ gtk_clipboard_clear( (GtkClipboard*) clipboard);
+}
+
+JNIEXPORT jint JNICALL Java_org_eclipse_swt_internal_gtk_OS_GDK_1POINTER_1TO_1ATOM
+ (JNIEnv *env, jclass that, jint ptr)
+{
+ return (jint) GDK_POINTER_TO_ATOM((GdkAtom)ptr);
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/swt-memmove.c b/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/swt-memmove.c
index 2d3ad9d..ac88d7c 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/swt-memmove.c
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/library/swt-memmove.c
@@ -269,3 +269,55 @@
(*env)->ReleaseByteArrayElements(env, src, src1, 0);
}
}
+
+/* Drag and Drop adds */
+
+JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_gtk_OS_memmove__Lorg_eclipse_swt_internal_gtk_GtkSelectionData_2I
+ (JNIEnv *env, jclass that, jobject dest, jint src)
+{
+ DECL_GLOB(pGlob)
+ if (dest) {
+ cacheGtkSelectionDataFids(env, dest, &PGLOB(GtkSelectionDataFc));
+ setGtkSelectionDataFields(env, dest, (GtkSelectionData *)src, &PGLOB(GtkSelectionDataFc));
+ }
+}
+
+JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_gtk_OS_memmove__Lorg_eclipse_swt_internal_gtk_GdkDragContext_2I
+ (JNIEnv *env, jclass that, jobject dest, jint src)
+{
+ DECL_GLOB(pGlob)
+ if (dest) {
+ cacheGdkDragContextFids(env, dest, &PGLOB(GdkDragContextFc));
+ setGdkDragContextFields(env, dest, (GdkDragContext *)src, &PGLOB(GdkDragContextFc));
+ }
+}
+
+JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_gtk_OS_memmove__ILorg_eclipse_swt_internal_gtk_GdkDragContext_2
+ (JNIEnv *env, jclass that, jint dest, jobject src)
+{
+ DECL_GLOB(pGlob)
+ if (src) {
+ cacheGdkDragContextFids(env, src, &PGLOB(GdkDragContextFc));
+ getGdkDragContextFields(env, src, (GdkDragContext *)dest, &PGLOB(GdkDragContextFc));
+ }
+}
+
+JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_gtk_OS_memmove__ILorg_eclipse_swt_internal_gtk_GtkTargetEntry_2
+ (JNIEnv *env, jclass that, jint dest, jobject src)
+{
+ DECL_GLOB(pGlob)
+ if (src) {
+ cacheGtkTargetEntryFids(env, src, &PGLOB(GtkTargetEntryFc));
+ getGtkTargetEntryFields(env, src, (GtkTargetEntry *)dest, &PGLOB(GtkTargetEntryFc));
+ }
+}
+
+JNIEXPORT void JNICALL Java_org_eclipse_swt_internal_gtk_OS_memmove__Lorg_eclipse_swt_internal_gtk_GtkTargetEntry_2I
+ (JNIEnv *env, jclass that, jobject dest, jint src)
+{
+ DECL_GLOB(pGlob)
+ if (dest) {
+ cacheGtkTargetEntryFids(env, dest, &PGLOB(GtkTargetEntryFc));
+ setGtkTargetEntryFields(env, dest, (GtkTargetEntry *)src, &PGLOB(GtkTargetEntryFc));
+ }
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/org/eclipse/swt/internal/gtk/GdkDragContext.java b/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/org/eclipse/swt/internal/gtk/GdkDragContext.java
new file mode 100644
index 0000000..21f3e14
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/org/eclipse/swt/internal/gtk/GdkDragContext.java
@@ -0,0 +1,38 @@
+package org.eclipse.swt.internal.gtk;
+
+/*
+ * Copyright (c) IBM Corp. 2000, 2002. All rights reserved.
+ *
+ * The contents of this file are made available under the terms
+ * of the GNU Lesser General Public License (LGPL) Version 2.1 that
+ * accompanies this distribution (lgpl-v21.txt). The LGPL is also
+ * available at http://www.gnu.org/licenses/lgpl.html. If the version
+ * of the LGPL at http://www.gnu.org is different to the version of
+ * the LGPL accompanying this distribution and there is any conflict
+ * between the two license versions, the terms of the LGPL accompanying
+ * this distribution shall govern.
+ */
+
+public class GdkDragContext {
+
+ public int parent_instance$g_type_instance$g_class;
+ public int parent_instance$ref_count;
+ public int parent_instance$qdata;
+ public int protocol;
+ public boolean is_source;
+ public int source_window;
+ public int dest_window;
+ public int targets;
+ public int actions;
+ public int suggested_action;
+ public int action;
+ public int start_time;
+ public int windowing_data; //guint32
+
+ public GdkDragContext(){
+ }
+ public GdkDragContext(int ptr){
+ OS.memmove(this, ptr);
+ }
+
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/org/eclipse/swt/internal/gtk/GtkSelectionData.java b/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/org/eclipse/swt/internal/gtk/GtkSelectionData.java
new file mode 100644
index 0000000..eac3f84
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/org/eclipse/swt/internal/gtk/GtkSelectionData.java
@@ -0,0 +1,29 @@
+package org.eclipse.swt.internal.gtk;
+
+/*
+ * Copyright (c) IBM Corp. 2000, 2001. All rights reserved.
+ *
+ * The contents of this file are made available under the terms
+ * of the GNU Lesser General Public License (LGPL) Version 2.1 that
+ * accompanies this distribution (lgpl-v21.txt). The LGPL is also
+ * available at http://www.gnu.org/licenses/lgpl.html. If the version
+ * of the LGPL at http://www.gnu.org is different to the version of
+ * the LGPL accompanying this distribution and there is any conflict
+ * between the two license versions, the terms of the LGPL accompanying
+ * this distribution shall govern.
+ */
+
+public class GtkSelectionData {
+ public int selection;
+ public int target;
+ public int type;
+ public int format;
+ public int data;
+ public int length;
+
+ public GtkSelectionData(){
+ }
+ public GtkSelectionData(int ptr){
+ OS.memmove(this, ptr);
+ }
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/org/eclipse/swt/internal/gtk/GtkTargetEntry.java b/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/org/eclipse/swt/internal/gtk/GtkTargetEntry.java
new file mode 100644
index 0000000..a060150
--- /dev/null
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/org/eclipse/swt/internal/gtk/GtkTargetEntry.java
@@ -0,0 +1,27 @@
+package org.eclipse.swt.internal.gtk;
+
+/*
+ * Copyright (c) IBM Corp. 2000, 2001. All rights reserved.
+ *
+ * The contents of this file are made available under the terms
+ * of the GNU Lesser General Public License (LGPL) Version 2.1 that
+ * accompanies this distribution (lgpl-v21.txt). The LGPL is also
+ * available at http://www.gnu.org/licenses/lgpl.html. If the version
+ * of the LGPL at http://www.gnu.org is different to the version of
+ * the LGPL accompanying this distribution and there is any conflict
+ * between the two license versions, the terms of the LGPL accompanying
+ * this distribution shall govern.
+ */
+
+public class GtkTargetEntry {
+ public int target;
+ public int flags;
+ public int info;
+ public static final int sizeof = 12;
+
+ public GtkTargetEntry(){
+ }
+ public GtkTargetEntry(int ptr){
+ OS.memmove(this, ptr);
+ }
+}
diff --git a/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/org/eclipse/swt/internal/gtk/OS.java b/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/org/eclipse/swt/internal/gtk/OS.java
index 1bc82e5..1fb4b2a 100644
--- a/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/org/eclipse/swt/internal/gtk/OS.java
+++ b/bundles/org.eclipse.swt/Eclipse SWT PI/gtk/org/eclipse/swt/internal/gtk/OS.java
@@ -20,6 +20,40 @@
Library.loadLibrary("swt-pi");
}
+ /* DRAG DROP SUPPORT - MOVE TO APPROPRIATE PLACE LATER */
+// public static final native void gtk_drag_source_set(int widget, int start_button_mask, int targets, int n_targets, int actions);
+// public static final native void gtk_drag_source_unset(int widget);
+// public static final native void gtk_drag_dest_set(int widget, int flags, int targets, int n_targets, int actions);
+// public static final native void gtk_drag_dest_unset(int widget);
+// public static final native void gdk_drag_abort(int context, int time);
+// public static final native void gtk_drag_finish(int context, boolean sucess, boolean del, int time);
+// public static final native int gtk_drag_dest_find_target(int widget, int context, int target_list);
+// static final native void memmove(GdkDragContext dest, int src);
+// public static final native void memmove(int dest, GdkDragContext src);
+// public static final int GDK_ACTION_DEFAULT = 1 << 0;
+// public static final int GDK_ACTION_COPY = 1 << 1;
+// public static final int GDK_ACTION_MOVE = 1 << 2;
+// public static final int GDK_ACTION_LINK = 1 << 3;
+// public static final int GDK_ACTION_PRIVATE = 1 << 4;
+// public static final int GDK_ACTION_ASK = 1 << 5;
+// public static final int GTK_DEST_DEFAULT_MOTION = 1 << 0; /* respond to "drag_motion" */
+// public static final int GTK_DEST_DEFAULT_HIGHLIGHT = 1 << 1; /* auto-highlight */
+// public static final int GTK_DEST_DEFAULT_DROP = 1 << 2; /* respond to "drag_drop" */
+// public static final int GTK_DEST_DEFAULT_ALL = 0x07;
+
+
+ /* CLIPBOARD SUPPORT - MOVE TO APPROPRIATE PLACE LATER */
+ public static final native int gtk_clipboard_get( int selection );
+ public static final native boolean gtk_clipboard_set_with_data (int clipboard, int targets, int n_targets, int get_func, int clear_func, int user_data);
+ public static final native int gtk_clipboard_wait_for_contents (int clipboard, int target);
+ public static final native void gtk_selection_data_set(int selection_data, int type, int format, int data, int length);
+
+ public static final native int gtk_clipboard_clear( int clipboard );
+ public static final native int gtk_selection_data_free( int selection_data );
+ public static final native void memmove(int dest, GtkTargetEntry src);
+ public static final native void memmove(GtkTargetEntry dest, int src);
+ public static final native void memmove(GtkSelectionData dest, int src);
+ public static final native int GDK_POINTER_TO_ATOM(int ptr);
public static final int GDK_NONE = 0;
