pascal OSErr SetDragImage ( DragReference theDragRef,
PixMapHandle imagePixMap,
RgnHandle imageRgn,
Point imageOffsetPt,
DragImageFlags theImageFlags )
{
enum
{
uppSetDragImageInfo = kD0DispatchedPascalStackBased
| RESULT_SIZE (SIZE_CODE (sizeof(OSErr)))
| DISPATCHED_STACK_ROUTINE_SELECTOR_SIZE
(SIZE_CODE (sizeof (unsigned long)))
| DISPATCHED_STACK_ROUTINE_PARAMETER
(1, SIZE_CODE (sizeof (theDragRef)))
| DISPATCHED_STACK_ROUTINE_PARAMETER
(2, SIZE_CODE (sizeof (imagePixMap)))
| DISPATCHED_STACK_ROUTINE_PARAMETER
(3, SIZE_CODE (sizeof (imageRgn)))
| DISPATCHED_STACK_ROUTINE_PARAMETER
(4, SIZE_CODE (sizeof (imageOffsetPt)))
| DISPATCHED_STACK_ROUTINE_PARAMETER
(5, SIZE_CODE (sizeof (theImageFlags)))
};
return CallUniversalProc (
GetToolTrapAddress (_DragDispatch),
uppSetDragImageInfo, 0x27L, theDragRef, imagePixMap,
imageRgn, imageOffsetPt, theImageFlags);
}
static pascal void SBShowHideControlStrip(Boolean showIt)
{
static short procData[] = THREEWORDSTUB(0x303C, 0x0101, 0xAAF2);
ProcInfoType procInfo = kD0DispatchedPascalStackBased
| DISPATCHED_STACK_ROUTINE_SELECTOR_SIZE(kFourByteCode)
| DISPATCHED_STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(Boolean)));
CallUniversalProc((UniversalProcPtr) procData, procInfo, 0x01, showIt);
}
/* ControlStrip inline glue for PowerPC */
static pascal Boolean SBIsControlStripVisible(void)
{
static short procData[] = TWOWORDSTUB(0x7000, 0xAAF2);
ProcInfoType procInfo = kD0DispatchedPascalStackBased
| RESULT_SIZE(SIZE_CODE(sizeof(Boolean)))
| DISPATCHED_STACK_ROUTINE_SELECTOR_SIZE(kFourByteCode);
return((Boolean) CallUniversalProc((UniversalProcPtr) procData, procInfo, 0x00));
}
pascal OSErr GetDragHiliteColor (WindowPtr window, RGBColor *color)
{
enum
{
uppGetDragHiliteColorInfo =
kD0DispatchedPascalStackBased
| RESULT_SIZE (SIZE_CODE (sizeof(OSErr)))
| DISPATCHED_STACK_ROUTINE_SELECTOR_SIZE
(SIZE_CODE (sizeof (unsigned long)))
| DISPATCHED_STACK_ROUTINE_PARAMETER
(1, SIZE_CODE (sizeof (window)))
| DISPATCHED_STACK_ROUTINE_PARAMETER
(2, SIZE_CODE (sizeof (color)))
};
return CallUniversalProc (
GetToolTrapAddress (_DragDispatch),
uppGetDragHiliteColorInfo, 0x26L, window, color);
}
InvokeDataHCompletionUPP(data->AsyncPtr, data->AsyncRefCon, noErr, data->AsyncCompletionRtn);
data->AsyncPtr = PlaceToPutDataPtr;
data->AsyncRefCon = RefCon;
data->AsyncCompletionRtn = CompletionRtn;
}
return noErr;
}
static const struct { LPVOID proc; ProcInfoType type;} componentFunctions[] =
{
{NULL, 0}, /* 0 */
{NULL, 0}, /* 1 */
{myDataHGetData, kPascalStackBased
| RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult)))
| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler)))
| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(Handle)))
| STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long)))
| STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(long)))
| STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(long)))
}, /* kDataHGetDataSelect */
{NULL, 0}, /* kDataHPutDataSelect */
{NULL, 0}, /* kDataHFlushDataSelect */
{NULL, 0}, /* kDataHOpenForWriteSelect */
{NULL, 0}, /* kDataHCloseForWriteSelect */
{NULL, 0}, /* 7 */
{myDataHOpenForRead, kPascalStackBased
| RESULT_SIZE(SIZE_CODE(sizeof(ComponentResult)))
| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DataHandler)))
}, /* kDataHOpenForReadSelect
#endif
/////////////////////////////////////////////////////////////////////
#pragma mark ----- PowerPC Code Cache Flush -----
#if TARGET_CPU_68K && !TARGET_RT_MAC_CFM
// This chunk of code implements the classic 68K case for MakeDataPowerPCExecutable,
// ie we're running classic 68K code that's generating PowerPC instructions. Boy,
// is this a pain to implement. We have to connect up to Interface, find the
// appropriate symbol, build a routine descriptor for it, and then call it.
enum {
uppMakeDataExecutableProcInfo = kPascalStackBased |
STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(void *))) |
STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(unsigned long)))
};
static CFragConnectionID gInterfaceLib = NULL;
static UniversalProcPtr gMakeDataExecutable = NULL;
typedef pascal void (*MakeDataExecutableProcPtr)(void *address, unsigned long count);
static pascal OSStatus MakeDataPowerPCExecutableFromClassic(void *address, ByteCount count)
{
OSErr err;
Ptr junkMain;
Str255 junkMessage;
CFragSymbolClass junkClass;
ProcPtr routinePtr;
#include "macintosh_cseries.h"
#include "macintosh_network.h"
#ifdef mpwc
#pragma segment network
#endif
#define SOCKET_LISTENER_RESOURCE_TYPE 'SOCK'
#define SOCKET_LISTENER_ID 128
enum
{
// info for calling the packet handler
uppPacketHandlerProcInfo = kCStackBased
| RESULT_SIZE(kNoByteCode)
| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(DDPPacketBufferPtr))),
// info for calling the procedure that initializes the ddp socket listener
uppInitializeListenerProcInfo = kCStackBased
| RESULT_SIZE(SIZE_CODE(sizeof(ProcPtr)))
| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(packetHandlerProcPtr)))
| STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(DDPPacketBufferPtr)))
};
/* ---------- prototypes/NETWORK_SOCKET_LISTENER.A */
/* ---------- globals */
static DDPPacketBufferPtr ddpPacketBuffer= (DDPPacketBufferPtr) NULL;
static DDPSocketListenerUPP listenerUPP= (DDPSocketListenerUPP) NULL;
#if defined (KPMAC)
#include <Types.h>
#include <OSUtils.h>
#endif
#if defined (KPMACPPC) && !(TARGET_API_MAC_CARBON)
#include <Traps.h>
/* declare the universal procedure pointer info */
enum {
uppCallProgressProcInfo =
kCStackBased |
RESULT_SIZE (SIZE_CODE (sizeof (PTErr_t) ) ) |
STACK_ROUTINE_PARAMETER (1, SIZE_CODE (sizeof (KpInt32_t) ) ),
upprelayProcInfo =
kCStackBased |
RESULT_SIZE (SIZE_CODE (sizeof (PTErr_t) ) ) |
STACK_ROUTINE_PARAMETER (1, SIZE_CODE (sizeof (long) ) ) |
STACK_ROUTINE_PARAMETER (2, SIZE_CODE (sizeof (long) ) ) |
STACK_ROUTINE_PARAMETER (3, SIZE_CODE (sizeof (PTProgress_t) ) ) |
STACK_ROUTINE_PARAMETER (4, SIZE_CODE (sizeof (KpInt32_t) ) )
};
#endif
#if defined (KPMAC) && !(TARGET_API_MAC_CARBON)
pascal Bool SBSafeToAccessStartupDisk(void)
{
return CallUniversalProc((UniversalProcPtr)&SBSafeToAccessStartupDisk68K[0],kRegisterBased|RESULT_SIZE(SIZE_CODE(1)));
}
pascal void SBShowHideControlStrip(Bool showIt)
{
CallUniversalProc((UniversalProcPtr)&SBShowHideControlStrip68K[0],kPascalStackBased
| STACK_ROUTINE_PARAMETER(1, SIZE_CODE(1)),showIt);
}
pascal Bool SBIsControlStripVisible(void)
{
return CallUniversalProc((UniversalProcPtr)&SBIsControlStripVisible68K[0],kRegisterBased|RESULT_SIZE(SIZE_CODE(1)));
}
