portability fixes
[xonotic/netradiant.git] / libs / gtkutil / clipboard.cpp
1 /*
2 Copyright (C) 2001-2006, William Joseph.
3 All Rights Reserved.
4
5 This file is part of GtkRadiant.
6
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20 */
21
22 #include "clipboard.h"
23
24 #include "stream/memstream.h"
25 #include "stream/textstream.h"
26
27
28 /// \file
29 /// \brief Platform-independent GTK clipboard support.
30 /// \todo Using GDK_SELECTION_CLIPBOARD fails on win32, so we use the win32 API directly for now.
31 #if defined(WIN32)
32
33 const char* c_clipboard_format = "RadiantClippings";
34
35 #include <windows.h>
36
37 void clipboard_copy(ClipboardCopyFunc copy)
38 {
39   BufferOutputStream ostream;
40   copy(ostream);
41
42   bool bClipped = false;
43   UINT nClipboard = ::RegisterClipboardFormat(c_clipboard_format);
44   if (nClipboard > 0)
45   {
46     if (::OpenClipboard(0))
47     {
48       EmptyClipboard();
49       std::size_t length = ostream.size();
50       HANDLE h = ::GlobalAlloc(GMEM_ZEROINIT | GMEM_MOVEABLE | GMEM_DDESHARE, length + sizeof(std::size_t));
51       if (h != 0)
52       {
53         char *buffer = reinterpret_cast<char*>(::GlobalLock(h));
54         *reinterpret_cast<std::size_t*>(buffer) = length;
55         buffer += sizeof(std::size_t);
56         memcpy(buffer, ostream.data(), length);
57         ::GlobalUnlock(h);
58         ::SetClipboardData(nClipboard, h);
59         ::CloseClipboard();
60         bClipped = true;
61       }
62     }
63   }
64
65   if (!bClipped)
66   {
67     globalOutputStream() << "Unable to register Windows clipboard formats, copy/paste between editors will not be possible\n";
68   }
69 }
70
71 void clipboard_paste(ClipboardPasteFunc paste)
72 {
73   UINT nClipboard = ::RegisterClipboardFormat(c_clipboard_format);
74   if (nClipboard > 0 && ::OpenClipboard(0))
75   {
76     if(IsClipboardFormatAvailable(nClipboard))
77     {
78       HANDLE h = ::GetClipboardData(nClipboard);
79       if(h)
80       {
81         const char *buffer = reinterpret_cast<const char*>(::GlobalLock(h));
82         std::size_t length = *reinterpret_cast<const std::size_t*>(buffer);
83         buffer += sizeof(std::size_t);
84         BufferInputStream istream(buffer, length);
85         paste(istream);
86         ::GlobalUnlock(h);
87       }
88     }
89     ::CloseClipboard();
90   }
91 }
92
93 #else
94
95 #include <gtk/gtkclipboard.h>
96
97 enum
98 {
99   RADIANT_CLIPPINGS = 23,
100 };
101
102 static const GtkTargetEntry clipboard_targets[] = {
103   { "RADIANT_CLIPPINGS", 0, RADIANT_CLIPPINGS, },
104 };
105
106 static void clipboard_get (GtkClipboard *clipboard, GtkSelectionData *selection_data, guint info, gpointer data)
107 {
108   std::size_t len = *reinterpret_cast<std::size_t*>(data);
109   const char* buffer = (len != 0) ? reinterpret_cast<const char*>(data) + sizeof(std::size_t) : 0;
110
111   GdkAtom type = GDK_NONE;
112   if(info == clipboard_targets[0].info)
113   {
114     type = gdk_atom_intern(clipboard_targets[0].target, FALSE);
115   }
116
117   gtk_selection_data_set (selection_data, type, 8, reinterpret_cast<const guchar*>(buffer), static_cast<gint>(len));
118 }
119
120 static void clipboard_clear (GtkClipboard *clipboard, gpointer data)
121 {
122   delete [] reinterpret_cast<const char*>(data);
123 }
124
125 static void clipboard_received (GtkClipboard *clipboard, GtkSelectionData *data, gpointer user_data)
126 {
127   if (data->length < 0)
128   {
129     globalErrorStream() << "Error retrieving selection\n";
130   }
131   else if(strcmp(gdk_atom_name(data->type), clipboard_targets[0].target) == 0)
132   {
133     BufferInputStream istream(reinterpret_cast<const char*>(data->data), data->length);
134     (*reinterpret_cast<ClipboardPasteFunc*>(user_data))(istream);
135   }
136 }
137
138 void clipboard_copy(ClipboardCopyFunc copy)
139 {
140   GtkClipboard* clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
141
142   BufferOutputStream ostream;
143   copy(ostream);
144   std::size_t length = ostream.size();
145   char* data = new char[length + sizeof(std::size_t)];
146   *reinterpret_cast<std::size_t*>(data) = length;
147   memcpy(data + sizeof(std::size_t), ostream.data(), length);
148
149   gtk_clipboard_set_with_data (clipboard, clipboard_targets, 1, clipboard_get, clipboard_clear, data);
150 }
151
152 ClipboardPasteFunc g_clipboardPasteFunc = 0;
153 void clipboard_paste(ClipboardPasteFunc paste)
154 {
155   GtkClipboard* clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
156   
157   g_clipboardPasteFunc = paste;
158   gtk_clipboard_request_contents (clipboard, gdk_atom_intern(clipboard_targets[0].target, FALSE), clipboard_received, &g_clipboardPasteFunc);
159 }
160
161
162 #endif