开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 压缩解压 > 查看源码
macscreen.c
资源名称：unzip540.zip　[点击查看]
上传用户：andy_li
上传日期：2007-01-06
资源大小：1019k
文件大小：10k
源码类别：

压缩解压

开发平台：

MultiPlatform

macscreen.c：源码内容
  1. /*---------------------------------------------------------------------------
  3.   macscreen.c
  4.   This file is only linked into the standalone version (not SIOUX) of unzip.
  5.   Macintosh-GUI routines.
  7.   ---------------------------------------------------------------------------*/
  10. /*****************************************************************************/
  11. /*  Includes                                                                 */
  12. /*****************************************************************************/
  14. #include <QuickDraw.h>
  16. #include <stdio.h>
  17. #include <stdarg.h>
  18. #include <string.h>
  21. /*****************************************************************************/
  22. /*  Macros, typedefs                                                         */
  23. /*****************************************************************************/
  25. #define bufferSize      4096
  27. #define screenWindow    128
  29. #define pauseOption     0x0001
  30. #define scrollOption    0x0002
  33. /*****************************************************************************/
  34. /*  Module level Vars                                                        */
  35. /*****************************************************************************/
  37. static Rect scrollRect, pauseRect;
  38. static WindowPtr theWindow;
  39. static RgnHandle scrollRgn;
  41. static short fontHeight, fontWidth, screenHeight, screenWidth;
  42. static short currentPosition, maxPosition, pausePosition;
  44. static short *screenLength, startLine, endLine;
  45. static char *screenImage, **screenLine;
  47. static int screenOptions;
  51. /*****************************************************************************/
  52. /*  Prototypes                                                               */
  53. /*****************************************************************************/
  55. void screenOpen(char *);
  56. void screenControl(char *, int);
  57. void screenClose(void);
  58. void screenUpdate(WindowPtr);
  59. void screenDisplay(char *);
  60. void screenDump(char *, long);
  62. char *macfgets(char *, int, FILE *);
  63. int  macfprintf(FILE *, char *, ...);
  64. int  macprintf(char *, ...);
  65. int  macgetch(void);
  68. /*****************************************************************************/
  69. /*  Functions                                                                */
  70. /*****************************************************************************/
  72. void screenOpen(char *Title) {
  73.     FontInfo fontInfo;
  74.     int n;
  75.     short       fontFamID;
  77.     theWindow = GetNewWindow(screenWindow, nil, (WindowPtr)(-1));
  79.     if ((Title != NULL) && (*Title != '')) {
  80.         c2pstr(Title);
  81.         SetWTitle(theWindow, (StringPtr)Title);
  82.         p2cstr((StringPtr)Title);
  83.     }
  85.     ShowWindow(theWindow);
  87.     SetPort(theWindow);
  88.     GetFNum( "pMonaco", &fontFamID );
  89.     TextFont(fontFamID);
  90.     TextSize(9);
  92.     GetFontInfo(&fontInfo);
  93.     fontHeight = fontInfo.ascent + fontInfo.descent + fontInfo.leading;
  94.     fontWidth = fontInfo.widMax;
  96.     scrollRgn = NewRgn();
  98.     screenWidth = (theWindow->portRect.right - theWindow->portRect.left - 10) /
  99.         fontWidth;
  100.     screenHeight = (theWindow->portRect.bottom - theWindow->portRect.top) /
  101.         fontHeight;
  102.     maxPosition = screenHeight * fontHeight;
  103.     pausePosition = maxPosition - (currentPosition = fontHeight);
  105.     SetRect(&scrollRect, theWindow->portRect.left,
  106.             theWindow->portRect.top + fontInfo.descent,
  107.             theWindow->portRect.right,
  108.             theWindow->portRect.bottom);
  109.     SetRect(&pauseRect, theWindow->portRect.left,
  110.             pausePosition + fontInfo.descent,
  111.             theWindow->portRect.right,
  112.             theWindow->portRect.bottom);
  114.     MoveTo(5, currentPosition);
  116.     n = (sizeof(char *) + sizeof(short) + screenWidth) * screenHeight;
  118.     screenLine = (char **)NewPtr(n);
  120.     screenLength = (short *)&screenLine[screenHeight];
  121.     screenImage = (char *)&screenLength[screenHeight];
  123.     for (n = 0; n < screenHeight; n++) {
  124.         screenLine[n] = &screenImage[n * screenWidth];
  125.         screenLength[n] = 0;
  126.     }
  128.     startLine = endLine = 0;
  130.     screenOptions = 0;
  132.     return;
  133. }
  135. void screenControl(char *options, int setting) {
  136.     int n = 0;
  138.     while (*options) {
  139.         switch (*options) {
  140.         case 'p':
  141.             n |= pauseOption;
  142.             break;
  143.         case 's':
  144.             n |= scrollOption;
  145.             break;
  146.         default:
  147.             break;
  148.         }
  149.         options += 1;
  150.     }
  152.     if (setting == 0)
  153.         screenOptions &= (n ^ (-1));
  154.     else
  155.         screenOptions |= n;
  157.     if ((pausePosition = maxPosition - currentPosition) == 0)
  158.         pausePosition = maxPosition - fontHeight;
  160.     return;
  161. }
  163. void screenClose(void) {
  164.     DisposePtr((Ptr)screenLine);
  166.     DisposeWindow(theWindow);
  168.     return;
  169. }
  171. void screenUpdate(WindowPtr window) {
  172.     GrafPort *savePort;
  173.     int m, n;
  175.     if (window == theWindow) {
  176.         BeginUpdate(window);
  177.         if (!EmptyRgn(window->visRgn)) {
  178.             GetPort(&savePort);
  179.             SetPort(window);
  180.             n = startLine;
  181.             for (m = 1; ; m++) {
  182.                 MoveTo(5, m * fontHeight);
  183.                 if (screenLength[n] != 0)
  184.                     DrawText(screenLine[n], 0, screenLength[n]);
  185.                 if (n == endLine) break;
  186.                 if ((n += 1) == screenHeight) n = 0;
  187.             }
  188.             SetPort(savePort);
  189.         }
  190.         EndUpdate(window);
  191.     }
  193.     return;
  194. }
  196. static void screenNewline(void) {
  197.     MoveTo(5, currentPosition += fontHeight);
  198.     if (currentPosition > maxPosition) {
  199.         if (screenOptions & scrollOption) {
  200.             ScrollRect(&scrollRect, 0, -fontHeight, scrollRgn);
  201.             MoveTo(5, currentPosition = maxPosition);
  202.             if ((startLine += 1) == screenHeight) startLine = 0;
  203.         } else {
  204.             ScrollRect(&scrollRect, 0, -maxPosition + fontHeight, scrollRgn);
  205.             MoveTo(5, currentPosition = fontHeight + fontHeight);
  206.             startLine = endLine;
  207.         }
  208.     }
  209.     pausePosition -= fontHeight;
  211.     if ((endLine += 1) == screenHeight) endLine = 0;
  212.     screenLength[endLine] = 0;
  214.     return;
  215. }
  217. static char waitChar(void) {
  218.     WindowPtr whichWindow;
  219.     EventRecord theEvent;
  221.     for ( ; ; ) {
  222.         SystemTask();
  223.         if (GetNextEvent(everyEvent, &theEvent)) {
  224.             switch (theEvent.what) {
  225.             case keyDown:
  226.                 if ((theEvent.modifiers & cmdKey) &&
  227.                     ((theEvent.message & charCodeMask) == '.'))
  228.                     ExitToShell();
  229.                 return(theEvent.message & charCodeMask);
  230.             case mouseDown:
  231.                 if (FindWindow(theEvent.where, &whichWindow) == inSysWindow)
  232.                     SystemClick(&theEvent, whichWindow);
  233.                 break;
  234.             case updateEvt:
  235.                 screenUpdate((WindowPtr)theEvent.message);
  236.                 break;
  237.             }
  238.         }
  239.     }
  240. }
  242. static void screenPause(void) {
  243.     if (pausePosition == 0) {
  244.         if (screenOptions & pauseOption) {
  245.             DrawText("Press any key to continue ...", 0, 29);
  246.             memcpy(screenLine[endLine], "Press any key to continue ...", 29);
  247.             screenLength[endLine] = 29;
  249.             (void)waitChar();
  251.             EraseRect(&pauseRect);
  252.             MoveTo(5, currentPosition);
  253.             screenLength[endLine] = 0;
  254.         }
  256.         pausePosition = maxPosition - fontHeight;
  257.     }
  259.     return;
  260. }
  262. void screenDisplay(char *s) {
  263.     GrafPort *savePort;
  264.     int m, n;
  265.     char *t;
  267.     GetPort(&savePort);
  268.     SetPort(theWindow);
  270.     while (*s) {
  271.         screenPause();
  273.         for (t = s; (*s) && (*s != 'n') && (*s != 'r'); s++)
  274.             ;  /* empty body */
  276.         if ((n = s - t) > (m = screenWidth - screenLength[endLine])) n = m;
  278.         if (n > 0) {
  279.             DrawText(t, 0, n);
  280.             memcpy(screenLine[endLine] + screenLength[endLine], t, n);
  281.             screenLength[endLine] += n;
  282.         }
  284.         if ((*s == 'n') || (*s == 'r')) {
  285.             screenNewline();
  286.             s += 1;
  287.         }
  288.     }
  290.     SetPort(savePort);
  292.     return;
  293. }
  295. void screenDump(char *s, long n) {
  296.     GrafPort *savePort;
  297.     int k, m;
  298.     char *t;
  300.     GetPort(&savePort);
  301.     SetPort(theWindow);
  303.     while (n) {
  304.         screenPause();
  306.         for (t = s; (n) && (*s != 'n') && (*s != 'r'); s++, n--)
  307.             ;  /* empty body */
  309.         if ((k = s - t) > (m = screenWidth - screenLength[endLine])) k = m;
  311.         if (k > 0) {
  312.             DrawText(t, 0, k);
  313.             memcpy(screenLine[endLine] + screenLength[endLine], t, k);
  314.             screenLength[endLine] += k;
  315.         }
  317.         if ((*s == 'n') || (*s == 'r')) {
  318.             screenNewline();
  319.             s += 1;
  320.             n -= 1;
  321.         }
  322.     }
  324.     SetPort(savePort);
  326.     return;
  327. }
  329. char *macfgets(char *s, int n, FILE *stream) {
  330.     GrafPort *savePort;
  331.     char c, *t = s;
  333.     stream = stream;
  335.     GetPort(&savePort);
  336.     SetPort(theWindow);
  338.     for (n -= 1; (n > 0) && ((c = waitChar()) != 'r'); n -= 1) {
  339.         DrawChar(*t++ = c);
  340.         if (screenLength[endLine] < screenWidth)
  341.             screenLine[endLine][screenLength[endLine]++] = c;
  342.     }
  344.     if (c == 'r') screenNewline();
  346.     *t = '';
  348.     SetPort(savePort);
  350.     return(s);
  351. }
  353. int macfprintf(FILE *stream, char *format, ...)
  354. {
  355.     char buffer[bufferSize];
  356.     va_list ap;
  357.     int rc;
  359.     stream = stream;
  361.     va_start(ap, format);
  362.     rc = vsprintf(buffer, format, ap);
  363.     va_end(ap);
  365.     screenDisplay(buffer);
  367.     return rc;
  368. }
  370. int macprintf(char *format, ...)
  371. {
  372.     char buffer[bufferSize];
  373.     va_list ap;
  374.     int rc;
  376.     va_start(ap, format);
  377.     rc = vsprintf(buffer, format, ap);
  378.     va_end(ap);
  380.     screenDisplay(buffer);
  382.     return rc;
  383. }
  387. /***********************/
  388. /* Function macgetch() */
  389. /***********************/
  391. int macgetch(void)
  392. {
  393.     WindowPtr whichWindow;
  394.     EventRecord theEvent;
  395.     char c;                     /* one-byte buffer for read() to use */
  397.     do {
  398.         SystemTask();
  399.         if (!GetNextEvent(everyEvent, &theEvent))
  400.             theEvent.what = nullEvent;
  401.         else {
  402.             switch (theEvent.what) {
  403.             case keyDown:
  404.                 c = theEvent.message & charCodeMask;
  405.                 break;
  406.             case mouseDown:
  407.                 if (FindWindow(theEvent.where, &whichWindow) ==
  408.                     inSysWindow)
  409.                     SystemClick(&theEvent, whichWindow);
  410.                 break;
  411.             case updateEvt:
  412.                 screenUpdate((WindowPtr)theEvent.message);
  413.                 break;
  414.             }
  415.         }
  416.     } while (theEvent.what != keyDown);
  418.     macprintf("*");
  420.     return (int)c;
  421. }