![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to enable.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 / vga|
Return to enable.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / video / displays / vga |
1.1 root 1: /******************************Module*Header*******************************\
2: * Module Name: enable.c
3: *
4: * Functions to enable and disable the driver
5: *
6: * Copyright (c) 1992 Microsoft Corporation
7: \**************************************************************************/
8:
9:
10: #include "driver.h"
11:
12:
13: FLONG gflDrv = 0;
14: #ifdef FIREWALLS
15: LONG cPDEV = 0; // PDEV counter for checking Engine
16: #endif
17:
18: extern GDIINFO gaulCap; // in gdiinfo.c
19: extern LOGPALETTE logPalVGA; // in gdiinfo.c
20: extern BYTE gaajPat[19][32]; // in gdiinfo.c
21: extern DEVINFO devinfoVGA; // in gdiinfo.c
22: extern LPBYTE pPtrSave;
23:
24: BOOL SetUpBanking(PDEVSURF, PPDEV);
25: BOOL bInitPointer(PPDEV);
26:
27: extern ajConvertBuffer[1]; // Arbitrary sized array!
28:
29: static DRVFN gadrvfn[] = {
30: { INDEX_DrvEnablePDEV, (PFN) DrvEnablePDEV },
31: { INDEX_DrvCompletePDEV, (PFN) DrvCompletePDEV },
32: { INDEX_DrvDisablePDEV, (PFN) DrvDisablePDEV },
33: { INDEX_DrvEnableSurface, (PFN) DrvEnableSurface },
34: { INDEX_DrvDisableSurface, (PFN) DrvDisableSurface },
35: { INDEX_DrvRealizeBrush, (PFN) DrvRealizeBrush },
36: { INDEX_DrvBitBlt, (PFN) DrvBitBlt },
37: { INDEX_DrvTextOut, (PFN) DrvTextOut },
38: { INDEX_DrvSetPointerShape, (PFN) DrvSetPointerShape },
39: { INDEX_DrvMovePointer, (PFN) DrvMovePointer },
40: { INDEX_DrvStrokePath, (PFN) DrvStrokePath },
41: { INDEX_DrvCopyBits, (PFN) DrvCopyBits },
42: { INDEX_DrvDitherColor, (PFN) DrvDitherColor },
43: { INDEX_DrvAssertMode, (PFN) DrvAssertMode },
44: { INDEX_DrvSaveScreenBits, (PFN) DrvSaveScreenBits },
45: { INDEX_DrvGetModes, (PFN) DrvGetModes },
46: { INDEX_DrvFillPath, (PFN) DrvFillPath },
47: { INDEX_DrvPaint, (PFN) DrvPaint }
48: };
49:
50: /******************************Public*Routine******************************\
51: * BOOL bEnableDriver(iEngineVersion, cb, pded)
52: *
53: * Enables the driver by filling the function table. This call is made by
54: * the Engine to fill its driver function table in the LDEV (Logical DEVice).
55: * This call should only be made once per driver but we can handle being
56: * called multiple times.
57: *
58: \**************************************************************************/
59:
60: BOOL DrvEnableDriver
61: (
62: ULONG iEngineVersion,
63: ULONG cb,
64: PDRVENABLEDATA pded
65: )
66: {
67: DISPDBG((2, "VGA: enabling Driver\n"));
68:
69: cb /= sizeof(ULONG);
70:
71: switch(cb)
72: {
73: case 3:
74: pded->pdrvfn = gadrvfn;
75: case 2:
76: pded->c = sizeof(gadrvfn) / sizeof(DRVFN);
77: case 1:
78: pded->iDriverVersion = DDI_DRIVER_VERSION;
79: }
80:
81: return(TRUE);
82: }
83:
84: /******************************Public*Routine******************************\
85: * VOID vDisableDriver
86: *
87: * Unload the driver and any data in may have created.
88: *
89: \**************************************************************************/
90:
91: VOID DrvDisableDriver()
92: {
93: DISPDBG((2, "VGA: disabling Driver\n"));
94: }
95:
96: /******************************Public*Routine******************************\
97: * BOOL bLoadResources()
98: *
99: * Load the resources used by the PDEV
100: *
101: \**************************************************************************/
102:
103: BOOL bLoadResources(PPDEV ppdev)
104: {
105: // Load the font resources
106:
107: return(TRUE);
108:
109: UNREFERENCED_PARAMETER(ppdev);
110: }
111:
112: /******************************Public*Routine******************************\
113: * bInitDefaultPatterns
114: *
115: * Creates the default monochrome patterns to be used on it's surface.
116: *
117: \**************************************************************************/
118:
119: BOOL bInitDefaultPatterns(PPDEV ppdev)
120: {
121: SIZEL sizl;
122: INT iLoop;
123: PULONG pulInit;
124:
125: sizl.cx = 8;
126: sizl.cy = 8;
127:
128: DISPDBG((2, "VGA: initializing defailt patterns\n"));
129:
130: for (iLoop = 0; iLoop < HS_DDI_MAX; iLoop++)
131: {
132: pulInit = (PULONG) (&gaajPat[iLoop][0]);
133: ppdev->ahbmPat[iLoop] = EngCreateBitmap(sizl, sizl.cx / 8, BMF_1BPP,
134: BMF_TOPDOWN, pulInit);
135:
136: if (ppdev->ahbmPat[iLoop] == (HBITMAP)0)
137: {
138: // Release any bitmaps we have created.
139:
140: while(iLoop--)
141: EngDeleteSurface((HSURF) ppdev->ahbmPat[iLoop]);
142:
143: return(FALSE);
144: }
145: }
146:
147: return(TRUE);
148: }
149:
150: /******************************Public*Routine******************************\
151: * DHPDEV DrvEnablePDEV
152: *
153: * Enable the Physical DEVice
154: *
155: * Warnings:
156: * The PDEV isn't complete until bCompletePDEV is called.
157: *
158: \**************************************************************************/
159:
160: DHPDEV DrvEnablePDEV
161: (
162: DEVMODEW *pdrivw,
163: PWSTR pwszLogAddress,
164: ULONG cPatterns,
165: PHSURF ahsurfPatterns,
166: ULONG cjGdiInfo,
167: ULONG *pdevcaps,
168: ULONG cb,
169: PDEVINFO pdevinfo,
170: PWSTR pwszDataFile,
171: PWSTR pwszDeviceName,
172: HANDLE hDriver // Handle to base driver
173: )
174: {
175: FLONG fl = 0;
176: DHPDEV dhpdev = (DHPDEV) 0;
177: PPDEV ppdev;
178: SYSTEM_INFO SystemInfo;
179:
180: DISPDBG((2, "VGA: enabling PDEV\n"));
181:
182: // Define flag to keep track of allocation
183:
184: #define PDEV_ALLOCED 0x01
185:
186: #ifdef DRV_ONE_PDEV
187: if (gflDrv & DRV_ENABLED_PDEV)
188: {
189: // SAVE_ERROR_CODE(DDI_PDEV_ALREADY_ENABLED);
190: goto error;
191: }
192: #endif
193:
194: dhpdev = (DHPDEV) LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, sizeof(PDEV));
195: if (dhpdev == (DHPDEV) 0)
196: goto error;
197:
198: fl |= PDEV_ALLOCED;
199:
200: ppdev = (PPDEV) dhpdev;
201:
202: // Identifier, for debugging purposes
203: ppdev->ident = PDEV_IDENT;
204:
205: // Determine whether this is a 386 or a better processor
206: GetSystemInfo(&SystemInfo);
207: if (SystemInfo.dwProcessorType == PROCESSOR_INTEL_386) {
208: ppdev->ulIs386 = 1;
209: } else {
210: ppdev->ulIs386 = 0;
211: }
212:
213: // Cache the device driver handle away for later use.
214:
215: ppdev->hDriver = hDriver;
216:
217: // Initialize the cursor stuff. We can violate the atomic rule here
218: // since nobody can talk to the driver yet.
219:
220: ppdev->xyCursor.x = 320; // Non-atomic
221: ppdev->xyCursor.y = 240; // Non-atomic
222:
223: ppdev->ptlExtent.x = 0;
224: ppdev->ptlExtent.y = 0;
225: ppdev->cExtent = 0;
226:
227: ppdev->flCursor = CURSOR_DOWN;
228:
229: //
230: // Get the current screen mode information. Set up device caps and devinfo.
231: //
232:
233: if (!bInitPDEV(ppdev, pdrivw, &gaulCap, &devinfoVGA))
234: {
235: DISPDBG((1, "DISP VGA DrvEnablePDEV failed bInitPDEV\n"));
236: goto error;
237: }
238:
239: if (!bLoadResources(ppdev))
240: goto error;
241:
242: if (!bInitDefaultPatterns(ppdev))
243: goto error;
244:
245: #ifdef DRV_ONE_PDEV
246: gflDrv |= DRV_ENABLED_PDEV; // So we're not called twice
247: #endif
248:
249: cPatterns=min(cPatterns, HS_DDI_MAX);
250:
251: memcpy((PVOID)ahsurfPatterns, ppdev->ahbmPat, cPatterns*sizeof(HBITMAP));
252:
253: cjGdiInfo=min(cjGdiInfo, sizeof(GDIINFO));
254:
255: memcpy(pdevcaps, &gaulCap, cjGdiInfo);
256:
257: // Now let's pass back the devinfo
258:
259: devinfoVGA.hpalDefault = EngCreatePalette(PAL_INDEXED, 16,
260: (PULONG) (logPalVGA.palPalEntry),
261: 0, 0, 0);
262:
263: // *pdevinfo = devinfoVGA;
264: memcpy((PVOID) pdevinfo, (PVOID) &devinfoVGA, (ULONG) sizeof(DEVINFO));
265:
266: // Try to preallocate a saved screen bits buffer. If we fail, set the flag
267: // to indicate the buffer is in use, so that we'll never attempt to use it.
268: // If we succeed, mark the buffer as free.
269:
270: if ((ppdev->pjPreallocSSBBuffer = (PUCHAR)
271: LocalAlloc(LMEM_FIXED | LMEM_ZEROINIT, PREALLOC_SSB_SIZE))
272: != NULL) {
273: ppdev->flPreallocSSBBufferInUse = FALSE;
274: ppdev->ulPreallocSSBSize = PREALLOC_SSB_SIZE;
275: } else {
276: ppdev->flPreallocSSBBufferInUse = TRUE;
277: }
278:
279: // Fill in the DIB4->VGA conversion tables. Allow 256 extra bytes so that
280: // we can always safely align the tables to a 256-byte boundary, for
281: // look-up reasons. There are four tables, each 256 bytes long
282:
283: ppdev->pucDIB4ToVGAConvBuffer =
284: (UCHAR *) LocalAlloc((LMEM_FIXED | LMEM_ZEROINIT),
285: ((256*4+256)*sizeof(UCHAR)));
286:
287: if (ppdev->pucDIB4ToVGAConvBuffer == NULL) {
288: goto error;
289: }
290:
291: // Round the table start up to the nearest 256 byte boundary, because the
292: // tables must start on 256-byte boundaries for look-up reasons
293:
294: ppdev->pucDIB4ToVGAConvTables =
295: (UCHAR *) ((ULONG) (ppdev->pucDIB4ToVGAConvBuffer + 0xFF) & ~0xFF);
296:
297: vSetDIB4ToVGATables(ppdev->pucDIB4ToVGAConvTables);
298:
299: return(dhpdev);
300:
301: error:
302: if (fl & PDEV_ALLOCED)
303: LocalFree(dhpdev);
304:
305: return((DHPDEV) 0);
306:
307: UNREFERENCED_PARAMETER(cb);
308: UNREFERENCED_PARAMETER(pwszLogAddress);
309: UNREFERENCED_PARAMETER(pwszDataFile);
310: UNREFERENCED_PARAMETER(pwszDeviceName);
311: }
312:
313: /******************************Public*Routine******************************\
314: * BOOL bCompletePDEV(dhpdev, hpdev)
315: *
316: * Complete the initialization of the PDEV
317: *
318: \**************************************************************************/
319:
320: VOID DrvCompletePDEV(
321: DHPDEV dhpdev,
322: HDEV hdev)
323: {
324: PPDEV ppdev;
325:
326: ppdev = (PPDEV) dhpdev;
327:
328: ppdev->hdevEng = hdev;
329: }
330:
331: /******************************Public*Routine******************************\
332: * VOID vFreeResources(ppdev)
333: *
334: * Free the resources used by the PDEV
335: *
336: * Effects:
337: *
338: * Warnings:
339: *
340: \**************************************************************************/
341:
342: VOID vFreeResources(PPDEV ppdev)
343: {
344:
345: UNREFERENCED_PARAMETER(ppdev);
346: }
347:
348: /******************************Public*Routine******************************\
349: * VOID vKillPatterns(ppdev)
350: *
351: * Clear the standard patterns
352: *
353: \**************************************************************************/
354:
355: VOID vKillPatterns(PPDEV ppdev)
356: {
357: INT ii;
358:
359: for (ii = 0; ii < HS_DDI_MAX; ii++)
360: EngDeleteSurface((HSURF) ppdev->ahbmPat[ii]);
361: }
362:
363: /******************************Public*Routine******************************\
364: * VOID DrvDisablePDEV(dhpdev)
365: *
366: * Shutdown this physical device.
367: *
368: * Warnings:
369: * If a surface is still active for this PDEV it will be freed.
370: *
371:
372: \**************************************************************************/
373:
374: VOID DrvDisablePDEV(DHPDEV dhpdev)
375: {
376: PPDEV ppdev;
377:
378: ppdev = (PPDEV) dhpdev;
379:
380: DISPDBG((2, "VGA:disabling PDEV\n"));
381:
382: // ASSERT(ppdev != (PPDEV) NULL, "PDEV error");
383:
384: // Is there a deliquent surface still in the PDEV?
385:
386: if (ppdev->hsurfEng != (HSURF) 0)
387: DrvDisableSurface(dhpdev);
388:
389: // Check if the Engine has called us to many times.
390:
391: // ASSERT(--cPDEV >= 0, "PDEV - too many disables");
392:
393: // Free the resources and bitmaps associated with this PDEV
394:
395: vFreeResources(ppdev);
396: vKillPatterns(ppdev);
397:
398: // Free the preallocated saved screen bits buffer, if there is one.
399:
400: if (ppdev->pjPreallocSSBBuffer != NULL) {
401: LocalFree(ppdev->pjPreallocSSBBuffer);
402: }
403:
404: // Free the conversion table buffer
405:
406: if (ppdev->pucDIB4ToVGAConvBuffer != NULL) {
407: LocalFree(ppdev->pucDIB4ToVGAConvBuffer);
408: }
409:
410: // Delete the PDEV
411:
412: LocalFree(dhpdev);
413:
414: DISPDBG((2, "VGA: disabled PDEV\n"));
415:
416: #ifdef DRV_ONE_PDEV
417: gflDrv &= ~DRV_ENABLED_PDEV;
418: #endif
419: }
420:
421: /******************************Public*Routine******************************\
422: * HSURF DrvEnableSurface(dhpdev)
423: *
424: * Enable the surface for the device. This will actually intialize the
425: * screen on the VGA.
426: *
427: * Warnings:
428: * This routine should only be called ONCE per PDEV.
429: *
430: \**************************************************************************/
431:
432: HSURF DrvEnableSurface(DHPDEV dhpdev)
433: {
434: PPDEV ppdev;
435: PDEVSURF pdsurf;
436: DHSURF dhsurf;
437: HSURF hsurf;
438:
439: DISPDBG((2, "VGA:enabling Surface\n"));
440:
441: ppdev = (PPDEV) dhpdev;
442:
443: //
444: // Initialize the VGA device into the selected mode which will also map
445: // the video frame buffer
446: //
447:
448: if (!bInitVGA(ppdev, TRUE))
449: {
450: goto error_done;
451: }
452:
453: dhsurf = (DHSURF) LocalAlloc(LMEM_FIXED, (SIZE_T) sizeof(DEVSURF));
454:
455: if (dhsurf == (DHSURF) 0)
456: goto error_done;
457:
458: pdsurf = (PDEVSURF) dhsurf;
459:
460: pdsurf->ident = DEVSURF_IDENT;
461: pdsurf->flSurf = 0;
462: pdsurf->iFormat = BMF_PHYSDEVICE;
463: pdsurf->jReserved1 = 0;
464: pdsurf->jReserved2 = 0;
465: pdsurf->ppdev = ppdev;
466: pdsurf->sizlSurf.cx = ppdev->sizlSurf.cx;
467: pdsurf->sizlSurf.cy = ppdev->sizlSurf.cy;
468: pdsurf->lNextPlane = 0;
469: pdsurf->pvScan0 = ppdev->pjScreen;
470: pdsurf->pvBitmapStart = ppdev->pjScreen;
471: pdsurf->pvStart = ppdev->pjScreen;
472: pdsurf->pvConv = &ajConvertBuffer[0];
473:
474: if (!bInitPointer(ppdev)) {
475: DISPDBG((0, "VGA DrvEnablePDEV failed bInitPointer\n"));
476: goto error_clean;
477: }
478:
479: if (!SetUpBanking(pdsurf, ppdev)) {
480: DISPDBG((0, "VGA DrvEnablePDEV failed SetUpBanking\n"));
481: goto error_clean;
482: }
483:
484: // Initialize pointer information.
485:
486: if ((hsurf = EngCreateSurface(dhsurf, ppdev->sizlSurf)) == (HSURF) 0)
487: {
488: DISPDBG((0, "VGA DrvEnablePDEV failed EngCreateSurface\n"));
489: goto error_clean;
490: }
491:
492: if (EngAssociateSurface(hsurf, ppdev->hdevEng,
493: HOOK_BITBLT | HOOK_TEXTOUT | HOOK_STROKEPATH |
494: HOOK_COPYBITS | HOOK_PAINT | HOOK_FILLPATH))
495: {
496: ppdev->hsurfEng = hsurf;
497: ppdev->pdsurf = pdsurf;
498:
499: // Set up an empty saved screen block list
500: pdsurf->ssbList = NULL;
501: // Initialize the offscreen adapter memory heap to currently all
502: // available
503: // Beginning of heap starts right after the displayed bitmap ends
504: pdsurf->pjAdapterHeapStart = ((PBYTE)pdsurf->pvBitmapStart) +
505: (pdsurf->lNextScan * pdsurf->sizlSurf.cy);
506:
507: // End of heap is the start of either the pointer work area or the
508: // hardware pointer reserved memory area, whichever comes first
509: pdsurf->pjAdapterHeapEnd = pPtrSave;
510: if (ppdev->pPointerAttributes != NULL)
511: {
512: // There's a hardware pointer, so check what display memory it
513: // uses, if any
514: if (ppdev->PointerCapabilities.HWPtrBitmapStart != -1)
515: {
516: // The hardware pointer does use display memory
517: if (( ((PBYTE)pdsurf->pvBitmapStart) +
518: ppdev->PointerCapabilities.HWPtrBitmapStart) <
519: pdsurf->pjAdapterHeapEnd)
520: {
521: // The hardware pointer marks the end of the heap
522: pdsurf->pjAdapterHeapEnd = ((PBYTE)pdsurf->pvBitmapStart) +
523: ppdev->PointerCapabilities.HWPtrBitmapStart;
524: }
525: }
526: }
527:
528: // The current top of the heap is the end of the heap, because the heap
529: // is empty
530: pdsurf->pjAdapterHeapTop = pdsurf->pjAdapterHeapEnd;
531:
532: DISPDBG((2, "VGA: enabled surface\n"));
533:
534: return(hsurf);
535:
536: }
537:
538: DISPDBG((0, "VGA DrvEnablePDEV failed EngDeleteSurface\n"));
539: EngDeleteSurface(hsurf);
540:
541: error_clean:
542: // We created the surface, so delete it
543: LocalFree(dhsurf);
544:
545: error_done:
546: return((HSURF) 0);
547: }
548:
549:
550: /******************************Public*Routine******************************\
551: * DrvDisableSurface
552: *
553: * Free resources associated with this surface.
554: *
555: \**************************************************************************/
556:
557: VOID DrvDisableSurface(DHPDEV dhpdev)
558: {
559: PPDEV ppdev = (PPDEV) dhpdev;
560: PDEVSURF pdsurf = ppdev->pdsurf;
561: PSAVED_SCREEN_BITS pSSB, pSSBNext;
562:
563: DISPDBG((2, "VGA:disabling surface\n"));
564:
565: // Free up banking-related stuff.
566: LocalFree(pdsurf->pBankSelectInfo);
567:
568: if (pdsurf->pbiBankInfo != NULL) {
569: LocalFree(pdsurf->pbiBankInfo);
570: }
571:
572: if (pdsurf->pbiBankInfo2RW != NULL) {
573: LocalFree(pdsurf->pbiBankInfo2RW);
574: }
575:
576: if (pdsurf->pvBankBufferPlane0 != NULL) {
577: LocalFree(pdsurf->pvBankBufferPlane0);
578: }
579:
580: if (ppdev->pPointerAttributes != NULL) {
581: LocalFree(ppdev->pPointerAttributes);
582: }
583:
584: // Free any pending saved screen bit blocks.
585: pSSB = pdsurf->ssbList;
586: while (pSSB != (PSAVED_SCREEN_BITS) NULL) {
587: // Point to the next saved screen bits block
588: pSSBNext = (PSAVED_SCREEN_BITS) pSSB->pvNextSSB;
589: // Free the current block
590: LocalFree(pSSB);
591: pSSB = pSSBNext;
592: }
593:
594: EngDeleteSurface((HSURF) ppdev->hsurfEng);
595:
596: LocalFree(pdsurf); // free the surface
597:
598: DISPDBG((2, "VGA:disabled surface\n"));
599:
600: }
601:
602: /******************************Public*Routine******************************\
603: * DrvAssertMode
604: *
605: * Ping the device back into its last known mode
606: *
607: \**************************************************************************/
608:
609: VOID DrvAssertMode(DHPDEV dhpdev, BOOL Enable)
610: {
611: PPDEV ppdev = (PPDEV) dhpdev;
612: ULONG returnedDataLength;
613:
614: DISPDBG((2, "VGA: DrvAssertMode\n"));
615:
616: if (Enable) {
617:
618: //
619: // The screen must be reenabled since we had gone to full screen.
620: // Re-initialize the device.
621: // !!! BUGBUG what happens if this fails ??
622: //
623:
624: bInitVGA(ppdev, FALSE);
625:
626: vForceBank0(ppdev);
627:
628: } else {
629:
630: //
631: // We must give up the display.
632: // Call the kernel driver to reset the device to a known state.
633: //
634:
635: if (!DeviceIoControl(ppdev->hDriver,
636: IOCTL_VIDEO_RESET_DEVICE,
637: NULL,
638: 0,
639: NULL,
640: 0,
641: &returnedDataLength,
642: NULL)) {
643:
644: RIP("VGA.DLL: Reset Device Failed");
645:
646: }
647: }
648:
649: return;
650: }
651:
652: /******************************Public*Routine******************************\
653: * DrvGetModes
654: *
655: * Returns the list of available modes for the device.
656: *
657: \**************************************************************************/
658:
659: ULONG DrvGetModes(
660: HANDLE hDriver,
661: ULONG cjSize,
662: DEVMODEW *pdm)
663:
664: {
665:
666: DWORD cModes;
667: DWORD cbOutputSize;
668: PVIDEO_MODE_INFORMATION pVideoModeInformation, pVideoTemp;
669: DWORD cOutputModes = cjSize / (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
670: DWORD cbModeSize;
671:
672: DISPDBG((2, "Vga.dll:DrvGetModes\n"));
673:
674: cModes = getAvailableModes(hDriver,
675: (PVIDEO_MODE_INFORMATION *) &pVideoModeInformation,
676: &cbModeSize);
677:
678: if (cModes == 0)
679: {
680: DISPDBG((0, "VGA DISP DrvGetModes failed to get mode information"));
681: return 0;
682: }
683:
684: if (pdm == NULL)
685: {
686: cbOutputSize = cModes * (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
687: }
688: else
689: {
690: //
691: // Now copy the information for the supported modes back into the output
692: // buffer
693: //
694:
695: cbOutputSize = 0;
696:
697: pVideoTemp = pVideoModeInformation;
698:
699: do
700: {
701: if (pVideoTemp->Length != 0)
702: {
703: if (cOutputModes == 0)
704: {
705: break;
706: }
707:
708: //
709: // Zero the entire structure to start off with.
710: //
711:
712: memset(pdm, 0, sizeof(DEVMODEW));
713:
714: //
715: // Set the name of the device to the name of the DLL.
716: //
717:
718: memcpy(&(pdm->dmDeviceName), L"vga", sizeof(L"vga"));
719:
720: pdm->dmSpecVersion = DM_SPECVERSION;
721: pdm->dmDriverVersion = DM_SPECVERSION;
722:
723: //
724: // We currently do not support Extra information in the driver
725: //
726:
727: pdm->dmDriverExtra = DRIVER_EXTRA_SIZE;
728:
729: pdm->dmSize = sizeof(DEVMODEW);
730: pdm->dmBitsPerPel = pVideoTemp->NumberOfPlanes *
731: pVideoTemp->BitsPerPlane;
732: pdm->dmPelsWidth = pVideoTemp->VisScreenWidth;
733: pdm->dmPelsHeight = pVideoTemp->VisScreenHeight;
734: pdm->dmDisplayFrequency = pVideoTemp->Frequency;
735:
736: if (pVideoTemp->AttributeFlags & VIDEO_MODE_INTERLACED)
737: {
738: pdm->dmDisplayFlags |= DM_INTERLACED;
739: }
740:
741: //
742: // Go to the next DEVMODE entry in the buffer.
743: //
744:
745: cOutputModes--;
746:
747: pdm = (LPDEVMODEW) ( ((ULONG)pdm) + sizeof(DEVMODEW) +
748: DRIVER_EXTRA_SIZE);
749:
750: cbOutputSize += (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
751:
752: }
753:
754: pVideoTemp = (PVIDEO_MODE_INFORMATION)
755: (((PUCHAR)pVideoTemp) + cbModeSize);
756:
757: } while (--cModes);
758: }
759:
760: LocalFree(pVideoModeInformation);
761:
762: return cbOutputSize;
763:
764: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.