AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
7332b4f1d9
gtk2/tests/testdnd.c

598 lines
22 KiB
C
Raw Normal View History

Add Copyright/License information.
2005-07-13 05:44:22 +00:00
/* testdnd.c
* Copyright (C) 1998 Red Hat, Inc.
* Author: Owen Taylor
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
Change FSF Address
2012-02-27 13:01:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
Add Copyright/License information.
2005-07-13 05:44:22 +00:00
*/
Include "config.h" instead of <config.h> Command used: find -name 2008-06-21 Johan Dahlin <jdahlin@async.com.br> * *.[ch]: Include "config.h" instead of <config.h> Command used: find -name \*.[ch]|xargs perl -p -i -e 's/^#include <config.h>/#include "config.h"/g' Rubberstamped by Mitch and Tim svn path=/trunk/; revision=20669
2008-06-22 14:28:52 +00:00
#include "config.h"
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
#include "gtk/gtk.h"
/* Target side drag signals */
/* XPM */
testdnd: Convert to use pixbufs as icons Using Pixmaps is outdated.
2010-08-06 18:33:57 +00:00
static const char * drag_icon_xpm[] = {
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
"36 48 9 1",
" c None",
". c #020204",
"+ c #8F8F90",
"@ c #D3D3D2",
"# c #AEAEAC",
"$ c #ECECEC",
"% c #A2A2A4",
"& c #FEFEFC",
"* c #BEBEBC",
" .....................",
" ..&&&&&&&&&&&&&&&&&&&.",
" ...&&&&&&&&&&&&&&&&&&&.",
" ..&.&&&&&&&&&&&&&&&&&&&.",
" ..&&.&&&&&&&&&&&&&&&&&&&.",
" ..&&&.&&&&&&&&&&&&&&&&&&&.",
" ..&&&&.&&&&&&&&&&&&&&&&&&&.",
" ..&&&&&.&&&@&&&&&&&&&&&&&&&.",
" ..&&&&&&.*$%$+$&&&&&&&&&&&&&.",
" ..&&&&&&&.%$%$+&&&&&&&&&&&&&&.",
" ..&&&&&&&&.#&#@$&&&&&&&&&&&&&&.",
" ..&&&&&&&&&.#$**#$&&&&&&&&&&&&&.",
" ..&&&&&&&&&&.&@%&%$&&&&&&&&&&&&&.",
" ..&&&&&&&&&&&.&&&&&&&&&&&&&&&&&&&.",
" ..&&&&&&&&&&&&.&&&&&&&&&&&&&&&&&&&.",
"................&$@&&&@&&&&&&&&&&&&.",
".&&&&&&&+&&#@%#+@#@*$%$+$&&&&&&&&&&.",
".&&&&&&&+&&#@#@&&@*%$%$+&&&&&&&&&&&.",
".&&&&&&&+&$%&#@&#@@#&#@$&&&&&&&&&&&.",
".&&&&&&@#@@$&*@&@#@#$**#$&&&&&&&&&&.",
".&&&&&&&&&&&&&&&&&&&@%&%$&&&&&&&&&&.",
".&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&.",
".&&&&&&&&$#@@$&&&&&&&&&&&&&&&&&&&&&.",
".&&&&&&&&&+&$+&$&@&$@&&$@&&&&&&&&&&.",
".&&&&&&&&&+&&#@%#+@#@*$%&+$&&&&&&&&.",
".&&&&&&&&&+&&#@#@&&@*%$%$+&&&&&&&&&.",
".&&&&&&&&&+&$%&#@&#@@#&#@$&&&&&&&&&.",
".&&&&&&&&@#@@$&*@&@#@#$#*#$&&&&&&&&.",
".&&&&&&&&&&&&&&&&&&&&&$%&%$&&&&&&&&.",
".&&&&&&&&&&$#@@$&&&&&&&&&&&&&&&&&&&.",
".&&&&&&&&&&&+&$%&$$@&$@&&$@&&&&&&&&.",
".&&&&&&&&&&&+&&#@%#+@#@*$%$+$&&&&&&.",
".&&&&&&&&&&&+&&#@#@&&@*#$%$+&&&&&&&.",
".&&&&&&&&&&&+&$+&*@&#@@#&#@$&&&&&&&.",
".&&&&&&&&&&$%@@&&*@&@#@#$#*#&&&&&&&.",
".&&&&&&&&&&&&&&&&&&&&&&&$%&%$&&&&&&.",
".&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&.",
".&&&&&&&&&&&&&&$#@@$&&&&&&&&&&&&&&&.",
".&&&&&&&&&&&&&&&+&$%&$$@&$@&&$@&&&&.",
".&&&&&&&&&&&&&&&+&&#@%#+@#@*$%$+$&&.",
".&&&&&&&&&&&&&&&+&&#@#@&&@*#$%$+&&&.",
".&&&&&&&&&&&&&&&+&$+&*@&#@@#&#@$&&&.",
".&&&&&&&&&&&&&&$%@@&&*@&@#@#$#*#&&&.",
".&&&&&&&&&&&&&&&&&&&&&&&&&&&$%&%$&&.",
".&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&.",
".&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&.",
".&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&.",
"...................................."};
/* XPM */
testdnd: Convert to use pixbufs as icons Using Pixmaps is outdated.
2010-08-06 18:33:57 +00:00
static const char * trashcan_closed_xpm[] = {
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
"64 80 17 1",
" c None",
". c #030304",
"+ c #5A5A5C",
"@ c #323231",
"# c #888888",
"$ c #1E1E1F",
"% c #767677",
"& c #494949",
"* c #9E9E9C",
"= c #111111",
"- c #3C3C3D",
"; c #6B6B6B",
"> c #949494",
", c #282828",
"' c #808080",
") c #545454",
"! c #AEAEAC",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ==......=$$...=== ",
" ..$------)+++++++++++++@$$... ",
" ..=@@-------&+++++++++++++++++++-.... ",
" =.$$@@@-&&)++++)-,$$$$=@@&+++++++++++++,..$ ",
" .$$$$@@&+++++++&$$$@@@@-&,$,-++++++++++;;;&.. ",
" $$$$,@--&++++++&$$)++++++++-,$&++++++;%%'%%;;$@ ",
" .-@@-@-&++++++++-@++++++++++++,-++++++;''%;;;%*-$ ",
" +------++++++++++++++++++++++++++++++;;%%%;;##*!. ",
" =+----+++++++++++++++++++++++;;;;;;;;;;;;%'>>). ",
" .=)&+++++++++++++++++;;;;;;;;;;;;;;%''>>#>#@. ",
" =..=&++++++++++++;;;;;;;;;;;;;%###>>###+%== ",
" .&....=-+++++%;;####''''''''''##'%%%)..#. ",
" .+-++@....=,+%#####'%%%%%%%%%;@$-@-@*++!. ",
" .+-++-+++-&-@$$=$=......$,,,@;&)+!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" =+-++-+++-+++++++++!++++!++++!+++!++!+++= ",
" $.++-+++-+++++++++!++++!++++!+++!++!+.$ ",
" =.++++++++++++++!++++!++++!+++!++.= ",
" $..+++++++++++++++!++++++...$ ",
" $$=.............=$$ ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" "};
/* XPM */
testdnd: Convert to use pixbufs as icons Using Pixmaps is outdated.
2010-08-06 18:33:57 +00:00
static const char * trashcan_open_xpm[] = {
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
"64 80 17 1",
" c None",
". c #030304",
"+ c #5A5A5C",
"@ c #323231",
"# c #888888",
"$ c #1E1E1F",
"% c #767677",
"& c #494949",
"* c #9E9E9C",
"= c #111111",
"- c #3C3C3D",
"; c #6B6B6B",
"> c #949494",
", c #282828",
"' c #808080",
") c #545454",
"! c #AEAEAC",
" ",
" ",
" ",
" ",
" ",
" ",
" .=.==.,@ ",
" ==.,@-&&&)-= ",
" .$@,&++;;;%>*- ",
" $,-+)+++%%;;'#+. ",
" =---+++++;%%%;%##@. ",
" @)++++++++;%%%%'#%$ ",
" $&++++++++++;%%;%##@= ",
" ,-++++)+++++++;;;'#%) ",
" @+++&&--&)++++;;%'#'-. ",
" ,&++-@@,,,,-)++;;;'>'+, ",
" =-++&@$@&&&&-&+;;;%##%+@ ",
" =,)+)-,@@&+++++;;;;%##%&@ ",
" @--&&,,@&)++++++;;;;'#)@ ",
" ---&)-,@)+++++++;;;%''+, ",
" $--&)+&$-+++++++;;;%%'';- ",
" .,-&+++-$&++++++;;;%''%&= ",
" $,-&)++)-@++++++;;%''%), ",
" =,@&)++++&&+++++;%'''+$@&++++++ ",
" .$@-++++++++++++;'#';,........=$@&++++ ",
" =$@@&)+++++++++++'##-.................=&++ ",
" .$$@-&)+++++++++;%#+$.....................=)+ ",
" $$,@-)+++++++++;%;@=........................,+ ",
" .$$@@-++++++++)-)@=............................ ",
" $,@---)++++&)@===............................,. ",
" $-@---&)))-$$=..............................=)!. ",
" --&-&&,,$=,==...........................=&+++!. ",
" =,=$..=$+)+++++&@$=.............=$@&+++++!++!. ",
" .)-++-+++++++++++++++++++++++++++!++!++!. ",
" .+-++-+++++++++++++++++++++++!+++!++!++!. ",
" .+-++-+++-+++++++++!+++!!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" .+-++-+++-+++++++++!++++!++++!+++!++!++!. ",
" =+-++-+++-+++++++++!++++!++++!+++!++!+++= ",
" $.++-+++-+++++++++!++++!++++!+++!++!+.$ ",
" =.++++++++++++++!++++!++++!+++!++.= ",
" $..+++++++++++++++!++++++...$ ",
" $$==...........==$$ ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" ",
" "};
testdnd: Convert to use pixbufs as icons Using Pixmaps is outdated.
2010-08-06 18:33:57 +00:00
GdkPixbuf *trashcan_open;
GdkPixbuf *trashcan_closed;
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
static GdkDragAction
action_make_unique (GdkDragAction action)
{
if (gdk_drag_action_is_unique (action))
return action;
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
if (action & GDK_ACTION_COPY)
return GDK_ACTION_COPY;
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
if (action & GDK_ACTION_MOVE)
return GDK_ACTION_MOVE;
if (action & GDK_ACTION_LINK)
return GDK_ACTION_LINK;
g_assert_not_reached ();
return 0;
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
}
tests: Add common_cflags to build And fix all the errors and warnings resulting from that See #2491
2020-03-06 17:05:43 +00:00
static GdkDragAction
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
trash_drag_enter (GtkDropTarget *dest,
GdkDrop *drop,
double x,
double y,
GtkWidget *widget)
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
{
gdkdnd: Make GdkDragContext->formats a GdkContentFormats Instead of it being a GList of GdkAtoms.
2017-11-18 04:53:25 +00:00
char *s;
New function to get the source widget of a drag. Fri Nov 27 12:17:15 1998 Owen Taylor <otaylor@redhat.com> * gtk/gtkdnd.[ch] (gtk_drag_get_source_widget): New function to get the source widget of a drag. * gtk/gtkdnd.[ch]: Target flags GTK_TARGET_SAME_[WIDGET/APP] to restrict certain targets to the same widget or to the same application. * gtk/testdnd.c: Test gtk_drag_get_source_widget().
1998-11-27 17:16:36 +00:00
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
gtk_image_set_from_pixbuf (GTK_IMAGE (widget), trashcan_open);
New function to get the source widget of a drag. Fri Nov 27 12:17:15 1998 Owen Taylor <otaylor@redhat.com> * gtk/gtkdnd.[ch] (gtk_drag_get_source_widget): New function to get the source widget of a drag. * gtk/gtkdnd.[ch]: Target flags GTK_TARGET_SAME_[WIDGET/APP] to restrict certain targets to the same widget or to the same application. * gtk/testdnd.c: Test gtk_drag_get_source_widget().
1998-11-27 17:16:36 +00:00
dnd: Make drag-motion and drag-drop signals use GdkDrop
2018-05-17 02:51:18 +00:00
s = gdk_content_formats_to_string (gdk_drop_get_formats (drop));
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
g_print ("trash enter: %s\n", s);
g_free (s);
tests: Don't access GdkDragContext fields directly
2010-12-14 00:09:11 +00:00
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
return action_make_unique (gdk_drop_get_actions (drop));;
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
}
tests: Add common_cflags to build And fix all the errors and warnings resulting from that See #2491
2020-03-06 17:05:43 +00:00
static GdkDragAction
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
trash_drag_leave (GtkDropTarget *dest,
testdnd: Fix up for current api
2020-01-09 15:29:33 +00:00
GdkDrop *drop,
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
GtkWidget *widget)
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
{
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
char *s;
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
testdnd: Convert to use pixbufs as icons Using Pixmaps is outdated.
2010-08-06 18:33:57 +00:00
gtk_image_set_from_pixbuf (GTK_IMAGE (widget), trashcan_closed);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
s = gdk_content_formats_to_string (gdk_drop_get_formats (drop));
g_print ("trash leave: %s\n", s);
g_free (s);
testdnd: Fix up for current api
2020-01-09 15:29:33 +00:00
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
return action_make_unique (gdk_drop_get_actions (drop));
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
}
tests: Add common_cflags to build And fix all the errors and warnings resulting from that See #2491
2020-03-06 17:05:43 +00:00
static gboolean
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
trash_drag_drop (GtkDropTarget *dest,
GdkDrop *drop,
double x,
double y,
GtkWidget *widget)
dnd: Make drag-motion and drag-drop signals use GdkDrop
2018-05-17 02:51:18 +00:00
{
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
char *s;
dnd: Make drag-motion and drag-drop signals use GdkDrop
2018-05-17 02:51:18 +00:00
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
s = gdk_content_formats_to_string (gdk_drop_get_formats (drop));
g_print ("trash drop: %s\n", s);
g_free (s);
dnd: Make drag-motion and drag-drop signals use GdkDrop
2018-05-17 02:51:18 +00:00
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
gdk_drop_finish (drop, action_make_unique (gdk_drop_get_actions (drop)));
testdnd: Convert to GtkDropTarget
2020-01-02 06:46:26 +00:00
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
return TRUE;
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
}
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
tests: Add common_cflags to build And fix all the errors and warnings resulting from that See #2491
2020-03-06 17:05:43 +00:00
static gboolean
testdnd: Convert to GtkDropTarget
2020-01-02 06:46:26 +00:00
label_drag_drop (GtkDropTarget *dest,
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
const GValue *value,
testdnd: Convert to GtkDropTarget
2020-01-02 06:46:26 +00:00
int x,
int y,
GtkWidget *widget)
Add a drag_data_received handler for the label. Tue Jan 12 18:30:51 1999 Owen Taylor <otaylor@redhat.com> * gtk/testdnd.c (label_drag_data_received): Add a drag_data_received handler for the label. Tue Jan 12 15:01:50 1999 Owen Taylor <otaylor@redhat.com> * gdk/gdkevents.c: Removed the putback_events queue, since it was causing problems with event ordering - just keep a single queue. If we need it, we can add priorities to events. * gdk/gdkevents.c: Annotate events with flags - we allocate a GdkEventPrivate structure in gdk_event_new() and use these flags to mark an event being translated as "pending" - I.e., not yet ready to be dequeued. So we can put the event on the queue and get the order of the events right. (This solves the double-click problems) * gdk/gdk.h gdk/gdkevents.h: Add gdk_event_peek() to get a copy of the next event on the event queue. * gtk/gtkmain.c (gtk_main_do_event): Use gdk_event_peek() to check the next event without causing event queue reordering.
1999-01-12 23:27:30 +00:00
{
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
g_print ("Received \"%s\" in label\n", g_value_get_string (value));
return TRUE;
Add a drag_data_received handler for the label. Tue Jan 12 18:30:51 1999 Owen Taylor <otaylor@redhat.com> * gtk/testdnd.c (label_drag_data_received): Add a drag_data_received handler for the label. Tue Jan 12 15:01:50 1999 Owen Taylor <otaylor@redhat.com> * gdk/gdkevents.c: Removed the putback_events queue, since it was causing problems with event ordering - just keep a single queue. If we need it, we can add priorities to events. * gdk/gdkevents.c: Annotate events with flags - we allocate a GdkEventPrivate structure in gdk_event_new() and use these flags to mark an event being translated as "pending" - I.e., not yet ready to be dequeued. So we can put the event on the queue and get the order of the events right. (This solves the double-click problems) * gdk/gdk.h gdk/gdkevents.h: Add gdk_event_peek() to get a copy of the next event on the event queue. * gtk/gtkmain.c (gtk_main_do_event): Use gdk_event_peek() to check the next event without causing event queue reordering.
1999-01-12 23:27:30 +00:00
}
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
/* The following is a rather elaborate example demonstrating/testing
Fix a typo svn path=/trunk/; revision=21877
2008-12-13 05:20:10 +00:00
* changing of the window hierarchy during a drag - in this case,
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
* via a "spring-loaded" popup window.
*/
static GtkWidget *popup_window = NULL;
static gboolean popped_up = FALSE;
static gboolean in_popup = FALSE;
static guint popdown_timer = 0;
static guint popup_timer = 0;
tests: Add common_cflags to build And fix all the errors and warnings resulting from that See #2491
2020-03-06 17:05:43 +00:00
static int
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
popdown_cb (gpointer data)
{
popdown_timer = 0;
gtk_widget_hide (popup_window);
popped_up = FALSE;
return FALSE;
}
tests: Add common_cflags to build And fix all the errors and warnings resulting from that See #2491
2020-03-06 17:05:43 +00:00
static void
testdnd: Fix up for current api
2020-01-09 15:29:33 +00:00
popup_enter (GtkDropTarget *dest)
{
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
g_print ("popup enter\n");
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
if (!in_popup)
{
in_popup = TRUE;
if (popdown_timer)
{
g_print ("removed popdown\n");
Replace gtk_timeout_* by their GLib counterparts. (#106532) 2003-02-19 Matthias Clasen <maclas@gmx.de> * tests/testdnd.c: Replace gtk_timeout_* by their GLib counterparts. (#106532)
2003-02-19 19:42:04 +00:00
g_source_remove (popdown_timer);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
popdown_timer = 0;
}
}
}
tests: Add common_cflags to build And fix all the errors and warnings resulting from that See #2491
2020-03-06 17:05:43 +00:00
static void
testdnd: Convert to GtkDropTarget
2020-01-02 06:46:26 +00:00
popup_leave (GtkDropTarget *dest)
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
{
testdnd: Fix up for current api
2020-01-09 15:29:33 +00:00
g_print ("popup leave\n");
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
if (in_popup)
{
in_popup = FALSE;
if (!popdown_timer)
{
g_print ("added popdown\n");
Replace gdk_threads_add_timeout* with g_timeout_add() The main GDK thread lock is not portable and deprecated. The only reason why gdk_threads_add_timeout() and gdk_threads_add_timeout_full() exist is to allow invoking a callback with the GDK lock held, in case 3rd party libraries still use the deprecated gdk_threads_enter()/gdk_threads_leave() API. Since we're removing the GDK lock, and we're releasing a new major API, such code cannot exist any more; this means we can use the GLib API for installing timeout callbacks. https://bugzilla.gnome.org/show_bug.cgi?id=793124
2018-02-02 14:51:47 +00:00
popdown_timer = g_timeout_add (500, popdown_cb, NULL);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
}
}
}
testdnd: Fix up for current api
2020-01-09 15:29:33 +00:00
static gboolean
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
popup_drop (GtkDropTarget *dest)
testdnd: Fix up for current api
2020-01-09 15:29:33 +00:00
{
popdown_cb (NULL);
return TRUE;
}
tests: Add common_cflags to build And fix all the errors and warnings resulting from that See #2491
2020-03-06 17:05:43 +00:00
static gboolean
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
popup_cb (gpointer data)
{
if (!popped_up)
{
if (!popup_window)
{
GtkWidget *button;
tests: Convert testdnd from GtkTable to GtkGrid
2011-09-27 20:23:26 +00:00
GtkWidget *grid;
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
int i, j;
window: Remove type argument from gtk_window_new()
2020-02-14 19:55:36 +00:00
popup_window = gtk_window_new ();
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
tests: Convert testdnd from GtkTable to GtkGrid
2011-09-27 20:23:26 +00:00
grid = gtk_grid_new ();
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
for (i=0; i<3; i++)
for (j=0; j<3; j++)
{
char buffer[128];
testdnd: Convert to GtkDropTarget
2020-01-02 06:46:26 +00:00
GtkDropTarget *dest;
use g_snprintf, eliminate need for string.h include string.h, for strlen * gtk/testdnd.c: use g_snprintf, eliminate need for string.h * gtk/testrgb.c: include string.h, for strlen
1998-12-10 06:18:32 +00:00
g_snprintf(buffer, sizeof(buffer), "%d,%d", i, j);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
button = gtk_button_new_with_label (buffer);
tests: Convert testdnd from GtkTable to GtkGrid
2011-09-27 20:23:26 +00:00
gtk_widget_set_hexpand (button, TRUE);
gtk_widget_set_vexpand (button, TRUE);
gtk_grid_attach (GTK_GRID (grid), button, i, j, 1, 1);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
dest = gtk_drop_target_new (G_TYPE_STRING, GDK_ACTION_COPY | GDK_ACTION_MOVE);
g_signal_connect (dest, "enter", G_CALLBACK (popup_enter), NULL);
g_signal_connect (dest, "leave", G_CALLBACK (popup_leave), NULL);
g_signal_connect (dest, "drop", G_CALLBACK (popup_drop), NULL);
Replace gtk_drop_target_attach/detach Since drop targets are now just event controller, gtk_widget_add/remove_controller works just fine for them.
2020-01-06 05:12:21 +00:00
gtk_widget_add_controller (button, GTK_EVENT_CONTROLLER (dest));
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
}
tests: Fix testdnd popup Don't use GtkContainer API for GtkWindow.
2020-05-10 22:38:10 +00:00
gtk_window_set_child (GTK_WINDOW (popup_window), grid);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
}
gtk_widget_show (popup_window);
popped_up = TRUE;
}
popup_timer = FALSE;
return FALSE;
}
tests: Add common_cflags to build And fix all the errors and warnings resulting from that See #2491
2020-03-06 17:05:43 +00:00
static void
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
popsite_enter (GtkDropControllerMotion *motion)
testdnd: Fix up for current api
2020-01-09 15:29:33 +00:00
{
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
g_print ("popsite enter\n");
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
if (!popup_timer)
Replace gdk_threads_add_timeout* with g_timeout_add() The main GDK thread lock is not portable and deprecated. The only reason why gdk_threads_add_timeout() and gdk_threads_add_timeout_full() exist is to allow invoking a callback with the GDK lock held, in case 3rd party libraries still use the deprecated gdk_threads_enter()/gdk_threads_leave() API. Since we're removing the GDK lock, and we're releasing a new major API, such code cannot exist any more; this means we can use the GLib API for installing timeout callbacks. https://bugzilla.gnome.org/show_bug.cgi?id=793124
2018-02-02 14:51:47 +00:00
popup_timer = g_timeout_add (500, popup_cb, NULL);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
}
tests: Add common_cflags to build And fix all the errors and warnings resulting from that See #2491
2020-03-06 17:05:43 +00:00
static void
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
popsite_leave (GtkDropControllerMotion *motion)
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
{
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
g_print ("popsite leave\n");
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
if (popup_timer)
{
Replace gtk_timeout_* by their GLib counterparts. (#106532) 2003-02-19 Matthias Clasen <maclas@gmx.de> * tests/testdnd.c: Replace gtk_timeout_* by their GLib counterparts. (#106532)
2003-02-19 19:42:04 +00:00
g_source_remove (popup_timer);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
popup_timer = 0;
}
}
Stop using gtk_main and gtk_main_quit Replace these calls with direct use of GMainContext api.
2020-02-10 03:24:47 +00:00
static void
quit_cb (GtkWidget *widget,
gpointer data)
{
gboolean *done = data;
*done = TRUE;
g_main_context_wakeup (NULL);
}
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
int
main (int argc, char **argv)
{
GtkWidget *window;
tests: Convert testdnd from GtkTable to GtkGrid
2011-09-27 20:23:26 +00:00
GtkWidget *grid;
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
GtkWidget *label;
GtkWidget *pixmap;
GtkWidget *button;
testdnd: Convert to use pixbufs as icons Using Pixmaps is outdated.
2010-08-06 18:33:57 +00:00
GdkPixbuf *drag_icon;
dragsource: Replace gtk_drag_source_set_icon_surface() ... with gtk_drag_source_set_icon_paintable().
2018-03-15 01:53:17 +00:00
GdkTexture *texture;
tests: Convert to GtkDragSource Some tests, such as testimage did not have anything particularly worth keeping, so were removed instead of fixed.
2020-01-01 02:10:15 +00:00
GdkContentProvider *content;
GtkDragSource *source;
testdnd: Convert to GtkDropTarget
2020-01-02 06:46:26 +00:00
GtkDropTarget *dest;
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
GtkDropTargetAsync *async;
GtkEventController *controller;
Stop using gtk_main and gtk_main_quit Replace these calls with direct use of GMainContext api.
2020-02-10 03:24:47 +00:00
gboolean done = FALSE;
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
Update callers Adapt all our tests and examples to the new initialization api.
2016-12-28 13:53:22 +00:00
gtk_init ();
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
window: Remove type argument from gtk_window_new()
2020-02-14 19:55:36 +00:00
window = gtk_window_new ();
Deprecation cleanup Sun Oct 13 16:20:41 2002 Manish Singh <yosh@gimp.org> * tests/pixbuf-randomly-modified.c tests/prop-editor.c tests/testcalendar.c tests/testdnd.c tests/testgtk.c tests/testinput.c tests/testmultidisplay.c tests/testmultiscreen.c tests/testrgb.c tests/testselection.c tests/testsocket.c tests/testsocket_common.c tests/testtext.c tests/testtextbuffer.c tests/testtreecolumns.c tests/testtreeedit.c tests/testtreeflow.c tests/testtreefocus.c tests/testtreesort.c tests/testtreeview.c tests/testxinerama.c tests/treestoretest.c: Deprecation cleanup * tests/Makefile.am: Added disable deprecation flags
2002-10-13 23:22:33 +00:00
g_signal_connect (window, "destroy",
Stop using gtk_main and gtk_main_quit Replace these calls with direct use of GMainContext api.
2020-02-10 03:24:47 +00:00
G_CALLBACK (quit_cb), &done);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
tests: Convert testdnd from GtkTable to GtkGrid
2011-09-27 20:23:26 +00:00
grid = gtk_grid_new ();
Use gtk_window_set_child throughout Replace all uses of gtk_container_add on windows by gtk_window_set_child.
2020-05-02 21:26:54 +00:00
gtk_window_set_child (GTK_WINDOW (window), grid);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
testdnd: Convert to use pixbufs as icons Using Pixmaps is outdated.
2010-08-06 18:33:57 +00:00
drag_icon = gdk_pixbuf_new_from_xpm_data (drag_icon_xpm);
dragsource: Replace gtk_drag_source_set_icon_surface() ... with gtk_drag_source_set_icon_paintable().
2018-03-15 01:53:17 +00:00
texture = gdk_texture_new_for_pixbuf (drag_icon);
testdnd: Stop using gtk_drag_source_set_icon_pixbuf We can avoid it here as well.
2017-11-30 01:02:01 +00:00
g_object_unref (drag_icon);
testdnd: Convert to use pixbufs as icons Using Pixmaps is outdated.
2010-08-06 18:33:57 +00:00
trashcan_open = gdk_pixbuf_new_from_xpm_data (trashcan_open_xpm);
trashcan_closed = gdk_pixbuf_new_from_xpm_data (trashcan_closed_xpm);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
label = gtk_label_new ("Drop Here\n");
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
dest = gtk_drop_target_new (G_TYPE_STRING, GDK_ACTION_COPY | GDK_ACTION_MOVE);
g_signal_connect (dest, "drop", G_CALLBACK (label_drag_drop), NULL);
Replace gtk_drop_target_attach/detach Since drop targets are now just event controller, gtk_widget_add/remove_controller works just fine for them.
2020-01-06 05:12:21 +00:00
gtk_widget_add_controller (label, GTK_EVENT_CONTROLLER (dest));
Add a drag_data_received handler for the label. Tue Jan 12 18:30:51 1999 Owen Taylor <otaylor@redhat.com> * gtk/testdnd.c (label_drag_data_received): Add a drag_data_received handler for the label. Tue Jan 12 15:01:50 1999 Owen Taylor <otaylor@redhat.com> * gdk/gdkevents.c: Removed the putback_events queue, since it was causing problems with event ordering - just keep a single queue. If we need it, we can add priorities to events. * gdk/gdkevents.c: Annotate events with flags - we allocate a GdkEventPrivate structure in gdk_event_new() and use these flags to mark an event being translated as "pending" - I.e., not yet ready to be dequeued. So we can put the event on the queue and get the order of the events right. (This solves the double-click problems) * gdk/gdk.h gdk/gdkevents.h: Add gdk_event_peek() to get a copy of the next event on the event queue. * gtk/gtkmain.c (gtk_main_do_event): Use gdk_event_peek() to check the next event without causing event queue reordering.
1999-01-12 23:27:30 +00:00
tests: Convert testdnd from GtkTable to GtkGrid
2011-09-27 20:23:26 +00:00
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_set_vexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
label = gtk_label_new ("Popup\n");
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
controller = gtk_drop_controller_motion_new ();
g_signal_connect (controller, "enter", G_CALLBACK (popsite_enter), NULL);
g_signal_connect (controller, "leave", G_CALLBACK (popsite_leave), NULL);
gtk_widget_add_controller (label, controller);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
tests: Convert testdnd from GtkTable to GtkGrid
2011-09-27 20:23:26 +00:00
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_set_vexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 1, 1, 1, 1);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
testdnd: Convert to use pixbufs as icons Using Pixmaps is outdated.
2010-08-06 18:33:57 +00:00
pixmap = gtk_image_new_from_pixbuf (trashcan_closed);
droptarget: Redo This is a huge reorganization of GtkDropTarget. I did not know how to split this up, so it's unfortunately all one commit. Highlights: - Split GtkDropTarget into GtkDropTarget and GtkDropTargetAsync GtkDropTarget is the simple one that only works with GTypes and offers a synchronous interface. GtkDropTargetAsync retains the full old functionality and allows handling mime types. - Drop events are handled differently Instead of picking a single drop target and sending all DND events to it, every event is sent to every drop target. The first one to handle the event gets to call gdk_drop_status(), further handlers do not interact with the GdkDrop. Of course, for the ultimate GDK_DROP_STARTING event, only the first one to accept the drop gets to handle it. This allows stacking DND event controllers that aren't necessarily interested in handling the event or that might decide later to drop it. - Port all widgets to either of those Both have a somewhat changed API due to the new event handling. For the ones who should use the sync version, lots of cleanup was involved to operate on a sync API.
2020-02-29 02:47:17 +00:00
async = gtk_drop_target_async_new (NULL, 0);
g_signal_connect (async, "drag-enter", G_CALLBACK (trash_drag_enter), pixmap);
g_signal_connect (async, "drag-leave", G_CALLBACK (trash_drag_leave), pixmap);
g_signal_connect (async, "drop", G_CALLBACK (trash_drag_drop), pixmap);
gtk_widget_add_controller (pixmap, GTK_EVENT_CONTROLLER (async));
testdnd: Convert to GtkDropTarget
2020-01-02 06:46:26 +00:00
tests: Convert testdnd from GtkTable to GtkGrid
2011-09-27 20:23:26 +00:00
gtk_widget_set_hexpand (pixmap, TRUE);
gtk_widget_set_vexpand (pixmap, TRUE);
gtk_grid_attach (GTK_GRID (grid), pixmap, 1, 0, 1, 1);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
/* Drag site */
testdnd: Fix up for current api
2020-01-09 15:29:33 +00:00
button = gtk_label_new ("Drag Here\n");
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
dragsource: Reshuffle api a bit Remove arguments from the constructor. For actions, we now default to COPY, which is the most common one that we should enable by default (MOVE requires handling deletion on the the source side, and ASK only makes sense if we have multiple actions). For the content provider, we add a new ::prepare signal where it should be provided just-in-time.
2020-01-06 19:46:14 +00:00
source = gtk_drag_source_new ();
contentprovider: Add gdk_content_provider_new_typed() Gets around the boilerplate required to create and initialize a GValue by having this function doing it via G_VALUE_COLLECT().
2020-02-16 13:24:03 +00:00
content = gdk_content_provider_new_typed (G_TYPE_STRING, "I'm data!");
dragsource: Reshuffle api a bit Remove arguments from the constructor. For actions, we now default to COPY, which is the most common one that we should enable by default (MOVE requires handling deletion on the the source side, and ASK only makes sense if we have multiple actions). For the content provider, we add a new ::prepare signal where it should be provided just-in-time.
2020-01-06 19:46:14 +00:00
gtk_drag_source_set_content (source, content);
g_object_unref (content);
gtk_drag_source_set_actions (source, GDK_ACTION_COPY|GDK_ACTION_MOVE);
testdnd: Use gtk_widget_add_controller for drag source
2020-01-07 06:12:48 +00:00
gtk_widget_add_controller (button, GTK_EVENT_CONTROLLER (source));
tests: Convert to GtkDragSource Some tests, such as testimage did not have anything particularly worth keeping, so were removed instead of fixed.
2020-01-01 02:10:15 +00:00
gtk_drag_source_set_icon (source, GDK_PAINTABLE (texture), 0, 0);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
dragsource: Replace gtk_drag_source_set_icon_surface() ... with gtk_drag_source_set_icon_paintable().
2018-03-15 01:53:17 +00:00
g_object_unref (texture);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
tests: Convert testdnd from GtkTable to GtkGrid
2011-09-27 20:23:26 +00:00
gtk_widget_set_hexpand (button, TRUE);
gtk_widget_set_vexpand (button, TRUE);
gtk_grid_attach (GTK_GRID (grid), button, 0, 1, 1, 1);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
Remove gtk_widget_show_all
2017-01-19 09:02:04 +00:00
gtk_widget_show (window);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
Stop using gtk_main and gtk_main_quit Replace these calls with direct use of GMainContext api.
2020-02-10 03:24:47 +00:00
while (!done)
g_main_context_iteration (NULL, TRUE);
New test program for new DND. (Old DND tests in testgtk still need to be * gtk/testdnd.c: New test program for new DND. (Old DND tests in testgtk still need to be converted.)
1998-10-18 23:28:36 +00:00
return 0;
}
Reference in New Issue Copy Permalink