home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / C / Applications / Eudora 1.3.1 / source / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-16  |  29.0 KB  |  1,212 lines  |  [TEXT/MPS ]
  1. #define FILE_NUM 22
  2. /* Copyright (c) 1990-1992 by the University of Illinois Board of Trustees */
  3. #pragma load EUDORA_LOAD
  4. #pragma segment Main
  5. #ifdef    KERBEROS
  6. #include                <krb.h>
  7. #endif
  8.  
  9. #define TICKS2MINS 3600
  10.  
  11.     Boolean HandleEvent(EventRecord *event);
  12.     extern void UnloadSegments(void);
  13.     void HouseKeeping(long activeTicks);
  14.     void DoKeyDown(WindowPtr topWin,EventRecord *event);
  15.     void DoMouseDown(WindowPtr topWin,EventRecord *event);
  16.     Boolean DoUpdate(WindowPtr topWin,EventRecord *event);
  17.     Boolean DoActivate(WindowPtr topWin,EventRecord *event);
  18.     Boolean DoApp4(WindowPtr topWin,EventRecord *event);
  19.     Boolean DoApp1(MyWindowPtr topWin,EventRecord *event);
  20.     void DoContentClick(MyWindowPtr topWin,MyWindowPtr win,EventRecord *event);
  21.     void NotifyNewMail(void);
  22.     void NewMailSound(void);
  23.     Boolean DoDisk(long message);
  24.     void TendNotificationManager(Boolean isActive);
  25.     long CloseUnused(void);
  26.  
  27. #ifndef KERBEROS
  28. void main()
  29. #else
  30. void c_main()
  31. #endif
  32. {
  33.     EventRecord theEvent;
  34.     MyWindowPtr topWin;
  35.     Boolean active=True;
  36.     long houseTicks=0;
  37.     long activeTicks=TickCount();
  38.     
  39.     /*
  40.      * perform set-up, including initializing mac managers
  41.      */
  42.     UnloadSegments();
  43.     Initialize();
  44.     UnloadSegments();
  45.  
  46.     /*
  47.      * run the event loop
  48.      */
  49.     while (!EjectBuckaroo && !Done)
  50.     {
  51. #ifdef DEBUG
  52.     if (BUG3 && !FrontWindow())
  53.     {
  54.         Str63 s;
  55.         long grow, newFree;
  56.         static long oldFree=1L<<30;
  57.         (void) MaxMem(&grow);
  58.         newFree = FreeMem();
  59.         if (oldFree>newFree)
  60.         {
  61.             DebugStr(ComposeString(s,"\p#%d;ht;g",oldFree-newFree));
  62.             AlertStr(OK_ALRT,Stop,ComposeString(s,
  63.              "\pLeak? was %d, now %d (%d)",oldFree,newFree,oldFree-newFree));
  64.         }
  65.         oldFree = newFree;
  66.     }
  67. #endif
  68. #ifdef DEBUG
  69.         if (BUG6) DebugStr("\p;hc;g");
  70. #endif
  71.         CommandPeriod = False;
  72.         
  73.         /*
  74.          * allocate a window here, in case we need it later
  75.          */
  76.         if (!HandyWindow)
  77.         {
  78.             HandyWindow = New(MyWindow);
  79.             if (HandyWindow != nil) WriteZero(HandyWindow,sizeof(MyWindow));
  80.         }
  81.         
  82.         /*
  83.          * handle any events we might come across 
  84.          */
  85.         active = GrabEvent(&theEvent) ? HandleEvent(&theEvent) : False;
  86.         if (active)
  87.             activeTicks = TickCount();
  88.         
  89.         TendNotificationManager(active);
  90.         
  91.         if (TickCount()-houseTicks > 120)
  92.         {
  93.             HouseKeeping(TickCount()-activeTicks);
  94.             houseTicks = TickCount();
  95.         }
  96.  
  97. #ifndef SLOW_CLOSE
  98.         /*
  99.      * destroy defunct streams
  100.        */
  101.         TcpFastFlush(False);
  102. #endif
  103.             
  104.         /*
  105.          * blink caret, if need be
  106.          */
  107.         topWin = FrontWindow();
  108.         if (topWin && IsMyWindow(topWin) && !InBG)
  109.         {
  110.             if (topWin->txe) TEIdle(topWin->txe);
  111.             else if (topWin->ste) TEIdle((*(STEHandle)topWin->ste)->te);
  112.         }
  113.         
  114.         /*
  115.          * write dirty toc's
  116.          */
  117.         if (!PrefIsSet(PREF_CORVAIR)) FlushTOCs(False,True);
  118.         
  119.         /*
  120.          * cursor & help
  121.          */
  122.         if (SFWTC) SetCursorByLocation();
  123.         if (theEvent.what==nullEvent && HasHelp && !InBG && HMGetBalloons())
  124.             DoHelp(topWin);
  125.                     
  126.         /*
  127.          * here's an interesting little goodie
  128.          */
  129.         if (theEvent.what==nullEvent && !InBG && AliasWinIsOpen() &&
  130.                 FrontWindow() && IsMyWindow(FrontWindow()) &&
  131.                 ((MyWindowPtr)(FrontWindow()))->txe && PrefIsSet(PREF_NICK_FOLLOW))
  132.         {
  133.             switch (((MyWindowPtr)(FrontWindow()))->qWindow.windowKind)
  134.             {
  135.                 case COMP_WIN:
  136.                 case TEXT_WIN:
  137.                     FinishAlias(FrontWindow(),False,True);
  138.                     break;
  139.                 default: break;
  140.             }
  141.         }
  142.  
  143.         /*
  144.          * Unload all segments
  145.          */
  146.         UnloadSegments();
  147.         
  148.         /*
  149.          * debugging...
  150.          */
  151. #ifdef DEBUG
  152.         {
  153.             extern void **AliasGlobals;
  154.             ASSERT(!AliasGlobals || Notes && *Notes);
  155.         }
  156. #endif
  157.         
  158.         /*
  159.          * all windows are fair game
  160.          */
  161.         NotUsingAllWindows();
  162.         if (EjectBuckaroo) DoQuit();
  163.     }
  164.     if (PrefIsSet(PREF_AUTO_EMPTY)) EmptyTrash();
  165.     FlushTOCs(True,False);
  166.     Cleanup();
  167. }
  168. /************************************************************************
  169.  * HouseKeeping - periodic cleanup functions
  170.  ************************************************************************/
  171. void HouseKeeping(long activeTicks)
  172. {
  173.     static long flushTicks=0;
  174.  
  175.     if (activeTicks)
  176.     {
  177.         long ivalTicks = TICKS2MINS * GetRLong(PREF_STRN+PREF_INTERVAL);
  178.  
  179.         /*
  180.          * warn the user if we're growing low (get it) on memory
  181.          */
  182.         MonitorGrow();
  183.     
  184.         /*
  185.          * check mail?
  186.          */
  187.         if (activeTicks > 60*60)
  188.         {
  189.             if (ivalTicks && (!CheckTicks || TickCount()-CheckTicks > ivalTicks))
  190.             {
  191.                 if (!(CurrentModifiers()&optionKey))
  192.                 {
  193.                     CheckForMail(False);
  194.                 }
  195.             }
  196.             if (ForceSend <= GMTDateTime()) {SetSendQueue();DoSendQueue();}
  197.         }
  198.         
  199.         /*
  200.          * close unneeded TOC's
  201.          */
  202.         FlushTOCs(True,True);
  203.         
  204.         /*
  205.          * just for good measure
  206.          */
  207.         if (TickCount()-flushTicks > 60*GetRLong(FLUSH_SECS))
  208.         {
  209.             FlushVol(nil,MyVRef);
  210.             flushTicks = TickCount();
  211.         }
  212.         
  213.         /*
  214.          * The resolver may have left us little poodle bombs...
  215.          */
  216.         FlushHIQ();
  217.         
  218.         /*
  219.          * and logging...
  220.          */
  221.         if (!(LogLevel&LOG_EVENT)) CloseLog();
  222.         
  223.         /*
  224.          * and that pesky settings file
  225.          */
  226.         UpdateResFile(SettingsRefN);
  227.         
  228.         /*
  229.          * for debugging
  230.          */
  231. #ifdef DEBUG
  232.         if (BUG7)
  233.         {
  234.             long bytes;
  235.             MaxMem(&bytes);
  236.         }
  237. #endif
  238.     }
  239. }
  240.  
  241. /**********************************************************************
  242.  * HandleEvent - handle an event
  243.  **********************************************************************/
  244. Boolean HandleEvent(EventRecord *event)
  245. {
  246.     WindowPtr topWin = FrontWindow();     /* in case we need to know */
  247.     Boolean active=False;
  248.     
  249.     if (IsDialogEvent(event))
  250.     {
  251.       DoModelessEvent(event);
  252.         return(True);
  253.     }
  254.  
  255.     if (topWin)
  256.     {
  257.         SetPort(topWin);
  258.         UsingWindow(topWin);
  259.     }
  260.     else
  261.         SetPort(InsurancePort);
  262.     /*
  263.      * slog through all the events...
  264.      */
  265.     switch (event->what)
  266.     {
  267.         case keyDown:
  268.         case autoKey:
  269.             /*if (HasHelp && HMIsBalloon()) HMRemoveBalloon();*/
  270.             DoKeyDown(topWin,event);
  271.             active = True;
  272.             break;
  273.         
  274.         case mouseUp:
  275.         case mouseDown:
  276.             /*if (HasHelp && HMIsBalloon()) HMRemoveBalloon();*/
  277.             DoMouseDown(topWin,event);
  278.             active = True;
  279.             break;
  280.             
  281.         case updateEvt:
  282.             DoUpdate(topWin,event);
  283.             break;
  284.             
  285.         case activateEvt:
  286.             if (!InBG) DoActivate(topWin,event);
  287.             break;
  288.             
  289.         case app4Evt:
  290.             active = DoApp4(topWin,event);
  291.             break;
  292.             
  293.         case app1Evt:
  294.             active = DoApp1(topWin,event);
  295.             break;
  296.             
  297.         case diskEvt:
  298.             active = DoDisk(event->message);
  299.             break;
  300.     }
  301.     if (!ForceSend) SetSendQueue();    /* a message from beyond */
  302.     EnableMenus(FrontWindow());     /* enable the correct menu items */
  303.     return(active);
  304. }
  305.  
  306. /************************************************************************
  307.  *
  308.  ************************************************************************/
  309. Boolean DoDisk(long message)
  310. {
  311.     if ((message>>16)&0xffff)
  312.     {
  313.         Point pt;
  314.         pt.h = pt.v = 50;
  315.         DILoad();
  316.         (void) DIBadMount(pt,message);
  317.         DIUnload();
  318.     }
  319.     return(True);
  320. }
  321.  
  322. /**********************************************************************
  323.  * DoApp4 - handle an app4 event; suspend/resume/mouse
  324.  **********************************************************************/
  325. Boolean DoApp4(WindowPtr topWin,EventRecord *event)
  326. {
  327.     if (((event->message>>24)&0xff) == 0xfa)
  328.     {
  329.         SFWTC = True;
  330.         return(False);
  331.     }
  332.     else
  333.     {
  334.         if (((event->message)>>24)&1 == 1)
  335.         {
  336.             if (!InBG)
  337.             {
  338.                 EnableProgress();
  339.                 SFWTC = True;
  340.             }
  341.             else
  342.                 DisableProgress();
  343.             if (CnH) CMResume(CnH,!InBG);
  344.             if (topWin && ((WindowPeek)topWin)->windowKind >= userKind)
  345.                 ActivateMyWindow(topWin,!InBG);
  346.         }
  347.         return(!InBG);
  348.     }
  349. }
  350.  
  351. /**********************************************************************
  352.  * DoApp1 - handle an app1 event; scrolling by saratoga keys
  353.  **********************************************************************/
  354. Boolean DoApp1(MyWindowPtr topWin,EventRecord *event)
  355. {
  356.     if (topWin && IsMyWindow(topWin))
  357.     {
  358.         if (topWin->app1 && (*topWin->app1)(topWin,event))
  359.             ;
  360.       else if (topWin->ste) STEApp1(topWin->ste,event);
  361.         else if (topWin->vBar)
  362.             switch(event->message & charCodeMask)
  363.             {
  364.                 case homeChar:
  365.                     ScrollIt(topWin,INFINITY,INFINITY);
  366.                     break;
  367.                 case endChar:
  368.                     ScrollIt(topWin,0,-INFINITY);
  369.                     break;
  370.                 case pageUpChar:
  371.                     ScrollIt(topWin,0,
  372.                         RoundDiv(topWin->contR.bottom-topWin->contR.top,topWin->vPitch)-1);
  373.                     break;
  374.                 case pageDownChar:
  375.                     ScrollIt(topWin,0,
  376.                         RoundDiv(topWin->contR.top-topWin->contR.bottom,topWin->vPitch)+1);
  377.                     break;
  378.             }
  379.     }
  380.     return(True);
  381. }
  382.  
  383. /**********************************************************************
  384.  * DoKeyDown - handle a keystroke aimed at a window
  385.  **********************************************************************/
  386. void DoKeyDown(WindowPtr topWin,EventRecord *event)
  387. {
  388.     long select;
  389.     short c = UnadornMessage(event)&0xff;
  390.  
  391.     /*
  392.      * handle key equivalents
  393.      */
  394.     if (event->modifiers&cmdKey)
  395.     {
  396.         if (select=MyMenuKey(event))
  397.         {
  398.             DoMenu(topWin,select,event->modifiers);
  399.             return;
  400.         }
  401.     }
  402.     if (topWin && ((WindowPeek)topWin)->windowKind >= userKind)
  403.     {
  404.         MyWindowPtr mw = (MyWindowPtr) topWin;
  405.         TEHandle teh = WinTEH(mw);
  406.         
  407.         SetPort(mw);
  408.         if (mw->key)
  409.             (*mw->key)(mw,event);
  410.         else if (event->modifiers&cmdKey)
  411.             SysBeep(20L);
  412.         else if (!teh)
  413.             AlertStr(NOT_HOME_ALRT, Stop, nil);
  414.         else if (mw->ro && DirtyKey(event->message))
  415.             AlertStr(READ_ONLY_ALRT, Stop, nil);
  416.         else
  417.         {
  418.             TEActivate(teh);
  419.             if ((event->message&0xff)==tabKey)
  420.                 TEFakeTab(mw,GetRLong(TAB_DISTANCE));
  421.             else
  422.                 TESomething(mw,TEKEY,event->message&charCodeMask,event->modifiers);
  423.         }
  424.     }
  425.     else if (event->modifiers&cmdKey)
  426.         SysBeep(20L);
  427.     else
  428.         StopAlert(NOT_HOME_ALRT, nil);
  429. }
  430.  
  431. pascal void Hook(void)
  432. {
  433.     if (RunType != Production && CurrentModifiers()&controlKey)
  434.     {
  435.         Handle fkey3;
  436.         if (fkey3 = GetResource('FKEY',3))
  437.         {
  438.             (*(ProcPtr)LDRef(fkey3))();
  439.             UL(fkey3);
  440.         }
  441.         else SysBeep(10);
  442.     }
  443. }
  444.  
  445. /**********************************************************************
  446.  * DoMouseDown - handle a mouse-down event, goodness knows where
  447.  **********************************************************************/
  448. void DoMouseDown(WindowPtr topWin,EventRecord *event)
  449. {
  450.     static Point downSpot;    /* Point of previous mouseDown */
  451.     static long upTicks;        /* time of previous mouseUp */
  452.     long dblTime;                        /* double-click time from PRAM */
  453.     long wPart;                         /* window part where click occurred */
  454.     MyWindowPtr win;                /* window where click occurred */
  455.     short tolerance;
  456.     long mSelect;
  457.     
  458.     if (event->what==mouseUp)
  459.     {
  460.         upTicks = event->when-1;
  461.         return;
  462.     }
  463.     
  464.     dblTime = GetDblTime();
  465.     tolerance = GetRLong(DOUBLE_TOLERANCE);
  466.     
  467.     /*
  468.      * figure out whether this is a double or triple click,
  469.      * and update double and triple click times
  470.      */
  471.     if (event->when!=upTicks && event->when-upTicks<dblTime)
  472.     {
  473.         int dx = event->where.h - downSpot.h;
  474.         int dy = event->where.v - downSpot.v;
  475.         if (ABS(dx)<tolerance && ABS(dy)<tolerance && !(event->modifiers&cmdKey))
  476.         {
  477.             /* upgrade the click */
  478.             ClickType++;
  479.             if (ClickType > Triple) ClickType = Single;
  480.         }
  481.         else
  482.             ClickType = Single;
  483.     }
  484.     else
  485.         ClickType = Single;
  486.         
  487.     upTicks = event->when;            /* ignore two downs in a row as far as clicktype */
  488.     downSpot = event->where;
  489.     
  490.     /*
  491.      * where was the click?
  492.      */
  493.     wPart = FindWindow(event->where,&win);
  494.     if (CnH && win && (long)CnH==win->qWindow.refCon)
  495.         CMEvent(CnH,event);
  496.     else
  497.         switch (wPart)
  498.         {
  499.             case inMenuBar:
  500.                 EnableMenuItems();
  501.                 mSelect = MenuSelect(event->where);
  502.                 DoMenu(topWin,mSelect,CurrentModifiers());
  503.                 break;
  504.             case inSysWindow:
  505.                 SystemClick(event,win);
  506.                 break;
  507.             case inDrag:
  508.                 DragMyWindow(win,event->where);
  509.                 break;
  510.             case inZoomIn:
  511.             case inZoomOut:
  512.                 if (IsMyWindow(win)) win->saveSize = True;
  513.                 ZoomMyWindow(win,event->where,wPart);
  514.                 break;
  515.             case inGrow:
  516.                 if (!(win->qWindow.windowKind==dialogKind ||
  517.                         win->qWindow.windowKind>=userKind && win->isRunt))
  518.                 {
  519.                     GrowMyWindow(win,event->where);
  520.                     break;
  521.                 }
  522.                 /* fall-through is deliberate */
  523.             case inContent:
  524.                 Undo.didClick = True;
  525.                 DoContentClick(topWin,win,event);
  526.                 break;
  527.             case inGoAway:
  528.                 if (event->modifiers & optionKey)
  529.                     CloseAll();
  530.                 else
  531.                     GoAwayMyWindow(win,event->where);
  532.                 break;
  533.         }
  534. }
  535.  
  536. /**********************************************************************
  537.  * DoContentClick - handle a click in the content region of a window
  538.  **********************************************************************/
  539. void DoContentClick(MyWindowPtr topWin,MyWindowPtr win,EventRecord *event)
  540. {
  541.     Point pt;
  542.     Rect r;
  543.     
  544.     if (win != (MyWindowPtr)topWin)
  545.     {
  546.         SelectWindow(win);
  547.         if (IsMyWindow(win) && win->hot) HandleEvent(event); /* resubmit */
  548.     }
  549.     else
  550.     {
  551.         SetPort(win);
  552.         pt = event->where;
  553.         GlobalToLocal(&pt);
  554.         if (!win->dontControl && HandleControl(pt,win))
  555.             ;
  556.         else if (((WindowPeek)win)->windowKind > userKind)
  557.         {
  558.             if (win->click)
  559.                 (*win->click)(win,event);
  560.             else if (win->ste && ((r=(*(STEHandle)win->ste)->encloseR),PtInRect(pt,&r)))
  561.                 STEClick(win->ste,event);
  562.         }
  563.     }
  564. }
  565.  
  566.  
  567. /************************************************************************
  568.  * 
  569.  ************************************************************************/
  570. Boolean HandleControl(Point pt, MyWindowPtr win)
  571. {
  572.     int part;
  573.     int oldValue, difference;
  574.     ControlHandle cntl;
  575.  
  576.     if (part = FindControl(pt,win,&cntl))
  577.     {
  578.         if ((*cntl)->contrlRfCon!='GREY')
  579.         {
  580.             oldValue = GetCtlValue(cntl);
  581.             part = TrackControl(cntl,pt,part==inThumb ? nil : (UPtr)(-1));
  582.             if (part==inThumb)
  583.             {
  584.                 difference = oldValue - GetCtlValue(cntl);
  585.                 if (difference)
  586.                 {
  587.                     if (ScrollIsH(cntl))
  588.                         ScrollMyWindow(win,difference,0);
  589.                     else
  590.                         ScrollMyWindow(win,0,difference);
  591.                     UpdateMyWindow(win);
  592.                 }
  593.             }
  594.             else if (win->button)
  595.                 (*win->button)(win,cntl,CurrentModifiers(),part);
  596.         }
  597.       return(True);
  598.     }
  599.     return(False);
  600. }
  601.  
  602. /**********************************************************************
  603.  * DoUpdate - handle an update event
  604.  **********************************************************************/
  605. Boolean DoUpdate(WindowPtr topWin,EventRecord *event)
  606. {
  607. #pragma unused(topWin)
  608.     MyWindowPtr win;
  609.     
  610.     win = (MyWindowPtr)event->message;
  611.     if (CnH && win->qWindow.refCon==(long)CnH)
  612.     {
  613.         CMEvent(CnH,event);
  614.         return(False);
  615.     }
  616.     if (IsMyWindow(win))
  617.     {
  618.         UpdateMyWindow(win);
  619.         return(False);
  620.     }
  621.     return(True);    /* somebody else better do this one */
  622. }
  623.  
  624. /**********************************************************************
  625.  * DoActivate - handle an activate event (and a prior deactivate, to boot)
  626.  **********************************************************************/
  627. Boolean DoActivate(WindowPtr topWin,EventRecord *event)
  628. {
  629. #pragma unused(topWin)
  630.     MyWindowPtr win;
  631.     Boolean active = !InBG && (event->modifiers&activeFlag)!=0;
  632.     Boolean yours = False;
  633.     
  634.     win = (MyWindowPtr) event->message;
  635.     if (CnH && (long)CnH==win->qWindow.refCon)
  636.         CMActivate(CnH,active);
  637.     else if (IsMyWindow(win))
  638.     {
  639.         if (active != win->isActive)
  640.             ActivateMyWindow(win,(event->modifiers&activeFlag)!=0);
  641.     }
  642.     else
  643.         yours=True;
  644.     SFWTC=True;
  645.     return(yours);
  646. }
  647.  
  648. /**********************************************************************
  649.  * WarnUser - tell the user that something bad is happening
  650.  **********************************************************************/
  651. int WU(int errorStr,int errorNum,int file,int line)
  652. {
  653.     Str255 message;
  654.     
  655.     ComposeRString(message,WU_FMT,errorStr,errorNum,file,line);
  656.     (void) AlertStr(OK_ALRT,Caution,message);
  657.     return(errorNum);
  658. }
  659.  
  660. /**********************************************************************
  661.  * DieWithError - die with the given error message
  662.  **********************************************************************/
  663. void DWE(int errorStr,int errorNum,int file,int line)
  664. {
  665.     Str255 fatal;
  666.     Str255 message;
  667.     Str255 number;
  668.     Str255 debugStr;
  669.     
  670.     GetRString(fatal,FATAL);
  671.     GetRString(message,errorStr);
  672.     NumToString((long)errorNum,number);
  673.     ComposeRString(debugStr,FILE_LINE_FMT,file,line);
  674.     MyParamText(fatal,message,number,debugStr);
  675.     (void) ReallyDoAnAlert(ERR_ALRT,Stop);
  676.     Cleanup();
  677.     ExitToShell();
  678. }
  679.  
  680. /**********************************************************************
  681.  * DumpData - put up an alert that shows some data.
  682.  **********************************************************************/
  683. void DumpData(UPtr description, UPtr data,int length)
  684. {
  685.     Str255 asAscii;
  686.     Str255 asHex;
  687.     static char hex[]="0123456789abcdef";
  688.     char *ac, *hx;
  689.     char *from;
  690.     
  691.     if (length > 255/2) length = 255/2;
  692.     
  693.     /*
  694.      * prepare display strings
  695.      */
  696.     *asAscii = 2*length;
  697.     *asHex = 2*length;
  698.     ac=asAscii+1;
  699.     hx=asHex+1;
  700.     for (from=data; from<data+length;from++)
  701.     {
  702.         *ac++ = optSpace;
  703.         if (*from==' ')
  704.             *ac++ = optSpace;
  705.         else if (*from<' ')
  706.             *ac++='.';
  707.         else
  708.             *ac++ = *from;
  709.         *hx++ = hex[((*from)>>4)&0xf];
  710.         *hx++ = hex[(*from)&0xf];
  711.     }
  712.     
  713.     SetDAFont(monaco);
  714.     MyParamText(description,asAscii,asHex,"");
  715.     switch (Alert(DUMP_ALRT,nil))
  716.     {
  717.         case DEBUG_BUTTON: Debugger(); break;
  718.         case EXIT_BUTTON:  Cleanup(); ExitToShell(); break;
  719.     }
  720.     SetDAFont(applFont);
  721. } 
  722.  
  723. /**********************************************************************
  724.  * monitor the heap situation
  725.  **********************************************************************/
  726. void MonitorGrow(void)
  727. {
  728.     static long memLeft = SPARE_SIZE;
  729.     long roomLeft = GetHandleSize(SpareSpace);
  730.     long roomAvailable;
  731.     
  732.     if (roomLeft < memLeft)
  733.     {
  734.         UnloadUnneeded(1L<<29);
  735.         FlushTOCs(True,True);
  736.         UnloadUnneeded(1L<<29);
  737.         if (memLeft==SPARE_SIZE || roomLeft+10K<memLeft || roomLeft<MEM_CRITICAL)
  738.             MemoryWarning();
  739.     }
  740.     
  741.     if (roomLeft < memLeft || roomLeft<MEM_CRITICAL)
  742.     {
  743.         memLeft = roomLeft;
  744.         DisposHandle(SpareSpace);
  745.         roomAvailable = CompactMem(SPARE_SIZE);
  746.         if (roomAvailable < SPARE_SIZE)
  747.             roomAvailable = MaxMem(&roomLeft);
  748.         if (roomAvailable > SPARE_SIZE) roomAvailable = SPARE_SIZE;
  749.         MakeGrow(roomAvailable);
  750.     }
  751. }
  752.  
  753. /************************************************************************
  754.  * MemoryWarning - warn the user about how much memory is left.
  755.  ************************************************************************/
  756. MemoryWarning(void)
  757. {
  758.     Str255 partitionString,warningString;
  759.     long currentSize, estSize, spareSize;
  760.     
  761.     currentSize = CurrentSize();
  762.     estSize = EstimatePartitionSize();
  763.     spareSize = GetHandleSize(SpareSpace);
  764.     estSize = MAX(estSize,SPARE_SIZE-spareSize+currentSize);
  765.     (void) ComposeRString(partitionString,MEM_PARTITION,currentSize/(1K),
  766.                                                 estSize/(1K));
  767.     GetRString(warningString,MEM_LOW);
  768.     MyParamText(warningString,partitionString,"\p\n\n\n","");
  769.     if (ReallyDoAnAlert(MEMORY_ALRT,Caution)==MEMORY_QUIT) EjectBuckaroo=True;
  770. }
  771.  
  772. /************************************************************************
  773.  * CurrentSize - how big is our partition?
  774.  ************************************************************************/
  775. long CurrentSize(void)
  776. {
  777.     SizeHandle sizeH;
  778.     long size=0;
  779.     
  780.     if (sizeH = GetResource('SIZE',0))
  781.     {
  782.         size = (*sizeH)->prefSize;
  783.         ReleaseResource(sizeH);
  784.         return(size);
  785.     }
  786.     else return(DefaultSize());
  787. }
  788.  
  789. /************************************************************************
  790.  * DefaultSize - how big is Eudora's normal partition?
  791.  ************************************************************************/
  792. long DefaultSize(void)
  793. {
  794.     SizeHandle sizeH;
  795.     long size=0;
  796.     
  797.     if (sizeH = GetResource('SIZE',-1))
  798.     {
  799.         size = (*sizeH)->prefSize;
  800.         ReleaseResource(sizeH);
  801.     }
  802.     return(size);
  803. }
  804.  
  805. /************************************************************************
  806.  * EstimatePartitionSize - estimate the "right" size for Eudora
  807.  ************************************************************************/
  808. long EstimatePartitionSize(void)
  809. {
  810.     HFileInfo info;
  811.   Str63 scratch;
  812.     Str31 suffix;
  813.     uLong drain = 0;
  814.     static short strids[] = {IN,OUT,TRASH,ALIAS_FILE};
  815.     short id;
  816.     MyWindowPtr win;
  817.     
  818.     GetRString(suffix,TOC_SUFFIX);
  819.     
  820.     for (id=0;id<sizeof(strids)/sizeof(short);id++)
  821.     {
  822.         GetRString(scratch,strids[id]);
  823.         if (strids[id]!=ALIAS_FILE) PCat(scratch,suffix);
  824.         if (!HGetFileInfo(MyVRef,MyDirId,scratch,&info))
  825.             drain+=info.ioFlLgLen;
  826.     }
  827.     
  828.     for (win=FrontWindow();win;win=win->qWindow.nextWindow)
  829.     {
  830.         drain += sizeof(MyWindow);
  831.         switch (win->qWindow.windowKind)
  832.         {
  833.             case COMP_WIN:
  834.             case MESS_WIN:
  835.                 drain += (*BodyOf((MessHandle)win->qWindow.refCon))->teLength;
  836.                 break;
  837.             case TEXT_WIN:
  838.                 drain += (*(*(STEHandle)win->ste)->te)->teLength;
  839.                 break;
  840.             case MBOX_WIN:
  841.             case CBOX_WIN:
  842.                 if (!(*(TOCHandle)win->qWindow.refCon)->which)
  843.                     drain += GetHandleSize((TOCHandle)win->qWindow.refCon);
  844.                 break;
  845.             default:
  846.                 drain += 1K;
  847.         }
  848.     }
  849.      return(DefaultSize()+drain-24K);
  850. }
  851.  
  852. /**********************************************************************
  853.  * create some space for the grow zone function
  854.  **********************************************************************/
  855. void MakeGrow(long howMuch)
  856. {
  857.     if (SpareSpace = NuHandle(howMuch)) *(long *)*SpareSpace = 'SPAR';
  858. }
  859.  
  860. /**********************************************************************
  861.  * grow that zone...
  862.  **********************************************************************/
  863. pascal long GrowZone(unsigned long needed)
  864. {
  865.     long roomLeft;
  866.     long freed=0;
  867.     long theA5=SetCurrentA5();
  868.     Handle dontMove = GZSaveHnd();
  869.     PScrapStuff scrap;
  870.     
  871.     if (freed = UnloadUnneeded(needed))
  872.         ;
  873.     else if (scrap=InfoScrap(),scrap->scrapHandle&&dontMove!=scrap->scrapHandle&&GetHandleSize(scrap->scrapHandle))
  874.     {
  875.         freed = GetHandleSize(scrap->scrapHandle);
  876.         if (UnloadScrap()) ZeroScrap();                /* if we can't write it, kill it */
  877.         return(freed);
  878.     }
  879. #ifndef SLOW_CLOSE
  880.     else if (FastList)
  881.     {
  882.         TcpFastFlush(True);
  883.         return(1);
  884.     }
  885. #endif
  886.     else if (roomLeft = GetHandleSize(SpareSpace))
  887.     { 
  888.         freed = needed <= roomLeft ? needed : roomLeft;
  889.         SetHandleSize(SpareSpace,roomLeft - freed);
  890. #ifdef NEVER
  891.         if (RunType != Production) DebugStr("\pSPARE!");
  892. #endif
  893.     }
  894.     else if (Undo.text && Undo.text != dontMove)
  895.     {
  896.         freed = GetHandleSize(Undo.text);
  897.         ZapHandle(Undo.text);
  898.     }
  899.     else if (DamagedTOC && DamagedTOC != dontMove)
  900.     {
  901.         freed = GetHandleSize(DamagedTOC);
  902.         ZapHandle(DamagedTOC);
  903.     }
  904.     else
  905.     {
  906.         freed = CloseUnused();
  907.     }
  908.     (void) SetA5(theA5);
  909.     return(freed);
  910. }
  911.  
  912. /************************************************************************
  913.  * CloseUnused - close unused windows
  914.  ************************************************************************/
  915. long CloseUnused(void)
  916. {
  917.     static short kinds[] = {MB_WIN,PH_WIN,TEXT_WIN,ALIAS_WIN,MESS_WIN,COMP_WIN};
  918.     MyWindowPtr win,deadWin=nil;
  919.     short kind;
  920.     
  921.     for (kind=0;kind<sizeof(kinds)/sizeof(short);kind++)
  922.     {
  923.         for (win=FrontWindow();win;win=win->qWindow.nextWindow)
  924.         {
  925.             if (win->qWindow.windowKind==kinds[kind] && !win->isDirty && !win->inUse)
  926.                 if (kinds[kind]!=MESS_WIN || Win2Body(win)==WinTEH(win)) deadWin = win;
  927.         }
  928.         if (deadWin)
  929.         {
  930.             if (!CloseMyWindow(deadWin))
  931.             {
  932.                 UsingWindow(deadWin);        /* couldn't close it ??? */
  933.                 deadWin = nil;
  934.                 kind--;    /* try again with this kind */
  935.             }
  936.             else
  937.             {
  938.                 return(1);
  939.             }
  940.         }
  941.     }
  942.     return(0);
  943. }
  944.         
  945. /**********************************************************************
  946.  * FileSystemError - report an error regarding the file system
  947.  **********************************************************************/
  948. int FSE(int context, UPtr name, int err, int file,int line)
  949. {
  950.     Str255 text;
  951.     Str255 contextStr;
  952.     Str63 debugStr;
  953.     Str127 nameStr;
  954.     int offset = 0;
  955.     
  956.     PCopy(nameStr,name);
  957.     NumToString(err,text);
  958.     PCatC(text,' ');
  959.     if (err < wrPermErr) offset += wrPermErr-dirNFErr;
  960.     if (err < volGoneErr) offset += volGoneErr+127;
  961.     err += offset;
  962.     err = dirFulErr - err + 2;
  963.     if (err > 37) err = 37;
  964.     GetRString(contextStr,FILE_STRN+err);
  965.     PCat(text,contextStr);
  966.     GetRString(contextStr,context);
  967.     ComposeRString(debugStr,FILE_LINE_FMT,file,line);
  968.     MyParamText(contextStr,nameStr,text,debugStr);
  969.     (void) ReallyDoAnAlert(BIG_OK_ALRT,Stop);
  970.     return(err);
  971. }
  972.  
  973. /************************************************************************
  974.  * MiniMainLoop - handle only a limited set of events.    returns the event
  975.  * if someone else needs to handle it
  976.  ************************************************************************/
  977. Boolean MiniMainLoop(EventRecord *event)
  978. {
  979.     MyWindowPtr topWin=FrontWindow();
  980.     
  981. #ifdef DEBUG
  982.     if (BUG6) DebugStr("\p;hc;g");
  983.     if (BUG7)
  984.     {
  985.         long bytes;
  986.         MaxMem(&bytes);
  987.     }
  988. #endif
  989.     
  990.     TcpFastFlush(False);    /* give lingering connections a chance to die */
  991.  
  992.     switch (event->what)
  993.     {
  994.         case keyDown:
  995.             if (((event->message&charCodeMask)=='.') && (event->modifiers&cmdKey) ||
  996.                     ((event->message&charCodeMask)==escChar) &&
  997.                      (((event->message&keyCodeMask)>>8)==escKey))
  998.             {
  999.                 CommandPeriod = True;
  1000.                 return(False);
  1001.             }
  1002.             break;
  1003.         case app4Evt:
  1004.             if (((event->message)>>24)&1 == 1)
  1005.                 DoApp4(topWin,event);
  1006.             return(False);
  1007.         case updateEvt:
  1008.             return(DoUpdate(topWin,event));
  1009.             break;
  1010.         case activateEvt:
  1011.             return(DoActivate(topWin,event));
  1012.             break;
  1013.         case mouseDown:
  1014.             if (IsSwitch(event) && Switch())
  1015.             {
  1016.                 event->what=nullEvent;
  1017.                 InBG = True;
  1018.                 return(False);
  1019.             }
  1020.             break;
  1021.     }
  1022.  
  1023.     if (CnH && topWin && topWin->qWindow.refCon==(long)CnH)
  1024.     {
  1025.         CMEvent(CnH,event);
  1026.         return(False);
  1027.     }
  1028.     
  1029.     return(True); 
  1030. }
  1031.  
  1032. /************************************************************************
  1033.  * CheckForMail - need I say more?
  1034.  ************************************************************************/
  1035. void CheckForMail(Boolean setTicks)
  1036. {
  1037.     short err=0;
  1038.     long interval=TICKS2MINS * GetRLong(PREF_STRN+PREF_INTERVAL);
  1039.     short gotSome=0;
  1040.     Boolean sendToo = SendQueue && PrefIsSet(PREF_SEND_CHECK);
  1041.     Str255 user;
  1042.     
  1043.     GetAlrtStage() = 0;
  1044.     SetSendQueue(); FlushTOCs(True,True);
  1045.     if (interval && (setTicks || !CheckTicks)) CheckTicks = TickCount();
  1046. #ifndef KERBEROS
  1047.     GetPref(user,PREF_POP);
  1048.     if (UUPCIn || *Password || !GetPassword(user,Password,sizeof(Password),ENTER))
  1049. #else
  1050.     if (UUPCIn || GetPassword())
  1051. #endif
  1052.     {
  1053.         AlertsTimeout = PrefIsSet(PREF_AUTO_DISMISS);
  1054.         OpenProgress();
  1055. #ifdef POPSECURE
  1056.         if (UseCTB && !UUPCIn) err=DialThePhone();
  1057. #else
  1058.         if (UseCTB && (!UUPCIn || (!UUPCOut&&sendToo))) err=DialThePhone();
  1059. #endif
  1060.         if (!err)
  1061.         {
  1062.             if (sendToo)
  1063.             {
  1064.                 err=SendTheQueue();
  1065.                 CommandPeriod = False;    /* clear condition, continue with POP */
  1066.                 if (!UUPCIn && !UUPCOut && UseCTB && !err) CTBNavigateSTRN(NAVMID);
  1067.             }
  1068.             if (!UseCTB || !err)
  1069.             {
  1070.                 Handle table;
  1071.                 if (!NewTables && !TransIn && (table=GetResource('taBL',TRANS_IN_TABL)))
  1072.                 {
  1073.                   HNoPurge(table);
  1074.                     if (TransIn=NuPtr(256)) BlockMove(*table,TransIn,256);
  1075.                     HPurge(table);
  1076.                 }
  1077.  
  1078.                 gotSome = UUPCIn ? GetUUPCMail(True) : GetMyMail(True);
  1079.             }
  1080.         }
  1081.         if (UseCTB) HangUpThePhone();
  1082.         CloseProgress();
  1083.         EnableProgress();
  1084.         if (gotSome>0) NotifyNewMail();
  1085.         AlertsTimeout = False;
  1086.         if (TransIn) {DisposPtr(TransIn); TransIn=nil;}
  1087.     }
  1088.     if (UseCTB) HangUpThePhone();    /* just making sure... */
  1089.     if (interval && CheckTicks+interval<TickCount()+45*60)
  1090.     {
  1091.         CheckTicks += interval*((TickCount()-CheckTicks+1)/interval);
  1092.         if (CheckTicks+interval<TickCount()+45*60) CheckTicks += interval;
  1093.     }
  1094. }
  1095.  
  1096. /************************************************************************
  1097.  * NotifyNewMail - notify the user that new mail has arrived, via the
  1098.  * notification manager.
  1099.  ************************************************************************/
  1100. void NotifyNewMail(void)
  1101. {
  1102.     TOCHandle tocH;
  1103.     if (PrefIsSet(PREF_NEW_SOUND)) NewMailSound();
  1104.     if (!PrefIsSet(PREF_NO_OPEN_IN) && (tocH=GetInTOC()))
  1105.     {
  1106.             short i=(*tocH)->count;
  1107.             while (i--) if ((*tocH)->sums[i].state!=UNREAD) break;
  1108.             i++;
  1109.             RedoTOC(tocH);
  1110.             ShowMyWindow((*tocH)->win);
  1111.             SelectBoxRange(tocH,i,i,False,-1,-1);
  1112.             ScrollIt((*tocH)->win,0,-INFINITY);
  1113.             SelectWindow((*tocH)->win);
  1114. #ifdef NEVER
  1115.         }
  1116.         else
  1117.         {
  1118.             UpdateMyWindow((*tocH)->win);
  1119.           ScrollIt((*tocH)->win,0,-INFINITY);
  1120.         }
  1121. #endif
  1122.     }
  1123.  
  1124.     if (InBG && PrefIsSet(PREF_NEW_ALERT) || !PrefIsSet(PREF_NO_APPLE_FLASH))
  1125.     {
  1126.         if (MyNMRec) return;                /* already done */
  1127.         MyNMRec = New(struct NMRec);
  1128.         if (!MyNMRec) return;             /* couldn't allocate memory (bad) */
  1129.         WriteZero(MyNMRec,sizeof(*MyNMRec));
  1130.         MyNMRec->qType = nmType;
  1131.         MyNMRec->nmMark = 1;
  1132.         MyNMRec->nmRefCon = TickCount();
  1133.         if (!PrefIsSet(PREF_NO_APPLE_FLASH))
  1134.             MyNMRec->nmIcon = GetResource('SICN',FLAG_SICN);
  1135.         if (InBG && PrefIsSet(PREF_NEW_ALERT))
  1136.         {
  1137.             Str255 scratch;
  1138.             GetRString(scratch,NEW_MAIL);
  1139.             MyNMRec->nmStr = NuPtr(*scratch+1);
  1140.             if (MyNMRec->nmStr) PCopy(MyNMRec->nmStr,scratch);
  1141.         }
  1142.         if (NMInstall(MyNMRec))
  1143.         {
  1144.             DisposPtr(MyNMRec->nmStr);
  1145.             DisposPtr(MyNMRec);
  1146.             MyNMRec = nil;
  1147.         }
  1148.     }
  1149.     if (!InBG && PrefIsSet(PREF_NEW_ALERT))
  1150.     {
  1151.         AlertTicks=GetRLong(ALERT_TIMEOUT)*60+TickCount();
  1152.         (void) ReallyDoAnAlert(NEW_MAIL_ALRT,Note);
  1153.         AlertTicks = 0;
  1154.     }
  1155. }
  1156.  
  1157. /************************************************************************
  1158.  * NewMailSound - play the sound for new mail
  1159.  ************************************************************************/
  1160. void NewMailSound(void)
  1161. {
  1162.     Handle sound=GetResource('snd ',NEW_MAIL_SND);
  1163.     if (sound)
  1164.     {
  1165.         HNoPurge(sound);
  1166.         (void) SndPlay(nil,sound,False);
  1167.         HPurge(sound);
  1168.     }
  1169.     else
  1170.         SysBeep(20);
  1171. }
  1172.  
  1173. /************************************************************************
  1174.  *
  1175.  ************************************************************************/
  1176. void FlushHIQ(void)
  1177. {
  1178.     HostInfoQHandle hiq, nextHIQ;
  1179.     for (hiq=HIQ;hiq;hiq=nextHIQ)
  1180.     {
  1181.         nextHIQ = (*hiq)->next;
  1182.         if ((*hiq)->hi.rtnCode!=inProgress && (*hiq)->hi.rtnCode!=cacheFault)
  1183.         {
  1184.             LL_Remove(HIQ,hiq,(HostInfoQHandle));
  1185.             DisposHandle(hiq);
  1186.         }
  1187.     }
  1188. #ifndef KERBEROS
  1189.     if (!HIQ) CloseResolver();
  1190. #endif
  1191. }
  1192.  
  1193. /************************************************************************
  1194.  * TendNotificationManager - see if an NM rec is active, and if it should
  1195.  * be taken down
  1196.  ************************************************************************/
  1197. void TendNotificationManager(Boolean isActive)
  1198. {
  1199.     if (MyNMRec)
  1200.     {
  1201.         long ticksSince = TickCount()-MyNMRec->nmRefCon;
  1202.         if (isActive && ticksSince>10 || AlertsTimeout &&
  1203.                 MyNMRec->nmRefCon && ticksSince>GetRLong(ALERT_TIMEOUT)*60)
  1204.         {
  1205.             NMRemove(MyNMRec);
  1206.             if (MyNMRec->nmStr) DisposPtr(MyNMRec->nmStr);
  1207.             DisposPtr(MyNMRec);
  1208.             MyNMRec = nil;
  1209.         }
  1210.     }
  1211. }
  1212.