src/MacOSX/clip_macosx.cpp

/*
 *  clip_macosx.cpp - Clipboard handling, MacOS X (Carbon) 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 <Carbon/Carbon.h>

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

#define DEBUG 0
#include "debug.h"


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


static void SwapScrapData(uint32 type, void *data, int32 length, int from_host) {
#if BYTE_ORDER != BIG_ENDIAN
        if (type == kScrapFlavorTypeTextStyle) {
                uint16 *sdata = (uint16 *) data;
                // the first short stores the number of runs
                uint16 runs = sdata[0];
                sdata[0] = htons(sdata[0]);
                if (from_host)
                        runs = sdata[0];
                sdata++;
                // loop through each run
                for (int i = 0; i < runs; i++) {
                        struct style_data {
                                uint32 offset;
                                uint16 line_height;
                                uint16 line_ascent;
                                uint16 font_family;
                                uint16 character_style; // not swapped
                                uint16 point_size;
                                uint16 red;
                                uint16 green;
                                uint16 blue;
                        } *style = (struct style_data *) (sdata + i*10);
                        style->offset = htonl(style->offset);
                        style->line_height = htons(style->line_height);
                        style->line_ascent = htons(style->line_ascent);
                        style->font_family = htons(style->font_family);
                        style->point_size = htons(style->point_size);
                        style->red = htons(style->red);
                        style->green = htons(style->green);
                        style->blue = htons(style->blue);
                }
        } else {
                // add byteswapping code for other flavor types here ...
        }
#endif
}


/*
 *  Initialization
 */

void ClipInit(void)
{
}


/*
 *  Deinitialization
 */

void ClipExit(void)
{
}


/*
 *  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));
        ScrapRef theScrap;

        if (GetCurrentScrap(&theScrap) != noErr) {
                D(bug(" could not open scrap\n"));
                return;
        }

        Size byteCount;
        if (GetScrapFlavorSize(theScrap, type, &byteCount) == noErr) {

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

                // Get the native clipboard data
                if (scrap_area) {
                        uint8 * const data = Mac2HostAddr(scrap_area);
                        if (GetScrapFlavorData(theScrap, type, &byteCount, data) == noErr) {
                                SwapScrapData(type, data, byteCount, FALSE);
                                // 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
                                };
                                r.d[0] = sizeof(proc);
                                Execute68kTrap(0xa71e, &r);             // NewPtrSysClear()
                                uint32 proc_area = r.a[0];

                                if (proc_area) {
                                        Host2Mac_memcpy(proc_area, proc, sizeof(proc));
                                        WriteMacInt32(proc_area +  6, byteCount);
                                        WriteMacInt32(proc_area + 12, type);
                                        WriteMacInt32(proc_area + 18, scrap_area);
                                        we_put_this_data = true;
                                        Execute68k(proc_area, &r);

                                        r.a[0] = proc_area;
                                        Execute68kTrap(0xa01f, &r);     // DisposePtr
                                }
                        }

                        r.a[0] = scrap_area;
                        Execute68kTrap(0xa01f, &r);                     // DisposePtr
                }
        }
}


/*
 *  Mac application wrote to clipboard
 */

void PutScrap(uint32 type, void *scrap, int32 length)
{
        D(bug("PutScrap type %08lx, data %08lx, length %ld\n", type, scrap, length));
        ScrapRef theScrap;

        if (we_put_this_data) {
                we_put_this_data = false;
                return;
        }
        if (length <= 0)
                return;

        ClearCurrentScrap();
        if (GetCurrentScrap(&theScrap) != noErr) {
                D(bug(" could not open scrap\n"));
                return;
        }

        SwapScrapData(type, scrap, length, TRUE);
        if (PutScrapFlavor(theScrap, type, kScrapFlavorMaskNone, length, scrap) != noErr) {
                D(bug(" could not put to scrap\n"));
                return;
        }
}
Revision:	1.7
Committed:	2008-01-01T09:40:32Z (16 years, 5 months ago) by gbeauche
Branch:	MAIN
Changes since 1.6:	+1 -1 lines
Log Message:	Happy New Year!
#	User	Rev	Content
1	gbeauche	1.1	/*
2			* clip_macosx.cpp - Clipboard handling, MacOS X (Carbon) implementation
3			*
4	gbeauche	1.7	* 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			#include <Carbon/Carbon.h>
23
24			#include "clip.h"
25			#include "main.h"
26			#include "cpu_emulation.h"
27			#include "emul_op.h"
28
29			#define DEBUG 0
30			#include "debug.h"
31
32
33	gbeauche	1.2	// Flag for PutScrap(): the data was put by GetScrap(), don't bounce it back to the MacOS X side
34	gbeauche	1.1	static bool we_put_this_data = false;
35
36
37	asvitkine	1.6	static void SwapScrapData(uint32 type, void *data, int32 length, int from_host) {
38			#if BYTE_ORDER != BIG_ENDIAN
39			if (type == kScrapFlavorTypeTextStyle) {
40			uint16 sdata = (uint16 ) data;
41			// the first short stores the number of runs
42			uint16 runs = sdata[0];
43			sdata[0] = htons(sdata[0]);
44			if (from_host)
45			runs = sdata[0];
46			sdata++;
47			// loop through each run
48			for (int i = 0; i < runs; i++) {
49			struct style_data {
50			uint32 offset;
51			uint16 line_height;
52			uint16 line_ascent;
53			uint16 font_family;
54			uint16 character_style; // not swapped
55			uint16 point_size;
56			uint16 red;
57			uint16 green;
58			uint16 blue;
59			} style = (struct style_data ) (sdata + i*10);
60			style->offset = htonl(style->offset);
61			style->line_height = htons(style->line_height);
62			style->line_ascent = htons(style->line_ascent);
63			style->font_family = htons(style->font_family);
64			style->point_size = htons(style->point_size);
65			style->red = htons(style->red);
66			style->green = htons(style->green);
67			style->blue = htons(style->blue);
68			}
69			} else {
70			// add byteswapping code for other flavor types here ...
71			}
72			#endif
73			}
74
75
76	gbeauche	1.1	/*
77			* Initialization
78			*/
79
80			void ClipInit(void)
81			{
82			}
83
84
85			/*
86			* Deinitialization
87			*/
88
89			void ClipExit(void)
90			{
91			}
92
93
94			/*
95			* Mac application reads clipboard
96			*/
97
98			void GetScrap(void **handle, uint32 type, int32 offset)
99			{
100			D(bug("GetScrap handle %p, type %08x, offset %d\n", handle, type, offset));
101			ScrapRef theScrap;
102
103			if (GetCurrentScrap(&theScrap) != noErr) {
104	gbeauche	1.3	D(bug(" could not open scrap\n"));
105			return;
106	gbeauche	1.1	}
107
108			Size byteCount;
109			if (GetScrapFlavorSize(theScrap, type, &byteCount) == noErr) {
110
111	gbeauche	1.5	// Allocate space for new scrap in MacOS side
112			M68kRegisters r;
113			r.d[0] = byteCount;
114			Execute68kTrap(0xa71e, &r); // NewPtrSysClear()
115			uint32 scrap_area = r.a[0];
116
117			// Get the native clipboard data
118			if (scrap_area) {
119			uint8 * const data = Mac2HostAddr(scrap_area);
120			if (GetScrapFlavorData(theScrap, type, &byteCount, data) == noErr) {
121	asvitkine	1.6	SwapScrapData(type, data, byteCount, FALSE);
122	gbeauche	1.5	// Add new data to clipboard
123			static uint8 proc[] = {
124			0x59, 0x8f, // subq.l #4,sp
125			0xa9, 0xfc, // ZeroScrap()
126			0x2f, 0x3c, 0, 0, 0, 0, // move.l #length,-(sp)
127			0x2f, 0x3c, 0, 0, 0, 0, // move.l #type,-(sp)
128			0x2f, 0x3c, 0, 0, 0, 0, // move.l #outbuf,-(sp)
129			0xa9, 0xfe, // PutScrap()
130			0x58, 0x8f, // addq.l #4,sp
131			M68K_RTS >> 8, M68K_RTS
132			};
133			r.d[0] = sizeof(proc);
134			Execute68kTrap(0xa71e, &r); // NewPtrSysClear()
135			uint32 proc_area = r.a[0];
136
137			if (proc_area) {
138			Host2Mac_memcpy(proc_area, proc, sizeof(proc));
139			WriteMacInt32(proc_area + 6, byteCount);
140			WriteMacInt32(proc_area + 12, type);
141			WriteMacInt32(proc_area + 18, scrap_area);
142			we_put_this_data = true;
143			Execute68k(proc_area, &r);
144
145			r.a[0] = proc_area;
146			Execute68kTrap(0xa01f, &r); // DisposePtr
147			}
148			}
149
150			r.a[0] = scrap_area;
151			Execute68kTrap(0xa01f, &r); // DisposePtr
152			}
153	gbeauche	1.1	}
154			}
155
156
157			/*
158			* Mac application wrote to clipboard
159			*/
160
161			void PutScrap(uint32 type, void *scrap, int32 length)
162			{
163			D(bug("PutScrap type %08lx, data %08lx, length %ld\n", type, scrap, length));
164			ScrapRef theScrap;
165
166			if (we_put_this_data) {
167	gbeauche	1.3	we_put_this_data = false;
168			return;
169	gbeauche	1.1	}
170			if (length <= 0)
171			return;
172
173			ClearCurrentScrap();
174			if (GetCurrentScrap(&theScrap) != noErr) {
175			D(bug(" could not open scrap\n"));
176			return;
177			}
178
179	asvitkine	1.6	SwapScrapData(type, scrap, length, TRUE);
180	gbeauche	1.1	if (PutScrapFlavor(theScrap, type, kScrapFlavorMaskNone, length, scrap) != noErr) {
181			D(bug(" could not put to scrap\n"));
182			return;
183			}
184			}