![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pointer.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / video / displays / jz484|
Return to pointer.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / jz484 |
1.1 root 1: /******************************Module*Header*******************************\
2: * Module Name: pointer.c *
3: * *
4: * This module contains the hardware Pointer support for the framebuffer *
5: * *
6: * Copyright (c) 1992 Microsoft Corporation *
7: \**************************************************************************/
8:
9: #include "driver.h"
10:
11: BOOL bCopyColorPointer(
12: PPDEV ppdev,
13: SURFOBJ *psoMask,
14: SURFOBJ *psoColor,
15: XLATEOBJ *pxlo);
16:
17: BOOL bCopyMonoPointer(
18: PPDEV ppdev,
19: SURFOBJ *psoMask);
20:
21: BOOL bSetHardwarePointerShape(
22: SURFOBJ *pso,
23: SURFOBJ *psoMask,
24: SURFOBJ *psoColor,
25: XLATEOBJ *pxlo,
26: LONG x,
27: LONG y,
28: FLONG fl);
29:
30: /******************************Public*Routine******************************\
31: * DrvMovePointer
32: *
33: * Moves the hardware pointer to a new position.
34: *
35: \**************************************************************************/
36:
37: VOID DrvMovePointer
38: (
39: SURFOBJ *pso,
40: LONG x,
41: LONG y,
42: RECTL *prcl
43: )
44: {
45: PPDEV ppdev = (PPDEV) pso->dhpdev;
46: DWORD returnedDataLength;
47: VIDEO_POINTER_POSITION NewPointerPosition;
48:
49: // We don't use the exclusion rectangle because we only support
50: // hardware Pointers. If we were doing our own Pointer simulations
51: // we would want to update prcl so that the engine would call us
52: // to exclude out pointer before drawing to the pixels in prcl.
53:
54: UNREFERENCED_PARAMETER(prcl);
55:
56: if (x == -1)
57: {
58: // A new position of (-1,-1) means hide the pointer.
59: if (!DeviceIoControl(ppdev->hDriver,
60: IOCTL_VIDEO_DISABLE_POINTER,
61: NULL,
62: 0,
63: NULL,
64: 0,
65: &returnedDataLength,
66: NULL))
67: {
68: // Not the end of the world, print warning in checked build.
69: DISPDBG((0, "DISP vMoveHardwarePointer failed IOCTL_VIDEO_DISABLE_POINTER\n"));
70: }
71: }
72: else
73: {
74: NewPointerPosition.Column = (SHORT) x - (SHORT) (ppdev->ptlHotSpot.x);
75: NewPointerPosition.Row = (SHORT) y - (SHORT) (ppdev->ptlHotSpot.y);
76: // Call NT screen driver to move Pointer.
77:
78: if (!DeviceIoControl(ppdev->hDriver,
79: IOCTL_VIDEO_SET_POINTER_POSITION,
80: &NewPointerPosition,
81: sizeof(VIDEO_POINTER_POSITION),
82: NULL,
83: 0,
84: &returnedDataLength,
85: NULL))
86: {
87: // Not the end of the world, print warning in checked build.
88: DISPDBG((0, "DISP vMoveHardwarePointer failed IOCTL_VIDEO_SET_POINTER_POSITION\n"));
89: }
90: }
91: }
92:
93: /******************************Public*Routine******************************\
94: * DrvSetPointerShape
95: *
96: * Sets the new pointer shape.
97: *
98: \**************************************************************************/
99:
100: ULONG DrvSetPointerShape
101: (
102: SURFOBJ *pso,
103: SURFOBJ *psoMask,
104: SURFOBJ *psoColor,
105: XLATEOBJ *pxlo,
106: LONG xHot,
107: LONG yHot,
108: LONG x,
109: LONG y,
110: RECTL *prcl,
111: FLONG fl
112: )
113: {
114: PPDEV ppdev = (PPDEV) pso->dhpdev;
115: DWORD returnedDataLength;
116:
117: // We don't use the exclusion rectangle because we only support
118: // hardware Pointers. If we were doing our own Pointer simulations
119: // we would want to update prcl so that the engine would call us
120: // to exclude out pointer before drawing to the pixels in prcl.
121:
122: UNREFERENCED_PARAMETER(prcl);
123:
124: if (ppdev->pPointerAttributes == (PVIDEO_POINTER_ATTRIBUTES) NULL)
125: {
126: // Mini-port has no hardware Pointer support.
127: return(SPS_ERROR);
128: }
129:
130: // See if we are being asked to hide the pointer
131:
132: if (psoMask == (SURFOBJ *) NULL)
133: {
134: if (!DeviceIoControl(ppdev->hDriver,
135: IOCTL_VIDEO_DISABLE_POINTER,
136: NULL,
137: 0,
138: NULL,
139: 0,
140: &returnedDataLength,
141: NULL))
142: {
143: // It should never be possible to fail.
144:
145: DISPDBG((0, "DISP bSetHardwarePointerShape failed IOCTL_VIDEO_DISABLE_POINTER\n"));
146: }
147:
148: return(TRUE);
149: }
150:
151: ppdev->ptlHotSpot.x = xHot;
152: ppdev->ptlHotSpot.y = yHot;
153:
154: if (!bSetHardwarePointerShape(pso,psoMask,psoColor,pxlo,x,y,fl))
155: {
156: if (ppdev->fHwCursorActive) {
157: ppdev->fHwCursorActive = FALSE;
158:
159: if (!DeviceIoControl(ppdev->hDriver,
160: IOCTL_VIDEO_DISABLE_POINTER,
161: NULL,
162: 0,
163: NULL,
164: 0,
165: &returnedDataLength, NULL)) {
166:
167: DISPDBG((0, "DISP bSetHardwarePointerShape failed IOCTL_VIDEO_DISABLE_POINTER\n"));
168: }
169: }
170: //
171: // Mini-port declines to realize this Pointer
172: //
173: return(SPS_DECLINE);
174: } else
175: ppdev->fHwCursorActive = TRUE;
176:
177: return(SPS_ACCEPT_NOEXCLUDE);
178: }
179:
180: /******************************Public*Routine******************************\
181: * bSetHardwarePointerShape
182: *
183: * Changes the shape of the Hardware Pointer.
184: *
185: * Returns: True if successful, False if Pointer shape can't be hardware.
186: *
187: \**************************************************************************/
188:
189: BOOL bSetHardwarePointerShape(
190: SURFOBJ *pso,
191: SURFOBJ *psoMask,
192: SURFOBJ *psoColor,
193: XLATEOBJ *pxlo,
194: LONG x,
195: LONG y,
196: FLONG fl)
197: {
198: PPDEV ppdev = (PPDEV) pso->dhpdev;
199: PVIDEO_POINTER_ATTRIBUTES pPointerAttributes = ppdev->pPointerAttributes;
200: DWORD returnedDataLength;
201:
202: if (psoColor != (SURFOBJ *) NULL)
203: {
204: if ((ppdev->PointerCapabilities.Flags & VIDEO_MODE_COLOR_POINTER) &&
205: bCopyColorPointer(ppdev, psoMask, psoColor, pxlo))
206: {
207: pPointerAttributes->Flags |= VIDEO_MODE_COLOR_POINTER;
208: } else {
209: return(FALSE);
210: }
211:
212: } else {
213:
214: if ((ppdev->PointerCapabilities.Flags & VIDEO_MODE_MONO_POINTER) &&
215: bCopyMonoPointer(ppdev, psoMask))
216: {
217: pPointerAttributes->Flags |= VIDEO_MODE_MONO_POINTER;
218: } else {
219: return(FALSE);
220: }
221: }
222:
223: // Initialize Pointer attributes and position
224:
225: pPointerAttributes->Column = (SHORT)(x - ppdev->ptlHotSpot.x);
226: pPointerAttributes->Row = (SHORT)(y - ppdev->ptlHotSpot.y);
227: pPointerAttributes->Enable = 1;
228:
229: if (fl & SPS_ANIMATESTART) {
230: pPointerAttributes->Flags |= VIDEO_MODE_ANIMATE_START;
231: } else if (fl & SPS_ANIMATEUPDATE) {
232: pPointerAttributes->Flags |= VIDEO_MODE_ANIMATE_UPDATE;
233: }
234:
235: // Set the new Pointer shape.
236:
237: if (!DeviceIoControl(ppdev->hDriver,
238: IOCTL_VIDEO_SET_POINTER_ATTR,
239: pPointerAttributes,
240: ppdev->cjPointerAttributes,
241: NULL,
242: 0,
243: &returnedDataLength,
244: NULL)) {
245:
246: DISPDBG((0, "DISP:Failed IOCTL_VIDEO_SET_POINTER_ATTR call\n"));
247: return(FALSE);
248: }
249:
250: return(TRUE);
251: }
252:
253: /******************************Public*Routine******************************\
254: * bCopyMonoPointer
255: *
256: * Copies two monochrome masks into a buffer of the maximum size handled by the
257: * miniport, with any extra bits set to 0. The masks are converted to topdown
258: * form if they aren't already. Returns TRUE if we can handle this pointer in
259: * hardware, FALSE if not.
260: *
261: \**************************************************************************/
262:
263: BOOL bCopyMonoPointer(
264: PPDEV ppdev,
265: SURFOBJ *pso)
266: {
267: ULONG cx;
268: ULONG cy;
269: PBYTE pjSrcAnd, pjSrcXor;
270: LONG lDeltaSrc, lDeltaDst;
271: LONG lSrcWidthInBytes;
272: ULONG cxSrc = pso->sizlBitmap.cx;
273: ULONG cySrc = pso->sizlBitmap.cy;
274: ULONG cxSrcBytes;
275: PVIDEO_POINTER_ATTRIBUTES pPointerAttributes = ppdev->pPointerAttributes;
276: PBYTE pjDstAnd = pPointerAttributes->Pixels;
277: PBYTE pjDstXor = pPointerAttributes->Pixels;
278:
279: // Make sure the new pointer isn't too big to handle
280: // (*2 because both masks are in there)
281: if ((cxSrc > ppdev->PointerCapabilities.MaxWidth) ||
282: (cySrc > (ppdev->PointerCapabilities.MaxHeight * 2)))
283: {
284: return(FALSE);
285: }
286:
287: pjDstXor += ((ppdev->PointerCapabilities.MaxWidth + 7) / 8) *
288: ppdev->pPointerAttributes->Height;
289:
290: // set the desk and mask to 0xff
291: memset(pjDstAnd, 0xFFFFFFFF, ppdev->pPointerAttributes->WidthInBytes *
292: ppdev->pPointerAttributes->Height);
293:
294: // Zero the dest XOR mask
295: memset(pjDstXor, 0, ppdev->pPointerAttributes->WidthInBytes *
296: ppdev->pPointerAttributes->Height);
297:
298: cxSrcBytes = (cxSrc + 7) / 8;
299:
300: if ((lDeltaSrc = pso->lDelta) < 0)
301: {
302: lSrcWidthInBytes = -lDeltaSrc;
303: } else {
304: lSrcWidthInBytes = lDeltaSrc;
305: }
306:
307: pjSrcAnd = (PBYTE) pso->pvBits;
308:
309: // If the incoming pointer bitmap is bottomup, we'll flip it to topdown to
310: // save the miniport some work
311: if (!(pso->fjBitmap & BMF_TOPDOWN))
312: {
313: // Copy from the bottom
314: pjSrcAnd += lSrcWidthInBytes * (cySrc - 1);
315: }
316:
317: // Height of just AND mask
318: cySrc = cySrc / 2;
319:
320: // Point to XOR mask
321: pjSrcXor = pjSrcAnd + (cySrc * lDeltaSrc);
322:
323: // Offset from end of one dest scan to start of next
324: lDeltaDst = ppdev->pPointerAttributes->WidthInBytes;
325:
326: for (cy = 0; cy < cySrc; ++cy)
327: {
328: memcpy(pjDstAnd, pjSrcAnd, cxSrcBytes);
329: memcpy(pjDstXor, pjSrcXor, cxSrcBytes);
330:
331: // Point to next source and dest scans
332: pjSrcAnd += lDeltaSrc;
333: pjSrcXor += lDeltaSrc;
334: pjDstAnd += lDeltaDst;
335: pjDstXor += lDeltaDst;
336: }
337:
338: return(TRUE);
339: }
340:
341: /******************************Public*Routine******************************\
342: * bCopyColorPointer
343: *
344: * Copies the mono and color masks into the buffer of maximum size
345: * handled by the miniport with any extra bits set to 0. Color translation
346: * is handled at this time. The masks are converted to topdown form if they
347: * aren't already. Returns TRUE if we can handle this pointer in hardware,
348: * FALSE if not.
349: *
350: \**************************************************************************/
351: BOOL bCopyColorPointer(
352: PPDEV ppdev,
353: SURFOBJ *psoMask,
354: SURFOBJ *psoColor,
355: XLATEOBJ *pxlo)
356: {
357: return(FALSE);
358: }
359:
360:
361: /******************************Public*Routine******************************\
362: * bInitPointer
363: *
364: * Initialize the Pointer attributes.
365: *
366: \**************************************************************************/
367:
368: BOOL bInitPointer(PPDEV ppdev, DEVINFO *pdevinfo)
369: {
370: DWORD returnedDataLength;
371:
372: ppdev->pPointerAttributes = (PVIDEO_POINTER_ATTRIBUTES) NULL;
373: ppdev->cjPointerAttributes = 0; // initialized in screen.c
374:
375: // Ask the miniport whether it provides pointer support.
376:
377: if (!DeviceIoControl(ppdev->hDriver,
378: IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES, &ppdev->ulMode,
379: sizeof(PVIDEO_MODE), &ppdev->PointerCapabilities,
380: sizeof(ppdev->PointerCapabilities), &returnedDataLength, NULL))
381: {
382: return(FALSE);
383: }
384:
385: // If neither mono nor color hardware pointer is supported, there's no
386: // hardware pointer support and we're done.
387: if ((!(ppdev->PointerCapabilities.Flags & VIDEO_MODE_MONO_POINTER)) &&
388: (!(ppdev->PointerCapabilities.Flags & VIDEO_MODE_COLOR_POINTER)))
389: {
390: return(TRUE);
391: }
392:
393: // Note: The buffer itself is allocated after we set the
394: // mode. At that time we know the pixel depth and we can
395: // allocate the correct size for the color pointer if supported.
396:
397:
398: // Set the asynchronous support status (async means miniport is capable of
399: // drawing the Pointer at any time, with no interference with any ongoing
400: // drawing operation)
401:
402: if (ppdev->PointerCapabilities.Flags & VIDEO_MODE_ASYNC_POINTER)
403: {
404: pdevinfo->flGraphicsCaps |= GCAPS_ASYNCMOVE;
405: }
406: else
407: {
408: pdevinfo->flGraphicsCaps &= ~GCAPS_ASYNCMOVE;
409: }
410:
411: return(TRUE);
412: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.