-/* $Id: macterm.c,v 1.48 2003/01/14 18:44:34 ben Exp $ */
+/* $Id: macterm.c,v 1.76 2004/06/20 17:07:37 jacob Exp $ */
/*
* Copyright (c) 1999 Simon Tatham
* Copyright (c) 1999, 2002 Ben Harris
#include <MacTypes.h>
#include <Controls.h>
#include <ControlDefinitions.h>
+#include <FixMath.h>
#include <Fonts.h>
#include <Gestalt.h>
#include <LowMem.h>
#include <Scrap.h>
#include <Script.h>
#include <Sound.h>
-#include <StandardFile.h>
#include <TextCommon.h>
-#include <Threads.h>
#include <ToolUtils.h>
#include <UnicodeConverter.h>
#include "putty.h"
#include "charset.h"
#include "mac.h"
-#include "storage.h"
#include "terminal.h"
#define NCOLOURS (lenof(((Config *)0)->colours))
static void mac_initfont(Session *);
static pascal OSStatus uni_to_font_fallback(UniChar *, ByteCount, ByteCount *,
TextPtr, ByteCount, ByteCount *,
- LogicalAddress *,
+ LogicalAddress,
ConstUnicodeMappingPtr);
static void mac_initpalette(Session *);
static void mac_adjustwinbg(Session *);
static pascal void mac_growtermdraghook(void);
static pascal void mac_scrolltracker(ControlHandle, short);
static pascal void do_text_for_device(short, short, GDHandle, long);
-static int mac_keytrans(Session *, EventRecord *, unsigned char *);
static void text_click(Session *, EventRecord *);
+static void mac_activateterm(WindowPtr, EventRecord *);
+static void mac_adjusttermcursor(WindowPtr, Point, RgnHandle);
+static void mac_adjusttermmenus(WindowPtr);
+static void mac_updateterm(WindowPtr);
+static void mac_clickterm(WindowPtr, EventRecord *);
+static void mac_growterm(WindowPtr, EventRecord *);
+static void mac_keyterm(WindowPtr, EventRecord *);
+static void mac_menuterm(WindowPtr, short, short);
+static void mac_closeterm(WindowPtr);
void pre_paint(Session *s);
void post_paint(Session *s);
-#if TARGET_RT_MAC_CFM
-static RoutineDescriptor mac_scrolltracker_upp =
- BUILD_ROUTINE_DESCRIPTOR(uppControlActionProcInfo,
- (ProcPtr)mac_scrolltracker);
-static RoutineDescriptor do_text_for_device_upp =
- BUILD_ROUTINE_DESCRIPTOR(uppDeviceLoopDrawingProcInfo,
- (ProcPtr)do_text_for_device);
-#else /* not TARGET_RT_MAC_CFM */
-#define mac_scrolltracker_upp mac_scrolltracker
-#define do_text_for_device_upp do_text_for_device
-#endif /* not TARGET_RT_MAC_CFM */
-
-void mac_opensession(void) {
- Session *s;
- StandardFileReply sfr;
- static const OSType sftypes[] = { 'Sess', 0, 0, 0 };
- void *sesshandle;
+void mac_startsession(Session *s)
+{
+ const char *errmsg;
int i;
+ WinInfo *wi;
- s = smalloc(sizeof(*s));
- memset(s, 0, sizeof(*s));
-
- StandardGetFile(NULL, 1, sftypes, &sfr);
- if (!sfr.sfGood) goto fail;
-
- sesshandle = open_settings_r_fsp(&sfr.sfFile);
- if (sesshandle == NULL) goto fail;
- load_open_settings(sesshandle, TRUE, &s->cfg);
- close_settings_r(sesshandle);
+ init_ucs(s);
/*
* Select protocol. This is farmed out into a table in a
s->back = backends[i].backend;
break;
}
- if (s->back == NULL) {
+ if (s->back == NULL)
fatalbox("Unsupported protocol number found");
- }
- mac_startsession(s);
- return;
-
- fail:
- sfree(s);
- return;
-}
-
-void mac_startsession(Session *s)
-{
- char *errmsg;
/* XXX: Own storage management? */
if (HAVE_COLOR_QD())
s->window = GetNewCWindow(wTerminal, NULL, (WindowPtr)-1);
else
s->window = GetNewWindow(wTerminal, NULL, (WindowPtr)-1);
- SetWRefCon(s->window, (long)s);
+ wi = snew(WinInfo);
+ memset(wi, 0, sizeof(*wi));
+ wi->s = s;
+ wi->wtype = wTerminal;
+ wi->activate = &mac_activateterm;
+ wi->adjustcursor = &mac_adjusttermcursor;
+ wi->adjustmenus = &mac_adjusttermmenus;
+ wi->update = &mac_updateterm;
+ wi->click = &mac_clickterm;
+ wi->grow = &mac_growterm;
+ wi->key = &mac_keyterm;
+ wi->menu = &mac_menuterm;
+ wi->close = &mac_closeterm;
+ SetWRefCon(s->window, (long)wi);
s->scrollbar = GetNewControl(cVScroll, s->window);
- s->term = term_init(&s->cfg, s);
+ s->term = term_init(&s->cfg, &s->ucsdata, s);
mac_initfont(s);
mac_initpalette(s);
ActivatePalette(s->window);
}
- s->logctx = log_init(s, &s->cfg);
+ s->logctx = log_init(s->term, &s->cfg);
term_provide_logctx(s->term, s->logctx);
- errmsg = s->back->init(s->term, &s->backhandle, &s->cfg, s->cfg.host,
- s->cfg.port, &s->realhost, s->cfg.tcp_nodelay);
+ errmsg = s->back->init(s, &s->backhandle, &s->cfg, s->cfg.host,
+ s->cfg.port, &s->realhost, s->cfg.tcp_nodelay,
+ s->cfg.tcp_keepalives);
if (errmsg != NULL)
fatalbox("%s", errmsg);
s->back->provide_logctx(s->backhandle, s->logctx);
ShowWindow(s->window);
s->next = sesslist;
- s->prev = s->next->prev;
+ s->prev = &sesslist;
if (s->next != NULL)
s->next->prev = &s->next;
sesslist = s;
int gotwidth, i;
const char text = 'W';
FontInfo fi;
+#if TARGET_API_MAC_CARBON
+ CQDProcsPtr gp = GetPortGrafProcs(GetWindowPort(s->window));
+#else
+ QDProcsPtr gp = s->window->grafProcs;
+#endif
numer.v = denom.v = 1; /* always */
numer.h = denom.h = 1;
for (i = 0; i < 3; i++) {
tmpnumer = numer;
tmpdenom = denom;
- if (s->window->grafProcs != NULL)
+ if (gp != NULL)
gotwidth = InvokeQDTxMeasUPP(1, &text, &tmpnumer, &tmpdenom, &fi,
- s->window->grafProcs->txMeasProc);
+ gp->txMeasProc);
else
gotwidth = StdTxMeas(1, &text, &tmpnumer, &tmpdenom, &fi);
/* The result of StdTxMeas must be scaled by the factors it returns. */
static UnicodeToTextFallbackUPP uni_to_font_fallback_upp;
-static void mac_initfont(Session *s) {
- Str255 macfont;
+static void mac_initfont(Session *s)
+{
FontInfo fi;
TextEncoding enc;
OptionBits fbflags;
- SetPort(s->window);
- c2pstrcpy(macfont, s->cfg.font);
- GetFNum(macfont, &s->fontnum);
+ SetPort((GrafPtr)GetWindowPort(s->window));
+ GetFNum(s->cfg.font.name, &s->fontnum);
TextFont(s->fontnum);
- TextFace(s->cfg.fontisbold ? bold : 0);
- TextSize(s->cfg.fontheight);
+ TextFace(s->cfg.font.face);
+ TextSize(s->cfg.font.size);
GetFontInfo(&fi);
s->font_width = CharWidth('W'); /* Well, it's what NCSA uses. */
s->font_ascent = fi.ascent;
&s->font_stdnumer, &s->font_stddenom);
mac_workoutfontscale(s, s->font_width * 2,
&s->font_widenumer, &s->font_widedenom);
- TextSize(s->cfg.fontheight * 2);
+ TextSize(s->cfg.font.size * 2);
mac_workoutfontscale(s, s->font_width * 2,
&s->font_bignumer, &s->font_bigdenom);
- TextSize(s->cfg.fontheight);
+ TextSize(s->cfg.font.size);
if (!s->cfg.bold_colour) {
TextFace(bold);
s->font_boldadjust = s->font_width - CharWidth('W');
if (mac_gestalts.encvvers != 0 &&
UpgradeScriptInfoToTextEncoding(kTextScriptDontCare,
kTextLanguageDontCare,
- kTextRegionDontCare, macfont,
+ kTextRegionDontCare, s->cfg.font.name,
&enc) == noErr &&
CreateUnicodeToTextInfoByEncoding(enc, &s->uni_to_font) == noErr) {
if (uni_to_font_fallback_upp == NULL)
uni_to_font_fallback_upp =
- NewUnicodeToTextFallbackProc(&uni_to_font_fallback);
+ NewUnicodeToTextFallbackUPP(&uni_to_font_fallback);
fbflags = kUnicodeFallbackCustomOnly;
if (mac_gestalts.uncvattr & kTECAddFallbackInterruptMask)
fbflags |= kUnicodeFallbackInterruptSafeMask;
goto no_encv;
}
} else {
+ char cfontname[256];
+
no_encv:
s->uni_to_font = NULL;
+ p2cstrcpy(cfontname, s->cfg.font.name);
s->font_charset =
charset_from_macenc(FontToScript(s->fontnum),
GetScriptManagerVariable(smRegionCode),
- mac_gestalts.sysvers, s->cfg.font);
+ mac_gestalts.sysvers, cfontname);
}
mac_adjustsize(s, s->term->rows, s->term->cols);
static pascal OSStatus uni_to_font_fallback(UniChar *ucp,
ByteCount ilen, ByteCount *iusedp, TextPtr obuf, ByteCount olen,
- ByteCount *ousedp, LogicalAddress *cookie, ConstUnicodeMappingPtr mapping)
+ ByteCount *ousedp, LogicalAddress cookie, ConstUnicodeMappingPtr mapping)
{
if (olen < 1)
mac_drawgrowicon(s);
}
-static void mac_initpalette(Session *s) {
+static void mac_initpalette(Session *s)
+{
if (!HAVE_COLOR_QD())
return;
* Set the background colour of the window correctly. Should be
* called whenever the default background changes.
*/
-static void mac_adjustwinbg(Session *s) {
+static void mac_adjustwinbg(Session *s)
+{
if (!HAVE_COLOR_QD())
return;
else
#endif
{
+#if !TARGET_API_MAC_CARBON
if (s->wctab == NULL)
s->wctab = (WCTabHandle)NewHandle(sizeof(**s->wctab));
if (s->wctab == NULL)
(*s->wctab)->ctTable[0].value = wContentColor;
(*s->wctab)->ctTable[0].rgb = (*s->palette)->pmInfo[DEFAULT_BG].ciRGB;
SetWinColor(s->window, s->wctab);
+#endif
}
}
/*
* Set the cursor shape correctly
*/
-void mac_adjusttermcursor(WindowPtr window, Point mouse, RgnHandle cursrgn) {
+static void mac_adjusttermcursor(WindowPtr window, Point mouse,
+ RgnHandle cursrgn)
+{
Session *s;
ControlHandle control;
short part;
int x, y;
+#if TARGET_API_MAC_CARBON
+ Cursor arrow;
+ Rect rect;
+ RgnHandle visrgn;
+#endif
- SetPort(window);
- s = (Session *)GetWRefCon(window);
+ SetPort((GrafPtr)GetWindowPort(window));
+ s = mac_windowsession(window);
GlobalToLocal(&mouse);
part = FindControl(mouse, window, &control);
if (control == s->scrollbar) {
+#if TARGET_API_MAC_CARBON
+ SetCursor(GetQDGlobalsArrow(&arrow));
+ RectRgn(cursrgn, GetControlBounds(s->scrollbar, &rect));
+#else
SetCursor(&qd.arrow);
RectRgn(cursrgn, &(*s->scrollbar)->contrlRect);
- SectRgn(cursrgn, window->visRgn, cursrgn);
+#endif
} else {
x = mouse.h / s->font_width;
y = mouse.v / s->font_height;
- if (s->raw_mouse)
+ if (s->raw_mouse) {
+#if TARGET_API_MAC_CARBON
+ SetCursor(GetQDGlobalsArrow(&arrow));
+#else
SetCursor(&qd.arrow);
- else
+#endif
+ } else
SetCursor(*GetCursor(iBeamCursor));
/* Ask for shape changes if we leave this character cell. */
SetRectRgn(cursrgn, x * s->font_width, y * s->font_height,
(x + 1) * s->font_width, (y + 1) * s->font_height);
- SectRgn(cursrgn, window->visRgn, cursrgn);
}
+#if TARGET_API_MAC_CARBON
+ visrgn = NewRgn();
+ GetPortVisibleRegion(GetWindowPort(window), visrgn);
+ SectRgn(cursrgn, visrgn, cursrgn);
+ DisposeRgn(visrgn);
+#else
+ SectRgn(cursrgn, window->visRgn, cursrgn);
+#endif
}
/*
* Enable/disable menu items based on the active terminal window.
*/
-void mac_adjusttermmenus(WindowPtr window) {
+#if TARGET_API_MAC_CARBON
+#define DisableItem DisableMenuItem
+#define EnableItem EnableMenuItem
+#endif
+static void mac_adjusttermmenus(WindowPtr window)
+{
Session *s;
MenuHandle menu;
+#if !TARGET_API_MAC_CARBON
long offset;
+#endif
- s = (Session *)GetWRefCon(window);
+ s = mac_windowsession(window);
+ menu = GetMenuHandle(mFile);
+ DisableItem(menu, iSave); /* XXX enable if modified */
+ EnableItem(menu, iSaveAs);
+ EnableItem(menu, iDuplicate);
menu = GetMenuHandle(mEdit);
EnableItem(menu, 0);
DisableItem(menu, iUndo);
EnableItem(menu, iCopy);
else
DisableItem(menu, iCopy);
- if (GetScrap(NULL, 'TEXT', &offset) == noTypeErr)
+#if TARGET_API_MAC_CARBON
+ if (1)
+#else
+ if (GetScrap(NULL, kScrapFlavorTypeText, &offset) == noTypeErr)
+#endif
DisableItem(menu, iPaste);
else
EnableItem(menu, iPaste);
DisableItem(menu, iClear);
EnableItem(menu, iSelectAll);
+ menu = GetMenuHandle(mWindow);
+ EnableItem(menu, 0);
+ EnableItem(menu, iShowEventLog);
}
-void mac_menuterm(WindowPtr window, short menu, short item) {
+static void mac_menuterm(WindowPtr window, short menu, short item)
+{
Session *s;
- s = (Session *)GetWRefCon(window);
+ s = mac_windowsession(window);
switch (menu) {
case mEdit:
switch (item) {
term_do_paste(s->term);
break;
}
+ break;
+ case mWindow:
+ switch(item) {
+ case iShowEventLog:
+ mac_showeventlog(s);
+ break;
+ }
+ break;
}
}
-void mac_clickterm(WindowPtr window, EventRecord *event) {
+static void mac_clickterm(WindowPtr window, EventRecord *event)
+{
Session *s;
Point mouse;
ControlHandle control;
int part;
+ static ControlActionUPP mac_scrolltracker_upp = NULL;
- s = (Session *)GetWRefCon(window);
- SetPort(window);
+ s = mac_windowsession(window);
+ SetPort((GrafPtr)GetWindowPort(window));
mouse = event->where;
GlobalToLocal(&mouse);
part = FindControl(mouse, window, &control);
case kControlDownButtonPart:
case kControlPageUpPart:
case kControlPageDownPart:
- TrackControl(control, mouse, &mac_scrolltracker_upp);
+ if (mac_scrolltracker_upp == NULL)
+ mac_scrolltracker_upp =
+ NewControlActionUPP(&mac_scrolltracker);
+ TrackControl(control, mouse, mac_scrolltracker_upp);
break;
}
} else {
}
}
-static void text_click(Session *s, EventRecord *event) {
+static void text_click(Session *s, EventRecord *event)
+{
Point localwhere;
int row, col;
static UInt32 lastwhen = 0;
static int lastrow = -1, lastcol = -1;
static Mouse_Action lastact = MA_NOTHING;
- SetPort(s->window);
+ SetPort((GrafPtr)GetWindowPort(s->window));
localwhere = event->where;
GlobalToLocal(&localwhere);
lastact == MA_3CLK ? MA_CLICK : MA_NOTHING);
else
lastact = MA_CLICK;
- /* Fake right button with shift key */
- term_mouse(s->term, event->modifiers & shiftKey ? MBT_RIGHT : MBT_LEFT,
+ term_mouse(s->term, MBT_LEFT,
+ event->modifiers & shiftKey ? MBT_EXTEND : MBT_SELECT,
lastact, col, row, event->modifiers & shiftKey,
event->modifiers & controlKey, event->modifiers & optionKey);
lastsess = s;
GetMouse(&localwhere);
col = PTOCC(localwhere.h);
row = PTOCR(localwhere.v);
- term_mouse(s->term,
- event->modifiers & shiftKey ? MBT_RIGHT : MBT_LEFT,
+ term_mouse(s->term, MBT_LEFT,
+ event->modifiers & shiftKey ? MBT_EXTEND : MBT_SELECT,
MA_DRAG, col, row, event->modifiers & shiftKey,
event->modifiers & controlKey,
event->modifiers & optionKey);
else if (row < 0)
term_scroll(s->term, 0, row);
}
- term_mouse(s->term, event->modifiers & shiftKey ? MBT_RIGHT : MBT_LEFT,
+ term_mouse(s->term, MBT_LEFT,
+ event->modifiers & shiftKey ? MBT_EXTEND : MBT_SELECT,
MA_RELEASE, col, row, event->modifiers & shiftKey,
event->modifiers & controlKey, event->modifiers & optionKey);
lastwhen = TickCount();
}
-Mouse_Button translate_button(void *frontend, Mouse_Button button)
+void write_clip(void *cookie, wchar_t *data, int len, int must_deselect)
{
+#if !TARGET_API_MAC_CARBON
+ Session *s = cookie;
+ char *mactextbuf;
+ ByteCount iread, olen;
+ wchar_t *unitextptr;
+ StScrpRec *stsc;
+ size_t stsz;
+ OSErr err;
+ int i;
- switch (button) {
- case MBT_LEFT:
- return MBT_SELECT;
- case MBT_RIGHT:
- return MBT_EXTEND;
- default:
- return 0;
- }
-}
-
-void write_clip(void *cookie, wchar_t *data, int len, int must_deselect) {
-
/*
* See "Programming with the Text Encoding Conversion Manager"
* Appendix E for Unicode scrap conventions.
*
- * XXX Need to support TEXT/styl scrap as well.
- * See STScrpRec in TextEdit (Inside Macintosh: Text) for styl details.
* XXX Maybe PICT scrap too.
*/
if (ZeroScrap() != noErr)
return;
- PutScrap(len * sizeof(*data), 'utxt', data);
+ PutScrap(len * sizeof(*data), kScrapFlavorTypeUnicode, data);
+
+ /* Replace LINE SEPARATORs with CR for TEXT output. */
+ for (i = 0; i < len; i++)
+ if (data[i] == 0x2028)
+ data[i] = 0x000d;
+
+ mactextbuf = snewn(len, char); /* XXX DBCS */
+ if (s->uni_to_font != NULL) {
+ err = ConvertFromUnicodeToText(s->uni_to_font, len * sizeof(UniChar),
+ (UniChar *)data,
+ kUnicodeUseFallbacksMask,
+ 0, NULL, NULL, NULL,
+ len, &iread, &olen, mactextbuf);
+ if (err != noErr && err != kTECUsedFallbacksStatus)
+ return;
+ } else if (s->font_charset != CS_NONE) {
+ unitextptr = data;
+ olen = charset_from_unicode(&unitextptr, &len, mactextbuf, 1024,
+ s->font_charset, NULL, ".", 1);
+ } else
+ return;
+ PutScrap(olen, kScrapFlavorTypeText, mactextbuf);
+ sfree(mactextbuf);
+
+ stsz = offsetof(StScrpRec, scrpStyleTab) + sizeof(ScrpSTElement);
+ stsc = smalloc(stsz);
+ stsc->scrpNStyles = 1;
+ stsc->scrpStyleTab[0].scrpStartChar = 0;
+ stsc->scrpStyleTab[0].scrpHeight = s->font_height;
+ stsc->scrpStyleTab[0].scrpAscent = s->font_ascent;
+ stsc->scrpStyleTab[0].scrpFont = s->fontnum;
+ stsc->scrpStyleTab[0].scrpFace = 0;
+ stsc->scrpStyleTab[0].scrpSize = s->cfg.font.size;
+ stsc->scrpStyleTab[0].scrpColor.red = 0;
+ stsc->scrpStyleTab[0].scrpColor.green = 0;
+ stsc->scrpStyleTab[0].scrpColor.blue = 0;
+ PutScrap(stsz, kScrapFlavorTypeTextStyle, stsc);
+ sfree(stsc);
+#endif
}
-void get_clip(void *frontend, wchar_t **p, int *lenp) {
+void get_clip(void *frontend, wchar_t **p, int *lenp)
+{
+#if TARGET_API_MAC_CARBON
+ *lenp = 0;
+#else
Session *s = frontend;
static Handle h = NULL;
+ static wchar_t *data = NULL;
+ Handle texth;
long offset;
+ int textlen;
+ TextEncoding enc;
+ TextToUnicodeInfo scrap_to_uni;
+ ByteCount iread, olen;
+ int charset;
+ char *tptr;
+ OSErr err;
if (p == NULL) {
/* release memory */
if (h != NULL)
DisposeHandle(h);
h = NULL;
- } else
- /* XXX Support TEXT-format scrap as well. */
- if (GetScrap(NULL, 'utxt', &offset) > 0) {
- h = NewHandle(0);
- *lenp = GetScrap(h, 'utxt', &offset) / sizeof(**p);
+ if (data != NULL)
+ sfree(data);
+ data = NULL;
+ } else {
+ if (GetScrap(NULL, kScrapFlavorTypeUnicode, &offset) > 0) {
+ if (h == NULL)
+ h = NewHandle(0);
+ *lenp =
+ GetScrap(h, kScrapFlavorTypeUnicode, &offset) / sizeof(**p);
HLock(h);
*p = (wchar_t *)*h;
- if (*p == NULL || *lenp <= 0)
- fatalbox("Empty scrap");
+ } else if (GetScrap(NULL, kScrapFlavorTypeText, &offset) > 0) {
+ texth = NewHandle(0);
+ textlen = GetScrap(texth, kScrapFlavorTypeText, &offset);
+ HLock(texth);
+ data = snewn(textlen, wchar_t);
+ /* XXX should use 'styl' scrap if it's there. */
+ if (mac_gestalts.encvvers != 0 &&
+ UpgradeScriptInfoToTextEncoding(smSystemScript,
+ kTextLanguageDontCare,
+ kTextRegionDontCare, NULL,
+ &enc) == noErr &&
+ CreateTextToUnicodeInfoByEncoding(enc, &scrap_to_uni) ==
+ noErr) {
+ err = ConvertFromTextToUnicode(scrap_to_uni, textlen,
+ *texth, 0, 0, NULL, NULL, NULL,
+ textlen * 2,
+ &iread, &olen, data);
+ DisposeTextToUnicodeInfo(&scrap_to_uni);
+ if (err == noErr) {
+ *p = data;
+ *lenp = olen / sizeof(**p);
+ } else {
+ *p = NULL;
+ *lenp = 0;
+ }
+ } else {
+ charset =
+ charset_from_macenc(GetScriptManagerVariable(smSysScript),
+ GetScriptManagerVariable(smRegionCode),
+ mac_gestalts.sysvers, NULL);
+ if (charset != CS_NONE) {
+ tptr = *texth;
+ *lenp = charset_to_unicode(&tptr, &textlen, data,
+ textlen * 2, charset, NULL,
+ NULL, 0);
+ }
+ *p = data;
+ }
+ DisposeHandle(texth);
} else {
*p = NULL;
*lenp = 0;
}
+ }
+#endif
}
-static pascal void mac_scrolltracker(ControlHandle control, short part) {
+static pascal void mac_scrolltracker(ControlHandle control, short part)
+{
Session *s;
- s = (Session *)GetWRefCon((*control)->contrlOwner);
+#if TARGET_API_MAC_CARBON
+ s = mac_windowsession(GetControlOwner(control));
+#else
+ s = mac_windowsession((*control)->contrlOwner);
+#endif
switch (part) {
case kControlUpButtonPart:
term_scroll(s->term, 0, -1);
}
}
-#define K_BS 0x3300
-#define K_F1 0x7a00
-#define K_F2 0x7800
-#define K_F3 0x6300
-#define K_F4 0x7600
-#define K_F5 0x6000
-#define K_F6 0x6100
-#define K_F7 0x6200
-#define K_F8 0x6400
-#define K_F9 0x6500
-#define K_F10 0x6d00
-#define K_F11 0x6700
-#define K_F12 0x6f00
-#define K_F13 0x6900
-#define K_F14 0x6b00
-#define K_F15 0x7100
-#define K_INSERT 0x7200
-#define K_HOME 0x7300
-#define K_PRIOR 0x7400
-#define K_DELETE 0x7500
-#define K_END 0x7700
-#define K_NEXT 0x7900
-#define K_LEFT 0x7b00
-#define K_RIGHT 0x7c00
-#define K_DOWN 0x7d00
-#define K_UP 0x7e00
-#define KP_0 0x5200
-#define KP_1 0x5300
-#define KP_2 0x5400
-#define KP_3 0x5500
-#define KP_4 0x5600
-#define KP_5 0x5700
-#define KP_6 0x5800
-#define KP_7 0x5900
-#define KP_8 0x5b00
-#define KP_9 0x5c00
-#define KP_CLEAR 0x4700
-#define KP_EQUAL 0x5100
-#define KP_SLASH 0x4b00
-#define KP_STAR 0x4300
-#define KP_PLUS 0x4500
-#define KP_MINUS 0x4e00
-#define KP_DOT 0x4100
-#define KP_ENTER 0x4c00
-
-void mac_keyterm(WindowPtr window, EventRecord *event) {
- unsigned char buf[20];
- int len;
- Session *s;
+static void mac_keyterm(WindowPtr window, EventRecord *event)
+{
+ Session *s = mac_windowsession(window);
+ Key_Sym keysym = PK_NULL;
+ unsigned int mods = 0, flags = PKF_NUMLOCK;
+ UniChar utxt[1];
+ char txt[1];
+ size_t len = 0;
+ ScriptCode key_script;
- s = (Session *)GetWRefCon(window);
- len = mac_keytrans(s, event, buf);
- ldisc_send(s->ldisc, (char *)buf, len, 1);
ObscureCursor();
- term_seen_key_event(s->term);
- term_out(s->term);
- term_update(s->term);
-}
-static int mac_keytrans(Session *s, EventRecord *event,
- unsigned char *output) {
- unsigned char *p = output;
- int code;
+#if 0
+ fprintf(stderr, "Got key event %08x\n", event->message);
+#endif
/* No meta key yet -- that'll be rather fun. */
/* Keys that we handle locally */
if (event->modifiers & shiftKey) {
- switch (event->message & keyCodeMask) {
- case K_PRIOR: /* shift-pageup */
+ switch ((event->message & keyCodeMask) >> 8) {
+ case 0x74: /* shift-pageup */
term_scroll(s->term, 0, -(s->term->rows - 1));
- return 0;
- case K_NEXT: /* shift-pagedown */
+ return;
+ case 0x79: /* shift-pagedown */
term_scroll(s->term, 0, +(s->term->rows - 1));
- return 0;
- }
- }
-
- /*
- * Control-2 should return ^@ (0x00), Control-6 should return
- * ^^ (0x1E), and Control-Minus should return ^_ (0x1F). Since
- * the DOS keyboard handling did it, and we have nothing better
- * to do with the key combo in question, we'll also map
- * Control-Backquote to ^\ (0x1C).
- */
-
- if (event->modifiers & controlKey) {
- switch (event->message & charCodeMask) {
- case ' ': case '2':
- *p++ = 0x00;
- return p - output;
- case '`':
- *p++ = 0x1c;
- return p - output;
- case '6':
- *p++ = 0x1e;
- return p - output;
- case '/':
- *p++ = 0x1f;
- return p - output;
+ return;
}
}
- /*
- * First, all the keys that do tilde codes. (ESC '[' nn '~',
- * for integer decimal nn.)
- *
- * We also deal with the weird ones here. Linux VCs replace F1
- * to F5 by ESC [ [ A to ESC [ [ E. rxvt doesn't do _that_, but
- * does replace Home and End (1~ and 4~) by ESC [ H and ESC O w
- * respectively.
- */
- code = 0;
- switch (event->message & keyCodeMask) {
- case K_F1: code = (event->modifiers & shiftKey ? 23 : 11); break;
- case K_F2: code = (event->modifiers & shiftKey ? 24 : 12); break;
- case K_F3: code = (event->modifiers & shiftKey ? 25 : 13); break;
- case K_F4: code = (event->modifiers & shiftKey ? 26 : 14); break;
- case K_F5: code = (event->modifiers & shiftKey ? 28 : 15); break;
- case K_F6: code = (event->modifiers & shiftKey ? 29 : 17); break;
- case K_F7: code = (event->modifiers & shiftKey ? 31 : 18); break;
- case K_F8: code = (event->modifiers & shiftKey ? 32 : 19); break;
- case K_F9: code = (event->modifiers & shiftKey ? 33 : 20); break;
- case K_F10: code = (event->modifiers & shiftKey ? 34 : 21); break;
- case K_F11: code = 23; break;
- case K_F12: code = 24; break;
- case K_HOME: code = 1; break;
- case K_INSERT: code = 2; break;
- case K_DELETE: code = 3; break;
- case K_END: code = 4; break;
- case K_PRIOR: code = 5; break;
- case K_NEXT: code = 6; break;
- }
- if (s->cfg.funky_type == 1 && code >= 11 && code <= 15) {
- p += sprintf((char *)p, "\x1B[[%c", code + 'A' - 11);
- return p - output;
- }
- if (s->cfg.rxvt_homeend && (code == 1 || code == 4)) {
- p += sprintf((char *)p, code == 1 ? "\x1B[H" : "\x1BOw");
- return p - output;
- }
- if (code) {
- p += sprintf((char *)p, "\x1B[%d~", code);
- return p - output;
+ if (event->modifiers & shiftKey)
+ mods |= PKM_SHIFT;
+ if (event->modifiers & controlKey)
+ mods |= PKM_CONTROL;
+ if (event->what == autoKey)
+ flags |= PKF_REPEAT;
+
+ /* Mac key events consist of a virtual key code and a character code. */
+
+ switch ((event->message & keyCodeMask) >> 8) {
+ case 0x24: keysym = PK_RETURN; break;
+ case 0x30: keysym = PK_TAB; break;
+ case 0x33: keysym = PK_BACKSPACE; break;
+ case 0x35: keysym = PK_ESCAPE; break;
+
+ case 0x7A: keysym = PK_F1; break;
+ case 0x78: keysym = PK_F2; break;
+ case 0x63: keysym = PK_F3; break;
+ case 0x76: keysym = PK_F4; break;
+ case 0x60: keysym = PK_F5; break;
+ case 0x61: keysym = PK_F6; break;
+ case 0x62: keysym = PK_F7; break;
+ case 0x64: keysym = PK_F8; break;
+ case 0x65: keysym = PK_F9; break;
+ case 0x6D: keysym = PK_F10; break;
+ case 0x67: keysym = PK_F11; break;
+ case 0x6F: keysym = PK_F12; break;
+ case 0x69: keysym = PK_F13; break;
+ case 0x6B: keysym = PK_F14; break;
+ case 0x71: keysym = PK_F15; break;
+
+ case 0x72: keysym = PK_INSERT; break;
+ case 0x73: keysym = PK_HOME; break;
+ case 0x74: keysym = PK_PAGEUP; break;
+ case 0x75: keysym = PK_DELETE; break;
+ case 0x77: keysym = PK_END; break;
+ case 0x79: keysym = PK_PAGEDOWN; break;
+
+ case 0x47: keysym = PK_PF1; break;
+ case 0x51: keysym = PK_PF2; break;
+ case 0x4B: keysym = PK_PF3; break;
+ case 0x43: keysym = PK_PF4; break;
+ case 0x4E: keysym = PK_KPMINUS; break;
+ case 0x45: keysym = PK_KPCOMMA; break;
+ case 0x41: keysym = PK_KPDECIMAL; break;
+ case 0x4C: keysym = PK_KPENTER; break;
+ case 0x52: keysym = PK_KP0; break;
+ case 0x53: keysym = PK_KP1; break;
+ case 0x54: keysym = PK_KP2; break;
+ case 0x55: keysym = PK_KP3; break;
+ case 0x56: keysym = PK_KP4; break;
+ case 0x57: keysym = PK_KP5; break;
+ case 0x58: keysym = PK_KP6; break;
+ case 0x59: keysym = PK_KP7; break;
+ case 0x5B: keysym = PK_KP8; break;
+ case 0x5C: keysym = PK_KP9; break;
+
+ case 0x7B: keysym = PK_LEFT; break;
+ case 0x7C: keysym = PK_RIGHT; break;
+ case 0x7D: keysym = PK_DOWN; break;
+ case 0x7E: keysym = PK_UP; break;
}
- if (s->term->app_keypad_keys) {
- switch (event->message & keyCodeMask) {
- case KP_ENTER: p += sprintf((char *)p, "\x1BOM"); return p - output;
- case KP_CLEAR: p += sprintf((char *)p, "\x1BOP"); return p - output;
- case KP_EQUAL: p += sprintf((char *)p, "\x1BOQ"); return p - output;
- case KP_SLASH: p += sprintf((char *)p, "\x1BOR"); return p - output;
- case KP_STAR: p += sprintf((char *)p, "\x1BOS"); return p - output;
- case KP_PLUS: p += sprintf((char *)p, "\x1BOl"); return p - output;
- case KP_MINUS: p += sprintf((char *)p, "\x1BOm"); return p - output;
- case KP_DOT: p += sprintf((char *)p, "\x1BOn"); return p - output;
- case KP_0: p += sprintf((char *)p, "\x1BOp"); return p - output;
- case KP_1: p += sprintf((char *)p, "\x1BOq"); return p - output;
- case KP_2: p += sprintf((char *)p, "\x1BOr"); return p - output;
- case KP_3: p += sprintf((char *)p, "\x1BOs"); return p - output;
- case KP_4: p += sprintf((char *)p, "\x1BOt"); return p - output;
- case KP_5: p += sprintf((char *)p, "\x1BOu"); return p - output;
- case KP_6: p += sprintf((char *)p, "\x1BOv"); return p - output;
- case KP_7: p += sprintf((char *)p, "\x1BOw"); return p - output;
- case KP_8: p += sprintf((char *)p, "\x1BOx"); return p - output;
- case KP_9: p += sprintf((char *)p, "\x1BOy"); return p - output;
+ /* Map from key script to Unicode. */
+ txt[0] = event->message & charCodeMask;
+ key_script = GetScriptManagerVariable(smKeyScript);
+
+ if (mac_gestalts.encvvers != 0) {
+ static TextToUnicodeInfo key_to_uni = NULL;
+ static ScriptCode key_to_uni_script;
+ TextEncoding enc;
+ ByteCount iread, olen;
+ OSErr err;
+
+ if (key_to_uni != NULL && key_to_uni_script != key_script)
+ DisposeTextToUnicodeInfo(&key_to_uni);
+ if (key_to_uni == NULL || key_to_uni_script != key_script) {
+ if (UpgradeScriptInfoToTextEncoding(key_script,
+ kTextLanguageDontCare,
+ kTextRegionDontCare, NULL,
+ &enc) == noErr &&
+ CreateTextToUnicodeInfoByEncoding(enc, &key_to_uni) == noErr)
+ key_to_uni_script = key_script;
+ else
+ key_to_uni = NULL;
+ }
+ if (key_to_uni != NULL) {
+ err = ConvertFromTextToUnicode(key_to_uni, 1, txt,
+ (kUnicodeKeepInfoMask |
+ kUnicodeStringUnterminatedMask),
+ 0, NULL, NULL, NULL,
+ sizeof(utxt), &iread, &olen, utxt);
+ if (err == noErr)
+ len = olen / sizeof(*utxt);
+ }
+ } else {
+ int charset;
+ char *tptr = txt;
+ int tlen = 1;
+
+ charset = charset_from_macenc(key_script,
+ GetScriptManagerVariable(smRegionCode),
+ mac_gestalts.sysvers, NULL);
+ if (charset != CS_NONE) {
+ len = charset_to_unicode(&tptr, &tlen, utxt, sizeof(utxt), charset,
+ NULL, NULL, 0);
}
}
-
- switch (event->message & keyCodeMask) {
- case K_UP:
- p += sprintf((char *)p,
- s->term->app_cursor_keys ? "\x1BOA" : "\x1B[A");
- return p - output;
- case K_DOWN:
- p += sprintf((char *)p,
- s->term->app_cursor_keys ? "\x1BOB" : "\x1B[B");
- return p - output;
- case K_RIGHT:
- p += sprintf((char *)p,
- s->term->app_cursor_keys ? "\x1BOC" : "\x1B[C");
- return p - output;
- case K_LEFT:
- p += sprintf((char *)p,
- s->term->app_cursor_keys ? "\x1BOD" : "\x1B[D");
- return p - output;
- case KP_ENTER:
- *p++ = 0x0d;
- return p - output;
- case K_BS:
- *p++ = (s->cfg.bksp_is_delete ? 0x7f : 0x08);
- return p - output;
- default:
- *p++ = event->message & charCodeMask;
- return p - output;
- }
+ term_key(s->term, keysym, utxt, len, mods, flags);
}
void request_paste(void *frontend)
char oldmsg[20];
} growterm_state;
-void mac_growterm(WindowPtr window, EventRecord *event) {
+static void mac_growterm(WindowPtr window, EventRecord *event)
+{
Rect limits;
long grow_result;
int newrows, newcols;
Session *s;
+#if !TARGET_API_MAC_CARBON
DragGrayRgnUPP draghooksave;
GrafPtr portsave;
FontInfo fi;
+#endif
- s = (Session *)GetWRefCon(window);
+ s = mac_windowsession(window);
+#if !TARGET_API_MAC_CARBON
draghooksave = LMGetDragHook();
growterm_state.oldmsg[0] = '\0';
growterm_state.zeromouse = event->where;
StringWidth("\p99999x99999") + 4, fi.ascent + fi.descent + 4);
SetPt(&growterm_state.msgorigin, 2, fi.ascent + 2);
LMSetDragHook(NewDragGrayRgnUPP(mac_growtermdraghook));
+#endif
SetRect(&limits, s->font_width + 15, s->font_height, SHRT_MAX, SHRT_MAX);
grow_result = GrowWindow(window, event->where, &limits);
+#if !TARGET_API_MAC_CARBON
DisposeDragGrayRgnUPP(LMGetDragHook());
LMSetDragHook(draghooksave);
InvalRect(&growterm_state.msgrect);
SetPort(portsave);
+#endif
if (grow_result != 0) {
newrows = HiWord(grow_result) / s->font_height;
}
}
+#if !TARGET_API_MAC_CARBON
static pascal void mac_growtermdraghook(void)
{
Session *s = growterm_state.s;
DrawString(pbuf);
SetPort(portsave);
}
+#endif
+
+void mac_closeterm(WindowPtr window)
+{
+ Session *s = mac_windowsession(window);
+
+ /* XXX warn on close */
+ HideWindow(s->window);
+ *s->prev = s->next;
+ s->next->prev = s->prev;
+ ldisc_free(s->ldisc);
+ s->back->free(s->backhandle);
+ log_free(s->logctx);
+ if (s->uni_to_font != NULL)
+ DisposeUnicodeToTextInfo(&s->uni_to_font);
+ term_free(s->term);
+ mac_freeeventlog(s);
+ sfree((WinInfo *)GetWRefCon(s->window));
+ DisposeWindow(s->window);
+ DisposePalette(s->palette);
+ sfree(s);
+}
-void mac_activateterm(WindowPtr window, Boolean active) {
+static void mac_activateterm(WindowPtr window, EventRecord *event)
+{
Session *s;
+ Boolean active = (event->modifiers & activeFlag) != 0;
- s = (Session *)GetWRefCon(window);
+ s = mac_windowsession(window);
s->term->has_focus = active;
term_update(s->term);
if (active)
mac_drawgrowicon(s);
}
-void mac_updateterm(WindowPtr window) {
+static void mac_updateterm(WindowPtr window)
+{
Session *s;
+ Rect bbox;
+#if TARGET_API_MAC_CARBON
+ RgnHandle visrgn;
+#endif
- s = (Session *)GetWRefCon(window);
- SetPort(window);
+ s = mac_windowsession(window);
+ SetPort((GrafPtr)GetWindowPort(window));
BeginUpdate(window);
pre_paint(s);
- term_paint(s->term, s,
- PTOCC((*window->visRgn)->rgnBBox.left),
- PTOCR((*window->visRgn)->rgnBBox.top),
- PTOCC((*window->visRgn)->rgnBBox.right),
- PTOCR((*window->visRgn)->rgnBBox.bottom), 1);
+#if TARGET_API_MAC_CARBON
+ visrgn = NewRgn();
+ GetPortVisibleRegion(GetWindowPort(window), visrgn);
+ GetRegionBounds(visrgn, &bbox);
+#else
+ bbox = (*window->visRgn)->rgnBBox;
+#endif
+ term_paint(s->term, s, PTOCC(bbox.left), PTOCR(bbox.top),
+ PTOCC(bbox.right), PTOCR(bbox.bottom), 1);
/* Restore default colours in case the Window Manager uses them */
if (HAVE_COLOR_QD()) {
PmForeColor(DEFAULT_FG);
BackColor(blackColor);
}
if (FrontWindow() != window)
+#if TARGET_API_MAC_CARBON
+ EraseRect(GetControlBounds(s->scrollbar, &bbox));
+ UpdateControls(window, visrgn);
+ DisposeRgn(visrgn);
+#else
EraseRect(&(*s->scrollbar)->contrlRect);
UpdateControls(window, window->visRgn);
+#endif
mac_drawgrowicon(s);
post_paint(s);
EndUpdate(window);
}
-static void mac_drawgrowicon(Session *s) {
+static void mac_drawgrowicon(Session *s)
+{
Rect clip;
RgnHandle savergn;
- SetPort(s->window);
+ SetPort((GrafPtr)GetWindowPort(s->window));
/*
* Stop DrawGrowIcon giving us space for a horizontal scrollbar
* See Tech Note TB575 for details.
*/
+#if TARGET_API_MAC_CARBON
+ GetPortBounds(GetWindowPort(s->window), &clip);
+#else
clip = s->window->portRect;
+#endif
clip.left = clip.right - 15;
savergn = NewRgn();
GetClip(savergn);
* x and y are text row and column (zero-based)
*/
void do_text(Context ctx, int x, int y, char *text, int len,
- unsigned long attr, int lattr) {
+ unsigned long attr, int lattr)
+{
Session *s = ctx;
- int style = 0;
+ int style;
struct do_text_args a;
RgnHandle textrgn, saveclip;
+#if TARGET_API_MAC_CARBON
+ RgnHandle visrgn;
+#endif
char mactextbuf[1024];
UniChar unitextbuf[1024];
wchar_t *unitextptr;
int i, fontwidth;
ByteCount iread, olen;
OSStatus err;
+ static DeviceLoopDrawingUPP do_text_for_device_upp = NULL;
assert(len <= 1024);
- SetPort(s->window);
+ SetPort((GrafPtr)GetWindowPort(s->window));
fontwidth = s->font_width;
if ((lattr & LATTR_MODE) != LATTR_NORM)
a.textrect.right = (x + len) * fontwidth;
if (a.textrect.right > s->term->cols * s->font_width)
a.textrect.right = s->term->cols * s->font_width;
+#if TARGET_API_MAC_CARBON
+ visrgn = NewRgn();
+ GetPortVisibleRegion(GetWindowPort(s->window), visrgn);
+ if (!RectInRgn(&a.textrect, visrgn)) {
+ DisposeRgn(visrgn);
+ return;
+ }
+ DisposeRgn(visrgn);
+#else
if (!RectInRgn(&a.textrect, s->window->visRgn))
return;
+#endif
/* Unpack Unicode from the mad format we get passed */
for (i = 0; i < len; i++)
a.lattr = lattr;
switch (lattr & LATTR_MODE) {
case LATTR_NORM:
- TextSize(s->cfg.fontheight);
+ TextSize(s->cfg.font.size);
a.numer = s->font_stdnumer;
a.denom = s->font_stddenom;
break;
case LATTR_WIDE:
- TextSize(s->cfg.fontheight);
+ TextSize(s->cfg.font.size);
a.numer = s->font_widenumer;
a.denom = s->font_widedenom;
break;
case LATTR_TOP:
case LATTR_BOT:
- TextSize(s->cfg.fontheight * 2);
+ TextSize(s->cfg.font.size * 2);
a.numer = s->font_bignumer;
a.denom = s->font_bigdenom;
break;
}
- SetPort(s->window);
+ SetPort((GrafPtr)GetWindowPort(s->window));
TextFont(s->fontnum);
- if (s->cfg.fontisbold || (attr & ATTR_BOLD) && !s->cfg.bold_colour)
+ style = s->cfg.font.face;
+ if ((attr & ATTR_BOLD) && !s->cfg.bold_colour)
style |= bold;
if (attr & ATTR_UNDER)
style |= underline;
ClipRect(&a.textrect);
textrgn = NewRgn();
RectRgn(textrgn, &a.textrect);
- if (HAVE_COLOR_QD())
- DeviceLoop(textrgn, &do_text_for_device_upp, (long)&a, 0);
- else
+ if (HAVE_COLOR_QD()) {
+ if (do_text_for_device_upp == NULL)
+ do_text_for_device_upp =
+ NewDeviceLoopDrawingUPP(&do_text_for_device);
+ DeviceLoop(textrgn, do_text_for_device_upp, (long)&a, 0);
+ } else
do_text_for_device(1, 0, NULL, (long)&a);
SetClip(saveclip);
DisposeRgn(saveclip);
DisposeRgn(textrgn);
/* Tell the window manager about it in case this isn't an update */
+#if TARGET_API_MAC_CARBON
+ ValidWindowRect(s->window, &a.textrect);
+#else
ValidRect(&a.textrect);
+#endif
}
static pascal void do_text_for_device(short depth, short devflags,
- GDHandle device, long cookie) {
- struct do_text_args *a;
+ GDHandle device, long cookie)
+{
+ struct do_text_args *a = (struct do_text_args *)cookie;
int bgcolour, fgcolour, bright, reverse, tmp;
-
- a = (struct do_text_args *)cookie;
+#if TARGET_API_MAC_CARBON
+ CQDProcsPtr gp = GetPortGrafProcs(GetWindowPort(a->s->window));
+#else
+ QDProcsPtr gp = a->s->window->grafProcs;
+#endif
bright = (a->attr & ATTR_BOLD) && a->s->cfg.bold_colour;
reverse = a->attr & ATTR_REVERSE;
if (HAVE_COLOR_QD()) {
if (depth > 2) {
- fgcolour = ((a->attr & ATTR_FGMASK) >> ATTR_FGSHIFT) * 2;
- bgcolour = ((a->attr & ATTR_BGMASK) >> ATTR_BGSHIFT) * 2;
+ fgcolour = ((a->attr & ATTR_FGMASK) >> ATTR_FGSHIFT);
+ fgcolour = (fgcolour & 0xF) * 2 + (fgcolour & 0x10 ? 1 : 0);
+ bgcolour = ((a->attr & ATTR_BGMASK) >> ATTR_BGSHIFT);
+ bgcolour = (bgcolour & 0xF) * 2 + (bgcolour & 0x10 ? 1 : 0);
} else {
/*
* NB: bold reverse in 2bpp breaks with the usual PuTTY model and
bgcolour = tmp;
}
if (bright && depth > 2)
- fgcolour++;
+ fgcolour |= 1;
if ((a->attr & TATTR_ACTCURS) && depth > 1) {
fgcolour = CURSOR_FG;
bgcolour = CURSOR_BG;
break;
}
/* FIXME: Sort out bold width adjustments on Original QuickDraw. */
- if (a->s->window->grafProcs != NULL)
- InvokeQDTextUPP(a->len, a->text, a->numer, a->denom,
- a->s->window->grafProcs->textProc);
+ if (gp != NULL)
+ InvokeQDTextUPP(a->len, a->text, a->numer, a->denom, gp->textProc);
else
StdText(a->len, a->text, a->numer, a->denom);
* Call from the terminal emulator to get its graphics context.
* Should probably be called start_redraw or something.
*/
-void pre_paint(Session *s) {
+void pre_paint(Session *s)
+{
GDHandle gdh;
Rect myrect, tmprect;
+#if TARGET_API_MAC_CARBON
+ RgnHandle visrgn;
+#endif
if (HAVE_COLOR_QD()) {
s->term->attr_mask = 0;
- SetPort(s->window);
+ SetPort((GrafPtr)GetWindowPort(s->window));
+#if TARGET_API_MAC_CARBON
+ visrgn = NewRgn();
+ GetPortVisibleRegion(GetWindowPort(s->window), visrgn);
+ GetRegionBounds(visrgn, &myrect);
+ DisposeRgn(visrgn);
+#else
myrect = (*s->window->visRgn)->rgnBBox;
+#endif
LocalToGlobal((Point *)&myrect.top);
LocalToGlobal((Point *)&myrect.bottom);
for (gdh = GetDeviceList();
(s->cfg.bold_colour ? ATTR_BOLD : 0));
}
-Context get_ctx(void *frontend) {
+Context get_ctx(void *frontend)
+{
Session *s = frontend;
pre_paint(s);
return s;
}
-void free_ctx(Context ctx) {
+void free_ctx(Context ctx)
+{
}
/*
* Presumably this does something in Windows
*/
-void post_paint(Session *s) {
+void post_paint(Session *s)
+{
}
* start is the line number of the top of the display
* page is the length of the displayed page
*/
-void set_sbar(void *frontend, int total, int start, int page) {
+void set_sbar(void *frontend, int total, int start, int page)
+{
Session *s = frontend;
/* We don't redraw until we've set everything up, to avoid glitches */
- (*s->scrollbar)->contrlMin = 0;
- (*s->scrollbar)->contrlMax = total - page;
+ SetControlMinimum(s->scrollbar, 0);
+ SetControlMaximum(s->scrollbar, total - page);
SetControlValue(s->scrollbar, start);
#if !TARGET_CPU_68K
if (mac_gestalts.cntlattr & gestaltControlMgrPresent)
/*
* Set the window title
*/
-void set_title(void *frontend, char *title) {
+void set_title(void *frontend, char *title)
+{
Session *s = frontend;
Str255 mactitle;
/*
* Resize the window at the emulator's request
*/
-void request_resize(void *frontend, int w, int h) {
+void request_resize(void *frontend, int w, int h)
+{
Session *s = frontend;
-
+ RgnHandle grayrgn;
+ Rect graybox;
+ int wlim, hlim;
+
+ /* Arbitrarily clip to the size of the desktop. */
+ grayrgn = GetGrayRgn();
+#if TARGET_API_MAC_CARBON
+ GetRegionBounds(grayrgn, &graybox);
+#else
+ graybox = (*grayrgn)->rgnBBox;
+#endif
+ wlim = (graybox.right - graybox.left) / s->font_width;
+ hlim = (graybox.bottom - graybox.top) / s->font_height;
+ if (w > wlim) w = wlim;
+ if (h > hlim) h = hlim;
term_size(s->term, h, w, s->cfg.savelines);
mac_initfont(s);
}
void get_window_pos(void *frontend, int *x, int *y)
{
Session *s = frontend;
+ Rect rect;
- *x = s->window->portRect.left;
- *y = s->window->portRect.top;
+#if TARGET_API_MAC_CARBON
+ GetPortBounds(GetWindowPort(s->window), &rect);
+#else
+ rect = s->window->portRect;
+#endif
+ *x = rect.left;
+ *y = rect.top;
}
/*
void get_window_pixels(void *frontend, int *x, int *y)
{
Session *s = frontend;
+ Rect rect;
- *x = s->window->portRect.right - s->window->portRect.left;
- *y = s->window->portRect.bottom - s->window->portRect.top;
+#if TARGET_API_MAC_CARBON
+ GetPortBounds(GetWindowPort(s->window), &rect);
+#else
+ rect = s->window->portRect;
+#endif
+ *x = rect.right - rect.left;
+ *y = rect.bottom - rect.top;
}
/*
/*
* Set the logical palette. Called by the terminal emulator.
*/
-void palette_set(void *frontend, int n, int r, int g, int b) {
+void palette_set(void *frontend, int n, int r, int g, int b)
+{
Session *s = frontend;
static const int first[21] = {
0, 2, 4, 6, 8, 10, 12, 14,
/*
* Reset to the default palette
*/
-void palette_reset(void *frontend) {
+void palette_reset(void *frontend)
+{
Session *s = frontend;
/* This maps colour indices in cfg to those used in our palette. */
static const int ww[] = {
* Scroll the screen. (`lines' is +ve for scrolling forward, -ve
* for backward.)
*/
-void do_scroll(void *frontend, int topline, int botline, int lines) {
- Session *s = frontend;
+void do_scroll(Context ctx, int topline, int botline, int lines)
+{
+ Session *s = ctx;
Rect r;
RgnHandle scrollrgn = NewRgn();
RgnHandle movedupdate = NewRgn();
RgnHandle update = NewRgn();
Point g2l = { 0, 0 };
- SetPort(s->window);
+ SetPort((GrafPtr)GetWindowPort(s->window));
/*
* Work out the part of the update region that will scrolled by
SetRectRgn(scrollrgn, 0, topline * s->font_height,
s->term->cols * s->font_width,
(botline - lines + 1) * s->font_height);
- CopyRgn(((WindowPeek)s->window)->updateRgn, movedupdate);
+#if TARGET_API_MAC_CARBON
+ GetWindowRegion(s->window, kWindowUpdateRgn, movedupdate);
+#else
+ GetWindowUpdateRgn(s->window, movedupdate);
+#endif
GlobalToLocal(&g2l);
OffsetRgn(movedupdate, g2l.h, g2l.v); /* Convert to local co-ords. */
SectRgn(scrollrgn, movedupdate, movedupdate); /* Clip scrolled section. */
+#if TARGET_API_MAC_CARBON
+ ValidWindowRgn(s->window, movedupdate);
+#else
ValidRgn(movedupdate);
+#endif
OffsetRgn(movedupdate, 0, -lines * s->font_height); /* Scroll it. */
PenNormal();
s->term->cols * s->font_width, (botline + 1) * s->font_height);
ScrollRect(&r, 0, - lines * s->font_height, update);
+#if TARGET_API_MAC_CARBON
+ InvalWindowRgn(s->window, update);
+ InvalWindowRgn(s->window, movedupdate);
+#else
InvalRgn(update);
InvalRgn(movedupdate);
+#endif
DisposeRgn(scrollrgn);
DisposeRgn(movedupdate);
DisposeRgn(update);
}
-void logevent(void *frontend, char *str) {
-
- fprintf(stderr, "%s\n", str);
-}
-
/* Dummy routine, only required in plink. */
void ldisc_update(void *frontend, int echo, int edit)
{
* Ask whether to wipe a session log file before writing to it.
* Returns 2 for wipe, 1 for append, 0 for cancel (don't log).
*/
-int askappend(void *frontend, char *filename)
+int askappend(void *frontend, Filename filename)
{
/* FIXME: not implemented yet. */
return 2;
}
+int from_backend(void *frontend, int is_stderr, const char *data, int len)
+{
+ Session *s = frontend;
+
+ return term_data(s->term, is_stderr, data, len);
+}
+
/*
* Emacs magic:
* Local Variables:
projects / u / mdw / putty / blobdiff