static void SaveToPICT (SFReply *reply)
{
Rect MyPicFrame ;
CQDProcs MyPicProcs,*SavePtr ;
OSErr error ;
long LongZero, LongCount ;
short Counter ;
CGrafPtr theCGrafPort;
WindowPtr theWindow;
OpenCPicParams myOpenCPicParams;
/* get my window */
theWindow = myWindow.theWindow;
theCGrafPort = (CGrafPtr) theWindow;
error = FSOpen(reply->fName, reply->vRefNum, &FileSys_RefNR ) ;
SetStdCProcs ( &MyPicProcs ) ;
SavePtr = (CQDProcs *) theWindow->grafProcs;
theWindow->grafProcs = (QDProcs *) (&MyPicProcs) ;
MyPicProcs.putPicProc = NewQDPutPicProc(MyPutPicData) ;
LongZero = 0 ;
LongCount = 4 ;
PicCounter = sizeof(Picture) ;
for (Counter=1 ; Counter <= 128+sizeof(Picture) ; Counter++ )
error = FSWrite(FileSys_RefNR, &LongCount, &LongZero );
error = SetFPos(FileSys_RefNR, fsFromStart, 512+sizeof(Picture)) ;
SetPort((GrafPtr)(theWindow));
MyPicFrame = ((GrafPtr)(theWindow))->portRect;
MyPicFrame.right = MyPicFrame.right-16;
MyPicFrame.bottom = MyPicFrame.bottom-16;
MyPicHand = NULL ;
myOpenCPicParams.srcRect = MyPicFrame;
myOpenCPicParams.hRes = cHRes;
myOpenCPicParams.vRes = cVRes;
myOpenCPicParams.version = -2;
myOpenCPicParams.reserved1 = 0;
myOpenCPicParams.reserved2 = 0;
MyPicHand = OpenCPicture ( &myOpenCPicParams );
ClipRect(&MyPicFrame);
/* draw picture */
RefreshCommand();
ClosePicture() ;
/* close File */
error = SetFPos(FileSys_RefNR, fsFromStart, 512) ;
LongCount = sizeof(Picture) ;
error = FSWrite(FileSys_RefNR, &LongCount, (void *) (*MyPicHand) );
error = FSClose(FileSys_RefNR) ;
KillPicture(MyPicHand);
theWindow->grafProcs = (QDProcs *) SavePtr ;
return;
}
void
TkpDisplayMenuButton(
ClientData clientData) /* Information about widget. */
{
TkMenuButton *butPtr = (TkMenuButton *) clientData;
Tk_Window tkwin = butPtr->tkwin;
TkWindow * winPtr;
Pixmap pixmap;
MacMenuButton * mbPtr = (MacMenuButton *) butPtr;
GWorldPtr dstPort;
CGrafPtr saveWorld;
GDHandle saveDevice;
int hasImageOrBitmap = 0;
int width, height;
int err;
ControlButtonGraphicAlignment theAlignment;
Rect paneRect, cntrRect;
butPtr->flags &= ~REDRAW_PENDING;
if ((butPtr->tkwin == NULL) || !Tk_IsMapped(tkwin)) {
return;
}
pixmap = ( Pixmap )Tk_WindowId(tkwin);
GetGWorld(&saveWorld, &saveDevice);
dstPort = TkMacOSXGetDrawablePort(Tk_WindowId(tkwin));
SetGWorld(dstPort, NULL);
TkMacOSXSetUpClippingRgn(Tk_WindowId(tkwin));
winPtr=(TkWindow *)butPtr->tkwin;
paneRect.left=winPtr->privatePtr->xOff;
paneRect.top=winPtr->privatePtr->yOff;
paneRect.right=paneRect.left+Tk_Width(butPtr->tkwin)-1;
paneRect.bottom=paneRect.top+Tk_Height(butPtr->tkwin)-1;
cntrRect=paneRect;
cntrRect.left+=butPtr->inset;
cntrRect.top+=butPtr->inset;
cntrRect.right-=butPtr->inset;
cntrRect.bottom-=butPtr->inset;
if (mbPtr->userPane) {
MenuButtonControlParams params;
bzero(¶ms, sizeof(params));
ComputeMenuButtonControlParams(butPtr, ¶ms );
if (bcmp(¶ms,&mbPtr->params,sizeof(params))) {
if (mbPtr->userPane) {
DisposeControl(mbPtr->userPane);
mbPtr->userPane = NULL;
mbPtr->control = NULL;
}
}
}
if (!mbPtr->userPane) {
if (MenuButtonInitControl(mbPtr,&paneRect,&cntrRect ) ) {
fprintf(stderr,"Init Control failed\n" );
return;
}
}
SetControlBounds(mbPtr->userPane,&paneRect);
SetControlBounds(mbPtr->control,&cntrRect);
/*
* We need to cache the title and its style
*/
if (!(mbPtr->flags&2)) {
ControlTitleParams titleParams;
int titleChanged;
int styleChanged;
ComputeControlTitleParams(butPtr,&titleParams);
CompareControlTitleParams(&titleParams,&mbPtr->titleParams,
&titleChanged,&styleChanged);
if (titleChanged) {
CFStringRef cf;
cf = CFStringCreateWithCString(NULL,
titleParams.title, kCFStringEncodingUTF8);
if (hasImageOrBitmap) {
SetControlTitleWithCFString(mbPtr->control, cf);
} else {
SetMenuItemTextWithCFString(mbPtr->menuRef, 1, cf);
}
CFRelease(cf);
bcopy(titleParams.title,mbPtr->titleParams.title,titleParams.len+1);
mbPtr->titleParams.len = titleParams.len;
}
if ((titleChanged||styleChanged) && titleParams .len) {
if (hasImageOrBitmap) {
if ((err=SetControlFontStyle(mbPtr->control,&titleParams.style))!=noErr) {
fprintf(stderr,"SetControlFontStyle failed %d\n", err);
return;
}
}
bcopy(&titleParams.style,&mbPtr->titleParams.style,sizeof(titleParams.style));
}
}
if (butPtr->image != None) {
Tk_SizeOfImage(butPtr->image, &width, &height);
hasImageOrBitmap = 1;
} else if (butPtr->bitmap != None) {
Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, &width, &height);
hasImageOrBitmap = 1;
}
if (hasImageOrBitmap) {
mbPtr->picParams.srcRect.right = width;
mbPtr->picParams.srcRect.bottom = height;
/* Set the flag to circumvent clipping and bounds problems with OS 10.0.4 */
tkPictureIsOpen = 1;
if (!(mbPtr->bevelButtonContent.u.picture = OpenCPicture(&mbPtr->picParams)) ) {
fprintf(stderr,"OpenCPicture failed\n");
}
/*
* TO DO - There is one case where XCopyPlane calls CopyDeepMask,
* which does not get recorded in the picture. So the bitmap code
* will fail in that case.
*/
if (butPtr->image != NULL) {
Tk_RedrawImage(butPtr->image, 0, 0, width,
height, pixmap, 0, 0);
} else {
XCopyPlane(butPtr->display, butPtr->bitmap, pixmap, NULL, 0, 0,
(unsigned int) width, (unsigned int) height, 0, 0, 1);
}
ClosePicture();
tkPictureIsOpen = 0;
if ( (err=SetControlData(mbPtr->control, kControlButtonPart,
kControlBevelButtonContentTag,
sizeof(ControlButtonContentInfo),
(char *) &mbPtr->bevelButtonContent)) != noErr ) {
fprintf(stderr,"SetControlData BevelButtonContent failed, %d\n", err );
}
switch (butPtr->anchor) {
case TK_ANCHOR_N:
theAlignment = kControlBevelButtonAlignTop;
break;
case TK_ANCHOR_NE:
theAlignment = kControlBevelButtonAlignTopRight;
break;
case TK_ANCHOR_E:
theAlignment = kControlBevelButtonAlignRight;
break;
case TK_ANCHOR_SE:
theAlignment = kControlBevelButtonAlignBottomRight;
break;
case TK_ANCHOR_S:
theAlignment = kControlBevelButtonAlignBottom;
break;
case TK_ANCHOR_SW:
theAlignment = kControlBevelButtonAlignBottomLeft;
break;
case TK_ANCHOR_W:
theAlignment = kControlBevelButtonAlignLeft;
break;
case TK_ANCHOR_NW:
theAlignment = kControlBevelButtonAlignTopLeft;
break;
case TK_ANCHOR_CENTER:
theAlignment = kControlBevelButtonAlignCenter;
break;
}
if ((err=SetControlData(mbPtr->control, kControlButtonPart,
kControlBevelButtonGraphicAlignTag,
sizeof(ControlButtonGraphicAlignment),
(char *) &theAlignment)) != noErr ) {
fprintf(stderr,"SetControlData BevelButtonGraphicAlign failed, %d\n", err );
}
}
if (butPtr->flags & GOT_FOCUS) {
HiliteControl(mbPtr->control,kControlButtonPart);
} else {
HiliteControl(mbPtr->control,kControlNoPart);
}
UpdateControlColors(mbPtr);
if (mbPtr->flags&2) {
ShowControl(mbPtr->control);
ShowControl(mbPtr->userPane);
mbPtr->flags ^= 2;
} else {
Draw1Control(mbPtr->userPane);
SetControlVisibility(mbPtr->control, true, true);
}
if (hasImageOrBitmap) {
KillPicture(mbPtr->bevelButtonContent.u.picture);
}
SetGWorld(saveWorld, saveDevice);
}
void
SetupBevelButton(
MacButton *mbPtr, /* Mac button. */
ControlRef controlHandle, /* The control to set this picture to. */
GWorldPtr destPort, /* Off screen GWorld. */
GC gc, /* The GC we are drawing into - needed for the
* bevel button. */
Pixmap pixmap) /* The pixmap we are drawing into - needed for
* the bevel button. */
{
TkButton *butPtr = (TkButton *) mbPtr;
int height, width;
ControlButtonGraphicAlignment theAlignment;
CGrafPtr savePort;
Boolean portChanged = false;
if (butPtr->image != None) {
Tk_SizeOfImage(butPtr->image, &width, &height);
} else {
Tk_SizeOfBitmap(butPtr->display, butPtr->bitmap, &width, &height);
}
if ((butPtr->width > 0) && (butPtr->width < width)) {
width = butPtr->width;
}
if ((butPtr->height > 0) && (butPtr->height < height)) {
height = butPtr->height;
}
{
portChanged = QDSwapPort(destPort, &savePort);
mbPtr->picParams.version = -2;
mbPtr->picParams.hRes = 0x00480000;
mbPtr->picParams.vRes = 0x00480000;
mbPtr->picParams.srcRect.top = 0;
mbPtr->picParams.srcRect.left = 0;
mbPtr->picParams.srcRect.bottom = height;
mbPtr->picParams.srcRect.right = width;
mbPtr->picParams.reserved1 = 0;
mbPtr->picParams.reserved2 = 0;
mbPtr->bevelButtonContent.contentType = kControlContentPictHandle;
mbPtr->bevelButtonContent.u.picture = OpenCPicture(&mbPtr->picParams);
if (!mbPtr->bevelButtonContent.u.picture) {
TkMacOSXDbgMsg("OpenCPicture failed");
}
tkPictureIsOpen = 1;
/*
* TO DO - There is one case where XCopyPlane calls CopyDeepMask,
* which does not get recorded in the picture. So the bitmap code
* will fail in that case.
*/
}
if (butPtr->selectImage != NULL && (butPtr->flags & SELECTED)) {
Tk_RedrawImage(butPtr->selectImage, 0, 0, width, height, pixmap, 0, 0);
#if 0
} else if (butPtr->tristateImage != NULL && (butPtr->flags & TRISTATED)) {
Tk_RedrawImage(butPtr->tristateImage, 0, 0, width, height, pixmap, 0,
0);
#endif
} else if (butPtr->image != NULL) {
Tk_RedrawImage(butPtr->image, 0, 0, width, height, pixmap, 0, 0);
} else {
XSetClipOrigin(butPtr->display, gc, 0, 0);
XCopyPlane(butPtr->display, butPtr->bitmap, pixmap, gc, 0, 0, width,
height, 0, 0, 1);
}
{
ClosePicture();
tkPictureIsOpen = 0;
if (portChanged) {
QDSwapPort(savePort, NULL);
}
}
ChkErr(SetControlData, controlHandle, kControlButtonPart,
kControlBevelButtonContentTag,
sizeof(ControlButtonContentInfo),
(char *) &mbPtr->bevelButtonContent);
if (butPtr->anchor == TK_ANCHOR_N) {
theAlignment = kControlBevelButtonAlignTop;
} else if (butPtr->anchor == TK_ANCHOR_NE) {
theAlignment = kControlBevelButtonAlignTopRight;
} else if (butPtr->anchor == TK_ANCHOR_E) {
theAlignment = kControlBevelButtonAlignRight;
} else if (butPtr->anchor == TK_ANCHOR_SE) {
theAlignment = kControlBevelButtonAlignBottomRight;
} else if (butPtr->anchor == TK_ANCHOR_S) {
theAlignment = kControlBevelButtonAlignBottom;
} else if (butPtr->anchor == TK_ANCHOR_SW) {
theAlignment = kControlBevelButtonAlignBottomLeft;
} else if (butPtr->anchor == TK_ANCHOR_W) {
theAlignment = kControlBevelButtonAlignLeft;
} else if (butPtr->anchor == TK_ANCHOR_NW) {
theAlignment = kControlBevelButtonAlignTopLeft;
} else if (butPtr->anchor == TK_ANCHOR_CENTER) {
theAlignment = kControlBevelButtonAlignCenter;
}
ChkErr(SetControlData, controlHandle, kControlButtonPart,
kControlBevelButtonGraphicAlignTag,
sizeof(ControlButtonGraphicAlignment), (char *) &theAlignment);
if (butPtr->compound != COMPOUND_NONE) {
ControlButtonTextPlacement thePlacement =
kControlBevelButtonPlaceNormally;
if (butPtr->compound == COMPOUND_TOP) {
thePlacement = kControlBevelButtonPlaceBelowGraphic;
} else if (butPtr->compound == COMPOUND_BOTTOM) {
thePlacement = kControlBevelButtonPlaceAboveGraphic;
} else if (butPtr->compound == COMPOUND_LEFT) {
thePlacement = kControlBevelButtonPlaceToRightOfGraphic;
} else if (butPtr->compound == COMPOUND_RIGHT) {
thePlacement = kControlBevelButtonPlaceToLeftOfGraphic;
}
ChkErr(SetControlData, controlHandle, kControlButtonPart,
kControlBevelButtonTextPlaceTag,
sizeof(ControlButtonTextPlacement), (char *) &thePlacement);
}
}
bool MCImageBitmapToPICT(MCImageBitmap *p_bitmap, MCMacSysPictHandle &r_pict)
{
#ifdef LIBGRAPHICS_BROKEN
bool t_success = true;
Pixmap drawdata = nil, drawmask = nil;
MCBitmap *maskimagealpha = nil;
t_success = MCImageSplitPixmaps(p_bitmap, drawdata, drawmask, maskimagealpha);
if (!t_success)
return false;
Rect t_rect;
SetRect(&t_rect, 0, 0, p_bitmap->width, p_bitmap->height);
GWorldPtr t_old_gworld;
GDHandle t_old_gdevice;
GetGWorld(&t_old_gworld, &t_old_gdevice);
PixMapHandle t_draw_pixmap;
t_draw_pixmap = GetGWorldPixMap((CGrafPtr)drawdata -> handle . pixmap);
GWorldPtr t_img_gworld;
t_img_gworld = NULL;
if (t_success)
{
QDErr t_err;
t_err = NewGWorld(&t_img_gworld, 32, &t_rect, NULL, NULL, 0);
if (t_err != noErr)
t_success = false;
}
if (t_success)
{
SetGWorld(t_img_gworld, GetGDevice());
PenMode(srcCopy);
ForeColor(blackColor);
BackColor(whiteColor);
if (maskimagealpha != NULL)
{
GWorldPtr t_alpha_gworld;
if (NewGWorldFromPtr(&t_alpha_gworld, 8, &t_rect, GetCTable(40), NULL, 0, maskimagealpha -> data, maskimagealpha -> bytes_per_line) == noErr)
{
const BitMap *t_dst_bits;
t_dst_bits = GetPortBitMapForCopyBits(t_img_gworld);
const BitMap *t_src_bits;
t_src_bits = GetPortBitMapForCopyBits((CGrafPtr)drawdata -> handle . pixmap);
const BitMap *t_mask_bits;
t_mask_bits = GetPortBitMapForCopyBits(t_alpha_gworld);
EraseRect(&t_rect);
CopyDeepMask(t_src_bits, t_mask_bits, t_dst_bits, &t_rect, &t_rect, &t_rect, srcCopy, NULL);
}
}
else if (drawmask != NULL)
{
PixMapHandle t_mask_pixmap;
t_mask_pixmap = GetGWorldPixMap((CGrafPtr)drawmask -> handle . pixmap);
EraseRect(&t_rect);
const BitMap *t_dst_bits;
t_dst_bits = GetPortBitMapForCopyBits(t_img_gworld);
const BitMap *t_src_bits;
LockPixels(t_draw_pixmap);
t_src_bits = (BitMap *)*t_draw_pixmap;
const BitMap *t_mask_bits;
LockPixels(t_mask_pixmap);
t_mask_bits = (BitMap *)*t_mask_pixmap;
CopyMask(t_src_bits, t_mask_bits, t_dst_bits, &t_rect, &t_rect, &t_rect);
UnlockPixels(t_mask_pixmap);
UnlockPixels(t_draw_pixmap);
}
else
{
const BitMap *t_dst_bits;
t_dst_bits = GetPortBitMapForCopyBits(t_img_gworld);
const BitMap *t_src_bits;
LockPixels(t_draw_pixmap);
t_src_bits = (BitMap *)*t_draw_pixmap;
CopyBits(t_src_bits, t_dst_bits, &t_rect, &t_rect, srcCopy, NULL);
UnlockPixels(t_draw_pixmap);
}
}
PicHandle t_handle;
t_handle = NULL;
if (t_success)
{
OpenCPicParams t_params;
t_params . srcRect = t_rect;
t_params . hRes = 72 << 16;
t_params . vRes = 72 << 16;
t_params . version = -2;
t_params . reserved1 = 0;
t_params . reserved2 = 0;
t_handle = OpenCPicture(&t_params);
if (t_handle == NULL)
t_success = false;
}
if (t_success)
{
GWorldPtr t_pict_gworld;
GDHandle t_pict_gdevice;
GetGWorld(&t_pict_gworld, &t_pict_gdevice);
PenMode(srcCopy);
ForeColor(blackColor);
BackColor(whiteColor);
const BitMap *t_dst_bits;
t_dst_bits = GetPortBitMapForCopyBits(t_pict_gworld);
const BitMap *t_src_bits;
t_src_bits = GetPortBitMapForCopyBits(t_img_gworld);
CopyBits(t_src_bits, t_dst_bits, &t_rect, &t_rect, srcCopy, NULL);
ClosePicture();
}
if (t_img_gworld != NULL)
DisposeGWorld(t_img_gworld);
SetGWorld(t_old_gworld, t_old_gdevice);
MCscreen->freepixmap(drawdata);
MCscreen->freepixmap(drawmask);
if (maskimagealpha != nil)
MCscreen->destroyimage(maskimagealpha);
if (t_success)
r_pict = (MCMacSysPictHandle)t_handle;
return t_success;
#else
return false;
#endif
}
/* convert IPIcon to Picture */
PicHandle IPIconToPicture(const IPIconRec *ipIcon,short iconKind)
{
ResType iconType;
short iconSize,iconDepth;
long offset=0;
OSErr err;
GWorldPtr iconGWorld;
PixMapHandle iconPix;
Handle dataHandle;
Ptr src,dst;
PicHandle picture;
OpenCPicParams picParam;
Rect iconRect;
Rect temp;
long rowBytes,iconRowBytes;
short i;
CTabHandle ctab=nil;
GWorldPtr cPort;
GDHandle cDevice;
/* invalid icon kind */
if (iconKind < 0) return nil;
iconType=gIconType[iconKind];
iconSize=gIconSize[iconKind];
iconDepth=gIconDepth[iconKind];
SetRect(&iconRect,0,0,iconSize,iconSize);
temp=iconRect;
temp.right++;
err=GetDataFromIPIcon(&dataHandle,ipIcon,iconKind);
if (err != noErr || dataHandle == nil) return nil; /* return nil when there are no icons */
if (GetHandleSize(dataHandle) != iconSize*(long)iconSize*(iconDepth>1 ? iconDepth : 2)/8) return nil;
switch (iconKind)
{
case kL1Mask:
offset=32*32/8;
break;
case kS1Mask:
offset=16*16/8;
break;
case kL8Mask:
case kS8Mask:
case kT8Mask:
ctab=GetGrayscaleCTable(iconDepth,true);
break;
}
GetGWorld(&cPort,&cDevice);
err=NewGWorld(&iconGWorld,iconDepth,&temp,ctab,0,useTempMem);
if (ctab != NULL) DisposeHandle((Handle)ctab);
if (err != noErr) return nil;
HLock(dataHandle);
SetGWorld(iconGWorld,0);
iconPix=GetGWorldPixMap(iconGWorld);
LockPixels(iconPix);
rowBytes=MyGetPixRowBytes(iconPix) & 0x3fff;
EraseRect(&iconRect);
src=*dataHandle+offset;
dst=MyGetPixBaseAddr(iconPix);
iconRowBytes=iconSize*iconDepth/8;
for (i=0; i<iconSize; i++)
{
BlockMoveData(src,dst,iconRowBytes);
src+=iconRowBytes;
dst+=rowBytes;
}
HUnlock(dataHandle);
UnlockPixels(iconPix);
picParam.srcRect=iconRect;
picParam.hRes=72L<<16;
picParam.vRes=72L<<16;
picParam.version=-2;
picParam.reserved1=0;
picParam.reserved2=0;
picture=OpenCPicture(&picParam);
ForeColor(blackColor);
BackColor(whiteColor);
ClipRect(&iconRect);
EraseRect(&iconRect);
#if 1
CopyBits(GetPortBitMapForCopyBits(iconGWorld),GetPortBitMapForCopyBits(iconGWorld),
&iconRect,&iconRect,srcCopy,nil);
#else
{
IconFamilyHandle iconFamily;
IconRef iconRef;
err=IPIconToIconFamily(ipIcon,&iconFamily);
err=RegisterIconRefFromIconFamily(kIconPartyCreator,'TEMP',iconFamily,&iconRef);
DisposeHandle((Handle)iconFamily);
err=PlotIconRef(&iconRect,kAlignNone,kTransformNone,kIconServicesNormalUsageFlag,
iconRef);
err=ReleaseIconRef(iconRef);
}
#endif
#if __BIG_ENDIAN__
(**picture).picFrame=iconRect;
#endif
ClosePicture();
SetGWorld(cPort,cDevice);
#if 0
CopyBits(GetPortBitMapForCopyBits(iconGWorld),GetPortBitMapForCopyBits(GetWindowPort(MyFrontNonFloatingWindow())),
&iconRect,&familyIconRect[iconKind],srcCopy,nil);
DrawPicture(picture,&familyIconRect[iconKind]);
#endif
DisposeGWorld(iconGWorld);
return picture;
}
