Commit a patch for hide and show mouse. (forget it)
[reactos.git] / reactos / subsys / win32k / eng / mouse.c
1 /*
2 * ReactOS W32 Subsystem
3 * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19 /* $Id$
20 *
21 * PROJECT: ReactOS kernel
22 * PURPOSE: Mouse
23 * FILE: subsys/win32k/eng/mouse.c
24 * PROGRAMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
25 * REVISION HISTORY:
26 * 06-06-2001 CSH Created
27 */
28 /* INCLUDES ******************************************************************/
29
30 #include <w32k.h>
31
32 #define NDEBUG
33 #include <debug.h>
34
35 /* FUNCTIONS *****************************************************************/
36
37 INT INTERNAL_CALL
38 MouseSafetyOnDrawStart(SURFOBJ *SurfObj, LONG HazardX1,
39 LONG HazardY1, LONG HazardX2, LONG HazardY2)
40 /*
41 * FUNCTION: Notify the mouse driver that drawing is about to begin in
42 * a rectangle on a particular surface.
43 */
44 {
45 LONG tmp;
46 GDIDEVICE *ppdev;
47 GDIPOINTER *pgp;
48
49 ASSERT(SurfObj != NULL);
50
51 ppdev = GDIDEV(SurfObj);
52
53 if(ppdev == NULL)
54 {
55 return(FALSE);
56 }
57
58 pgp = &ppdev->Pointer;
59
60 if (SPS_ACCEPT_NOEXCLUDE == pgp->Status ||
61 pgp->Exclude.right == -1)
62 {
63 return(FALSE);
64 }
65
66 if (HazardX1 > HazardX2)
67 {
68 tmp = HazardX2; HazardX2 = HazardX1; HazardX1 = tmp;
69 }
70 if (HazardY1 > HazardY2)
71 {
72 tmp = HazardY2; HazardY2 = HazardY1; HazardY1 = tmp;
73 }
74
75 if (ppdev->SafetyRemoveLevel != 0)
76 {
77 ppdev->SafetyRemoveCount++;
78 return FALSE;
79 }
80
81 ppdev->SafetyRemoveCount++;
82
83 if (pgp->Exclude.right >= HazardX1
84 && pgp->Exclude.left <= HazardX2
85 && pgp->Exclude.bottom >= HazardY1
86 && pgp->Exclude.top <= HazardY2)
87 {
88 ppdev->SafetyRemoveLevel = ppdev->SafetyRemoveCount;
89 if (pgp->MovePointer)
90 pgp->MovePointer(SurfObj, -1, -1, NULL);
91 else
92 EngMovePointer(SurfObj, -1, -1, NULL);
93 }
94
95 return(TRUE);
96 }
97
98 INT INTERNAL_CALL
99 MouseSafetyOnDrawEnd(SURFOBJ *SurfObj)
100 /*
101 * FUNCTION: Notify the mouse driver that drawing has finished on a surface.
102 */
103 {
104 GDIDEVICE *ppdev;
105 GDIPOINTER *pgp;
106
107 ASSERT(SurfObj != NULL);
108
109 ppdev = GDIDEV(SurfObj);
110
111 if(ppdev == NULL)
112 {
113 return(FALSE);
114 }
115
116 pgp = &ppdev->Pointer;
117
118 if(SPS_ACCEPT_NOEXCLUDE == pgp->Status ||
119 pgp->Exclude.right == -1)
120 {
121 return FALSE;
122 }
123
124 if (--ppdev->SafetyRemoveCount >= ppdev->SafetyRemoveLevel)
125 {
126 return FALSE;
127 }
128 if (pgp->MovePointer)
129 pgp->MovePointer(SurfObj, pgp->Pos.x, pgp->Pos.y, &pgp->Exclude);
130 else
131 EngMovePointer(SurfObj, pgp->Pos.x, pgp->Pos.y, &pgp->Exclude);
132
133 ppdev->SafetyRemoveLevel = 0;
134
135 return(TRUE);
136 }
137
138 /* SOFTWARE MOUSE POINTER IMPLEMENTATION **************************************/
139
140 VOID INTERNAL_CALL
141 IntHideMousePointer(GDIDEVICE *ppdev, SURFOBJ *DestSurface)
142 {
143 GDIPOINTER *pgp;
144 POINTL pt;
145
146 ASSERT(ppdev);
147 ASSERT(DestSurface);
148
149 pgp = &ppdev->Pointer;
150
151 if (!pgp->Enabled)
152 {
153 return;
154 }
155
156
157
158 pgp->Enabled = FALSE;
159
160 /*
161 * The mouse is hide from ShowCours and it is frist ??
162 */
163 if (pgp->ShowPointer < 0)
164 {
165 return ;
166 }
167
168
169 /*
170 * Hide the cours
171 */
172 pt.x = pgp->Pos.x - pgp->HotSpot.x;
173 pt.y = pgp->Pos.y - pgp->HotSpot.y;
174
175
176 if (pgp->SaveSurface != NULL)
177 {
178 RECTL DestRect;
179 POINTL SrcPoint;
180 SURFOBJ *SaveSurface;
181 SURFOBJ *MaskSurface;
182
183 DestRect.left = max(pt.x, 0);
184 DestRect.top = max(pt.y, 0);
185 DestRect.right = min(
186 pt.x + pgp->Size.cx,
187 DestSurface->sizlBitmap.cx);
188 DestRect.bottom = min(
189 pt.y + pgp->Size.cy,
190 DestSurface->sizlBitmap.cy);
191
192 SrcPoint.x = max(-pt.x, 0);
193 SrcPoint.y = max(-pt.y, 0);
194
195 if((SaveSurface = EngLockSurface(pgp->SaveSurface)))
196 {
197 if((MaskSurface = EngLockSurface(pgp->MaskSurface)))
198 {
199 IntEngBitBltEx(DestSurface, SaveSurface, MaskSurface, NULL, NULL,
200 &DestRect, &SrcPoint, &SrcPoint, NULL, NULL,
201 ROP3_TO_ROP4(SRCCOPY), FALSE);
202 EngUnlockSurface(MaskSurface);
203 }
204 EngUnlockSurface(SaveSurface);
205 }
206 }
207 }
208
209 VOID INTERNAL_CALL
210 IntShowMousePointer(GDIDEVICE *ppdev, SURFOBJ *DestSurface)
211 {
212 GDIPOINTER *pgp;
213 SURFOBJ *SaveSurface;
214 POINTL pt;
215
216 ASSERT(ppdev);
217 ASSERT(DestSurface);
218
219 pgp = &ppdev->Pointer;
220
221 if (pgp->Enabled)
222 {
223 return;
224 }
225
226 pgp->Enabled = TRUE;
227
228 /*
229 * Do not blt the mouse if it in hide
230 */
231 if (pgp->ShowPointer < 0)
232 {
233 return ;
234 }
235
236 pt.x = pgp->Pos.x - pgp->HotSpot.x;
237 pt.y = pgp->Pos.y - pgp->HotSpot.y;
238
239 /*
240 * Copy the pixels under the cursor to temporary surface.
241 */
242
243 if (pgp->SaveSurface != NULL &&
244 (SaveSurface = EngLockSurface(pgp->SaveSurface)))
245 {
246 RECTL DestRect;
247 POINTL SrcPoint;
248
249 SrcPoint.x = max(pt.x, 0);
250 SrcPoint.y = max(pt.y, 0);
251
252 DestRect.left = SrcPoint.x - pt.x;
253 DestRect.top = SrcPoint.y - pt.y;
254 DestRect.right = min(
255 pgp->Size.cx,
256 DestSurface->sizlBitmap.cx - pt.x);
257 DestRect.bottom = min(
258 pgp->Size.cy,
259 DestSurface->sizlBitmap.cy - pt.y);
260
261 IntEngBitBltEx(SaveSurface, DestSurface, NULL, NULL, NULL,
262 &DestRect, &SrcPoint, NULL, NULL, NULL,
263 ROP3_TO_ROP4(SRCCOPY), FALSE);
264 EngUnlockSurface(SaveSurface);
265 }
266
267
268 /*
269 * Blit the cursor on the screen.
270 */
271
272 {
273 RECTL DestRect;
274 POINTL SrcPoint;
275 SURFOBJ *ColorSurf;
276 SURFOBJ *MaskSurf = NULL;
277
278 DestRect.left = max(pt.x, 0);
279 DestRect.top = max(pt.y, 0);
280 DestRect.right = min(
281 pt.x + pgp->Size.cx,
282 DestSurface->sizlBitmap.cx);
283 DestRect.bottom = min(
284 pt.y + pgp->Size.cy,
285 DestSurface->sizlBitmap.cy);
286
287 SrcPoint.x = max(-pt.x, 0);
288 SrcPoint.y = max(-pt.y, 0);
289
290
291 if (pgp->MaskSurface)
292 MaskSurf = EngLockSurface(pgp->MaskSurface);
293
294 if (MaskSurf != NULL)
295 {
296 if (pgp->ColorSurface != NULL)
297 {
298 if((ColorSurf = EngLockSurface(pgp->ColorSurface)))
299 {
300 IntEngBitBltEx(DestSurface, ColorSurf, MaskSurf, NULL,
301 pgp->XlateObject, &DestRect, &SrcPoint, &SrcPoint,
302 NULL, NULL, R4_MASK, FALSE);
303 EngUnlockSurface(ColorSurf);
304 }
305 }
306 else
307 {
308 IntEngBitBltEx(DestSurface, MaskSurf, NULL, NULL, pgp->XlateObject,
309 &DestRect, &SrcPoint, NULL, NULL, NULL,
310 ROP3_TO_ROP4(SRCAND), FALSE);
311 SrcPoint.y += pgp->Size.cy;
312 IntEngBitBltEx(DestSurface, MaskSurf, NULL, NULL, pgp->XlateObject,
313 &DestRect, &SrcPoint, NULL, NULL, NULL,
314 ROP3_TO_ROP4(SRCINVERT), FALSE);
315 }
316 EngUnlockSurface(MaskSurf);
317 }
318 }
319 }
320
321 /*
322 * @implemented
323 */
324
325 ULONG STDCALL
326 EngSetPointerShape(
327 IN SURFOBJ *pso,
328 IN SURFOBJ *psoMask,
329 IN SURFOBJ *psoColor,
330 IN XLATEOBJ *pxlo,
331 IN LONG xHot,
332 IN LONG yHot,
333 IN LONG x,
334 IN LONG y,
335 IN RECTL *prcl,
336 IN FLONG fl)
337 {
338 GDIDEVICE *ppdev;
339 SURFOBJ *TempSurfObj;
340 GDIPOINTER *pgp;
341
342 ASSERT(pso);
343
344 ppdev = GDIDEV(pso);
345 pgp = &ppdev->Pointer;
346
347 IntHideMousePointer(ppdev, pso);
348
349 if (pgp->ColorSurface != NULL)
350 {
351 /* FIXME: Is this really needed? */
352 if((TempSurfObj = EngLockSurface(pgp->ColorSurface)))
353 {
354 EngFreeMem(TempSurfObj->pvBits);
355 TempSurfObj->pvBits = 0;
356 EngUnlockSurface(TempSurfObj);
357 }
358
359 EngDeleteSurface(pgp->ColorSurface);
360 pgp->MaskSurface = NULL;
361 }
362
363 if (pgp->MaskSurface != NULL)
364 {
365 /* FIXME: Is this really needed? */
366 if((TempSurfObj = EngLockSurface(pgp->MaskSurface)))
367 {
368 EngFreeMem(TempSurfObj->pvBits);
369 TempSurfObj->pvBits = 0;
370 EngUnlockSurface(TempSurfObj);
371 }
372
373 EngDeleteSurface(pgp->MaskSurface);
374 pgp->MaskSurface = NULL;
375 }
376
377 if (pgp->SaveSurface != NULL)
378 {
379 EngDeleteSurface(pgp->SaveSurface);
380 pgp->SaveSurface = NULL;
381 }
382
383 if (pgp->XlateObject != NULL)
384 {
385 EngDeleteXlate(pgp->XlateObject);
386 pgp->XlateObject = NULL;
387 }
388
389 /*
390 * See if we are being asked to hide the pointer.
391 */
392
393 if (psoMask == NULL)
394 {
395 return SPS_ACCEPT_NOEXCLUDE;
396 }
397
398 pgp->HotSpot.x = xHot;
399 pgp->HotSpot.y = yHot;
400
401 /* Actually this should be set by 'the other side', but it would be
402 * done right after this. It helps IntShowMousePointer. */
403 if (x != -1)
404 {
405 pgp->Pos.x = x;
406 pgp->Pos.y = y;
407 }
408
409 pgp->Size.cx = abs(psoMask->lDelta) << 3;
410 pgp->Size.cy = (psoMask->cjBits / abs(psoMask->lDelta)) >> 1;
411
412 if (psoColor != NULL)
413 {
414 PBYTE Bits;
415
416 Bits = EngAllocMem(0, psoColor->cjBits, TAG_MOUSE);
417 if (Bits == NULL)
418 {
419 return SPS_ERROR;
420 }
421
422 memcpy(Bits, psoColor->pvBits, psoColor->cjBits);
423
424 pgp->ColorSurface = (HSURF)EngCreateBitmap(pgp->Size,
425 psoColor->lDelta, psoColor->iBitmapFormat,
426 psoColor->lDelta < 0 ? 0 : BMF_TOPDOWN, Bits);
427 }
428 else
429 {
430 pgp->ColorSurface = NULL;
431 }
432
433 {
434 SIZEL Size;
435 PBYTE Bits;
436
437 Size.cx = pgp->Size.cx;
438 Size.cy = pgp->Size.cy << 1;
439 Bits = EngAllocMem(0, psoMask->cjBits, TAG_MOUSE);
440 if (Bits == NULL)
441 {
442 return SPS_ERROR;
443 }
444
445 memcpy(Bits, psoMask->pvBits, psoMask->cjBits);
446
447 pgp->MaskSurface = (HSURF)EngCreateBitmap(Size,
448 psoMask->lDelta, psoMask->iBitmapFormat,
449 psoMask->lDelta < 0 ? 0 : BMF_TOPDOWN, Bits);
450 }
451
452 /*
453 * Create an XLATEOBJ that will be used for drawing masks.
454 * FIXME: We should get this in pxlo parameter!
455 */
456
457 if (pxlo == NULL)
458 {
459 HPALETTE BWPalette, DestPalette;
460 ULONG BWColors[] = {0, 0xFFFFFF};
461
462 BWPalette = EngCreatePalette(PAL_INDEXED, sizeof(BWColors) / sizeof(ULONG),
463 BWColors, 0, 0, 0);
464
465 DestPalette = ppdev->DevInfo.hpalDefault;
466 pgp->XlateObject = IntEngCreateXlate(0, PAL_INDEXED,
467 DestPalette, BWPalette);
468 EngDeletePalette(BWPalette);
469 }
470 else
471 {
472 pgp->XlateObject = pxlo;
473 }
474
475 /*
476 * Create surface for saving the pixels under the cursor.
477 */
478
479 {
480 LONG lDelta;
481
482 switch (pso->iBitmapFormat)
483 {
484 case BMF_1BPP:
485 lDelta = pgp->Size.cx >> 3;
486 break;
487 case BMF_4BPP:
488 lDelta = pgp->Size.cx >> 1;
489 break;
490 case BMF_8BPP:
491 lDelta = pgp->Size.cx;
492 break;
493 case BMF_16BPP:
494 lDelta = pgp->Size.cx << 1;
495 break;
496 case BMF_24BPP:
497 lDelta = pgp->Size.cx * 3;
498 break;
499 case BMF_32BPP:
500 lDelta = pgp->Size.cx << 2;
501 break;
502 default:
503 lDelta = 0;
504 break;
505 }
506
507 pgp->SaveSurface = (HSURF)EngCreateBitmap(
508 pgp->Size, lDelta, pso->iBitmapFormat, BMF_TOPDOWN | BMF_NOZEROINIT, NULL);
509 }
510
511 if(x != -1)
512 {
513 IntShowMousePointer(ppdev, pso);
514
515 if (prcl != NULL)
516 {
517 prcl->left = x - pgp->HotSpot.x;
518 prcl->top = y - pgp->HotSpot.x;
519 prcl->right = prcl->left + pgp->Size.cx;
520 prcl->bottom = prcl->top + pgp->Size.cy;
521 }
522 } else if (prcl != NULL)
523 prcl->left = prcl->top = prcl->right = prcl->bottom = -1;
524
525 return SPS_ACCEPT_EXCLUDE;
526 }
527
528 /*
529 * @implemented
530 */
531
532 VOID STDCALL
533 EngMovePointer(
534 IN SURFOBJ *pso,
535 IN LONG x,
536 IN LONG y,
537 IN RECTL *prcl)
538 {
539 GDIDEVICE *ppdev;
540 GDIPOINTER *pgp;
541
542 ASSERT(pso);
543
544 ppdev = GDIDEV(pso);
545
546 ASSERT(ppdev);
547
548 pgp = &ppdev->Pointer;
549
550 IntHideMousePointer(ppdev, pso);
551 if (x != -1)
552 {
553 /* Actually this should be set by 'the other side', but it would be
554 * done right after this. It helps IntShowMousePointer. */
555 pgp->Pos.x = x;
556 pgp->Pos.y = y;
557 IntShowMousePointer(ppdev, pso);
558 if (prcl != NULL)
559 {
560 prcl->left = x - pgp->HotSpot.x;
561 prcl->top = y - pgp->HotSpot.x;
562 prcl->right = prcl->left + pgp->Size.cx;
563 prcl->bottom = prcl->top + pgp->Size.cy;
564 }
565 } else if (prcl != NULL)
566 prcl->left = prcl->top = prcl->right = prcl->bottom = -1;
567
568 }
569
570 VOID STDCALL
571 IntEngMovePointer(
572 IN SURFOBJ *SurfObj,
573 IN LONG x,
574 IN LONG y,
575 IN RECTL *prcl)
576 {
577 BITMAPOBJ *BitmapObj = CONTAINING_RECORD(SurfObj, BITMAPOBJ, SurfObj);
578
579 BITMAPOBJ_LockBitmapBits(BitmapObj);
580 if (GDIDEV(SurfObj)->Pointer.MovePointer)
581 {
582 GDIDEV(SurfObj)->Pointer.MovePointer(SurfObj, x, y, prcl);
583 }
584 else
585 {
586 EngMovePointer(SurfObj, x, y, prcl);
587 }
588 BITMAPOBJ_UnlockBitmapBits(BitmapObj);
589 }
590
591 /* EOF */