home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Python 1.4 / stdwin / Ports / mac / stdwin.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-12-21  |  8.8 KB  |  447 lines  |  [TEXT/CWIE]
  1. /* MAC STDWIN -- BASIC ROUTINES. */
  2.  
  3. #include "macwin.h"
  4. #include <Fonts.h>
  5. #include <Menus.h>
  6. #include <TextEdit.h>
  7. #include <Dialogs.h>
  8. #include <OSUtils.h>
  9. #include <SegLoad.h>
  10. #include <Memory.h>
  11.  
  12.  
  13. /* Parameters for top left corner choice algorithm in wopen() */
  14.  
  15. #define LEFT    20    /* Initial left */
  16. #define TOP    40    /* Initial top */
  17. #define HINCR    20    /* Increment for left */
  18. #define VINCR    16    /* Increment for top */
  19.  
  20.  
  21. /* GLOBAL DATA. */
  22.  
  23.             /* XXX choose less obvious names */
  24. GrafPtr screen;        /* The Mac Window Manager's GrafPort */
  25. TEXTATTR wattr;        /* Current or default text attributes */
  26.  
  27. static int def_left = 0;
  28. static int def_top = 0;
  29. static int def_width = 0;
  30. static int def_height = 0;
  31. static int def_horscroll = 0;
  32. static int def_verscroll = 1;
  33. static int next_left = LEFT;    /* For default placement algorithm */
  34. static int next_top = TOP;
  35.  
  36.  
  37. /* INITIALIZATION AND TERMINATION. */
  38.  
  39. /* Initialization */
  40.  
  41. int std_open_hook();
  42. STATIC pascal void resume _ARGS((void));
  43.  
  44. /* Initialize, using and updating argc/argv: */
  45. void
  46. winitargs(pargc, pargv)
  47.     int *pargc;
  48.     char ***pargv;
  49. {
  50.     wargs(pargc, pargv);
  51.     winit();
  52. }
  53.  
  54. /* Initialize without touching argc/argv */
  55. void
  56. winit()
  57. {
  58.     static init_done;
  59.  
  60.     /* System 7 uses events to build argc/argv, so wargs() calls
  61.      ** winit(). We don't want to initialize twice, so the next time
  62.      ** we immedeately return.
  63.      */
  64.     if (init_done)
  65.         return;
  66.     init_done = 1;
  67.  
  68. #ifdef CONSOLE_IO
  69.     /* 
  70.        THINK C may have done these initializations for us when
  71.        the application has already used the console in any way.
  72.        Doing them again is not a good idea.
  73.        The THINK library avoids initializing the world if it appears
  74.        that it has already been initialized, but in that case it
  75.        will only allow output (all input requests return EOF).
  76.        Thus, the application has two options:
  77.        - call winit() or winitargs() first; then the console
  78.          can only be used for (debugging) output; or
  79.        - print at least one character to stdout first; then the
  80.          stdwin menu bar may not function properly.
  81.        From inspection of the THINK library source it appears that
  82.        when the console is initialized, stdin->std is cleared,
  83.        so the test below suffices to skip initializations.
  84.     */
  85.     if (stdin->std)
  86. #endif
  87.     {
  88.         MaxApplZone();
  89.         InitGraf(&QD(thePort));
  90.         InitFonts();
  91.         InitWindows();
  92.         TEInit();
  93. #ifdef __MWERKS__
  94.         InitDialogs((long)0);
  95. #else
  96.         InitDialogs(resume);
  97. #endif
  98.         InitMenus();
  99.         InitCursor();
  100.         setup_menus();
  101.     }
  102.     GetWMgrPort(&screen);
  103.     initwattr();
  104.     set_watch();
  105. }
  106.  
  107. void
  108. wdone()
  109. {
  110. }
  111.  
  112. void
  113. wgetscrsize(pwidth, pheight)
  114.     int *pwidth, *pheight;
  115. {
  116.     Rect r;
  117.     r= screen->portRect;
  118.     *pwidth= r.right - r.left;
  119.     *pheight= r.bottom - r.top - MENUBARHEIGHT;
  120. }
  121.  
  122. void
  123. wgetscrmm(pmmwidth, pmmheight)
  124.     int *pmmwidth, *pmmheight;
  125. {
  126.     int width, height;
  127.     wgetscrsize(&width, &height);
  128.     /* XXX Three pixels/mm is an approximation of the truth at most */
  129.     *pmmwidth= width / 3;
  130.     *pmmheight= height / 3;
  131. }
  132.  
  133. int
  134. wgetmouseconfig()
  135. {
  136.     return WM_BUTTON1 | WM_SHIFT | WM_META | WM_LOCK | WM_OPTION;
  137.     /* XXX Should figure out if we have a Control button as well */
  138. }
  139.  
  140. /* Routine called by "Resume" button in bomb box (passed to InitDialogs).
  141.    I have yet to see a program crash where an attempted exit to the
  142.    Finder caused any harm, so I think it's safe.
  143.    Anyway, it's tremendously useful during debugging. */
  144.  
  145. static pascal void
  146. resume()
  147. {
  148.     ExitToShell();
  149. }
  150.  
  151.  
  152. /* WINDOWS. */
  153.  
  154. /* Find the WINDOW pointer corresponding to a WindowPtr. */
  155.  
  156. WINDOW *
  157. whichwin(w)
  158.     WindowPtr w;
  159. {
  160.     if (((WindowPeek)w)->windowKind < userKind)
  161.         return NULL; /* Not an application-created window */
  162.     else {
  163.         WINDOW *win;
  164.         
  165.         win= (WINDOW *) GetWRefCon(w);
  166.         if (win != NULL && win->w == w)
  167.             return win;
  168.         else
  169.             return NULL;
  170.     }
  171. }
  172.  
  173. WINDOW *
  174. wopen(title, drawproc)
  175.     char *title;
  176.     void (*drawproc)();
  177. {
  178.     WINDOW *win= ALLOC(WINDOW);
  179.     Rect r;
  180.     int width, height;        /* As seen by the user */
  181.     int tot_width, tot_height;    /* Including slop & scroll bars */
  182.     int left, top;            /* Window corner as seen by the user */
  183.     
  184.     if (win == NULL) {
  185.         dprintf("wopen: ALLOC failed");
  186.         return NULL;
  187.     }
  188.     
  189.     /* Determine window size.
  190.        If the program specified a size, use that, within reason --
  191.        sizes are clipped to 0x7000 to avoid overflow in QuickDraw's
  192.        calculations.
  193.        Otherwise, use two-third of the screen size, but at most
  194.        512x342 (to avoid creating gigantic windows by default on
  195.        large screen Macs). */
  196.     
  197.     if (def_width <= 0) {
  198.         width = screen->portRect.right * 2/3;
  199.         CLIPMAX(width, 512);
  200.     }
  201.     else {
  202.         width = def_width;
  203.         CLIPMAX(width, 0x7000);
  204.     }
  205.     if (def_horscroll)
  206.         CLIPMIN(width, 3*BAR);
  207.     tot_width = width + LSLOP + RSLOP;
  208.     if (def_verscroll)
  209.         tot_width += BAR;
  210.     
  211.     if (def_height <= 0) {
  212.         height= screen->portRect.bottom * 2/3;
  213.         CLIPMAX(height, 342);
  214.     }
  215.     else {
  216.         height = def_height;
  217.         CLIPMAX(height, 0x7000);
  218.     }
  219.     if (def_verscroll)
  220.         CLIPMIN(height, 3*BAR);
  221.     tot_height = height;
  222.     if (def_horscroll)
  223.         tot_height += BAR;
  224.     
  225.     /* Determine window position.
  226.        It the program specified a position, use that, but make sure
  227.        that at least a small piece of the title bar is visible --
  228.        so the user can recover a window that "fell off the screen".
  229.        Exception: the title bar may hide completely under the menu
  230.        bar, since this is the only way to get an (almost) full
  231.        screen window.
  232.        Otherwise, place the window a little to the right and below
  233.        the last window placed; it it doesn't fit, move it up.
  234.        With default placement, the window will never hide under the
  235.        title bar. */
  236.     
  237.     if (def_left <= 0) {
  238.         left = next_left;
  239.         if (left + tot_width >= screen->portRect.right) {
  240.             left = LEFT;
  241.             CLIPMAX(left, screen->portRect.right - tot_width);
  242.             CLIPMIN(left, 0);
  243.         }
  244.     }
  245.     else {
  246.         left = def_left - LSLOP;
  247.         CLIPMAX(left, screen->portRect.right - BAR);
  248.         CLIPMIN(left, BAR - tot_width);
  249.     }
  250.     
  251.     if (def_top <= 0) {
  252.         top = next_top;
  253.         if (top + tot_height >= screen->portRect.bottom) {
  254.             top = TOP;
  255.             CLIPMAX(top, screen->portRect.bottom - tot_height);
  256.             CLIPMIN(top, MENUBARHEIGHT + TITLEBARHEIGHT);
  257.         }
  258.     }
  259.     else {
  260.         top = def_top;
  261.         CLIPMAX(top, screen->portRect.bottom);
  262.         CLIPMIN(top, MENUBARHEIGHT);
  263.     }
  264.     
  265.     next_left = left + HINCR;
  266.     next_top = top + VINCR;
  267.     
  268.     /* Create the window now and initialize its attributes */
  269.     
  270.     SetRect(&r, left, top, left + tot_width, top + tot_height);
  271.     win->w= NewWindow((Ptr)NULL, &r, PSTRING(title), TRUE, zoomDocProc,
  272.         (WindowPtr)(-1), TRUE, 0L);
  273.     SetWRefCon(win->w, (long)win);
  274.     
  275.     win->tag= 0;
  276.     win->drawproc= drawproc;
  277.     win->hcaret= win->vcaret= -1;
  278.     win->caret_on= FALSE;
  279.     win->attr= wattr;
  280.     win->hbar= win->vbar= NULL;
  281.     win->docwidth= 0;
  282.     win->docheight= 0;
  283.     win->orgh= -LSLOP;
  284.     win->orgv= 0;
  285.     win->timer= 0;
  286.     win->cursor = NULL;
  287.     win->fgcolor = _w_fgcolor;
  288.     win->bgcolor = _w_bgcolor;
  289.     
  290.     SetPort(win->w);
  291.     _w_usefgcolor(win->fgcolor);
  292.     _w_usebgcolor(win->bgcolor);
  293.     
  294.     initmbar(&win->mbar);
  295.     makescrollbars(win, def_horscroll, def_verscroll);
  296.     
  297.     return win;
  298. }
  299.  
  300. void
  301. wclose(win)
  302.     WINDOW *win;
  303. {
  304.     if (win == active) {
  305.         rmlocalmenus(win);
  306.         active= NULL;
  307.     }
  308.     killmbar(&win->mbar);
  309.     DisposeWindow(win->w);
  310.     FREE(win);
  311. }
  312.  
  313. void
  314. wgetwinsize(win, pwidth, pheight)
  315.     WINDOW *win;
  316.     int *pwidth, *pheight;
  317. {
  318.     Rect r;
  319.     
  320.     getwinrect(win, &r);
  321.     *pwidth= r.right - r.left - LSLOP - RSLOP;
  322.     *pheight= r.bottom - r.top;
  323. }
  324.  
  325. void
  326. wsetwinsize(win, width, height)
  327.     WINDOW *win;
  328.     int width, height;
  329. {
  330.     /* XXX not yet implemented */
  331. }
  332.  
  333. void
  334. wgetwinpos(win, ph, pv)
  335.     WINDOW *win;
  336.     int *ph, *pv;
  337. {
  338.     Point p;
  339.     GrafPtr saveport;
  340.     
  341.     GetPort(&saveport);
  342.     
  343.     SetPort(win->w);
  344.     p.h = win->w->portRect.left + LSLOP;
  345.     p.v = win->w->portRect.top;
  346.     LocalToGlobal(&p);
  347.     *ph = p.h;
  348.     *pv = p.v;
  349.     
  350.     SetPort(saveport);
  351. }
  352.  
  353. void
  354. wsetwinpos(win, left, top)
  355.     WINDOW *win;
  356.     int left, top;
  357. {
  358.     /* XXX not yet implemented */
  359. }
  360.  
  361. void
  362. wsettitle(win, title)
  363.     WINDOW *win;
  364.     char *title;
  365. {
  366.     SetWTitle(win->w, PSTRING(title));
  367. }
  368.  
  369. char *
  370. wgettitle(win)
  371.     WINDOW *win;
  372. {
  373.     static Str255 title;
  374.     GetWTitle(win->w, title);
  375. #ifndef CLEVERGLUE
  376.     PtoCstr(title);
  377. #endif
  378.     return (char *)title;
  379. }
  380.  
  381. void
  382. wfleep()
  383. {
  384.     SysBeep(5);
  385. }
  386.  
  387. void
  388. wsetmaxwinsize(width, height)
  389.     int width, height;
  390. {
  391.     /* Not supported yet (should be stored in the window struct
  392.        and used by do_grow). */
  393.     /* XXX This procedure should disappear completely, it was
  394.        only invented for the Whitechapel which allocates bitmap
  395.        memory to the window when it is first created! */
  396.     /* XXX Well, maybe it has some use.  In fact both min and max
  397.        window size are sometimes useful... */
  398. }
  399.  
  400. void
  401. wsetdefwinpos(h, v)
  402.     int h, v;
  403. {
  404.     def_left = h;
  405.     def_top = v;
  406. }
  407.  
  408. void
  409. wgetdefwinpos(ph, pv)
  410.     int *ph, *pv;
  411. {
  412.     *ph = def_left;
  413.     *pv = def_top;
  414. }
  415.  
  416. void
  417. wsetdefwinsize(width, height)
  418.     int width, height;
  419. {
  420.     def_width= width;
  421.     def_height= height;
  422. }
  423.  
  424. void
  425. wgetdefwinsize(pwidth, pheight)
  426.     int *pwidth, *pheight;
  427. {
  428.     *pwidth = def_width;
  429.     *pheight = def_height;
  430. }
  431.  
  432. void
  433. wsetdefscrollbars(hor, ver)
  434.     int hor, ver;
  435. {
  436.     def_horscroll = hor;
  437.     def_verscroll = ver;
  438. }
  439.  
  440. void
  441. wgetdefscrollbars(phor, pver)
  442.     int *phor, *pver;
  443. {
  444.     *phor = def_horscroll;
  445.     *pver = def_verscroll;
  446. }
  447.