src/Windows/clip_windows.cpp

/*
 *  clip_windows.cpp - Clipboard handling, Windows implementation
 *
 *  Basilisk II (C) 1997-2008 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "sysdeps.h"

#include <vector>
#define WIN32_LEAN_AND_MEAN
#include <windows.h>

#include "macos_util.h"
#include "clip.h"
#include "prefs.h"
#include "cpu_emulation.h"
#include "main.h"
#include "emul_op.h"

#define DEBUG 0
#include "debug.h"

#ifndef NO_STD_NAMESPACE
using std::vector;
#endif


// Conversion tables
static const uint8 mac2iso[0x80] = {
        0xc4, 0xc5, 0xc7, 0xc9, 0xd1, 0xd6, 0xdc, 0xe1,
        0xe0, 0xe2, 0xe4, 0xe3, 0xe5, 0xe7, 0xe9, 0xe8,
        0xea, 0xeb, 0xed, 0xec, 0xee, 0xef, 0xf1, 0xf3,
        0xf2, 0xf4, 0xf6, 0xf5, 0xfa, 0xf9, 0xfb, 0xfc,
        0x2b, 0xb0, 0xa2, 0xa3, 0xa7, 0xb7, 0xb6, 0xdf,
        0xae, 0xa9, 0x20, 0xb4, 0xa8, 0x23, 0xc6, 0xd8,
        0x20, 0xb1, 0x3c, 0x3e, 0xa5, 0xb5, 0xf0, 0x53,
        0x50, 0x70, 0x2f, 0xaa, 0xba, 0x4f, 0xe6, 0xf8,
        0xbf, 0xa1, 0xac, 0x2f, 0x66, 0x7e, 0x44, 0xab,
        0xbb, 0x2e, 0x20, 0xc0, 0xc3, 0xd5, 0x4f, 0x6f,
        0x2d, 0x2d, 0x22, 0x22, 0x60, 0x27, 0xf7, 0x20,
        0xff, 0x59, 0x2f, 0xa4, 0x3c, 0x3e, 0x66, 0x66,
        0x23, 0xb7, 0x2c, 0x22, 0x25, 0xc2, 0xca, 0xc1,
        0xcb, 0xc8, 0xcd, 0xce, 0xcf, 0xcc, 0xd3, 0xd4,
        0x20, 0xd2, 0xda, 0xdb, 0xd9, 0x69, 0x5e, 0x7e,
        0xaf, 0x20, 0xb7, 0xb0, 0xb8, 0x22, 0xb8, 0x20
};

static const uint8 iso2mac[0x80] = {
        0xad, 0xb0, 0xe2, 0xc4, 0xe3, 0xc9, 0xa0, 0xe0,
        0xf6, 0xe4, 0xde, 0xdc, 0xce, 0xb2, 0xb3, 0xb6,
        0xb7, 0xd4, 0xd5, 0xd2, 0xd3, 0xa5, 0xd0, 0xd1,
        0xf7, 0xaa, 0xdf, 0xdd, 0xcf, 0xba, 0xfd, 0xd9,
        0xca, 0xc1, 0xa2, 0xa3, 0xdb, 0xb4, 0xbd, 0xa4,
        0xac, 0xa9, 0xbb, 0xc7, 0xc2, 0xf0, 0xa8, 0xf8,
        0xa1, 0xb1, 0xc3, 0xc5, 0xab, 0xb5, 0xa6, 0xe1,
        0xfc, 0xc6, 0xbc, 0xc8, 0xf9, 0xda, 0xd7, 0xc0,
        0xcb, 0xe7, 0xe5, 0xcc, 0x80, 0x81, 0xae, 0x82,
        0xe9, 0x83, 0xe6, 0xe8, 0xed, 0xea, 0xeb, 0xec,
        0xf5, 0x84, 0xf1, 0xee, 0xef, 0xcd, 0x85, 0xfb,
        0xaf, 0xf4, 0xf2, 0xf3, 0x86, 0xfa, 0xb8, 0xa7,
        0x88, 0x87, 0x89, 0x8b, 0x8a, 0x8c, 0xbe, 0x8d,
        0x8f, 0x8e, 0x90, 0x91, 0x93, 0x92, 0x94, 0x95,
        0xfe, 0x96, 0x98, 0x97, 0x99, 0x9b, 0x9a, 0xd6,
        0xbf, 0x9d, 0x9c, 0x9e, 0x9f, 0xff, 0xb9, 0xd8
};

// Flag: Don't convert clipboard text
static bool no_clip_conversion;

// Flag for PutScrap(): the data was put by GetScrap(), don't bounce it back to the Windows  side
static bool we_put_this_data = false;

// Define a byte array (rewrite if it's a bottleneck)
struct ByteArray : public vector<uint8> {
        uint8 *data() { return &(*this)[0]; }
};

// Prototypes
static void do_putscrap(uint32 type, void *scrap, int32 length);
static void do_getscrap(void **handle, uint32 type, int32 offset);

// From main_windows.cpp
extern HWND GetMainWindowHandle(void);


/*
 *  Initialization
 */

void ClipInit(void)
{
        no_clip_conversion = PrefsFindBool("noclipconversion");
}


/*
 *  Deinitialization
 */

void ClipExit(void)
{
}


/*
 *  Mac application wrote to clipboard
 */

void PutScrap(uint32 type, void *scrap, int32 length)
{
        D(bug("PutScrap type %08lx, data %p, length %ld\n", type, scrap, length));
        if (we_put_this_data) {
                we_put_this_data = false;
                return;
        }
        if (length <= 0)
                return;

        do_putscrap(type, scrap, length);
}

static void do_putscrap(uint32 type, void *scrap, int32 length)
{
        ByteArray clip_data;
        UINT uFormat = 0;

        switch (type) {
        case FOURCC('T','E','X','T'): {
                D(bug(" clipping TEXT\n"));

                // Convert text from Mac charset to ISO-Latin1
                uint8 *p = (uint8 *)scrap;
                for (int i=0; i<length; i++) {
                        uint8 c = *p++;
                        if (c < 0x80) {
                                if (c == 13) {  // CR -> CR/LF
                                        clip_data.push_back(c);
                                        c = 10;
                                }
                        } else if (!no_clip_conversion)
                                c = mac2iso[c & 0x7f];
                        clip_data.push_back(c);
                }
                clip_data.push_back(0);
                uFormat = CF_TEXT;
                break;
        }
        }
        if (uFormat != CF_TEXT)                         // 'TEXT' only
                return;

        // Transfer data to the native clipboard
        HWND hMainWindow = GetMainWindowHandle();
        if (!hMainWindow ||!OpenClipboard(hMainWindow))
                return;
        EmptyClipboard();
        HANDLE hData = GlobalAlloc(GMEM_DDESHARE, clip_data.size());
        if (hData) {
                uint8 *data = (uint8 *)GlobalLock(hData);
                memcpy(data, clip_data.data(), clip_data.size());
                GlobalUnlock(hData);
                if (!SetClipboardData(uFormat, hData))
                        GlobalFree(hData);
        }
        CloseClipboard();
}


/*
 *  Mac application reads clipboard
 */

void GetScrap(void **handle, uint32 type, int32 offset)
{
        D(bug("GetScrap handle %p, type %08x, offset %d\n", handle, type, offset));

        do_getscrap(handle, type, offset);
}

static void do_getscrap(void **handle, uint32 type, int32 offset)
{
        // Get appropriate format for requested data
        UINT uFormat = 0;
        switch (type) {
        case FOURCC('T','E','X','T'):
                uFormat = CF_TEXT;
                break;
        }
        if (uFormat != CF_TEXT)                         // 'TEXT' only
                return;

        // Get the native clipboard data
        HWND hMainWindow = GetMainWindowHandle();
        if (!hMainWindow || !OpenClipboard(hMainWindow))
                return;
        HANDLE hData = GetClipboardData(uFormat);
        if (hData) {
                uint8 *data = (uint8 *)GlobalLock(hData);
                if (data) {
                        uint32 length = GlobalSize(hData);
                        if (length) {
                                int32 out_length = 0;

                                // Allocate space for new scrap in MacOS side
                                M68kRegisters r;
                                r.d[0] = length;
                                Execute68kTrap(0xa71e, &r);     // NewPtrSysClear()
                                uint32 scrap_area = r.a[0];

                                if (scrap_area) {
                                        switch (type) {
                                        case FOURCC('T','E','X','T'):
                                                D(bug(" clipping TEXT\n"));

                                                // Convert text from ISO-Latin1 to Mac charset
                                                uint8 *p = Mac2HostAddr(scrap_area);
                                                for (int i = 0; i < length; i++) {
                                                        uint8 c = data[i];
                                                        if (c < 0x80) {
                                                                if (c == 13 && i < length - 1 && data[i + 1] == 10) {   // CR/LF -> CR
                                                                        c = 13;
                                                                        i++;
                                                                }
                                                        } else if (!no_clip_conversion)
                                                                c = iso2mac[c & 0x7f];
                                                        *p++ = c;
                                                        out_length++;
                                                }
                                                break;
                                        }

                                        // Add new data to clipboard
                                        static uint8 proc[] = {
                                                0x59, 0x8f,                                     // subq.l       #4,sp
                                                0xa9, 0xfc,                                     // ZeroScrap()
                                                0x2f, 0x3c, 0, 0, 0, 0,         // move.l       #length,-(sp)
                                                0x2f, 0x3c, 0, 0, 0, 0,         // move.l       #type,-(sp)
                                                0x2f, 0x3c, 0, 0, 0, 0,         // move.l       #outbuf,-(sp)
                                                0xa9, 0xfe,                                     // PutScrap()
                                                0x58, 0x8f,                                     // addq.l       #4,sp
                                                M68K_RTS >> 8, M68K_RTS
                                        };
                                        uint32 proc_area = Host2MacAddr(proc);
                                        WriteMacInt32(proc_area +  6, out_length);
                                        WriteMacInt32(proc_area + 12, type);
                                        WriteMacInt32(proc_area + 18, scrap_area);
                                        we_put_this_data = true;
                                        Execute68k(proc_area, &r);

                                        // We are done with scratch memory
                                        r.a[0] = scrap_area;
                                        Execute68kTrap(0xa01f, &r);             // DisposePtr
                                }
                        }
                        GlobalUnlock(hData);
                }
        }
        CloseClipboard();
}
Revision:	1.5
Committed:	2008-01-01T09:40:33Z (16 years, 10 months ago) by gbeauche
Branch:	MAIN
Changes since 1.4:	+1 -1 lines
Log Message:	Happy New Year!
#	User	Rev	Content
1	gbeauche	1.1	/*
2			* clip_windows.cpp - Clipboard handling, Windows implementation
3			*
4	gbeauche	1.5	* Basilisk II (C) 1997-2008 Christian Bauer
5	gbeauche	1.1	*
6			* This program is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#include "sysdeps.h"
22
23			#include <vector>
24			#define WIN32_LEAN_AND_MEAN
25			#include <windows.h>
26
27			#include "macos_util.h"
28			#include "clip.h"
29			#include "prefs.h"
30			#include "cpu_emulation.h"
31			#include "main.h"
32			#include "emul_op.h"
33
34			#define DEBUG 0
35			#include "debug.h"
36
37			#ifndef NO_STD_NAMESPACE
38			using std::vector;
39			#endif
40
41
42			// Conversion tables
43			static const uint8 mac2iso[0x80] = {
44			0xc4, 0xc5, 0xc7, 0xc9, 0xd1, 0xd6, 0xdc, 0xe1,
45			0xe0, 0xe2, 0xe4, 0xe3, 0xe5, 0xe7, 0xe9, 0xe8,
46			0xea, 0xeb, 0xed, 0xec, 0xee, 0xef, 0xf1, 0xf3,
47			0xf2, 0xf4, 0xf6, 0xf5, 0xfa, 0xf9, 0xfb, 0xfc,
48			0x2b, 0xb0, 0xa2, 0xa3, 0xa7, 0xb7, 0xb6, 0xdf,
49			0xae, 0xa9, 0x20, 0xb4, 0xa8, 0x23, 0xc6, 0xd8,
50			0x20, 0xb1, 0x3c, 0x3e, 0xa5, 0xb5, 0xf0, 0x53,
51			0x50, 0x70, 0x2f, 0xaa, 0xba, 0x4f, 0xe6, 0xf8,
52			0xbf, 0xa1, 0xac, 0x2f, 0x66, 0x7e, 0x44, 0xab,
53			0xbb, 0x2e, 0x20, 0xc0, 0xc3, 0xd5, 0x4f, 0x6f,
54			0x2d, 0x2d, 0x22, 0x22, 0x60, 0x27, 0xf7, 0x20,
55			0xff, 0x59, 0x2f, 0xa4, 0x3c, 0x3e, 0x66, 0x66,
56			0x23, 0xb7, 0x2c, 0x22, 0x25, 0xc2, 0xca, 0xc1,
57			0xcb, 0xc8, 0xcd, 0xce, 0xcf, 0xcc, 0xd3, 0xd4,
58			0x20, 0xd2, 0xda, 0xdb, 0xd9, 0x69, 0x5e, 0x7e,
59			0xaf, 0x20, 0xb7, 0xb0, 0xb8, 0x22, 0xb8, 0x20
60			};
61
62			static const uint8 iso2mac[0x80] = {
63			0xad, 0xb0, 0xe2, 0xc4, 0xe3, 0xc9, 0xa0, 0xe0,
64			0xf6, 0xe4, 0xde, 0xdc, 0xce, 0xb2, 0xb3, 0xb6,
65			0xb7, 0xd4, 0xd5, 0xd2, 0xd3, 0xa5, 0xd0, 0xd1,
66			0xf7, 0xaa, 0xdf, 0xdd, 0xcf, 0xba, 0xfd, 0xd9,
67			0xca, 0xc1, 0xa2, 0xa3, 0xdb, 0xb4, 0xbd, 0xa4,
68			0xac, 0xa9, 0xbb, 0xc7, 0xc2, 0xf0, 0xa8, 0xf8,
69			0xa1, 0xb1, 0xc3, 0xc5, 0xab, 0xb5, 0xa6, 0xe1,
70			0xfc, 0xc6, 0xbc, 0xc8, 0xf9, 0xda, 0xd7, 0xc0,
71			0xcb, 0xe7, 0xe5, 0xcc, 0x80, 0x81, 0xae, 0x82,
72			0xe9, 0x83, 0xe6, 0xe8, 0xed, 0xea, 0xeb, 0xec,
73			0xf5, 0x84, 0xf1, 0xee, 0xef, 0xcd, 0x85, 0xfb,
74			0xaf, 0xf4, 0xf2, 0xf3, 0x86, 0xfa, 0xb8, 0xa7,
75			0x88, 0x87, 0x89, 0x8b, 0x8a, 0x8c, 0xbe, 0x8d,
76			0x8f, 0x8e, 0x90, 0x91, 0x93, 0x92, 0x94, 0x95,
77			0xfe, 0x96, 0x98, 0x97, 0x99, 0x9b, 0x9a, 0xd6,
78			0xbf, 0x9d, 0x9c, 0x9e, 0x9f, 0xff, 0xb9, 0xd8
79			};
80
81			// Flag: Don't convert clipboard text
82			static bool no_clip_conversion;
83
84			// Flag for PutScrap(): the data was put by GetScrap(), don't bounce it back to the Windows side
85			static bool we_put_this_data = false;
86
87			// Define a byte array (rewrite if it's a bottleneck)
88			struct ByteArray : public vector<uint8> {
89			uint8 data() { return &(this)[0]; }
90			};
91
92			// Prototypes
93			static void do_putscrap(uint32 type, void *scrap, int32 length);
94			static void do_getscrap(void **handle, uint32 type, int32 offset);
95
96	gbeauche	1.4	// From main_windows.cpp
97			extern HWND GetMainWindowHandle(void);
98	gbeauche	1.1
99
100			/*
101			* Initialization
102			*/
103
104			void ClipInit(void)
105			{
106			no_clip_conversion = PrefsFindBool("noclipconversion");
107			}
108
109
110			/*
111			* Deinitialization
112			*/
113
114			void ClipExit(void)
115			{
116			}
117
118
119			/*
120			* Mac application wrote to clipboard
121			*/
122
123			void PutScrap(uint32 type, void *scrap, int32 length)
124			{
125			D(bug("PutScrap type %08lx, data %p, length %ld\n", type, scrap, length));
126			if (we_put_this_data) {
127			we_put_this_data = false;
128			return;
129			}
130			if (length <= 0)
131			return;
132
133			do_putscrap(type, scrap, length);
134			}
135
136			static void do_putscrap(uint32 type, void *scrap, int32 length)
137			{
138			ByteArray clip_data;
139			UINT uFormat = 0;
140
141			switch (type) {
142			case FOURCC('T','E','X','T'): {
143			D(bug(" clipping TEXT\n"));
144
145			// Convert text from Mac charset to ISO-Latin1
146			uint8 p = (uint8 )scrap;
147			for (int i=0; i<length; i++) {
148			uint8 c = *p++;
149			if (c < 0x80) {
150			if (c == 13) { // CR -> CR/LF
151			clip_data.push_back(c);
152			c = 10;
153			}
154			} else if (!no_clip_conversion)
155			c = mac2iso[c & 0x7f];
156			clip_data.push_back(c);
157			}
158			clip_data.push_back(0);
159			uFormat = CF_TEXT;
160			break;
161			}
162			}
163			if (uFormat != CF_TEXT) // 'TEXT' only
164			return;
165
166			// Transfer data to the native clipboard
167			HWND hMainWindow = GetMainWindowHandle();
168			if (!hMainWindow \|\|!OpenClipboard(hMainWindow))
169			return;
170			EmptyClipboard();
171			HANDLE hData = GlobalAlloc(GMEM_DDESHARE, clip_data.size());
172			if (hData) {
173			uint8 data = (uint8 )GlobalLock(hData);
174			memcpy(data, clip_data.data(), clip_data.size());
175			GlobalUnlock(hData);
176			if (!SetClipboardData(uFormat, hData))
177			GlobalFree(hData);
178			}
179			CloseClipboard();
180			}
181
182
183			/*
184			* Mac application reads clipboard
185			*/
186
187			void GetScrap(void **handle, uint32 type, int32 offset)
188			{
189			D(bug("GetScrap handle %p, type %08x, offset %d\n", handle, type, offset));
190
191			do_getscrap(handle, type, offset);
192			}
193
194			static void do_getscrap(void **handle, uint32 type, int32 offset)
195			{
196			// Get appropriate format for requested data
197			UINT uFormat = 0;
198			switch (type) {
199			case FOURCC('T','E','X','T'):
200			uFormat = CF_TEXT;
201			break;
202			}
203			if (uFormat != CF_TEXT) // 'TEXT' only
204			return;
205
206			// Get the native clipboard data
207			HWND hMainWindow = GetMainWindowHandle();
208			if (!hMainWindow \|\| !OpenClipboard(hMainWindow))
209			return;
210			HANDLE hData = GetClipboardData(uFormat);
211			if (hData) {
212			uint8 data = (uint8 )GlobalLock(hData);
213			if (data) {
214			uint32 length = GlobalSize(hData);
215			if (length) {
216			int32 out_length = 0;
217
218			// Allocate space for new scrap in MacOS side
219			M68kRegisters r;
220			r.d[0] = length;
221			Execute68kTrap(0xa71e, &r); // NewPtrSysClear()
222			uint32 scrap_area = r.a[0];
223
224			if (scrap_area) {
225			switch (type) {
226			case FOURCC('T','E','X','T'):
227			D(bug(" clipping TEXT\n"));
228
229			// Convert text from ISO-Latin1 to Mac charset
230			uint8 *p = Mac2HostAddr(scrap_area);
231			for (int i = 0; i < length; i++) {
232			uint8 c = data[i];
233			if (c < 0x80) {
234			if (c == 13 && i < length - 1 && data[i + 1] == 10) { // CR/LF -> CR
235			c = 13;
236			i++;
237			}
238			} else if (!no_clip_conversion)
239			c = iso2mac[c & 0x7f];
240			*p++ = c;
241			out_length++;
242			}
243			break;
244			}
245
246			// Add new data to clipboard
247			static uint8 proc[] = {
248			0x59, 0x8f, // subq.l #4,sp
249			0xa9, 0xfc, // ZeroScrap()
250			0x2f, 0x3c, 0, 0, 0, 0, // move.l #length,-(sp)
251			0x2f, 0x3c, 0, 0, 0, 0, // move.l #type,-(sp)
252			0x2f, 0x3c, 0, 0, 0, 0, // move.l #outbuf,-(sp)
253			0xa9, 0xfe, // PutScrap()
254			0x58, 0x8f, // addq.l #4,sp
255			M68K_RTS >> 8, M68K_RTS
256			};
257			uint32 proc_area = Host2MacAddr(proc);
258			WriteMacInt32(proc_area + 6, out_length);
259			WriteMacInt32(proc_area + 12, type);
260			WriteMacInt32(proc_area + 18, scrap_area);
261			we_put_this_data = true;
262			Execute68k(proc_area, &r);
263
264			// We are done with scratch memory
265			r.a[0] = scrap_area;
266			Execute68kTrap(0xa01f, &r); // DisposePtr
267			}
268			}
269			GlobalUnlock(hData);
270			}
271			}
272			CloseClipboard();
273			}