windows/caret.c

   1 /*
   2  * Caret functions
   3  *
   4  * Copyright 1993 David Metcalfe
   5  * Copyright 1996 Frans van Dorsselaer
   6  */
   7
   8 #include "windows.h"
   9 #include "module.h"
  10 #include "stddebug.h"
  11 /* #define DEBUG_CARET */
  12 #include "debug.h"
  13
  14 typedef struct
  15 {
  16     HWND32     hwnd;
  17     UINT32     hidden;
  18     BOOL32     on;
  19     INT32      x;
  20     INT32      y;
  21     INT32      width;
  22     INT32      height;
  23     HBRUSH16   hBrush;
  24     UINT32     timeout;
  25     UINT32     timerid;
  26 } CARET;
  27
  28 typedef enum
  29 {
  30     CARET_OFF = 0,
  31     CARET_ON,
  32     CARET_TOGGLE,
  33 } DISPLAY_CARET;
  34
  35 static CARET Caret = { 0, 0, FALSE, 0, 0, 2, 12, 0, 500, 0 };
  36
  37 /*****************************************************************
  38  *              CARET_GetHwnd
  39  */
  40 HWND32 CARET_GetHwnd(void)
  41 {
  42     return Caret.hwnd;
  43 }
  44
  45 /*****************************************************************
  46  *              CARET_GetRect
  47  */
  48 void CARET_GetRect(LPRECT32 lprc)
  49 {
  50     lprc->right = (lprc->left = Caret.x) + Caret.width - 1;
  51     lprc->bottom = (lprc->top = Caret.y) + Caret.height - 1;
  52 }
  53
  54 /*****************************************************************
  55  *               CARET_DisplayCaret
  56  */
  57 static void CARET_DisplayCaret( DISPLAY_CARET status )
  58 {
  59     HDC32 hdc;
  60     HBRUSH16 hPrevBrush;
  61
  62     if (Caret.on && (status == CARET_ON)) return;
  63     if (!Caret.on && (status == CARET_OFF)) return;
  64
  65     /* So now it's always a toggle */
  66
  67     Caret.on = !Caret.on;
  68     if (!(hdc = GetDCEx32( Caret.hwnd, 0, DCX_USESTYLE | DCX_CACHE ))) return;
  69     hPrevBrush = SelectObject32( hdc, Caret.hBrush );
  70     PatBlt32( hdc, Caret.x, Caret.y, Caret.width, Caret.height, PATINVERT );
  71     SelectObject32( hdc, hPrevBrush );
  72     ReleaseDC32( Caret.hwnd, hdc );
  73 }
  74
  75
  76 /*****************************************************************
  77  *               CARET_Callback
  78  */
  79 static VOID CARET_Callback( HWND32 hwnd, UINT32 msg, UINT32 id, DWORD ctime)
  80 {
  81     dprintf_caret(stddeb,"CARET_Callback: hwnd=%04x, timerid=%d, caret=%d\n",
  82                   hwnd, id, Caret.on);
  83     CARET_DisplayCaret(CARET_TOGGLE);
  84 }
  85
  86
  87 /*****************************************************************
  88  *               CARET_SetTimer
  89  */
  90 static void CARET_SetTimer(void)
  91 {
  92     if (Caret.timerid) KillSystemTimer32( (HWND32)0, Caret.timerid );
  93     Caret.timerid = SetSystemTimer32( (HWND32)0, 0, Caret.timeout,
  94                                       CARET_Callback );
  95 }
  96
  97
  98 /*****************************************************************
  99  *               CARET_ResetTimer
 100  */
 101 static void CARET_ResetTimer(void)
 102 {
 103     if (Caret.timerid)
 104     {
 105         KillSystemTimer32( (HWND32)0, Caret.timerid );
 106         Caret.timerid = SetSystemTimer32( (HWND32)0, 0, Caret.timeout,
 107                                           CARET_Callback );
 108     }
 109 }
 110
 111
 112 /*****************************************************************
 113  *               CARET_KillTimer
 114  */
 115 static void CARET_KillTimer(void)
 116 {
 117     if (Caret.timerid)
 118     {
 119         KillSystemTimer32( (HWND32)0, Caret.timerid );
 120         Caret.timerid = 0;
 121     }
 122 }
 123
 124
 125 /*****************************************************************
 126  *           CreateCaret   (USER.163) (USER32.65)
 127  */
 128 BOOL16 CreateCaret( HWND32 hwnd, HBITMAP32 bitmap, INT32 width, INT32 height )
 129 {
 130     dprintf_caret(stddeb,"CreateCaret: hwnd=%04x\n", hwnd);
 131
 132     if (!hwnd) return FALSE;
 133
 134     /* if cursor already exists, destroy it */
 135     if (Caret.hwnd) DestroyCaret();
 136
 137     if (bitmap && (bitmap != 1))
 138     {
 139         BITMAP16 bmp;
 140         if (!GetObject16( bitmap, sizeof(bmp), &bmp )) return FALSE;
 141         Caret.width = bmp.bmWidth;
 142         Caret.height = bmp.bmHeight;
 143         /* FIXME: we should make a copy of the bitmap instead of a brush */
 144         Caret.hBrush = CreatePatternBrush32( bitmap );
 145     }
 146     else
 147     {
 148         Caret.width = width ? width : GetSystemMetrics32(SM_CXBORDER);
 149         Caret.height = height ? height : GetSystemMetrics32(SM_CYBORDER);
 150         Caret.hBrush = CreateSolidBrush32(bitmap ?
 151                                           GetSysColor32(COLOR_GRAYTEXT) :
 152                                           GetSysColor32(COLOR_WINDOW) );
 153     }
 154
 155     Caret.hwnd = hwnd;
 156     Caret.hidden = 1;
 157     Caret.on = FALSE;
 158     Caret.x = 0;
 159     Caret.y = 0;
 160
 161     Caret.timeout = GetProfileInt32A( "windows", "CursorBlinkRate", 500 );
 162     return TRUE;
 163 }
 164
 165
 166 /*****************************************************************
 167  *           DestroyCaret   (USER.164) (USER32.130)
 168  */
 169 BOOL16 DestroyCaret(void)
 170 {
 171     if (!Caret.hwnd) return FALSE;
 172
 173     dprintf_caret(stddeb,"DestroyCaret: hwnd=%04x, timerid=%d\n",
 174                 Caret.hwnd, Caret.timerid);
 175
 176     CARET_KillTimer();
 177     CARET_DisplayCaret(CARET_OFF);
 178     DeleteObject32( Caret.hBrush );
 179     Caret.hwnd = 0;
 180     return TRUE;
 181 }
 182
 183
 184 /*****************************************************************
 185  *           SetCaretPos   (USER.165) (USER32.465)
 186  */
 187 BOOL16 SetCaretPos( INT32 x, INT32 y)
 188 {
 189     if (!Caret.hwnd) return FALSE;
 190     if ((x == Caret.x) && (y == Caret.y)) return TRUE;
 191
 192     dprintf_caret(stddeb,"SetCaretPos: x=%d, y=%d\n", x, y);
 193
 194     CARET_KillTimer();
 195     CARET_DisplayCaret(CARET_OFF);
 196     Caret.x = x;
 197     Caret.y = y;
 198     if (!Caret.hidden)
 199     {
 200         CARET_DisplayCaret(CARET_ON);
 201         CARET_SetTimer();
 202     }
 203     return TRUE;
 204 }
 205
 206
 207 /*****************************************************************
 208  *           HideCaret16   (USER.166)
 209  */
 210 BOOL16 HideCaret16( HWND16 hwnd )
 211 {
 212     return HideCaret32( hwnd );
 213 }
 214
 215
 216 /*****************************************************************
 217  *           HideCaret32   (USER32.316)
 218  */
 219 BOOL32 HideCaret32( HWND32 hwnd )
 220 {
 221     if (!Caret.hwnd) return FALSE;
 222     if (hwnd && (Caret.hwnd != hwnd)) return FALSE;
 223
 224     dprintf_caret(stddeb,"HideCaret: hwnd=%04x, hidden=%d\n",
 225                   hwnd, Caret.hidden);
 226
 227     CARET_KillTimer();
 228     CARET_DisplayCaret(CARET_OFF);
 229     Caret.hidden++;
 230     return TRUE;
 231 }
 232
 233
 234 /*****************************************************************
 235  *           ShowCaret16   (USER.167)
 236  */
 237 BOOL16 ShowCaret16( HWND16 hwnd )
 238 {
 239     return ShowCaret32( hwnd );
 240 }
 241
 242
 243 /*****************************************************************
 244  *           ShowCaret32   (USER32.528)
 245  */
 246 BOOL32 ShowCaret32( HWND32 hwnd )
 247 {
 248     if (!Caret.hwnd) return FALSE;
 249     if (hwnd && (Caret.hwnd != hwnd)) return FALSE;
 250
 251     dprintf_caret(stddeb,"ShowCaret: hwnd=%04x, hidden=%d\n",
 252                 hwnd, Caret.hidden);
 253
 254     if (Caret.hidden)
 255     {
 256         Caret.hidden--;
 257         if (!Caret.hidden)
 258         {
 259             CARET_DisplayCaret(CARET_ON);
 260             CARET_SetTimer();
 261         }
 262     }
 263     return TRUE;
 264 }
 265
 266
 267 /*****************************************************************
 268  *           SetCaretBlinkTime   (USER.168) (USER32.464)
 269  */
 270 BOOL16 SetCaretBlinkTime( UINT32 msecs )
 271 {
 272     if (!Caret.hwnd) return FALSE;
 273
 274     dprintf_caret(stddeb,"SetCaretBlinkTime: hwnd=%04x, msecs=%d\n",
 275                 Caret.hwnd, msecs);
 276
 277     Caret.timeout = msecs;
 278     CARET_ResetTimer();
 279     return TRUE;
 280 }
 281
 282
 283 /*****************************************************************
 284  *           GetCaretBlinkTime16   (USER.169)
 285  */
 286 UINT16 GetCaretBlinkTime16(void)
 287 {
 288     return (UINT16)GetCaretBlinkTime32();
 289 }
 290
 291
 292 /*****************************************************************
 293  *           GetCaretBlinkTime32   (USER32.208)
 294  */
 295 UINT32 GetCaretBlinkTime32(void)
 296 {
 297     return Caret.timeout;
 298 }
 299
 300
 301 /*****************************************************************
 302  *           GetCaretPos16   (USER.183)
 303  */
 304 VOID GetCaretPos16( LPPOINT16 pt )
 305 {
 306     if (!Caret.hwnd || !pt) return;
 307
 308     dprintf_caret(stddeb,"GetCaretPos: hwnd=%04x, pt=%p, x=%d, y=%d\n",
 309                   Caret.hwnd, pt, Caret.x, Caret.y);
 310     pt->x = (INT16)Caret.x;
 311     pt->y = (INT16)Caret.y;
 312 }
 313
 314
 315 /*****************************************************************
 316  *           GetCaretPos32   (USER32.209)
 317  */
 318 BOOL32 GetCaretPos32( LPPOINT32 pt )
 319 {
 320     if (!Caret.hwnd || !pt) return FALSE;
 321     pt->x = Caret.x;
 322     pt->y = Caret.y;
 323     return TRUE;
 324 }