home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / e20313sr.zip / emacs / 20.3.1 / src / w32xfns.c < prev    next >
C/C++ Source or Header  |  1999-07-31  |  9KB  |  382 lines
  1. /* Functions taken directly from X sources for use with the Microsoft W32 API.
  2.    Copyright (C) 1989, 1992, 1993, 1994, 1995 Free Software Foundation.
  3.  
  4. This file is part of GNU Emacs.
  5.  
  6. GNU Emacs is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2, or (at your option)
  9. any later version.
  10.  
  11. GNU Emacs is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with GNU Emacs; see the file COPYING.  If not, write to
  18. the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19. Boston, MA 02111-1307, USA.  */
  20.  
  21. #include <signal.h>
  22. #include <config.h>
  23. #include <stdio.h>
  24. #include "lisp.h"
  25. #include "frame.h"
  26. #include "blockinput.h"
  27. #include "w32term.h"
  28. #include "windowsx.h"
  29.  
  30. #define myalloc(cb) GlobalAllocPtr (GPTR, cb)
  31. #define myfree(lp) GlobalFreePtr (lp)
  32.  
  33. CRITICAL_SECTION critsect;
  34. extern HANDLE keyboard_handle;
  35. HANDLE input_available = NULL;
  36. HANDLE interrupt_handle = NULL;
  37.  
  38. void 
  39. init_crit ()
  40. {
  41.   InitializeCriticalSection (&critsect);
  42.  
  43.   /* For safety, input_available should only be reset by get_next_msg
  44.      when the input queue is empty, so make it a manual reset event. */
  45.   keyboard_handle = input_available = CreateEvent (NULL, TRUE, FALSE, NULL);
  46.  
  47.   /* interrupt_handle is signalled when quit (C-g) is detected, so that
  48.      blocking system calls can be interrupted.  We make it a manual
  49.      reset event, so that if we should ever have multiple threads
  50.      performing system calls, they will all be interrupted (I'm guessing
  51.      that would the right response).  Note that we use PulseEvent to
  52.      signal this event, so that it never remains signalled.  */
  53.   interrupt_handle = CreateEvent (NULL, TRUE, FALSE, NULL);
  54. }
  55.  
  56. void 
  57. delete_crit ()
  58. {
  59.   DeleteCriticalSection (&critsect);
  60.  
  61.   if (input_available)
  62.     {
  63.       CloseHandle (input_available);
  64.       input_available = NULL;
  65.     }
  66.   if (interrupt_handle)
  67.     {
  68.       CloseHandle (interrupt_handle);
  69.       interrupt_handle = NULL;
  70.     }
  71. }
  72.  
  73. void
  74. signal_quit ()
  75. {
  76.   /* Make sure this event never remains signalled; if the main thread
  77.      isn't in a blocking call, then this should do nothing.  */
  78.   PulseEvent (interrupt_handle);
  79. }
  80.  
  81. void
  82. select_palette (FRAME_PTR f, HDC hdc)
  83. {
  84.   if (!NILP (Vw32_enable_palette))
  85.     f->output_data.w32->old_palette =
  86.       SelectPalette (hdc, one_w32_display_info.palette, FALSE);
  87.   else
  88.     f->output_data.w32->old_palette = NULL;
  89.  
  90.   if (RealizePalette (hdc))
  91.   {
  92.     Lisp_Object frame, framelist;
  93.     FOR_EACH_FRAME (framelist, frame)
  94.     {
  95.       SET_FRAME_GARBAGED (XFRAME (frame));
  96.     }
  97.   }
  98. }
  99.  
  100. void
  101. deselect_palette (FRAME_PTR f, HDC hdc)
  102. {
  103.   if (f->output_data.w32->old_palette)
  104.     SelectPalette (hdc, f->output_data.w32->old_palette, FALSE);
  105. }
  106.  
  107. /* Get a DC for frame and select palette for drawing; force an update of
  108.    all frames if palette's mapping changes.  */
  109. HDC
  110. get_frame_dc (FRAME_PTR f)
  111. {
  112.   HDC hdc;
  113.  
  114.   enter_crit ();
  115.  
  116.   hdc = GetDC (f->output_data.w32->window_desc);
  117.   select_palette (f, hdc);
  118.  
  119.   return hdc;
  120. }
  121.  
  122. int
  123. release_frame_dc (FRAME_PTR f, HDC hdc)
  124. {
  125.   int ret;
  126.  
  127.   deselect_palette (f, hdc);
  128.   ret = ReleaseDC (f->output_data.w32->window_desc, hdc);
  129.  
  130.   leave_crit ();
  131.  
  132.   return ret;
  133. }
  134.  
  135. typedef struct int_msg
  136. {
  137.   W32Msg w32msg;
  138.   struct int_msg *lpNext;
  139. } int_msg;
  140.  
  141. int_msg *lpHead = NULL;
  142. int_msg *lpTail = NULL;
  143. int nQueue = 0;
  144.  
  145. BOOL 
  146. get_next_msg (lpmsg, bWait)
  147.      W32Msg * lpmsg;
  148.      BOOL bWait;
  149. {
  150.   BOOL bRet = FALSE;
  151.   
  152.   enter_crit ();
  153.   
  154.   /* The while loop takes care of multiple sets */
  155.   
  156.   while (!nQueue && bWait)
  157.     {
  158.       leave_crit ();
  159.       WaitForSingleObject (input_available, INFINITE);
  160.       enter_crit ();
  161.     }
  162.   
  163.   if (nQueue)
  164.     {
  165.       bcopy (&(lpHead->w32msg), lpmsg, sizeof (W32Msg));
  166.  
  167.       {
  168.     int_msg * lpCur = lpHead;
  169.         
  170.     lpHead = lpHead->lpNext;
  171.         
  172.     myfree (lpCur);
  173.       }
  174.  
  175.       nQueue--;
  176.  
  177.       bRet = TRUE;
  178.     }
  179.  
  180.   if (nQueue == 0)
  181.     ResetEvent (input_available);
  182.   
  183.   leave_crit ();
  184.   
  185.   return (bRet);
  186. }
  187.  
  188. BOOL 
  189. post_msg (lpmsg)
  190.      W32Msg * lpmsg;
  191. {
  192.   int_msg * lpNew = (int_msg *) myalloc (sizeof (int_msg));
  193.  
  194.   if (!lpNew)
  195.     return (FALSE);
  196.  
  197.   bcopy (lpmsg, &(lpNew->w32msg), sizeof (W32Msg));
  198.   lpNew->lpNext = NULL;
  199.  
  200.   enter_crit ();
  201.  
  202.   if (nQueue++)
  203.     {
  204.       lpTail->lpNext = lpNew;
  205.     }
  206.   else 
  207.     {
  208.       lpHead = lpNew;
  209.     }
  210.  
  211.   lpTail = lpNew;
  212.   SetEvent (input_available);
  213.     
  214.   leave_crit ();
  215.  
  216.   return (TRUE);
  217. }
  218.  
  219. BOOL
  220. prepend_msg (W32Msg *lpmsg)
  221. {
  222.   int_msg * lpNew = (int_msg *) myalloc (sizeof (int_msg));
  223.  
  224.   if (!lpNew)
  225.     return (FALSE);
  226.  
  227.   bcopy (lpmsg, &(lpNew->w32msg), sizeof (W32Msg));
  228.  
  229.   enter_crit ();
  230.  
  231.   nQueue++;
  232.   lpNew->lpNext = lpHead;
  233.   lpHead = lpNew;
  234.  
  235.   leave_crit ();
  236.  
  237.   return (TRUE);
  238. }
  239.  
  240. /*
  241.  *    XParseGeometry parses strings of the form
  242.  *   "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
  243.  *   width, height, xoffset, and yoffset are unsigned integers.
  244.  *   Example:  "=80x24+300-49"
  245.  *   The equal sign is optional.
  246.  *   It returns a bitmask that indicates which of the four values
  247.  *   were actually found in the string.  For each value found,
  248.  *   the corresponding argument is updated;  for each value
  249.  *   not found, the corresponding argument is left unchanged. 
  250.  */
  251.  
  252. static int
  253. read_integer (string, NextString)
  254.      register char *string;
  255.      char **NextString;
  256. {
  257.   register int Result = 0;
  258.   int Sign = 1;
  259.   
  260.   if (*string == '+')
  261.     string++;
  262.   else if (*string == '-')
  263.     {
  264.       string++;
  265.       Sign = -1;
  266.     }
  267.   for (; (*string >= '0') && (*string <= '9'); string++)
  268.     {
  269.       Result = (Result * 10) + (*string - '0');
  270.     }
  271.   *NextString = string;
  272.   if (Sign >= 0)
  273.     return (Result);
  274.   else
  275.     return (-Result);
  276. }
  277.  
  278. int 
  279. XParseGeometry (string, x, y, width, height)
  280.      char *string;
  281.      int *x, *y;
  282.      unsigned int *width, *height;    /* RETURN */
  283. {
  284.   int mask = NoValue;
  285.   register char *strind;
  286.   unsigned int tempWidth, tempHeight;
  287.   int tempX, tempY;
  288.   char *nextCharacter;
  289.   
  290.   if ((string == NULL) || (*string == '\0')) return (mask);
  291.   if (*string == '=')
  292.     string++;  /* ignore possible '=' at beg of geometry spec */
  293.   
  294.   strind = (char *)string;
  295.   if (*strind != '+' && *strind != '-' && *strind != 'x') 
  296.     {
  297.       tempWidth = read_integer (strind, &nextCharacter);
  298.       if (strind == nextCharacter) 
  299.     return (0);
  300.       strind = nextCharacter;
  301.       mask |= WidthValue;
  302.     }
  303.   
  304.   if (*strind == 'x' || *strind == 'X') 
  305.     {    
  306.       strind++;
  307.       tempHeight = read_integer (strind, &nextCharacter);
  308.       if (strind == nextCharacter)
  309.     return (0);
  310.       strind = nextCharacter;
  311.       mask |= HeightValue;
  312.     }
  313.   
  314.   if ((*strind == '+') || (*strind == '-')) 
  315.     {
  316.       if (*strind == '-') 
  317.     {
  318.       strind++;
  319.       tempX = -read_integer (strind, &nextCharacter);
  320.       if (strind == nextCharacter)
  321.         return (0);
  322.       strind = nextCharacter;
  323.       mask |= XNegative;
  324.  
  325.     }
  326.       else
  327.     {    
  328.       strind++;
  329.       tempX = read_integer (strind, &nextCharacter);
  330.       if (strind == nextCharacter)
  331.         return (0);
  332.       strind = nextCharacter;
  333.     }
  334.       mask |= XValue;
  335.       if ((*strind == '+') || (*strind == '-')) 
  336.     {
  337.       if (*strind == '-') 
  338.         {
  339.           strind++;
  340.           tempY = -read_integer (strind, &nextCharacter);
  341.           if (strind == nextCharacter)
  342.         return (0);
  343.           strind = nextCharacter;
  344.           mask |= YNegative;
  345.  
  346.         }
  347.       else
  348.         {
  349.           strind++;
  350.           tempY = read_integer (strind, &nextCharacter);
  351.           if (strind == nextCharacter)
  352.         return (0);
  353.           strind = nextCharacter;
  354.         }
  355.       mask |= YValue;
  356.     }
  357.     }
  358.   
  359.   /* If strind isn't at the end of the string the it's an invalid
  360.      geometry specification. */
  361.   
  362.   if (*strind != '\0') return (0);
  363.   
  364.   if (mask & XValue)
  365.     *x = tempX;
  366.   if (mask & YValue)
  367.     *y = tempY;
  368.   if (mask & WidthValue)
  369.     *width = tempWidth;
  370.   if (mask & HeightValue)
  371.     *height = tempHeight;
  372.   return (mask);
  373. }
  374.  
  375. /* x_sync is a no-op on W32.  */
  376. void
  377. x_sync (f)
  378.      void *f;
  379. {
  380. }
  381.  
  382.