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