ReactOS 0.4.15-dev-7131-ge4d03f4
enable.c File Reference
#include <vgaddi.h>
Include dependency graph for enable.c:

Go to the source code of this file.

Classes

struct  _VGALOGPALETTE
 

Macros

#define SYSTM_LOGFONT   {16,7,0,0,700,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,VARIABLE_PITCH | FF_DONTCARE, L"System"}
 
#define HELVE_LOGFONT   {12,9,0,0,400,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_STROKE_PRECIS,PROOF_QUALITY,VARIABLE_PITCH | FF_DONTCARE, L"MS Sans Serif"}
 
#define COURI_LOGFONT   {12,9,0,0,400,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_STROKE_PRECIS,PROOF_QUALITY,FIXED_PITCH | FF_DONTCARE, L"Courier"}
 

Typedefs

typedef struct _VGALOGPALETTE VGALOGPALETTE
 

Functions

BOOL APIENTRY DrvEnableDriver (IN ULONG EngineVersion, IN ULONG SizeOfDED, OUT PDRVENABLEDATA DriveEnableData)
 
VOID APIENTRY DrvDisableDriver (VOID)
 
DHPDEV APIENTRY DrvEnablePDEV (IN DEVMODEW *DM, IN LPWSTR LogAddress, IN ULONG PatternCount, OUT HSURF *SurfPatterns, IN ULONG GDIInfoSize, OUT ULONG *GDIInfo, IN ULONG DevInfoSize, OUT DEVINFO *DevInfo, IN HDEV Dev, IN LPWSTR DeviceName, IN HANDLE Driver)
 
VOID APIENTRY DrvCompletePDEV (IN DHPDEV PDev, IN HDEV Dev)
 
BOOL APIENTRY DrvAssertMode (IN DHPDEV DPev, IN BOOL Enable)
 
VOID APIENTRY DrvDisablePDEV (IN DHPDEV PDev)
 
VOID APIENTRY DrvDisableSurface (IN DHPDEV PDev)
 
static VOID InitSavedBits (IN PPDEV ppdev)
 
HSURF APIENTRY DrvEnableSurface (IN DHPDEV PDev)
 
ULONG APIENTRY DrvGetModes (IN HANDLE Driver, IN ULONG DataSize, OUT PDEVMODEW DM)
 
ULONG DbgPrint (PCCH Format,...)
 

Variables

static BOOL VGAInitialized = FALSE
 
static DRVFN FuncList []
 
static GDIINFO gaulCap
 
const VGALOGPALETTE VGApalette
 
DEVINFO devinfoVGA
 

Macro Definition Documentation

◆ COURI_LOGFONT

#define COURI_LOGFONT   {12,9,0,0,400,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_STROKE_PRECIS,PROOF_QUALITY,FIXED_PITCH | FF_DONTCARE, L"Courier"}

Definition at line 169 of file enable.c.

◆ HELVE_LOGFONT

#define HELVE_LOGFONT   {12,9,0,0,400,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,CLIP_STROKE_PRECIS,PROOF_QUALITY,VARIABLE_PITCH | FF_DONTCARE, L"MS Sans Serif"}

Definition at line 168 of file enable.c.

◆ SYSTM_LOGFONT

Definition at line 167 of file enable.c.

Typedef Documentation

◆ VGALOGPALETTE

Function Documentation

◆ DbgPrint()

ULONG DbgPrint ( PCCH  Format,
  ... 
)

Definition at line 582 of file enable.c.

583{
584 va_list ap;
586 EngDebugPrint("VGADDI", (PCHAR)Format, ap);
587 va_end(ap);
588 return 0;
589}
char * va_list
Definition: acmsvcex.h:78
#define va_end(ap)
Definition: acmsvcex.h:90
#define va_start(ap, A)
Definition: acmsvcex.h:91
char * PCHAR
Definition: typedefs.h:51
ENGAPI VOID APIENTRY EngDebugPrint(_In_z_ PCHAR StandardPrefix, _In_z_ PCHAR DebugMessage, _In_ va_list ap)
Definition: debug.c:19
void int int ULONGLONG int va_list * ap
Definition: winesup.h:36

◆ DrvAssertMode()

BOOL APIENTRY DrvAssertMode ( IN DHPDEV  DPev,
IN BOOL  Enable 
)

Definition at line 297 of file enable.c.

299{
300 PPDEV ppdev = (PPDEV)DPev;
301 ULONG returnedDataLength;
302
303 if (Enable)
304 {
305 /* Reenable our graphics mode */
306 if (!InitPointer(ppdev))
307 {
308 /* Failed to set pointer */
309 return FALSE;
310 }
311
312 if (!VGAInitialized)
313 {
314 if (!InitVGA(ppdev, FALSE))
315 {
316 /* Failed to initialize the VGA */
317 return FALSE;
318 }
320 }
321 }
322 else
323 {
324 /* Go back to last known mode */
325 DPRINT("ppdev: %p, KMDriver: %p\n", ppdev, ppdev->KMDriver);
326 if (EngDeviceIoControl(ppdev->KMDriver, IOCTL_VIDEO_RESET_DEVICE, NULL, 0, NULL, 0, &returnedDataLength))
327 {
328 /* Failed to go back to mode */
329 return FALSE;
330 }
332 }
333 return TRUE;
334}
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
struct _PDEV * PPDEV
_In_ ULONGLONG _In_ ULONGLONG _In_ BOOLEAN Enable
Definition: ntddpcm.h:142
#define IOCTL_VIDEO_RESET_DEVICE
Definition: ntddvdeo.h:137
#define DPRINT
Definition: sndvol32.h:71
Definition: framebuf.h:34
HANDLE KMDriver
Definition: vgaddi.h:108
uint32_t ULONG
Definition: typedefs.h:59
BOOL InitPointer(PPDEV ppdev)
Definition: pointer.c:143
static BOOL VGAInitialized
Definition: enable.c:11
BOOL InitVGA(PPDEV ppdev, BOOL bFirst)
Definition: screen.c:134

◆ DrvCompletePDEV()

VOID APIENTRY DrvCompletePDEV ( IN DHPDEV  PDev,
IN HDEV  Dev 
)

Definition at line 290 of file enable.c.

292{
293 ((PPDEV) PDev)->GDIDevHandle = Dev; // Handle to the DC
294}

◆ DrvDisableDriver()

VOID APIENTRY DrvDisableDriver ( VOID  )

Definition at line 215 of file enable.c.

216{
217 return;
218}

◆ DrvDisablePDEV()

VOID APIENTRY DrvDisablePDEV ( IN DHPDEV  PDev)

Definition at line 337 of file enable.c.

338{
339 PPDEV ppdev = (PPDEV)PDev;
340
341 /* EngDeletePalette(devinfoVGA.hpalDefault); */
342 if (ppdev->pjPreallocSSBBuffer)
344
345 if (ppdev->pucDIB4ToVGAConvBuffer)
347
348 DPRINT("Freeing PDEV\n");
349 EngFreeMem(PDev);
350}
#define EngFreeMem
Definition: polytest.cpp:56
PUCHAR pucDIB4ToVGAConvBuffer
Definition: vgaddi.h:130
PUCHAR pjPreallocSSBBuffer
Definition: vgaddi.h:125

◆ DrvDisableSurface()

VOID APIENTRY DrvDisableSurface ( IN DHPDEV  PDev)

Definition at line 353 of file enable.c.

354{
355 PPDEV ppdev = (PPDEV)PDev;
356 PDEVSURF pdsurf = ppdev->AssociatedSurf;
357
358 DPRINT("KMDriver: %x\n", ppdev->KMDriver);
359 DeinitVGA(ppdev);
360 /* EngFreeMem(pdsurf->BankSelectInfo); */
361
362 if (pdsurf->BankInfo != NULL)
363 EngFreeMem(pdsurf->BankInfo);
364 if (pdsurf->BankInfo2RW != NULL)
365 EngFreeMem(pdsurf->BankInfo2RW);
366 if (pdsurf->BankBufferPlane0 != NULL)
368 if (ppdev->pPointerAttributes != NULL)
370
371 /* free any pending saved screen bit blocks */
372#if 0
373 pSSB = pdsurf->ssbList;
374 while (pSSB != NULL)
375 {
376 /* Point to the next saved screen bits block */
377 pSSBNext = (PSAVED_SCREEN_BITS) pSSB->pvNextSSB;
378
379 /* Free the current block */
380 EngFreeMem(pSSB);
381 pSSB = pSSBNext;
382 }
383#endif
385 /* EngFreeMem(pdsurf); */ /* free the surface */
386}
PBANK_INFO BankInfo
Definition: vgaddi.h:198
PBANK_INFO BankInfo2RW
Definition: vgaddi.h:200
PVOID BankBufferPlane0
Definition: vgaddi.h:208
PSAVED_SCREEN_BITS ssbList
Definition: vgaddi.h:226
PVIDEO_POINTER_ATTRIBUTES pPointerAttributes
Definition: vgaddi.h:117
PVOID AssociatedSurf
Definition: vgaddi.h:111
HSURF SurfHandle
Definition: vgaddi.h:110
struct _SAVED_SCREEN_BITS * PSAVED_SCREEN_BITS
BOOL DeinitVGA(PPDEV ppdev)
Definition: screen.c:112
ENGAPI BOOL APIENTRY EngDeleteSurface(_In_ _Post_ptr_invalid_ HSURF hsurf)
Definition: surface.c:567
typedef HSURF(APIENTRY FN_DrvEnableSurface)(_In_ DHPDEV dhpdev)

◆ DrvEnableDriver()

BOOL APIENTRY DrvEnableDriver ( IN ULONG  EngineVersion,
IN ULONG  SizeOfDED,
OUT PDRVENABLEDATA  DriveEnableData 
)

Definition at line 189 of file enable.c.

192{
193 DPRINT("DrvEnableDriver called...\n");
194
195 vgaPreCalc();
196
198
199 DriveEnableData->pdrvfn = FuncList;
200 DriveEnableData->c = sizeof(FuncList) / sizeof(DRVFN);
201 DriveEnableData->iDriverVersion = DDI_DRIVER_VERSION_NT4;
202
203 return TRUE;
204}
#define SCREEN_X
Definition: vgavideo.h:2
#define SCREEN_Y
Definition: vgavideo.h:3
VOID VGADDI_InitializeOffScreenMem(IN ULONG Start, IN ULONG Length)
Definition: offscreen.c:164
Definition: winddi.h:529
VOID vgaPreCalc()
Definition: vgavideo.c:58
static DRVFN FuncList[]
Definition: enable.c:13
#define DDI_DRIVER_VERSION_NT4
Definition: winddi.h:535

◆ DrvEnablePDEV()

DHPDEV APIENTRY DrvEnablePDEV ( IN DEVMODEW DM,
IN LPWSTR  LogAddress,
IN ULONG  PatternCount,
OUT HSURF SurfPatterns,
IN ULONG  GDIInfoSize,
OUT ULONG GDIInfo,
IN ULONG  DevInfoSize,
OUT DEVINFO DevInfo,
IN HDEV  Dev,
IN LPWSTR  DeviceName,
IN HANDLE  Driver 
)

Definition at line 244 of file enable.c.

255{
256 PPDEV PDev;
257
258 PDev = EngAllocMem(FL_ZERO_MEMORY, sizeof(PDEV), ALLOC_TAG);
259 if (PDev == NULL)
260 {
261 DPRINT1("EngAllocMem failed for PDEV\n");
262 return NULL;
263 }
264 PDev->KMDriver = Driver;
265 DPRINT( "PDev: %x, Driver: %x\n", PDev, PDev->KMDriver );
266
269 if (sizeof(GDIINFO) < GDIInfoSize)
270 GDIInfoSize = sizeof(GDIINFO);
271 memcpy(GDIInfo, &gaulCap, GDIInfoSize);
272 DM->dmBitsPerPel = gaulCap.cBitsPixel * gaulCap.cPlanes;
273 DM->dmPelsWidth = gaulCap.ulHorzRes;
274 DM->dmPelsHeight = gaulCap.ulVertRes;
275
277 if (sizeof(DEVINFO) < DevInfoSize)
278 DevInfoSize = sizeof(DEVINFO);
279 memcpy(DevInfo, &devinfoVGA, DevInfoSize);
280
281 return (DHPDEV) PDev;
282}
#define DPRINT1
Definition: precomp.h:8
#define ALLOC_TAG
Definition: btrfs_drv.h:87
#define DM
Definition: ftp_var.h:26
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define FL_ZERO_MEMORY
Definition: polytest.cpp:58
void * EngAllocMem(int zero, unsigned long size, int tag=0)
Definition: polytest.cpp:70
HPALETTE hpalDefault
Definition: winddi.h:398
ULONG cBitsPixel
Definition: winddi.h:884
ULONG ulVertRes
Definition: winddi.h:883
ULONG ulHorzRes
Definition: winddi.h:882
ULONG cPlanes
Definition: winddi.h:885
PALETTEENTRY PaletteEntry[16]
Definition: enable.c:137
_Must_inspect_result_ _In_ WDFDRIVER Driver
Definition: wdfcontrol.h:83
const VGALOGPALETTE VGApalette
Definition: enable.c:140
static GDIINFO gaulCap
Definition: enable.c:58
DEVINFO devinfoVGA
Definition: enable.c:171
typedef DHPDEV(APIENTRY FN_DrvEnablePDEV)(_In_ DEVMODEW *pdm
struct _DEVINFO DEVINFO
struct _GDIINFO GDIINFO
#define PAL_INDEXED
Definition: winddi.h:1561
_Must_inspect_result_ ENGAPI HPALETTE APIENTRY EngCreatePalette(_In_ ULONG iMode, _In_ ULONG cColors, _In_ ULONG *pulColors, _In_ FLONG flRed, _In_ FLONG flGreen, _In_ FLONG flBlue)

◆ DrvEnableSurface()

HSURF APIENTRY DrvEnableSurface ( IN DHPDEV  PDev)

Definition at line 428 of file enable.c.

429{
430 PPDEV ppdev = (PPDEV)PDev;
431 PDEVSURF pdsurf;
432 DHSURF dhsurf;
433 HSURF hsurf;
434
435 DPRINT("DrvEnableSurface() called\n");
436
437 /* Initialize the VGA */
438 if (!VGAInitialized)
439 {
440 if (!InitVGA(ppdev, TRUE))
441 goto error_done;
443 }
444
445 /* dhsurf is of type DEVSURF, which is the drivers specialized surface type */
446 dhsurf = (DHSURF)EngAllocMem(0, sizeof(DEVSURF), ALLOC_TAG);
447 if (dhsurf == NULL)
448 goto error_done;
449
450 pdsurf = (PDEVSURF) dhsurf;
451 pdsurf->ident = DEVSURF_IDENT;
452 pdsurf->flSurf = 0;
453 pdsurf->Format = BMF_PHYSDEVICE;
454 pdsurf->jReserved1 = 0;
455 pdsurf->jReserved2 = 0;
456 pdsurf->ppdev = ppdev;
457 pdsurf->sizeSurf.cx = ppdev->sizeSurf.cx;
458 pdsurf->sizeSurf.cy = ppdev->sizeSurf.cy;
459 pdsurf->NextPlane = 0;
460 pdsurf->Scan0 = ppdev->fbScreen;
461 pdsurf->BitmapStart = ppdev->fbScreen;
462 pdsurf->StartBmp = ppdev->fbScreen;
463 pdsurf->BankInfo = NULL;
464 pdsurf->BankInfo2RW = NULL;
465 pdsurf->BankBufferPlane0 = NULL;
466
467/* pdsurf->Conv = &ConvertBuffer[0]; */
468
469 if (!InitPointer(ppdev))
470 {
471 DPRINT1("DrvEnablePDEV failed bInitPointer\n");
472 goto error_clean;
473 }
474
475/* if (!SetUpBanking(pdsurf, ppdev))
476 {
477 DPRINT1("DrvEnablePDEV failed SetUpBanking\n");
478 goto error_clean;
479 } BANKING CODE UNIMPLEMENTED */
480
481 if ((hsurf = EngCreateDeviceSurface(dhsurf, ppdev->sizeSurf, BMF_4BPP)) ==
482 NULL)
483 {
484 /* Call to EngCreateDeviceSurface failed */
485 DPRINT("EngCreateDeviceSurface call failed\n");
486 goto error_clean;
487 }
488
489 InitSavedBits(ppdev);
490
493 {
494 DPRINT("Successfully associated surface\n");
495 ppdev->SurfHandle = hsurf;
496 ppdev->AssociatedSurf = pdsurf;
497
498 /* Set up an empty saved screen block list */
499 pdsurf->ssbList = NULL;
500
501 return hsurf;
502 }
503 DPRINT("EngAssociateSurface() failed\n");
504 EngDeleteSurface(hsurf);
505
506error_clean:
507 EngFreeMem(dhsurf);
508
509error_done:
510 return NULL;
511}
BYTE jReserved2
Definition: vgaddi.h:174
PPDEV ppdev
Definition: vgaddi.h:175
PVOID StartBmp
Definition: vgaddi.h:181
PVOID BitmapStart
Definition: vgaddi.h:205
PVOID Scan0
Definition: vgaddi.h:179
ULONG NextPlane
Definition: vgaddi.h:178
BYTE Format
Definition: vgaddi.h:172
SIZEL sizeSurf
Definition: vgaddi.h:176
BYTE jReserved1
Definition: vgaddi.h:173
ULONG flSurf
Definition: vgaddi.h:166
IDENT ident
Definition: vgaddi.h:165
SIZEL sizeSurf
Definition: vgaddi.h:136
HDEV GDIDevHandle
Definition: vgaddi.h:109
PBYTE fbScreen
Definition: vgaddi.h:137
LONG cx
Definition: kdterminal.h:27
LONG cy
Definition: kdterminal.h:28
#define BMF_PHYSDEVICE
Definition: vgaddi.h:234
struct _DEVSURF * PDEVSURF
#define DEVSURF_IDENT
Definition: vgaddi.h:240
static VOID InitSavedBits(IN PPDEV ppdev)
Definition: enable.c:389
#define HOOK_TRANSPARENTBLT
Definition: winddi.h:1434
#define HOOK_PAINT
Definition: winddi.h:1424
_Must_inspect_result_ ENGAPI HSURF APIENTRY EngCreateDeviceSurface(_In_ DHSURF dhsurf, _In_ SIZEL sizl, _In_ ULONG iFormatCompat)
Definition: surface.c:391
#define HOOK_BITBLT
Definition: winddi.h:1420
ENGAPI BOOL APIENTRY EngAssociateSurface(_In_ HSURF hsurf, _In_ HDEV hdev, _In_ FLONG flHooks)
Definition: surface.c:431
#define HOOK_COPYBITS
Definition: winddi.h:1429
#define HOOK_LINETO
Definition: winddi.h:1428
#define BMF_4BPP
Definition: winddi.h:356

◆ DrvGetModes()

ULONG APIENTRY DrvGetModes ( IN HANDLE  Driver,
IN ULONG  DataSize,
OUT PDEVMODEW  DM 
)

Definition at line 514 of file enable.c.

517{
518 DWORD NumModes;
519 DWORD ModeSize;
520 DWORD OutputSize;
521 DWORD OutputModes = DataSize / (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
522 PVIDEO_MODE_INFORMATION VideoModeInformation, VideoTemp;
523
524 NumModes = getAvailableModes(Driver,
525 (PVIDEO_MODE_INFORMATION *) &VideoModeInformation,
526 &ModeSize);
527
528 if (NumModes == 0)
529 return 0;
530
531 if (DM == NULL)
532 {
533 OutputSize = NumModes * (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
534 }
535 else
536 {
537 OutputSize=0;
538 VideoTemp = VideoModeInformation;
539
540 do
541 {
542 if (VideoTemp->Length != 0)
543 {
544 if (OutputModes == 0)
545 break;
546
547 memset(DM, 0, sizeof(DEVMODEW));
548 memcpy(DM->dmDeviceName, DLL_NAME, sizeof(DLL_NAME));
549
550 DM->dmSpecVersion = DM_SPECVERSION;
551 DM->dmDriverVersion = DM_SPECVERSION;
552 DM->dmSize = sizeof(DEVMODEW);
553 DM->dmDriverExtra = DRIVER_EXTRA_SIZE;
554 DM->dmBitsPerPel = VideoTemp->NumberOfPlanes *
555 VideoTemp->BitsPerPlane;
556 DM->dmPelsWidth = VideoTemp->VisScreenWidth;
557 DM->dmPelsHeight = VideoTemp->VisScreenHeight;
558 DM->dmDisplayFrequency = VideoTemp->Frequency;
559 DM->dmDisplayFlags = 0;
560
561 DM->dmFields = DM_BITSPERPEL |
566
567 /* next DEVMODE entry */
568 OutputModes--;
569
570 DM = (PDEVMODEW) ( ((ULONG_PTR)DM) + sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
571
572 OutputSize += (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
573 }
574
575 VideoTemp = (PVIDEO_MODE_INFORMATION)(((PUCHAR)VideoTemp) + ModeSize);
576
577 } while (--NumModes);
578 }
579 return OutputSize;
580}
unsigned long DWORD
Definition: ntddk_ex.h:95
_In_ NDIS_STATUS _In_ ULONG _In_ USHORT _In_opt_ PVOID _In_ ULONG DataSize
Definition: ndis.h:4755
struct _VIDEO_MODE_INFORMATION * PVIDEO_MODE_INFORMATION
#define memset(x, y, z)
Definition: compat.h:39
uint32_t ULONG_PTR
Definition: typedefs.h:65
unsigned char * PUCHAR
Definition: typedefs.h:53
#define DLL_NAME
Definition: vgaddi.h:247
#define DRIVER_EXTRA_SIZE
Definition: vgaddi.h:245
DWORD getAvailableModes(IN HANDLE Driver, OUT PVIDEO_MODE_INFORMATION *modeInformation, OUT DWORD *ModeSize)
Definition: screen.c:38
#define DM_DISPLAYFREQUENCY
Definition: wingdi.h:1272
#define DM_PELSWIDTH
Definition: wingdi.h:1269
struct _devicemodeW * PDEVMODEW
struct _devicemodeW DEVMODEW
#define DM_BITSPERPEL
Definition: wingdi.h:1268
#define DM_SPECVERSION
Definition: wingdi.h:1243
#define DM_PELSHEIGHT
Definition: wingdi.h:1270
#define DM_DISPLAYFLAGS
Definition: wingdi.h:1271

◆ InitSavedBits()

static VOID InitSavedBits ( IN PPDEV  ppdev)
static

Definition at line 389 of file enable.c.

390{
391 if (!(ppdev->fl & DRIVER_OFFSCREEN_REFRESHED))
392 return;
393
394 /* set up rect to right of visible screen */
395 ppdev->SavedBitsRight.left = ppdev->sizeSurf.cx;
396 ppdev->SavedBitsRight.top = 0;
397 ppdev->SavedBitsRight.right = ppdev->sizeMem.cx - PLANAR_PELS_PER_CPU_ADDRESS;
398 ppdev->SavedBitsRight.bottom = ppdev->sizeSurf.cy;
399
400 if ((ppdev->SavedBitsRight.right <= ppdev->SavedBitsRight.left) ||
401 (ppdev->SavedBitsRight.bottom <= ppdev->SavedBitsRight.top))
402 {
403 ppdev->SavedBitsRight.left = 0;
404 ppdev->SavedBitsRight.top = 0;
405 ppdev->SavedBitsRight.right = 0;
406 ppdev->SavedBitsRight.bottom = 0;
407 }
408
409 /* set up rect below visible screen */
410 ppdev->SavedBitsBottom.left = 0;
411 ppdev->SavedBitsBottom.top = ppdev->sizeSurf.cy;
412 ppdev->SavedBitsBottom.right = ppdev->sizeMem.cx - PLANAR_PELS_PER_CPU_ADDRESS;
413 ppdev->SavedBitsBottom.bottom = ppdev->sizeMem.cy - ppdev->NumScansUsedByPointer;
414
415 if ((ppdev->SavedBitsBottom.right <= ppdev->SavedBitsBottom.left) ||
416 (ppdev->SavedBitsBottom.bottom <= ppdev->SavedBitsBottom.top))
417 {
418 ppdev->SavedBitsBottom.left = 0;
419 ppdev->SavedBitsBottom.top = 0;
420 ppdev->SavedBitsBottom.right = 0;
421 ppdev->SavedBitsBottom.bottom = 0;
422 }
423
424 ppdev->BitsSaved = FALSE;
425}
#define PLANAR_PELS_PER_CPU_ADDRESS
Definition: vgaddi.h:251
#define DRIVER_OFFSCREEN_REFRESHED
Definition: vgaddi.h:250

Referenced by DrvEnableSurface().

Variable Documentation

◆ devinfoVGA

DEVINFO devinfoVGA
Initial value:
=
{
),
0,
8,
8,
NULL,
0
}
#define COURI_LOGFONT
Definition: enable.c:169
#define HELVE_LOGFONT
Definition: enable.c:168
#define SYSTM_LOGFONT
Definition: enable.c:167
#define GCAPS_OPAQUERECT
Definition: winddi.h:331
#define GCAPS_WINDINGFILL
Definition: winddi.h:326
#define GCAPS_MONO_DITHER
Definition: winddi.h:333
#define GCAPS_HORIZSTRIKE
Definition: winddi.h:329
#define GCAPS_ALTERNATEFILL
Definition: winddi.h:325
#define GCAPS_DITHERONREALIZE
Definition: winddi.h:342
#define GCAPS_COLOR_DITHER
Definition: winddi.h:328

Definition at line 171 of file enable.c.

Referenced by DrvEnablePDEV().

◆ FuncList

DRVFN FuncList[]
static

Definition at line 13 of file enable.c.

Referenced by DrvEnableDriver().

◆ gaulCap

GDIINFO gaulCap
static

Definition at line 58 of file enable.c.

Referenced by DrvEnablePDEV().

◆ VGAInitialized

BOOL VGAInitialized = FALSE
static

Definition at line 11 of file enable.c.

Referenced by DrvAssertMode(), and DrvEnableSurface().

◆ VGApalette

const VGALOGPALETTE VGApalette
Initial value:
=
{
0x400,
16,
{
{ 0x00, 0x00, 0x00, 0x00 },
{ 0x80, 0x00, 0x00, 0x00 },
{ 0x00, 0x80, 0x00, 0x00 },
{ 0x80, 0x80, 0x00, 0x00 },
{ 0x00, 0x00, 0x80, 0x00 },
{ 0x80, 0x00, 0x80, 0x00 },
{ 0x00, 0x80, 0x80, 0x00 },
{ 0x80, 0x80, 0x80, 0x00 },
{ 0xc0, 0xc0, 0xc0, 0x00 },
{ 0xff, 0x00, 0x00, 0x00 },
{ 0x00, 0xff, 0x00, 0x00 },
{ 0xff, 0xff, 0x00, 0x00 },
{ 0x00, 0x00, 0xff, 0x00 },
{ 0xff, 0x00, 0xff, 0x00 },
{ 0x00, 0xff, 0xff, 0x00 },
{ 0xff, 0xff, 0xff, 0x00 }
}
}

Definition at line 140 of file enable.c.

Referenced by DrvEnablePDEV().