mac/mac.c

   1 /* $Id: mac.c,v 1.36 2003/01/24 00:25:33 ben Exp $ */
   2 /*
   3  * Copyright (c) 1999 Ben Harris
   4  * All rights reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person
   7  * obtaining a copy of this software and associated documentation
   8  * files (the "Software"), to deal in the Software without
   9  * restriction, including without limitation the rights to use,
  10  * copy, modify, merge, publish, distribute, sublicense, and/or
  11  * sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following
  13  * conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be
  16  * included in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  21  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
  23  * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  25  * SOFTWARE.
  26  */
  27 /*
  28  * mac.c -- miscellaneous Mac-specific routines
  29  */
  30
  31 #include <MacTypes.h>
  32 #include <AEDataModel.h>
  33 #include <AppleEvents.h>
  34 #include <Quickdraw.h>
  35 #include <Fonts.h>
  36 #include <MacWindows.h>
  37 #include <Menus.h>
  38 #include <TextEdit.h>
  39 #include <Appearance.h>
  40 #include <CodeFragments.h>
  41 #include <Dialogs.h>
  42 #include <Devices.h>
  43 #include <DiskInit.h>
  44 #include <Gestalt.h>
  45 #include <LowMem.h>
  46 #include <Resources.h>
  47 #include <Script.h>
  48 #include <TextCommon.h>
  49 #include <ToolUtils.h>
  50 #include <UnicodeConverter.h>
  51
  52 #include <assert.h>
  53 #include <limits.h>
  54 #include <stdarg.h>
  55 #include <stdlib.h>             /* putty.h needs size_t */
  56 #include <stdio.h>              /* for vsprintf */
  57
  58 #define PUTTY_DO_GLOBALS
  59
  60 #include "macresid.h"
  61 #include "putty.h"
  62 #include "ssh.h"
  63 #include "mac.h"
  64
  65 QDGlobals qd;
  66
  67 Session *sesslist;
  68
  69 static int cold = 1;
  70 static int borednow = FALSE;
  71 struct mac_gestalts mac_gestalts;
  72
  73 static void mac_startup(void);
  74 static void mac_eventloop(void);
  75 #pragma noreturn (mac_eventloop)
  76 static void mac_event(EventRecord *);
  77 static void mac_contentclick(WindowPtr, EventRecord *);
  78 static void mac_growwindow(WindowPtr, EventRecord *);
  79 static void mac_activatewindow(WindowPtr, EventRecord *);
  80 static void mac_activateabout(WindowPtr, EventRecord *);
  81 static void mac_updatewindow(WindowPtr);
  82 static void mac_updatelicence(WindowPtr);
  83 static void mac_keypress(EventRecord *);
  84 static int mac_windowtype(WindowPtr);
  85 static void mac_menucommand(long);
  86 static void mac_openabout(void);
  87 static void mac_openlicence(void);
  88 static void mac_adjustcursor(RgnHandle);
  89 static void mac_adjustmenus(void);
  90 static void mac_closewindow(WindowPtr);
  91 static void mac_zoomwindow(WindowPtr, short);
  92 #pragma noreturn (cleanup_exit)
  93
  94 struct mac_windows {
  95     WindowPtr about;
  96     WindowPtr licence;
  97 };
  98
  99 struct mac_windows windows;
 100
 101 int main (int argc, char **argv) {
 102
 103     mac_startup();
 104     mac_eventloop();
 105 }
 106
 107 #pragma noreturn (main)
 108
 109 static void mac_startup(void) {
 110     Handle menuBar;
 111     TECInfoHandle ti;
 112
 113     /* Init Memory Manager */
 114     MaxApplZone();
 115     /* Init QuickDraw */
 116     InitGraf(&qd.thePort);
 117     /* Init Font Manager */
 118     InitFonts();
 119     /* Init Window Manager */
 120     InitWindows();
 121     /* Init Menu Manager */
 122     InitMenus();
 123     /* Init TextEdit */
 124     TEInit();
 125     /* Init Dialog Manager */
 126     InitDialogs(NULL);
 127     cold = 0;
 128
 129     /* Get base system version (only used if there's no better selector) */
 130     if (Gestalt(gestaltSystemVersion, &mac_gestalts.sysvers) != noErr ||
 131         (mac_gestalts.sysvers &= 0xffff) < 0x700)
 132         fatalbox("PuTTY requires System 7 or newer");
 133     /* Find out if we've got Color Quickdraw */
 134     if (Gestalt(gestaltQuickdrawVersion, &mac_gestalts.qdvers) != noErr)
 135         mac_gestalts.qdvers = gestaltOriginalQD;
 136     /* ... and the Appearance Manager? */
 137     if (Gestalt(gestaltAppearanceVersion, &mac_gestalts.apprvers) != noErr)
 138         if (Gestalt(gestaltAppearanceAttr, NULL) == noErr)
 139             mac_gestalts.apprvers = 0x0100;
 140         else
 141             mac_gestalts.apprvers = 0;
 142 #if TARGET_RT_MAC_CFM
 143     /* Paranoia: Did we manage to pull in AppearanceLib? */
 144     if (&RegisterAppearanceClient == kUnresolvedCFragSymbolAddress)
 145         mac_gestalts.apprvers = 0;
 146 #endif
 147 #if TARGET_CPU_68K
 148     mac_gestalts.cntlattr = 0;
 149     mac_gestalts.windattr = 0;
 150 #else
 151     /* Mac OS 8.5 Control Manager (proportional scrollbars)? */
 152     if (Gestalt(gestaltControlMgrAttr, &mac_gestalts.cntlattr) != noErr ||
 153         &SetControlViewSize == kUnresolvedCFragSymbolAddress)
 154         mac_gestalts.cntlattr = 0;
 155     /* Mac OS 8.5 Window Manager? */
 156     if (Gestalt(gestaltWindowMgrAttr, &mac_gestalts.windattr) != noErr ||
 157         &SetWindowContentColor == kUnresolvedCFragSymbolAddress)
 158         mac_gestalts.windattr = 0;
 159 #endif
 160     /* Text Encoding Conversion Manager? */
 161     if (
 162 #if TARGET_RT_MAC_CFM
 163         &TECGetInfo == kUnresolvedCFragSymbolAddress ||
 164 #else
 165         InitializeUnicodeConverter(NULL) != noErr ||
 166 #endif
 167         TECGetInfo(&ti) != noErr)
 168         mac_gestalts.encvvers = 0;
 169     else {
 170         mac_gestalts.encvvers = (*ti)->tecVersion;
 171         mac_gestalts.uncvattr = (*ti)->tecUnicodeConverterFeatures;
 172         DisposeHandle((Handle)ti);
 173     }
 174
 175     sk_init();
 176
 177     /* We've been tested with the Appearance Manager */
 178     if (mac_gestalts.apprvers != 0)
 179         RegisterAppearanceClient();
 180
 181     menuBar = GetNewMBar(128);
 182     if (menuBar == NULL)
 183         fatalbox("Unable to create menu bar.");
 184     SetMenuBar(menuBar);
 185     AppendResMenu(GetMenuHandle(mApple), 'DRVR');
 186     mac_adjustmenus();
 187     DrawMenuBar();
 188     InitCursor();
 189     windows.about = NULL;
 190     windows.licence = NULL;
 191
 192     default_protocol = be_default_protocol;
 193     /* Find the appropriate default port. */
 194     {
 195         int i;
 196         default_port = 0; /* illegal */
 197         for (i = 0; backends[i].backend != NULL; i++)
 198             if (backends[i].protocol == default_protocol) {
 199                 default_port = backends[i].backend->default_port;
 200                 break;
 201             }
 202     }
 203     flags = FLAG_INTERACTIVE;
 204
 205     {
 206         short vol;
 207         long dirid;
 208
 209         /* Set the default directory for loading and saving settings. */
 210         /* XXX Should we create it? */
 211         if (get_session_dir(FALSE, &vol, &dirid) == noErr) {
 212             LMSetSFSaveDisk(-vol);
 213             LMSetCurDirStore(dirid);
 214         }
 215     }
 216
 217     /* Install Apple Event handlers. */
 218     AEInstallEventHandler(kCoreEventClass, kAEOpenApplication,
 219                           NewAEEventHandlerUPP(&mac_aevt_oapp), 0, FALSE);
 220     AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments,
 221                           NewAEEventHandlerUPP(&mac_aevt_odoc), 0, FALSE);
 222     AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments,
 223                           NewAEEventHandlerUPP(&mac_aevt_pdoc), 0, FALSE);
 224     AEInstallEventHandler(kCoreEventClass, kAEQuitApplication,
 225                           NewAEEventHandlerUPP(&mac_aevt_quit), 0, FALSE);
 226 }
 227
 228 static void mac_eventloop(void) {
 229     Boolean gotevent;
 230     EventRecord event;
 231     RgnHandle cursrgn;
 232
 233     cursrgn = NewRgn();
 234     for (;;) {
 235         mac_adjustcursor(cursrgn);
 236         gotevent = WaitNextEvent(everyEvent, &event, LONG_MAX, cursrgn);
 237         mac_adjustcursor(cursrgn);
 238         if (gotevent)
 239             mac_event(&event);
 240         if (borednow)
 241             cleanup_exit(0);
 242         sk_poll();
 243         mac_pollterm();
 244     }
 245     DisposeRgn(cursrgn);
 246 }
 247
 248 static void mac_event(EventRecord *event) {
 249     short part;
 250     WindowPtr window;
 251     Point pt;
 252
 253     switch (event->what) {
 254       case mouseDown:
 255         part = FindWindow(event->where, &window);
 256         switch (part) {
 257           case inMenuBar:
 258             mac_adjustmenus();
 259             mac_menucommand(MenuSelect(event->where));
 260             break;
 261           case inSysWindow:
 262             SystemClick(event, window);
 263             break;
 264           case inContent:
 265             if (window != FrontWindow())
 266                 /* XXX: check for movable modal dboxes? */
 267                 SelectWindow(window);
 268             else
 269                 mac_contentclick(window, event);
 270             break;
 271           case inGoAway:
 272             if (TrackGoAway(window, event->where))
 273                 mac_closewindow(window);
 274             break;
 275           case inDrag:
 276             /* XXX: moveable modal check? */
 277             DragWindow(window, event->where, &qd.screenBits.bounds);
 278             break;
 279           case inGrow:
 280             mac_growwindow(window, event);
 281             break;
 282           case inZoomIn:
 283           case inZoomOut:
 284             if (TrackBox(window, event->where, part))
 285                 mac_zoomwindow(window, part);
 286             break;
 287         }
 288         break;
 289       case keyDown:
 290       case autoKey:
 291         mac_keypress(event);
 292         break;
 293       case activateEvt:
 294         mac_activatewindow((WindowPtr)event->message, event);
 295         break;
 296       case updateEvt:
 297         mac_updatewindow((WindowPtr)event->message);
 298         break;
 299       case diskEvt:
 300         if (HiWord(event->message) != noErr) {
 301             SetPt(&pt, 120, 120);
 302             DIBadMount(pt, event->message);
 303         }
 304         break;
 305       case kHighLevelEvent:
 306         AEProcessAppleEvent(event); /* errors? */
 307         break;
 308     }
 309 }
 310
 311 static void mac_contentclick(WindowPtr window, EventRecord *event) {
 312     short item;
 313
 314     switch (mac_windowtype(window)) {
 315       case wTerminal:
 316         mac_clickterm(window, event);
 317         break;
 318       case wAbout:
 319         if (DialogSelect(event, &window, &item))
 320             switch (item) {
 321               case wiAboutLicence:
 322                 mac_openlicence();
 323                 break;
 324             }
 325         break;
 326       case wSettings:
 327         mac_clickdlg(window, event);
 328         break;
 329     }
 330 }
 331
 332 static void mac_growwindow(WindowPtr window, EventRecord *event) {
 333
 334     switch (mac_windowtype(window)) {
 335       case wTerminal:
 336         mac_growterm(window, event);
 337     }
 338 }
 339
 340 static void mac_activatewindow(WindowPtr window, EventRecord *event) {
 341     int active;
 342
 343     active = (event->modifiers & activeFlag) != 0;
 344     mac_adjustmenus();
 345     switch (mac_windowtype(window)) {
 346       case wTerminal:
 347         mac_activateterm(window, active);
 348         break;
 349       case wSettings:
 350         mac_activatedlg(window, event);
 351         break;
 352       case wAbout:
 353         mac_activateabout(window, event);
 354         break;
 355     }
 356 }
 357
 358 static void mac_activateabout(WindowPtr window, EventRecord *event) {
 359     DialogItemType itemtype;
 360     Handle itemhandle;
 361     short item;
 362     Rect itemrect;
 363     int active;
 364
 365     active = (event->modifiers & activeFlag) != 0;
 366     GetDialogItem(window, wiAboutLicence, &itemtype, &itemhandle, &itemrect);
 367     HiliteControl((ControlHandle)itemhandle, active ? 0 : 255);
 368     DialogSelect(event, &window, &item);
 369 }
 370
 371 static void mac_updatewindow(WindowPtr window) {
 372
 373     switch (mac_windowtype(window)) {
 374       case wTerminal:
 375         mac_updateterm(window);
 376         break;
 377       case wAbout:
 378       case wSettings:
 379         BeginUpdate(window);
 380         UpdateDialog(window, window->visRgn);
 381         EndUpdate(window);
 382         break;
 383       case wLicence:
 384         mac_updatelicence(window);
 385         break;
 386     }
 387 }
 388
 389 static void mac_updatelicence(WindowPtr window)
 390 {
 391     Handle h;
 392     int len;
 393     long fondsize;
 394
 395     SetPort(window);
 396     BeginUpdate(window);
 397     fondsize = GetScriptVariable(smRoman, smScriptSmallFondSize);
 398     TextFont(HiWord(fondsize));
 399     TextSize(LoWord(fondsize));
 400     h = Get1Resource('TEXT', wLicence);
 401     len = GetResourceSizeOnDisk(h);
 402     if (h != NULL) {
 403         HLock(h);
 404         TETextBox(*h, len, &window->portRect, teFlushDefault);
 405         HUnlock(h);
 406     }
 407     EndUpdate(window);
 408 }
 409
 410 /*
 411  * Work out what kind of window we're dealing with.
 412  * Concept shamelessly nicked from SurfWriter.
 413  */
 414 static int mac_windowtype(WindowPtr window) {
 415     int kind;
 416     long refcon;
 417
 418     if (window == NULL)
 419         return wNone;
 420     kind = ((WindowPeek)window)->windowKind;
 421     if (kind < 0)
 422         return wDA;
 423     if (GetWVariant(window) == zoomDocProc)
 424         return wTerminal;
 425     refcon = GetWRefCon(window);
 426     if (refcon < 1024)
 427         return refcon;
 428     else
 429         return wSettings;
 430 }
 431
 432 /*
 433  * Handle a key press
 434  */
 435 static void mac_keypress(EventRecord *event) {
 436     WindowPtr window;
 437
 438     window = FrontWindow();
 439     /*
 440      * Check for a command-key combination, but ignore it if it counts
 441      * as a meta-key combination and we're in a terminal window.
 442      */
 443     if (event->what == keyDown && (event->modifiers & cmdKey) /*&&
 444         !((event->modifiers & cfg.meta_modifiers) == cfg.meta_modifiers &&
 445             mac_windowtype(window) == wTerminal)*/) {
 446         mac_adjustmenus();
 447         mac_menucommand(MenuKey(event->message & charCodeMask));
 448     } else {
 449         switch (mac_windowtype(window)) {
 450           case wTerminal:
 451             mac_keyterm(window, event);
 452             break;
 453         }
 454     }
 455 }
 456
 457 static void mac_menucommand(long result) {
 458     short menu, item;
 459     Str255 da;
 460     WindowPtr window;
 461
 462     menu = HiWord(result);
 463     item = LoWord(result);
 464     window = FrontWindow();
 465     /* Things which do the same whatever window we're in. */
 466     switch (menu) {
 467       case mApple:
 468         switch (item) {
 469           case iAbout:
 470             mac_openabout();
 471             goto done;
 472           default:
 473             GetMenuItemText(GetMenuHandle(mApple), item, da);
 474             OpenDeskAcc(da);
 475             goto done;
 476         }
 477         break;
 478       case mFile:
 479         switch (item) {
 480           case iNew:
 481             mac_newsession();
 482             goto done;
 483           case iOpen:
 484             mac_opensession();
 485             goto done;
 486           case iClose:
 487             mac_closewindow(window);
 488             goto done;
 489           case iSave:
 490             mac_savesession();
 491             goto done;
 492           case iSaveAs:
 493             mac_savesessionas();
 494             goto done;
 495           case iQuit:
 496             cleanup_exit(0);
 497             goto done;
 498         }
 499         break;
 500     }
 501     /* If we get here, handling is up to window-specific code. */
 502     switch (mac_windowtype(window)) {
 503       case wTerminal:
 504         mac_menuterm(window, menu, item);
 505         break;
 506     }
 507   done:
 508     HiliteMenu(0);
 509 }
 510
 511 static void mac_openabout(void) {
 512     DialogItemType itemtype;
 513     Handle item;
 514     VersRecHndl vers;
 515     Rect box;
 516     StringPtr longvers;
 517
 518     if (windows.about)
 519         SelectWindow(windows.about);
 520     else {
 521         windows.about = GetNewDialog(wAbout, NULL, (WindowPtr)-1);
 522         vers = (VersRecHndl)Get1Resource('vers', 1);
 523         if (vers != NULL && *vers != NULL) {
 524             longvers = (*vers)->shortVersion + (*vers)->shortVersion[0] + 1;
 525             GetDialogItem(windows.about, wiAboutVersion,
 526                           &itemtype, &item, &box);
 527             assert(itemtype & kStaticTextDialogItem);
 528             SetDialogItemText(item, longvers);
 529         }
 530         ShowWindow(windows.about);
 531     }
 532 }
 533
 534 static void mac_openlicence(void) {
 535
 536     if (windows.licence)
 537         SelectWindow(windows.licence);
 538     else {
 539         windows.licence = GetNewWindow(wLicence, NULL, (WindowPtr)-1);
 540         ShowWindow(windows.licence);
 541     }
 542 }
 543
 544 static void mac_closewindow(WindowPtr window) {
 545
 546     switch (mac_windowtype(window)) {
 547       case wDA:
 548         CloseDeskAcc(((WindowPeek)window)->windowKind);
 549         break;
 550       case wTerminal:
 551         mac_closeterm(window);
 552         break;
 553       case wAbout:
 554         windows.about = NULL;
 555         DisposeDialog(window);
 556         break;
 557       case wLicence:
 558         windows.licence = NULL;
 559         DisposeWindow(window);
 560         break;
 561     }
 562 }
 563
 564 static void mac_zoomwindow(WindowPtr window, short part) {
 565
 566     /* FIXME: do something */
 567 }
 568
 569 /*
 570  * Make the menus look right before the user gets to see them.
 571  */
 572 static void mac_adjustmenus(void) {
 573     WindowPtr window;
 574     MenuHandle menu;
 575
 576     window = FrontWindow();
 577     menu = GetMenuHandle(mApple);
 578     EnableItem(menu, 0);
 579     EnableItem(menu, iAbout);
 580
 581     menu = GetMenuHandle(mFile);
 582     EnableItem(menu, 0);
 583     EnableItem(menu, iNew);
 584     if (window != NULL)
 585         EnableItem(menu, iClose);
 586     else
 587         DisableItem(menu, iClose);
 588     EnableItem(menu, iQuit);
 589
 590     switch (mac_windowtype(window)) {
 591       case wSettings:
 592         DisableItem(menu, iSave); /* XXX enable if modified */
 593         EnableItem(menu, iSaveAs);
 594         menu = GetMenuHandle(mEdit);
 595         DisableItem(menu, 0);
 596         break;
 597       case wTerminal:
 598         mac_adjusttermmenus(window);
 599         break;
 600       default:
 601         DisableItem(menu, iSave);
 602         DisableItem(menu, iSaveAs);
 603         menu = GetMenuHandle(mEdit);
 604         DisableItem(menu, 0);
 605         break;
 606     }
 607     DrawMenuBar();
 608 }
 609
 610 /*
 611  * Make sure the right cursor's being displayed.
 612  */
 613 static void mac_adjustcursor(RgnHandle cursrgn) {
 614     Point mouse;
 615     WindowPtr window, front;
 616     short part;
 617
 618     GetMouse(&mouse);
 619     LocalToGlobal(&mouse);
 620     part = FindWindow(mouse, &window);
 621     front = FrontWindow();
 622     if (part != inContent || window == NULL || window != front) {
 623         /* Cursor isn't in the front window, so switch to arrow */
 624         SetCursor(&qd.arrow);
 625         SetRectRgn(cursrgn, SHRT_MIN, SHRT_MIN, SHRT_MAX, SHRT_MAX);
 626         if (front != NULL)
 627             DiffRgn(cursrgn, front->visRgn, cursrgn);
 628     } else {
 629         switch (mac_windowtype(window)) {
 630           case wTerminal:
 631             mac_adjusttermcursor(window, mouse, cursrgn);
 632             break;
 633           default:
 634             SetCursor(&qd.arrow);
 635             CopyRgn(window->visRgn, cursrgn);
 636             break;
 637         }
 638     }
 639 }
 640
 641 pascal OSErr mac_aevt_quit(const AppleEvent *req, AppleEvent *reply,
 642                                   long refcon)
 643 {
 644     DescType type;
 645     Size size;
 646
 647     if (AEGetAttributePtr(req, keyMissedKeywordAttr, typeWildCard,
 648                           &type, NULL, 0, &size) == noErr)
 649         return errAEParamMissed;
 650
 651     borednow = 1;
 652     return noErr;
 653 }
 654
 655 void cleanup_exit(int status)
 656 {
 657
 658 #if !TARGET_RT_MAC_CFM
 659     if (mac_gestalts.encvvers != 0)
 660         TerminateUnicodeConverter();
 661 #endif
 662     sk_cleanup();
 663     exit(status);
 664 }
 665
 666 void fatalbox(char *fmt, ...) {
 667     va_list ap;
 668     Str255 stuff;
 669
 670     va_start(ap, fmt);
 671     /* We'd like stuff to be a Pascal string */
 672     stuff[0] = vsprintf((char *)(&stuff[1]), fmt, ap);
 673     va_end(ap);
 674     ParamText(stuff, NULL, NULL, NULL);
 675     StopAlert(128, NULL);
 676     cleanup_exit(1);
 677 }
 678
 679 void modalfatalbox(char *fmt, ...) {
 680     va_list ap;
 681     Str255 stuff;
 682
 683     va_start(ap, fmt);
 684     /* We'd like stuff to be a Pascal string */
 685     stuff[0] = vsprintf((char *)(&stuff[1]), fmt, ap);
 686     va_end(ap);
 687     ParamText(stuff, NULL, NULL, NULL);
 688     StopAlert(128, NULL);
 689     cleanup_exit(1);
 690 }
 691
 692 /* This should only kill the current session, not the whole application. */
 693 void connection_fatal(void *fontend, char *fmt, ...) {
 694     va_list ap;
 695     Str255 stuff;
 696
 697     va_start(ap, fmt);
 698     /* We'd like stuff to be a Pascal string */
 699     stuff[0] = vsprintf((char *)(&stuff[1]), fmt, ap);
 700     va_end(ap);
 701     ParamText(stuff, NULL, NULL, NULL);
 702     StopAlert(128, NULL);
 703     cleanup_exit(1);
 704 }
 705
 706 /* Null SSH agent client -- never finds an agent. */
 707
 708 int agent_exists(void)
 709 {
 710
 711     return FALSE;
 712 }
 713
 714 void agent_query(void *in, int inlen, void **out, int *outlen)
 715 {
 716
 717     *out = NULL;
 718     *outlen = 0;
 719 }
 720
 721 /* Temporary null routines for testing. */
 722
 723 void verify_ssh_host_key(void *frontend, char *host, int port, char *keytype,
 724                          char *keystr, char *fingerprint)
 725 {
 726
 727 }
 728
 729 void askcipher(void *frontend, char *ciphername, int cs)
 730 {
 731
 732 }
 733
 734 void old_keyfile_warning(void)
 735 {
 736
 737 }
 738
 739 char *platform_default_s(char const *name)
 740 {
 741     long smfs;
 742     Str255 pname;
 743     static char cname[256];
 744
 745     if (!strcmp(name, "Font")) {
 746         smfs = GetScriptVariable(smSystemScript, smScriptMonoFondSize);
 747         if (smfs == 0)
 748             smfs = GetScriptVariable(smRoman, smScriptMonoFondSize);
 749         if (smfs != 0) {
 750             GetFontName(HiWord(smfs), pname);
 751             if (pname[0] == 0)
 752                 return "Monaco";
 753             p2cstrcpy(cname, pname);
 754             return cname;
 755         } else
 756             return "Monaco";
 757     }
 758     return NULL;
 759 }
 760
 761 int platform_default_i(char const *name, int def)
 762 {
 763     long smfs;
 764
 765     if (!strcmp(name, "FontHeight")) {
 766         smfs = GetScriptVariable(smSystemScript, smScriptMonoFondSize);
 767         if (smfs == 0)
 768             smfs = GetScriptVariable(smRoman, smScriptMonoFondSize);
 769         if (smfs != 0)
 770             return LoWord(smfs);
 771         else
 772             return 9;
 773     }
 774
 775     /* Non-raw cut and paste of line-drawing chars works badly on the
 776      * current Unix stub implementation of the Unicode functions.
 777      * So I'm going to temporarily set the default to raw mode so
 778      * that the failure mode isn't quite so drastically horrid.
 779      * When Unicode comes in, this can all be put right. */
 780     if (!strcmp(name, "RawCNP"))
 781         return 1;
 782     return def;
 783 }
 784
 785 void platform_get_x11_auth(char *display, int *proto,
 786                            unsigned char *data, int *datalen)
 787 {
 788     /* SGT: I have no idea whether Mac X servers need anything here. */
 789 }
 790
 791 /*
 792  * Local Variables:
 793  * c-file-style: "simon"
 794  * End:
 795  */