int4 MCScreenDC::textwidth(MCFontStruct *f, const char *s, uint2 len, bool p_unicode_override)
{
if (len == 0)
return 0;
if (f->unicode || p_unicode_override)
{
if (MCmajorosversion >= 0x1050)
{
return OSX_DrawUnicodeText(0, 0, s, len, f, false, true);
}
else
{
int4 fwidth;
short oldfid = GetPortTextFont(GetQDGlobalsThePort());
short oldsize = GetPortTextSize(GetQDGlobalsThePort());
short oldstyle = GetPortTextFace(GetQDGlobalsThePort());
TextFont((short)(intptr_t)f->fid);
TextSize(f->size);
TextFace(f->style);
SInt16 baseline;
CFStringRef cfstring;
char *tempbuffer = NULL;
if (len)
{
uint2 *testchar = (uint2 *)s;
if (testchar[(len - 2 )>> 1] == 12398)
{
tempbuffer = new char[len+2];
memcpy(tempbuffer,s,len);
uint2 *tchar = (uint2 *)&tempbuffer[len];
*tchar = 0;
}
}
cfstring = CFStringCreateWithCharactersNoCopy(NULL, (UniChar *)(tempbuffer != NULL? tempbuffer: s), (tempbuffer != NULL? len + 2:len) >> 1,
kCFAllocatorNull);
Point dimensions = {0, 0};
GetThemeTextDimensions(cfstring, kThemeCurrentPortFont, kThemeStateActive, false, &dimensions, &baseline);
fwidth = dimensions.h;
CFRelease(cfstring);
if (tempbuffer)
delete tempbuffer;
TextFont(oldfid);
TextSize(oldsize);
TextFace(oldstyle);
return fwidth;
}
}
else
{
// MW-2012-09-21: [[ Bug 3884 ]] If the font is wide, measure using OS routine.
if (f -> wide)
static void mac_updatelicence(WindowPtr window)
{
Handle h;
int len;
long fondsize;
Rect textrect;
SetPort((GrafPtr)GetWindowPort(window));
BeginUpdate(window);
fondsize = GetScriptVariable(smRoman, smScriptSmallFondSize);
TextFont(HiWord(fondsize));
TextSize(LoWord(fondsize));
h = Get1Resource('TEXT', wLicence);
len = GetResourceSizeOnDisk(h);
#if TARGET_API_MAC_CARBON
GetPortBounds(GetWindowPort(window), &textrect);
#else
textrect = window->portRect;
#endif
if (h != NULL) {
HLock(h);
TETextBox(*h, len, &textrect, teFlushDefault);
HUnlock(h);
}
EndUpdate(window);
}
/////////////////////////////////////////////////////////////
//
// DrawString
//
void
nsPluginInstance::DrawString(const unsigned char* text,
short width,
short height,
short centerX,
Rect drawRect)
{
short length, textHeight, textWidth;
if(text == NULL)
return;
length = strlen((char*)text);
TextFont(1);
TextFace(bold);
TextMode(srcCopy);
TextSize(12);
FontInfo fontInfo;
GetFontInfo(&fontInfo);
textHeight = fontInfo.ascent + fontInfo.descent + fontInfo.leading;
textWidth = TextWidth(text, 0, length);
if (width > textWidth && height > textHeight)
{
MoveTo(centerX - (textWidth >> 1), height >> 1);
DrawText(text, 0, length);
}
// for scaling text
void MacPrinterCanvas::flush()
{
// ---- check if there is anything to do ----
//int nchars = (int) (text_ptr_ - text_buff_);
//if ((nchars == 0) || (lg_font_ == nil))
// return;
// ---- render the text ----
if (text_item_.count > 0) {
//set font
FontRep* fr = lg_font_->rep(nil);
TextFont(fr->font_);
TextFace(fr->face_);
float a00, a01, a10, a11, a20, a21;
transformer().matrix(a00, a01, a10, a11, a20, a21);
int size = int(double(fr->size_)*sqrt(a00*a00 + a01*a01) +.01);
TextSize(size);
TextMode(fr->mode_);
//if (printing) debugfile("flush %d %d\n",toPixelX(text_item_.x), toPixelY(text_item_.y));
MoveTo(toPixelX(text_item_.x), toPixelY(text_item_.y));
DrawText(text_item_.buffer, 0, text_item_.count);
// text_item_.buffer[text_item_.count] = '\0';
// debugfile("|%s|\n", text_item_.buffer);
}
text_item_.count = 0;
return;
}
void SetFont(
TextSpec *spec)
{
TextFont(spec->font);
TextFace(spec->style);
TextSize(spec->size);
}
void AboutBox::DrawUserItem( const short item )
{
short itemType;
Handle itemHand;
Rect itemBox;
GetDialogItem( mDialogPtr, item, &itemType, &itemHand, &itemBox );
if (item == kUrlItem) {
if (!mUrlPane) {
mUrlPane = MakeURLPane(itemBox);
}
mUrlPane->Draw();
}
else if (kVersionItem == item) {
MoveTo(itemBox.left, itemBox.bottom - 3);
TextFont(kFontIDGeneva);
TextSize(9);
DrawVersion();
}
else {
inherited::DrawUserItem(item);
return;
}
}
void drawBackground()
{
Rect rect;
RGBColor color;
Rect tempRect1;
color.red = color.green = color.blue = 8700;
RGBForeColor( &color );
PaintRect( GetPortBounds(GetWindowPort(gWindow), &tempRect1));
TextFont( kFontIDTimes );
TextMode( srcOr );
TextSize( 24 );
drawName( 85, 22, "\pSource Image" );
drawName( GetPortBounds(GetWindowPort(gWindow), &tempRect1)->right - 215, 22, "\pNew Image" );
GetPortBounds(GetWindowPort(gWindow), &tempRect1);
SetRect( &rect, 15, tempRect1.bottom - 180, tempRect1.right - 15, tempRect1.bottom - 30);
drawDeepBox( &rect );
TextSize( 12 );
drawName( tItem[0].rect.left, tItem[0].rect.top - 8, "\pTransfer Mode" );
drawName( aItem[0].rect.left, aItem[0].rect.top - 8, "\pArithmetic Mode" );
drawName( cItem[0].rect.left, cItem[0].rect.top - 8, "\pColorization" );
drawName( dItem[0].rect.left, dItem[0].rect.top - 8, "\pDither" );
drawName( mItem[0].rect.left, mItem[0].rect.top - 8, "\pColor Mapping" );
drawName( bItem[0].rect.left, bItem[0].rect.top - 8, "\pDestination" );
drawName( pItem[0].rect.left, pItem[0].rect.top - 8, "\pPaint Bucket" );
drawName( lItem[0].rect.left, lItem[0].rect.top - 8, "\pLasso Tool" );
}
void LCD_dofont(Lcd *x, Symbol *s, short argc, Atom *argv)
{
long font, size; /* check patcher font settings */
GrafPtr sp,pp;
short sFont,sSize;
EnterCallback();
font = argv->a_w.w_long;
size = (argv+1)->a_w.w_long;
x->font = (short)font;
x->f_size = (short)size;
if (sp=patcher_setport(x->lcd_box.b_patcher)){
GetPort(&pp);
if (!font&&!size){
x->font = pp->txFont;
x->f_size = pp->txSize;
}
else{
sFont = pp->txFont;
sSize = pp->txSize;
TextFont(font);
TextSize(size);
}
#ifdef debug
post("font:%d size:%d",x->font,x->f_size);
#endif
LCD_calcfont(x);
LCD_resize(x);
if (font||size){
TextFont(sFont);
TextSize(sSize);
}
SetPort(sp);
} else { /* note that this needs to be calced later */
x->f_width = -1;
x->f_ascent = -1;
x->f_descent = -1;
x->f_height = -1;
x->f_lineSpace = -1;
}
ExitCallback();
}
static void setfontsizestyle (short fontnum, short fontsize, short fontstyle) {
TextFont (fontnum);
TextSize (fontsize);
TextFace (fontstyle);
} /*setfontsizestyle*/
static
void set_font(int font)
{
double rad, scale, ux, uy;
int family, size, angle;
double width, height, capheight;
StyleParameter face;
Str255 name;
font = abs(font);
if (font >= 101 && font <= 129)
font -= 100;
else if (font >= 1 && font <= 32)
font = map[font - 1];
else
font = 9;
WC_to_NDC_rel(gkss->chup[0], gkss->chup[1], gkss->cntnr, ux, uy);
seg_xform_rel(&ux, &uy);
rad = -atan2(ux, uy);
angle = (int)(rad * 180 / M_PI + 0.5);
if (angle < 0) angle += 360;
p->path = ((angle + 45) / 90) % 4;
scale = sqrt(gkss->chup[0] * gkss->chup[0] + gkss->chup[1] * gkss->chup[1]);
ux = gkss->chup[0] / scale * gkss->chh;
uy = gkss->chup[1] / scale * gkss->chh;
WC_to_NDC_rel(ux, uy, gkss->cntnr, ux, uy);
width = 0;
height = sqrt(ux * ux + uy * uy);
seg_xform_rel(&width, &height);
height = sqrt(width * width + height * height);
capheight = nint(height * (fabs(p->c) + 1));
p->capheight = nint(capheight);
size = nint(capheight / capheights[font - 1]);
if (font > 13)
font += 3;
p->family = (font - 1) / 4;
face = (font % 4 == 1 || font % 4 == 2) ? normal : bold;
if (font % 4 == 2 || font % 4 == 0)
face |= italic;
CopyCStringToPascal(fonts[p->family], name);
family = FMGetFontFamilyFromName(name);
if (family != kInvalidFontFamily)
{
TextFont(family);
TextFace(face);
TextSize(size);
}
else
gks_perror("invalid font family (%s)", fonts[p->family]);
}
void screenOpen(char *Title) {
FontInfo fontInfo;
int n;
theWindow = GetNewWindow(screenWindow, nil, (WindowPtr)(-1));
if ((Title != NULL) && (*Title != '\0')) {
c2pstr(Title);
SetWTitle(theWindow, Title);
p2cstr(Title);
}
ShowWindow(theWindow);
SetPort(theWindow);
TextFont(monaco);
TextSize(9);
GetFontInfo(&fontInfo);
fontHeight = fontInfo.ascent + fontInfo.descent + fontInfo.leading;
fontWidth = fontInfo.widMax;
scrollRgn = NewRgn();
screenWidth = (theWindow->portRect.right - theWindow->portRect.left - 10) /
fontWidth;
screenHeight = (theWindow->portRect.bottom - theWindow->portRect.top) /
fontHeight;
maxPosition = screenHeight * fontHeight;
pausePosition = maxPosition - (currentPosition = fontHeight);
SetRect(&scrollRect, theWindow->portRect.left, theWindow->portRect.top + fontInfo.descent,
theWindow->portRect.right, theWindow->portRect.bottom);
SetRect(&pauseRect, theWindow->portRect.left, pausePosition + fontInfo.descent,
theWindow->portRect.right, theWindow->portRect.bottom);
MoveTo(5, currentPosition);
n = (sizeof(char *) + sizeof(short) + screenWidth) * screenHeight;
screenLine = (char **)NewPtr(n);
screenLength = (short *)&screenLine[screenHeight];
screenImage = (char *)&screenLength[screenHeight];
for (n = 0; n < screenHeight; n++) {
screenLine[n] = &screenImage[n * screenWidth];
screenLength[n] = 0;
}
startLine = endLine = 0;
screenOptions = 0;
return;
}
void _HYPlatformGraphicPane::_SetFont (_HYFont f)
{
Str255 fontFace;
StringToStr255 (f.face,fontFace);
short fNum;
GetFNum (fontFace,&fNum);
TextFont (fNum);
TextSize (f.size);
TextFace (f.style);
}
static int CreateApplicationWindow (AWindowRecord *wr, char *fname, short h, short v, short dh, short dv)
{
Rect r;
GrafPtr myPort;
PaletteHandle myPalette;
char name[80];
/* init AWindowRecord */
wr->theWindow = (WindowPtr) wr;
/* read in resources */
if (GetNewCWindow(appWinId,(Ptr)wr,(WindowPtr) -1)==NULL)
{
return(1);
}
myPalette = GetNewPalette(defaultPaletteId);
SetPalette(wr->theWindow,myPalette,false);
/* move and size window */
myPort = (GrafPtr) wr->theWindow;
SetPort(myPort);
MoveWindow(wr->theWindow,h,v,false);
SizeWindow(wr->theWindow,dh+15,dv+15,false);
strcpy(name,fname);
SetWTitle(wr->theWindow,c2pstr(name));
ShowWindow(wr->theWindow);
SelectWindow(wr->theWindow);
DrawGrowIcon(wr->theWindow);
r = myPort->portRect;
TextFont(kFontIDMonaco);
/* get the scroll bars */
wr->vScrollBar = GetNewControl(vScrollBarId,wr->theWindow);
wr->hScrollBar = GetNewControl(hScrollBarId,wr->theWindow);
/* set correct size of the scroll bars */
MoveControl(wr->vScrollBar,r.right-15,-1);
SizeControl(wr->vScrollBar,16,r.bottom-13);
SetControlMinimum(wr->vScrollBar,0);
SetControlMaximum(wr->vScrollBar,0);
SetControlValue(wr->vScrollBar,0);
ShowControl(wr->vScrollBar);
MoveControl(wr->hScrollBar,-1,r.bottom-15);
SizeControl(wr->hScrollBar,r.right-13,16);
SetControlMinimum(wr->hScrollBar,0);
SetControlMaximum(wr->hScrollBar,0);
SetControlValue(wr->hScrollBar,0);
ShowControl(wr->hScrollBar);
DrawControls(wr->theWindow);
SetRect(&(wr->usableRect),0,0,dh,dv);
return(0);
}
// FIXME: expensive - cache it?
int KstLabel::lineSpacing(QPainter &p) {
int LineSpacing = 0;
QFont TextFont(FontName, fontSize(p), QFont::Normal, false);
p.save();
p.setFont(TextFont);
LineSpacing = p.fontMetrics().lineSpacing();
p.restore();
return LineSpacing;
}
int KstLabel::ascent(QPainter &p) {
int Ascent = 0;
QFont TextFont(FontName, fontSize(p), QFont::Normal, false);
p.save();
p.setFont(TextFont);
Ascent = p.fontMetrics().boundingRect("1234567890").height();
p.restore();
return Ascent;
}
/* DisplayDialogCmd(theDialog, dlogItemNo, cmd)
Displays the command in an IGOR-style dialog. See GBLoadWaveDialog.c
for an example.
dlogItemNo is the item number of the dialog item in which the command
is to be displayed. On the Macintosh, this must be a user item. On Windows,
it must be an EDITTEXT item.
Thread Safety: DisplayDialogCmd is not thread-safe.
*/
void
DisplayDialogCmd(DialogPtr theDialog, int dlogItemNo, const char* cmd)
{
WindowRef theWindow;
CGrafPtr thePort;
Rect box;
int font, size;
int lineHeight;
FontInfo info;
RgnHandle saveClipRgnH;
theWindow = GetDialogWindow(theDialog);
thePort = GetWindowPort(theWindow);
font = GetPortTextFont(thePort); // Save text characteristics.
size = GetPortTextSize(thePort);
TextFont(kFontIDMonaco);
TextSize(9);
GetFontInfo(&info);
lineHeight = info.ascent + info.descent + info.leading;
GetDBox(theDialog, dlogItemNo, &box);
saveClipRgnH = NewRgn();
if (saveClipRgnH != NULL) {
GetClip(saveClipRgnH);
ClipRect(&box);
InsetRect(&box, 2, 2);
EraseRect(&box);
if (*cmd != 0) {
MoveTo(box.left+2, box.top + info.ascent + 2);
DrawDialogCmd(cmd, lineHeight);
}
SetClip(saveClipRgnH);
DisposeRgn(saveClipRgnH);
}
TextFont(font); // Restore font, size, style.
TextSize(size);
}
void RestoreQDDrawingState( QDDrawingState *inDrawingState, const Boolean inDisposeNow )
{// PixPatHandle tempPixPat;
#if !(ALIST_USEAPPEARANCEMGR && TARGET_RT_MAC_CFM )
#pragma unused( inDisposeNow ) // Eliminate compiler warnings in 68K targets because PixPatHandle stuff is screwed up!
#endif
Assert( inDrawingState != nil );
// Restore the pen/foreground state.
/* if ( !inDisposeNow && inDrawingState->penPixPatH != nil ) {
// Make a copy of the penPixPatH so we can put it somewhere else later because we're not supposed to dispose of it now.
tempPixPat = NewPixPat( );
if ( tempPixPat != nil )
CopyPixPat( inDrawingState->penPixPatH, tempPixPat );
} else
tempPixPat = nil;
PenPixPat( inDrawingState->penPixPatH );
inDrawingState->penPixPatH = tempPixPat;
*/ RGBForeColor( &inDrawingState->foreColor );
SetPenState( &inDrawingState->penState );
// Restore the background state.
/* if ( !inDisposeNow && inDrawingState->backPixPatH != nil ) {
// Make a copy of the backPixPatH so we can put it somewhere else later because we're not supposed to dispose of it now.
tempPixPat = NewPixPat( );
if ( tempPixPat != nil )
CopyPixPat( inDrawingState->backPixPatH, tempPixPat );
} else
tempPixPat = nil;
BackPixPat( inDrawingState->backPixPatH );
inDrawingState->penPixPatH = tempPixPat;
*/ RGBBackColor( &inDrawingState->backColor );
// Optionally restore the text state.
if ( inDrawingState->haveTextState ) {
TextFont( inDrawingState->textStyle.tsFont );
TextFace( inDrawingState->textStyle.tsFace );
TextSize( inDrawingState->textStyle.tsSize );
TextMode( inDrawingState->textMode );
}
#if ALIST_USEAPPEARANCEMGR && TARGET_RT_MAC_CFM
// If we're running under CFM and have Appearance Mgr 1.1 or later, use the ThemeDrawingState routines.
if ( inDrawingState->haveThemeState ) {
SetThemeDrawingState( inDrawingState->themeState, inDisposeNow );
if ( inDisposeNow )
inDrawingState->themeState = nil;
}
#endif
}
static void Quartz_SetFont(char *family,
int style, double cex, double ps, NewDevDesc *dd)
{
QuartzDesc *xd = (QuartzDesc*)dd->deviceSpecific;
int size = cex * ps + 0.5;
FMFontFamily CurrFontId;
GrafPtr savePort;
Str255 CurrFontName;
char CurrFont[256];
char *fontFamily;
GetPort(&savePort);
SetPortWindowPort(xd->window);
fontFamily = Quartz_TranslateFontFamily(family, style, xd->family);
if (fontFamily)
strcpy(CurrFont,fontFamily);
else
strcpy(CurrFont,"Helvetica");
if(style==5)
strcpy(CurrFont, "Symbol");
if(strcmp(CurrFont,"Symbol")==0){
if(WeAreOnPanther)
CGContextSelectFont( GetContext(xd), CurrFont, size,
kCGEncodingFontSpecific);
else
CGContextSelectFont( GetContext(xd), CurrFont, size,
kCGEncodingMacRoman);
}
else CGContextSelectFont( GetContext(xd), CurrFont, size,
kCGEncodingMacRoman);
/* This is needed for test only purposes
if(strcmp(CurrFont,"Symbol")==0)
CGContextSelectFont( GetContext(xd), CurrFont, size, kCGEncodingFontSpecific);
*/
CopyCStringToPascal(CurrFont,CurrFontName);
GetFNum(CurrFontName, &CurrFontId);
TextSize(size);
TextFont(CurrFontId);
SetPort(savePort);
}
// initialize g_rgchLeadBytes
//
// use the Windows API IsDBCSLeadByte() or the Mac API ParseTable()
//
static VOID InitLeadByteTable()
{
#if MAC
// as in Silver, the font must be switched first
// preserve the old font in the current grafPort
short fontSave = qd.thePort->txFont;
// then set the grafPort font to 1 (Application Default) because
// ParseTable uses qd.thePort->txFont to determine the currect script,
// which in turn determines the lead byte table. We want the application
// default table.
TextFont(1);
// UNDONE: is it necessary to init this to 0?
memset(g_rgchLeadBytes, 0, 256);
ParseTable(g_rgchLeadBytes);
// restore the old font
TextFont(fontSave);
#else // !MAC
int c;
memset(g_rgchLeadBytes, 0, 128);
// start at 128 since there aren't any lead bytes before that
for(c = 128; c < 256; c++) {
g_rgchLeadBytes[c] = (char)IsDBCSLeadByte((char)c);
}
#endif // !MAC
}
void mac_setfont(GWorldPtr world, Str255 fontname)
{
GDHandle oldGD;
GWorldPtr oldGW;
GetGWorld(&oldGW, &oldGD);
LockPixels(world->portPixMap);
{
short fontID;
SetGWorld( world, 0);
GetFNum(fontname, &fontID);
TextFont(fontID);
TextSize(14);
TextFace(extend/*|bold*/);
}
SetGWorld(oldGW, oldGD);
UnlockPixels(world->portPixMap);
}
int16 AboutDialog::hit(void)
{
GrafPtr saveport;
short item;
GetPort(&saveport);
SetPort(dialogptr);
BringToFront(dialogptr);
TextFont(geneva);
TextFace(0);
TextSize(10);
ShowWindow(dialogptr);
ModalDialog(NULL, &item);
SetPort(saveport);
return item;
}
PRBool
SimplePluginInstance::StartDraw(nsPluginWindow* window)
{
NP_Port* port;
Rect clipRect;
RGBColor col;
if (window == NULL)
return FALSE;
port = (NP_Port*) window->window;
if (window->clipRect.left < window->clipRect.right)
{
/* Preserve the old port */
GetPort((GrafPtr*)&gOldPort);
SetPort((GrafPtr)port->port);
/* Preserve the old drawing environment */
gSavePort.portRect = port->port->portRect;
gSavePort.txFont = port->port->txFont;
gSavePort.txFace = port->port->txFace;
gSavePort.txMode = port->port->txMode;
gSavePort.rgbFgColor = port->port->rgbFgColor;
gSavePort.rgbBkColor = port->port->rgbBkColor;
GetClip(gSavePort.clipRgn);
/* Setup our drawing environment */
clipRect.top = window->clipRect.top + port->porty;
clipRect.left = window->clipRect.left + port->portx;
clipRect.bottom = window->clipRect.bottom + port->porty;
clipRect.right = window->clipRect.right + port->portx;
SetOrigin(port->portx,port->porty);
ClipRect(&clipRect);
clipRect.top = clipRect.left = 0;
TextSize(12);
TextFont(geneva);
TextMode(srcCopy);
col.red = col.green = col.blue = 0;
RGBForeColor(&col);
col.red = col.green = col.blue = 65000;
RGBBackColor(&col);
return TRUE;
}
else
return FALSE;
}
void
x_redraw_status_lines()
{
// OG Disable status line
#ifndef ACTIVEGS
Rect rect;
Pattern white_pattern;
char tmp_buf[256];
char *buf;
int len;
int line;
int height;
int margin;
SetPortWindowPort(g_main_window);
PenNormal();
height = 16;
margin = 0;
TextFont(g_status_font_family);
TextFace(normal);
TextSize(12);
SetRect(&rect, 0, X_A2_WINDOW_HEIGHT + margin, X_A2_WINDOW_WIDTH,
X_A2_WINDOW_HEIGHT + margin + MAX_STATUS_LINES*height);
GetQDGlobalsWhite(&white_pattern);
FillRect(&rect, &white_pattern);
for(line = 0; line < MAX_STATUS_LINES; line++) {
buf = g_status_ptrs[line];
if(buf == 0) {
/* skip it */
continue;
}
MoveTo(10, X_A2_WINDOW_HEIGHT + height*line + margin + height);
len = MIN(250, strlen(buf));
strncpy(&tmp_buf[1], buf, len);
tmp_buf[0] = len;
DrawString((const unsigned char*)&tmp_buf[0]);
}
#endif
}
static void mac_createeventlog(Session *s)
{
Rect view;
ListBounds bounds = { 0, 0, 0, 1 }; /* 1 column, 0 rows */
Point csize = { 0, 0 };
GrafPtr saveport;
long fondsize;
WinInfo *wi;
s->eventlog_window = GetNewWindow(wEventLog, NULL, (WindowPtr)-1);
wi = snew(WinInfo);
memset(wi, 0, sizeof(*wi));
wi->s = s;
wi->wtype = wEventLog;
wi->click = &mac_clickeventlog;
wi->activate = &mac_activateeventlog;
wi->grow = &mac_groweventlog;
wi->update = &mac_updateeventlog;
wi->close = &mac_closeeventlog;
SetWRefCon(s->eventlog_window, (long)wi);
GetPort(&saveport);
SetPort((GrafPtr)GetWindowPort(s->eventlog_window));
fondsize = GetScriptVariable(smRoman, smScriptSmallFondSize);
TextFont(HiWord(fondsize));
TextSize(LoWord(fondsize));
SetPort(saveport);
#if TARGET_API_MAC_CARBON
GetPortBounds(GetWindowPort(s->eventlog_window), &view);
#else
view = s->eventlog_window->portRect;
#endif
view.right -= 15; /* Scrollbar */
s->eventlog = LNew(&view, &bounds, csize, 0, s->eventlog_window,
TRUE, TRUE, FALSE, TRUE);
mac_adjusteventlogscrollbar(s);
#if TARGET_API_MAC_CARBON
SetListSelectionFlags(s->eventlog, lExtendDrag | lNoDisjoint | lNoExtend);
#else
(*s->eventlog)->selFlags = lExtendDrag | lNoDisjoint | lNoExtend;
#endif
}
void createWindow()
{
Rect rect;
BitMap bitMap;
int top, left;
GetQDGlobalsScreenBits(&bitMap);
top = (((bitMap.bounds.bottom - bitMap.bounds.top) - WHEIGHT) / 2);
left = (((bitMap.bounds.right - bitMap.bounds.left) - WWIDTH) / 2);
//SetRect( &rect, WLEFT, WTOP, WLEFT + WWIDTH, WTOP + WHEIGHT );
SetRect( &rect, left, top, left + WWIDTH, top + WHEIGHT );
gWindow = NewCWindow( 0L, &rect, "\pMyDeviceLoop", true, documentProc,
(WindowPtr)-1L, true, 0L );
//SetPort( gWindow );
SetPortWindowPort( gWindow );
TextFont( kFontIDTimes );
TextSize( 48 );
TextMode( srcCopy );
}
void createWindow()
{
Rect rect;
BitMap bitMap;
Rect tempRect1;
int top, left;
GetQDGlobalsScreenBits(&bitMap);
tempRect1 = bitMap.bounds;
left = (((tempRect1.right - tempRect1.left) - WWIDTH) / 2);
top = (((tempRect1.bottom - tempRect1.top) - WHEIGHT) / 2);
//SetRect( &rect, WLEFT, WTOP, WLEFT + WWIDTH, WTOP + WHEIGHT );
SetRect( &rect, left, top, left + WWIDTH, top + WHEIGHT );
gWindow = NewCWindow( 0L, &rect, "\pDirect Pixel Access", true, documentProc,
(WindowPtr)-1L, true, 0L );
//SetPort( gWindow );
SetPortWindowPort( gWindow );
TextFont( kFontIDGeneva );
TextSize( 9 );
TextMode( srcXor );
}
void VectDraw(DialogPtr d, Rect *rectPtr, long itemNumber)
{
#pragma unused (rectPtr)
Point p;
short h,v;
RGBColor rgb;
Rect rgbrect;
char numstr[30],numstr2[30];
double x = (*gEditContourLevels)[itemNumber];
float colorLevel;
long numLevels = GetNumDoubleHdlItems(gEditContourLevels);
SetRGBColor(&rgb,0,0,0);
TextFont(kFontIDGeneva); TextSize(LISTTEXTSIZE);
rgbrect=GetDialogItemBox(d,CONT_LISTID);
h=(rgbrect.left);
GetPen(&p);
v=p.v;
MySetRect(&rgbrect,h+4,v-9,h+14,v+1);
// set unique color for each value, not on linear scale
colorLevel = float(itemNumber)/float(numLevels-1);
//rgb = GetRGBColor(colorLevel);
#ifdef IBM
rgb = GetRGBColor(colorLevel);
#else
rgb = GetRGBColor(1.-colorLevel);
#endif
//rgb = GetRGBColor(0.8-colorLevel);
RGBForeColor(&rgb);
PaintRect(&rgbrect);
MyFrameRect(&rgbrect);
MyMoveTo(h+30,v+1);
RGBForeColor(&colors[BLACK]);
if (itemNumber<numLevels-1)
{
MyNumToStr(x,numstr);
MyNumToStr((*gEditContourLevels)[itemNumber+1],numstr2);
strcat(numstr," - ");
strcat(numstr,numstr2);
}
else
{
strcpy(numstr,"> ");
MyNumToStr(x,numstr2);
strcat(numstr,numstr2);
}
if (gContourType==0)
{
strcat(numstr," mg/L");
}
else
{
MyNumToStr(x,numstr);
strcat(numstr," m");
}
//drawstring(MyNumToStr(x,numstr));
drawstring(numstr);
return;
}
/* ------------ Local code */
static void add_overhead_thumbnail(
FileSpecifier &File)
{
PicHandle picture;
PicHandle preview;
RgnHandle clip_region;
FontInfo info;
short text_x, text_y;
short text_length;
Str255 temporary;
GWorldPtr old_gworld;
GDHandle old_device;
struct overhead_map_data overhead_data;
Rect bounds;
AEDesc aeFileSpec;
FSSpec *SpecPtr;
// Skip all this if there's no nav services to install the preview
if(!machine_has_nav_services() || NavLibraryVersion() < kNavServicesVersion_2_0)
return;
GetGWorld(&old_gworld, &old_device);
SetGWorld(world_pixels, (GDHandle) NULL);
// Note well. We're using world_pixels to create our thumbnail pict within.
// If world_pixels is runing as a postage stamp (low-res + small display space)
// Then it is actually smaller than the size we're looking to build a thumbnail
// within. But seeing as we're generating pict images and using drawing commands
// instead of bit-wise operations. It all works out.
/* Create the bounding rectangle */
SetRect(&bounds, 0, 0, THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT);
/* Start recording.. */
picture= OpenPicture(&bounds);
PaintRect(&bounds);
overhead_data.scale= OVERHEAD_MAP_MINIMUM_SCALE;
overhead_data.origin.x= local_player->location.x;
overhead_data.origin.y= local_player->location.y;
overhead_data.half_width= RECTANGLE_WIDTH(&bounds)/2;
overhead_data.half_height= RECTANGLE_HEIGHT(&bounds)/2;
overhead_data.width= RECTANGLE_WIDTH(&bounds);
overhead_data.height= RECTANGLE_HEIGHT(&bounds);
overhead_data.mode= _rendering_saved_game_preview;
_render_overhead_map(&overhead_data);
RGBForeColor(&rgb_black);
PenSize(1, 1);
TextFont(0);
TextFace(normal);
TextSize(0);
ClosePicture();
// JTP: Add Nav Services style preview
SetRect(&bounds, 0, 0, PREVIEW_WIDTH, PREVIEW_HEIGHT);
preview= OpenPicture(&bounds);
SetRect(&bounds, PREVIEW_IMAGE_X, PREVIEW_IMAGE_Y,
THUMBNAIL_WIDTH + PREVIEW_IMAGE_X, THUMBNAIL_HEIGHT + PREVIEW_IMAGE_Y);
clip_region= NewRgn();
GetClip(clip_region);
ClipRect(&bounds);
DrawPicture(picture, &bounds);
SetClip(clip_region);
/* Center the text in the rectangle */
// LP: Classic doesn't have this function
#ifdef TARGET_API_MAC_CARBON
CopyCStringToPascal(static_world->level_name, temporary);
#else
strncpy((char *)temporary,static_world->level_name,LEVEL_NAME_LENGTH);
c2pstr((char *)temporary);
#endif
// LP: fix to allow lengths more than 127 bytes (not really necessary, but...)
text_length = *ptemporary;
TruncText(PREVIEW_WIDTH, (char *)temporary+1, &text_length, smTruncEnd);
*ptemporary = text_length;
GetFontInfo(&info);
text_y= PREVIEW_HEIGHT - info.descent;
text_x= PREVIEW_LABEL_X + (PREVIEW_WIDTH-StringWidth(temporary))/2;
MoveTo(text_x, text_y);
DrawString(temporary);
ClosePicture();
// This requires NavServices 2.0, what's the inline check?
// From FSS get a AEDesc
OSStatus err;
SpecPtr = &File.GetSpec();
err = AECreateDesc(typeFSS, SpecPtr, sizeof(FSSpec), &aeFileSpec);
HLock((Handle)preview);
err = NavCreatePreview(&aeFileSpec, 'PICT', *preview, GetHandleSize((Handle)preview));
HUnlock((Handle)preview);
AEDisposeDesc(&aeFileSpec);
KillPicture(preview);
KillPicture(picture);
DisposeRgn(clip_region);
SetGWorld(old_gworld, old_device);
}
// --------------------------------------------------------------------------------------
static void drawIconListCell(ListHandle theList, const Rect *cellRect,
IconListCellDataRec *theCellData, Boolean selected)
{
GrafPtr savedPort;
CGrafPtr listPort;
ThemeDrawingState savedState;
Boolean active;
Rect iconRect, textRect;
short savedFont, savedSize;
Style savedFace;
CFStringRef cellName;
GetPort(&savedPort);
listPort = GetListPort(theList);
SetPort((GrafPtr)listPort);
GetThemeDrawingState(&savedState);
if (selected) // we don't need to change the background
{ // color if this Cell isn't highlighted
Pattern whitePattern;
RGBColor highlightColor;
GetQDGlobalsWhite(&whitePattern); // set the background pattern so that
BackPat(&whitePattern); // the color is properly set as a solid color
LMGetHiliteRGB(&highlightColor);
RGBBackColor(&highlightColor); // set the background to the highlight color
}
EraseRect(cellRect);
calculateDrawingBounds(cellRect, &iconRect, &textRect); // get the drawing Rects
active = GetListActive(theList);
// draw the IconRef using Icon Services
PlotIconRef(&iconRect, kAlignNone, active ? kTransformNone : kTransformDisabled,
kIconServicesNormalUsageFlag, theCellData->icon);
#if TARGET_API_MAC_OS8 // draw TextEdit text in Classic
#pragma unused (cellName)
savedFont = GetPortTextFont(listPort); // Get/SetThemeDrawingState doesn't save or
savedFace = GetPortTextFace(listPort); // restore these
savedSize = GetPortTextSize(listPort);
UseThemeFont(kThemeViewsFont, smCurrentScript);
TETextBox(&theCellData->name[1], theCellData->name[0], &textRect, teCenter);
TextFont(savedFont);
TextFace(savedFace);
TextSize(savedSize);
#else // draw Appearance text in Carbon
#pragma unused (savedFont, savedSize, savedFace)
cellName = CFStringCreateWithPascalString(kCFAllocatorDefault, theCellData->name,
GetApplicationTextEncoding());
DrawThemeTextBox(cellName, kThemeViewsFont,
active ? kThemeStateActive : kThemeStateInactive, true,
&textRect, teCenter, NULL);
CFRelease(cellName);
#endif
SetThemeDrawingState(savedState, true);
SetPort(savedPort);
} // drawIconListCell
void
ShowAdditionsWin(void)
{
Str255 next, back;
Str255 compDescTitle;
StringPtr selCompMsg;
Handle listBoxRect;
Rect dataBounds, listBoxFrame, viewRect;
short reserr;
int totalRows = 0, i, instChoice;
Point cSize;
Boolean bCellSelected;
GrafPtr oldPort;
GetPort(&oldPort);
SetPort(gWPtr);
gCurrWin = kAdditionsID;
/* gControls->aw = (CompWin *) NewPtrClear(sizeof(CompWin)); */
GetResourcedString(next, rInstList, sNextBtn);
GetResourcedString(back, rInstList, sBackBtn);
// get controls
listBoxRect = Get1Resource('RECT', rCompListBox);
reserr = ResError();
if (reserr == noErr && listBoxRect != NULL)
{
HLock((Handle)listBoxRect);
SetRect(&gControls->aw->compListBox, ((Rect*)*listBoxRect)->left,
((Rect*)*listBoxRect)->top,
((Rect*)*listBoxRect)->right,
((Rect*)*listBoxRect)->bottom);
HUnlock((Handle)listBoxRect);
}
else
{
ErrorHandler(reserr, nil);
return;
}
gControls->aw->compDescBox = NULL;
gControls->aw->compDescBox = GetNewControl(rCompDescBox, gWPtr);
if (!gControls->aw->compDescBox)
{
ErrorHandler(eMem, nil);
return;
}
gControls->aw->compListBox.right -= kScrollBarWidth;
instChoice = gControls->opt->instChoice-1;
for (i=0; i<kMaxComponents; i++)
{
if (totalRows >= gControls->cfg->numComps)
break;
if (!gControls->cfg->comp[i].invisible && gControls->cfg->comp[i].additional &&
(gControls->cfg->st[instChoice].comp[i] == kInSetupType))
totalRows++;
}
SetRect(&dataBounds, 0, 0, 1, totalRows);
SetPt( &cSize, 0, 0);
gControls->aw->compList = LNew((const Rect*)&gControls->aw->compListBox, (const Rect*)&dataBounds,
cSize, rCheckboxLDEF, gWPtr, true, false, false, true);
(*gControls->aw->compList)->selFlags = lExtendDrag + lUseSense + lDoVAutoscroll;
HLock((Handle)gControls->aw->compDescBox);
SetRect(&viewRect, (*gControls->aw->compDescBox)->contrlRect.left,
(*gControls->aw->compDescBox)->contrlRect.top,
(*gControls->aw->compDescBox)->contrlRect.right,
(*gControls->aw->compDescBox)->contrlRect.bottom);
HUnlock((Handle)gControls->aw->compDescBox);
viewRect.top += kInterWidgetPad;
SetRect(&viewRect, viewRect.left + kTxtRectPad,
viewRect.top + kTxtRectPad,
viewRect.right - kTxtRectPad,
viewRect.bottom - kTxtRectPad);
TextFont(applFont);
TextSize(9);
gControls->aw->compDescTxt = TENew(&viewRect, &viewRect);
TextFont(systemFont);
TextSize(12);
// populate controls
bCellSelected = AddPopulateCompInfo();
// show controls
GetResourcedString(compDescTitle, rInstList, sCompDescTitle);
SetControlTitle(gControls->aw->compDescBox, compDescTitle);
MoveTo( gControls->aw->compListBox.left, gControls->aw->compListBox.top - kInterWidgetPad);
HLock(gControls->cfg->selCompMsg);
selCompMsg = CToPascal(*gControls->cfg->selAddMsg);
if (selCompMsg)
DrawString( selCompMsg );
HUnlock(gControls->cfg->selCompMsg);
SetRect(&listBoxFrame, gControls->aw->compListBox.left,
--gControls->aw->compListBox.top,
gControls->aw->compListBox.right + kScrollBarWidth,
++gControls->aw->compListBox.bottom);
FrameRect(&listBoxFrame);
ShowNavButtons( back, next );
if (bCellSelected)
AddSetOptInfo(true);
else
DrawDiskSpaceMsgs( gControls->opt->vRefNum );
// default highlight first row
AddInitRowHighlight(0);
#if 0
RGBColor backColorOld;
Rect adjustedRect, *clRect = &gControls->aw->compListBox;
SetRect(&adjustedRect, clRect->left, clRect->top+1, clRect->right, clRect->bottom-1);
GetBackColor(&backColorOld);
BackColor(whiteColor);
EraseRect(&adjustedRect);
RGBBackColor(&backColorOld);
#endif
SetPort(oldPort);
}