3 Copyright (c) 2006 - 2009, Intel Corporation
4 All rights reserved. This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
18 This file produces the graphics abstration of GOP. It is called by
19 WinNtGopDriver.c file which deals with the UEFI 2.0 driver model.
20 This file just does graphics.
27 EFI_WIN_NT_THUNK_PROTOCOL
*mWinNt
;
28 DWORD mTlsIndex
= TLS_OUT_OF_INDEXES
;
29 DWORD mTlsIndexUseCount
= 0; // lets us know when we can free mTlsIndex.
30 EFI_EVENT mGopScreenExitBootServicesEvent
;
31 GOP_MODE_DATA mGopModeData
[] = {
41 IN GOP_PRIVATE_DATA
*Private
,
42 IN UINT32 HorizontalResolution
,
43 IN UINT32 VerticalResolution
,
56 WinNtGopConvertParamToEfiKeyShiftState (
57 IN GOP_PRIVATE_DATA
*Private
,
64 // BUGBUG: Only GetAsyncKeyState() and GetKeyState() can distinguish
65 // left and right Ctrl, and Shift key.
66 // Neither of the two is defined in EFI_WIN_NT_THUNK_PROTOCOL.
67 // Therefor, we can not set the correct Shift state here.
70 Private
->LeftShift
= Flag
;
73 Private
->LeftCtrl
= Flag
;
76 Private
->LeftLogo
= Flag
;
79 Private
->RightLogo
= Flag
;
85 // BUGBUG: PrintScreen/SysRq can not trigger WM_KEYDOWN message,
86 // so SySReq shift state is not supported here.
89 Private
->SysReq
= Flag
;
95 WinNtGopConvertParamToEfiKey (
96 IN GOP_PRIVATE_DATA
*Private
,
102 case VK_HOME
: Key
->ScanCode
= SCAN_HOME
; break;
103 case VK_END
: Key
->ScanCode
= SCAN_END
; break;
104 case VK_LEFT
: Key
->ScanCode
= SCAN_LEFT
; break;
105 case VK_RIGHT
: Key
->ScanCode
= SCAN_RIGHT
; break;
106 case VK_UP
: Key
->ScanCode
= SCAN_UP
; break;
107 case VK_DOWN
: Key
->ScanCode
= SCAN_DOWN
; break;
108 case VK_DELETE
: Key
->ScanCode
= SCAN_DELETE
; break;
109 case VK_INSERT
: Key
->ScanCode
= SCAN_INSERT
; break;
110 case VK_PRIOR
: Key
->ScanCode
= SCAN_PAGE_UP
; break;
111 case VK_NEXT
: Key
->ScanCode
= SCAN_PAGE_DOWN
; break;
112 case VK_ESCAPE
: Key
->ScanCode
= SCAN_ESC
; break;
114 case VK_F1
: Key
->ScanCode
= SCAN_F1
; break;
115 case VK_F2
: Key
->ScanCode
= SCAN_F2
; break;
116 case VK_F3
: Key
->ScanCode
= SCAN_F3
; break;
117 case VK_F4
: Key
->ScanCode
= SCAN_F4
; break;
118 case VK_F5
: Key
->ScanCode
= SCAN_F5
; break;
119 case VK_F6
: Key
->ScanCode
= SCAN_F6
; break;
120 case VK_F7
: Key
->ScanCode
= SCAN_F7
; break;
121 case VK_F8
: Key
->ScanCode
= SCAN_F8
; break;
122 case VK_F9
: Key
->ScanCode
= SCAN_F9
; break;
123 case VK_F11
: Key
->ScanCode
= SCAN_F11
; break;
124 case VK_F12
: Key
->ScanCode
= SCAN_F12
; break;
126 case VK_F13
: Key
->ScanCode
= SCAN_F13
; break;
127 case VK_F14
: Key
->ScanCode
= SCAN_F14
; break;
128 case VK_F15
: Key
->ScanCode
= SCAN_F15
; break;
129 case VK_F16
: Key
->ScanCode
= SCAN_F16
; break;
130 case VK_F17
: Key
->ScanCode
= SCAN_F17
; break;
131 case VK_F18
: Key
->ScanCode
= SCAN_F18
; break;
132 case VK_F19
: Key
->ScanCode
= SCAN_F19
; break;
133 case VK_F20
: Key
->ScanCode
= SCAN_F20
; break;
134 case VK_F21
: Key
->ScanCode
= SCAN_F21
; break;
135 case VK_F22
: Key
->ScanCode
= SCAN_F22
; break;
136 case VK_F23
: Key
->ScanCode
= SCAN_F23
; break;
137 case VK_F24
: Key
->ScanCode
= SCAN_F24
; break;
143 Private
->NumLock
= !Private
->NumLock
;
146 Private
->ScrollLock
= !Private
->ScrollLock
;
149 Private
->CapsLock
= !Private
->CapsLock
;
153 WinNtGopConvertParamToEfiKeyShiftState (Private
, wParam
, TRUE
);
158 // GOP Protocol Member Functions
163 Graphics Output protocol interface to get video mode
165 @param This Protocol instance pointer.
166 @param ModeNumber The mode number to return information on.
167 @param Info Caller allocated buffer that returns information
169 @param SizeOfInfo A pointer to the size, in bytes, of the Info
172 @retval EFI_SUCCESS Mode information returned.
173 @retval EFI_BUFFER_TOO_SMALL The Info buffer was too small.
174 @retval EFI_DEVICE_ERROR A hardware error occurred trying to retrieve the
176 @retval EFI_NOT_STARTED Video display is not initialized. Call SetMode ()
177 @retval EFI_INVALID_PARAMETER One of the input args was NULL.
183 IN EFI_GRAPHICS_OUTPUT_PROTOCOL
*This
,
184 IN UINT32 ModeNumber
,
185 OUT UINTN
*SizeOfInfo
,
186 OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION
**Info
189 GOP_PRIVATE_DATA
*Private
;
191 Private
= GOP_PRIVATE_DATA_FROM_THIS (This
);
193 if (Info
== NULL
|| SizeOfInfo
== NULL
|| (UINTN
) ModeNumber
>= This
->Mode
->MaxMode
) {
194 return EFI_INVALID_PARAMETER
;
197 *Info
= AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION
));
199 return EFI_OUT_OF_RESOURCES
;
202 *SizeOfInfo
= sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION
);
204 (*Info
)->Version
= 0;
205 (*Info
)->HorizontalResolution
= Private
->ModeData
[ModeNumber
].HorizontalResolution
;
206 (*Info
)->VerticalResolution
= Private
->ModeData
[ModeNumber
].VerticalResolution
;
207 (*Info
)->PixelFormat
= PixelBltOnly
;
208 (*Info
)->PixelsPerScanLine
= (*Info
)->HorizontalResolution
;
215 Graphics Output protocol interface to set video mode
217 @param This Protocol instance pointer.
218 @param ModeNumber The mode number to be set.
220 @retval EFI_SUCCESS Graphics mode was changed.
221 @retval EFI_DEVICE_ERROR The device had an error and could not complete the
223 @retval EFI_UNSUPPORTED ModeNumber is not supported by this device.
229 IN EFI_GRAPHICS_OUTPUT_PROTOCOL
* This
,
234 GOP_PRIVATE_DATA
*Private
;
235 GOP_MODE_DATA
*ModeData
;
236 EFI_GRAPHICS_OUTPUT_BLT_PIXEL Fill
;
237 EFI_GRAPHICS_OUTPUT_BLT_PIXEL
*NewFillLine
;
243 Private
= GOP_PRIVATE_DATA_FROM_THIS (This
);
245 if (ModeNumber
>= This
->Mode
->MaxMode
) {
246 return EFI_UNSUPPORTED
;
249 ModeData
= &Private
->ModeData
[ModeNumber
];
250 This
->Mode
->Mode
= ModeNumber
;
251 Private
->GraphicsOutput
.Mode
->Info
->HorizontalResolution
= ModeData
->HorizontalResolution
;
252 Private
->GraphicsOutput
.Mode
->Info
->VerticalResolution
= ModeData
->VerticalResolution
;
253 Private
->GraphicsOutput
.Mode
->Info
->PixelsPerScanLine
= ModeData
->HorizontalResolution
;
255 if (Private
->HardwareNeedsStarting
) {
256 Status
= WinNtGopStartWindow (
258 ModeData
->HorizontalResolution
,
259 ModeData
->VerticalResolution
,
260 ModeData
->ColorDepth
,
261 ModeData
->RefreshRate
263 if (EFI_ERROR (Status
)) {
264 return EFI_DEVICE_ERROR
;
267 Private
->HardwareNeedsStarting
= FALSE
;
270 // Change the resolution and resize of the window
274 // Free the old buffer. We do not save the content of the old buffer since the
275 // screen is to be cleared anyway. Clearing the screen is required by the EFI spec.
276 // See UEFI spec -EFI_GRAPHICS_OUTPUT_PROTOCOL.SetMode()
278 Private
->WinNtThunk
->HeapFree (Private
->WinNtThunk
->GetProcessHeap (), 0, Private
->VirtualScreenInfo
);
281 // Allocate DIB frame buffer directly from NT for performance enhancement
282 // This buffer is the virtual screen/frame buffer. This buffer is not the
283 // same a a frame buffer. The first row of this buffer will be the bottom
284 // line of the image. This is an artifact of the way we draw to the screen.
286 Size
= ModeData
->HorizontalResolution
* ModeData
->VerticalResolution
* sizeof (RGBQUAD
) + sizeof (BITMAPV4HEADER
);
287 Private
->VirtualScreenInfo
= Private
->WinNtThunk
->HeapAlloc (
288 Private
->WinNtThunk
->GetProcessHeap (),
294 // Update the virtual screen info data structure
296 Private
->VirtualScreenInfo
->bV4Size
= sizeof (BITMAPV4HEADER
);
297 Private
->VirtualScreenInfo
->bV4Width
= ModeData
->HorizontalResolution
;
298 Private
->VirtualScreenInfo
->bV4Height
= ModeData
->VerticalResolution
;
299 Private
->VirtualScreenInfo
->bV4Planes
= 1;
300 Private
->VirtualScreenInfo
->bV4BitCount
= 32;
304 Private
->VirtualScreenInfo
->bV4V4Compression
= BI_RGB
;
307 // The rest of the allocated memory block is the virtual screen buffer
309 Private
->VirtualScreen
= (RGBQUAD
*) (Private
->VirtualScreenInfo
+ 1);
312 // Use the AdjuctWindowRect fuction to calculate the real width and height
313 // of the new window including the border and caption
317 Rect
.right
= ModeData
->HorizontalResolution
;
318 Rect
.bottom
= ModeData
->VerticalResolution
;
320 Private
->WinNtThunk
->AdjustWindowRect (&Rect
, WS_OVERLAPPEDWINDOW
, 0);
322 Width
= Rect
.right
- Rect
.left
;
323 Height
= Rect
.bottom
- Rect
.top
;
326 // Retrieve the original window position information
328 Private
->WinNtThunk
->GetWindowRect (Private
->WindowHandle
, &Rect
);
331 // Adjust the window size
333 Private
->WinNtThunk
->MoveWindow (Private
->WindowHandle
, Rect
.left
, Rect
.top
, Width
, Height
, TRUE
);
337 NewFillLine
= AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL
) * ModeData
->HorizontalResolution
);
338 if (NewFillLine
== NULL
) {
339 return EFI_DEVICE_ERROR
;
342 if (Private
->FillLine
!= NULL
) {
343 FreePool (Private
->FillLine
);
346 Private
->FillLine
= NewFillLine
;
359 ModeData
->HorizontalResolution
,
360 ModeData
->VerticalResolution
,
361 ModeData
->HorizontalResolution
* sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL
)
368 Blt pixels from the rectangle (Width X Height) formed by the BltBuffer
369 onto the graphics screen starting a location (X, Y). (0, 0) is defined as
370 the upper left hand side of the screen. (X, Y) can be outside of the
371 current screen geometry and the BltBuffer will be cliped when it is
372 displayed. X and Y can be negative or positive. If Width or Height is
373 bigger than the current video screen the image will be clipped.
375 @param This Protocol instance pointer.
376 @param X X location on graphics screen.
377 @param Y Y location on the graphics screen.
378 @param Width Width of BltBuffer.
379 @param Height Hight of BltBuffer
380 @param BltOperation Operation to perform on BltBuffer and video memory
381 @param BltBuffer Buffer containing data to blt into video buffer.
382 This buffer has a size of
383 Width*Height*sizeof(EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
384 @param SourceX If the BltOperation is a EfiCopyBlt this is the
385 source of the copy. For other BLT operations this
386 argument is not used.
387 @param SourceX If the BltOperation is a EfiCopyBlt this is the
388 source of the copy. For other BLT operations this
389 argument is not used.
391 @retval EFI_SUCCESS The palette is updated with PaletteArray.
392 @retval EFI_INVALID_PARAMETER BltOperation is not valid.
393 @retval EFI_DEVICE_ERROR A hardware error occured writting to the video
397 // TODO: SourceY - add argument and description to function comment
398 // TODO: DestinationX - add argument and description to function comment
399 // TODO: DestinationY - add argument and description to function comment
400 // TODO: Delta - add argument and description to function comment
404 IN EFI_GRAPHICS_OUTPUT_PROTOCOL
*This
,
405 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL
*BltBuffer
, OPTIONAL
406 IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION BltOperation
,
409 IN UINTN DestinationX
,
410 IN UINTN DestinationY
,
413 IN UINTN Delta OPTIONAL
416 GOP_PRIVATE_DATA
*Private
;
422 EFI_GRAPHICS_OUTPUT_BLT_PIXEL
*Blt
;
425 EFI_GRAPHICS_OUTPUT_BLT_PIXEL
*FillPixel
;
426 UINT32 VerticalResolution
;
427 UINT32 HorizontalResolution
;
429 Private
= GOP_PRIVATE_DATA_FROM_THIS (This
);
431 if ((BltOperation
< 0) || (BltOperation
>= EfiGraphicsOutputBltOperationMax
)) {
432 return EFI_INVALID_PARAMETER
;
435 if (Width
== 0 || Height
== 0) {
436 return EFI_INVALID_PARAMETER
;
439 // If Delta is zero, then the entire BltBuffer is being used, so Delta
440 // is the number of bytes in each row of BltBuffer. Since BltBuffer is Width pixels size,
441 // the number of bytes in each row can be computed.
444 Delta
= Width
* sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL
);
448 // We need to fill the Virtual Screen buffer with the blt data.
449 // The virtual screen is upside down, as the first row is the bootom row of
452 VerticalResolution
= This
->Mode
->Info
->VerticalResolution
;
453 HorizontalResolution
= This
->Mode
->Info
->HorizontalResolution
;
454 if (BltOperation
== EfiBltVideoToBltBuffer
) {
457 // Video to BltBuffer: Source is Video, destination is BltBuffer
459 if (SourceY
+ Height
> VerticalResolution
) {
460 return EFI_INVALID_PARAMETER
;
463 if (SourceX
+ Width
> HorizontalResolution
) {
464 return EFI_INVALID_PARAMETER
;
467 // We have to raise to TPL Notify, so we make an atomic write the frame buffer.
468 // We would not want a timer based event (Cursor, ...) to come in while we are
469 // doing this operation.
471 OriginalTPL
= gBS
->RaiseTPL (TPL_NOTIFY
);
473 for (SrcY
= SourceY
, DstY
= DestinationY
; DstY
< (Height
+ DestinationY
); SrcY
++, DstY
++) {
474 Blt
= (EFI_GRAPHICS_OUTPUT_BLT_PIXEL
*) ((UINT8
*) BltBuffer
+ (DstY
* Delta
) + DestinationX
* sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL
));
475 VScreen
= &Private
->VirtualScreen
[(VerticalResolution
- SrcY
- 1) * HorizontalResolution
+ SourceX
];
476 CopyMem (Blt
, VScreen
, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL
) * Width
);
480 // BltBuffer to Video: Source is BltBuffer, destination is Video
482 if (DestinationY
+ Height
> VerticalResolution
) {
483 return EFI_INVALID_PARAMETER
;
486 if (DestinationX
+ Width
> HorizontalResolution
) {
487 return EFI_INVALID_PARAMETER
;
491 // We have to raise to TPL Notify, so we make an atomic write the frame buffer.
492 // We would not want a timer based event (Cursor, ...) to come in while we are
493 // doing this operation.
495 OriginalTPL
= gBS
->RaiseTPL (TPL_NOTIFY
);
497 if (BltOperation
== EfiBltVideoFill
) {
498 FillPixel
= BltBuffer
;
499 for (Index
= 0; Index
< Width
; Index
++) {
500 Private
->FillLine
[Index
] = *FillPixel
;
504 for (Index
= 0; Index
< Height
; Index
++) {
505 if (DestinationY
<= SourceY
) {
506 SrcY
= SourceY
+ Index
;
507 DstY
= DestinationY
+ Index
;
509 SrcY
= SourceY
+ Height
- Index
- 1;
510 DstY
= DestinationY
+ Height
- Index
- 1;
513 VScreen
= &Private
->VirtualScreen
[(VerticalResolution
- DstY
- 1) * HorizontalResolution
+ DestinationX
];
514 switch (BltOperation
) {
515 case EfiBltBufferToVideo
:
516 Blt
= (EFI_GRAPHICS_OUTPUT_BLT_PIXEL
*) ((UINT8
*) BltBuffer
+ (SrcY
* Delta
) + SourceX
* sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL
));
517 CopyMem (VScreen
, Blt
, Width
* sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL
));
520 case EfiBltVideoToVideo
:
521 VScreenSrc
= &Private
->VirtualScreen
[(VerticalResolution
- SrcY
- 1) * HorizontalResolution
+ SourceX
];
522 CopyMem (VScreen
, VScreenSrc
, Width
* sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL
));
525 case EfiBltVideoFill
:
526 CopyMem (VScreen
, Private
->FillLine
, Width
* sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL
));
532 if (BltOperation
!= EfiBltVideoToBltBuffer
) {
534 // Mark the area we just blted as Invalid so WM_PAINT will update.
536 Rect
.left
= DestinationX
;
537 Rect
.top
= DestinationY
;
538 Rect
.right
= DestinationX
+ Width
;
539 Rect
.bottom
= DestinationY
+ Height
;
540 Private
->WinNtThunk
->InvalidateRect (Private
->WindowHandle
, &Rect
, FALSE
);
543 // Send the WM_PAINT message to the thread that is drawing the window. We
544 // are in the main thread and the window drawing is in a child thread.
545 // There is a child thread per window. We have no CriticalSection or Mutex
546 // since we write the data and the other thread displays the data. While
547 // we may miss some data for a short period of time this is no different than
548 // a write combining on writes to a frame buffer.
551 Private
->WinNtThunk
->UpdateWindow (Private
->WindowHandle
);
554 gBS
->RestoreTPL (OriginalTPL
);
560 // Construction and Destruction functions
570 // TODO: WinNtIo - add argument and description to function comment
571 // TODO: EFI_UNSUPPORTED - add return value to function comment
572 // TODO: EFI_SUCCESS - add return value to function comment
575 IN EFI_WIN_NT_IO_PROTOCOL
*WinNtIo
579 // Check to see if the IO abstraction represents a device type we support.
581 // This would be replaced a check of PCI subsystem ID, etc.
583 if (!CompareGuid (WinNtIo
->TypeGuid
, &gEfiWinNtGopGuid
)) {
584 return EFI_UNSUPPORTED
;
592 Win32 Windows event handler.
596 @return See Win32 Book
599 // TODO: hwnd - add argument and description to function comment
600 // TODO: iMsg - add argument and description to function comment
601 // TODO: wParam - add argument and description to function comment
602 // TODO: lParam - add argument and description to function comment
605 WinNtGopThreadWindowProc (
612 GOP_PRIVATE_DATA
*Private
;
615 PAINTSTRUCT PaintStruct
;
620 // BugBug - if there are two instances of this DLL in memory (such as is
621 // the case for ERM), the correct instance of this function may not be called.
622 // This also means that the address of the mTlsIndex value will be wrong, and
623 // the value may be wrong too.
628 // Use mTlsIndex global to get a Thread Local Storage version of Private.
629 // This works since each Gop protocol has a unique Private data instance and
632 Private
= mWinNt
->TlsGetValue (mTlsIndex
);
633 ASSERT (NULL
!= Private
);
637 Size
= Private
->GraphicsOutput
.Mode
->Info
->HorizontalResolution
* Private
->GraphicsOutput
.Mode
->Info
->VerticalResolution
* sizeof (RGBQUAD
);
640 // Allocate DIB frame buffer directly from NT for performance enhancement
641 // This buffer is the virtual screen/frame buffer. This buffer is not the
642 // same a a frame buffer. The first fow of this buffer will be the bottom
643 // line of the image. This is an artifact of the way we draw to the screen.
645 Private
->VirtualScreenInfo
= Private
->WinNtThunk
->HeapAlloc (
646 Private
->WinNtThunk
->GetProcessHeap (),
651 Private
->VirtualScreenInfo
->bV4Size
= sizeof (BITMAPV4HEADER
);
652 Private
->VirtualScreenInfo
->bV4Width
= Private
->GraphicsOutput
.Mode
->Info
->HorizontalResolution
;
653 Private
->VirtualScreenInfo
->bV4Height
= Private
->GraphicsOutput
.Mode
->Info
->VerticalResolution
;
654 Private
->VirtualScreenInfo
->bV4Planes
= 1;
655 Private
->VirtualScreenInfo
->bV4BitCount
= 32;
659 Private
->VirtualScreenInfo
->bV4V4Compression
= BI_RGB
;
660 Private
->VirtualScreen
= (RGBQUAD
*) (Private
->VirtualScreenInfo
+ 1);
665 // I have not found a way to convert hwnd into a Private context. So for
666 // now we use this API to convert hwnd to Private data.
669 Handle
= mWinNt
->BeginPaint (hwnd
, &PaintStruct
);
671 mWinNt
->SetDIBitsToDevice (
672 Handle
, // Destination Device Context
673 0, // Destination X - 0
674 0, // Destination Y - 0
675 Private
->GraphicsOutput
.Mode
->Info
->HorizontalResolution
, // Width
676 Private
->GraphicsOutput
.Mode
->Info
->VerticalResolution
, // Height
679 0, // DIB Start Scan Line
680 Private
->GraphicsOutput
.Mode
->Info
->VerticalResolution
, // Number of scan lines
681 Private
->VirtualScreen
, // Address of array of DIB bits
682 (BITMAPINFO
*) Private
->VirtualScreenInfo
, // Address of structure with bitmap info
683 DIB_RGB_COLORS
// RGB or palette indexes
686 mWinNt
->EndPaint (hwnd
, &PaintStruct
);
690 // F10 and the ALT key do not create a WM_KEYDOWN message, thus this special case
691 // WM_SYSKEYDOWN is posted when F10 is pressed or
692 // holds down ALT key and then presses another key.
698 Key
.ScanCode
= SCAN_F10
;
700 GopPrivateAddQ (Private
, Key
);
704 if ((lParam
& GOP_ALT_KEY_PRESSED
) == GOP_ALT_KEY_PRESSED
) {
706 // ALT is pressed with another key pressed
708 WinNtGopConvertParamToEfiKey (Private
, &wParam
, &Key
);
710 if ((lParam
& GOP_EXTENDED_KEY
) == GOP_EXTENDED_KEY
) {
711 Private
->RightAlt
= TRUE
;
713 Private
->LeftAlt
= TRUE
;
716 if (Private
->RightAlt
&& Private
->LeftAlt
) {
717 Private
->LeftAlt
= FALSE
;
721 if (Key
.ScanCode
!= 0) {
723 GopPrivateAddQ (Private
, Key
);
729 if ((lParam
& GOP_ALT_KEY_PRESSED
) == GOP_ALT_KEY_PRESSED
) {
731 // ALT is pressed with another key released
733 WinNtGopConvertParamToEfiKeyShiftState (Private
, &wParam
, FALSE
);
735 // Actually ALT key is still held down here.
736 // Change the ALT key state when another key is released
737 // by user because we did not find a better solution to
738 // get a released ALT key.
740 Private
->RightAlt
= FALSE
;
741 Private
->LeftAlt
= FALSE
;
749 WinNtGopConvertParamToEfiKey (Private
, &wParam
, &Key
);
750 if (Key
.ScanCode
!= 0) {
752 GopPrivateAddQ (Private
, Key
);
758 WinNtGopConvertParamToEfiKeyShiftState (Private
, &wParam
, FALSE
);
763 // The ESC key also generate WM_CHAR.
765 if (wParam
== 0x1B) {
769 for (Index
= 0; Index
< (lParam
& 0xffff); Index
++) {
771 Key
.UnicodeChar
= (CHAR16
) wParam
;
773 GopPrivateAddQ (Private
, Key
);
781 // This close message is issued by user, core is not aware of this,
782 // so don't release the window display resource, just hide the window.
784 Private
->WinNtThunk
->ShowWindow (Private
->WindowHandle
, SW_HIDE
);
788 mWinNt
->DestroyWindow (hwnd
);
789 mWinNt
->PostQuitMessage (0);
791 mWinNt
->HeapFree (Private
->WinNtThunk
->GetProcessHeap (), 0, Private
->VirtualScreenInfo
);
793 mWinNt
->ExitThread (0);
800 return mWinNt
->DefWindowProc (hwnd
, iMsg
, wParam
, lParam
);
805 This thread simulates the end of WinMain () aplication. Each Winow nededs
806 to process it's events. The messages are dispatched to
807 WinNtGopThreadWindowProc ().
808 Be very careful sine WinNtGopThreadWinMain () and WinNtGopThreadWindowProc ()
809 are running in a seperate thread. We have to do this to process the events.
811 @param lpParameter Handle of window to manage.
813 @return if a WM_QUIT message is returned exit.
818 WinNtGopThreadWinMain (
823 GOP_PRIVATE_DATA
*Private
;
827 Private
= (GOP_PRIVATE_DATA
*) lpParameter
;
828 ASSERT (NULL
!= Private
);
831 // Since each thread has unique private data, save the private data in Thread
832 // Local Storage slot. Then the shared global mTlsIndex can be used to get
833 // thread specific context.
835 Private
->WinNtThunk
->TlsSetValue (mTlsIndex
, Private
);
837 Private
->ThreadId
= Private
->WinNtThunk
->GetCurrentThreadId ();
839 Private
->WindowsClass
.cbSize
= sizeof (WNDCLASSEX
);
840 Private
->WindowsClass
.style
= CS_HREDRAW
| CS_VREDRAW
| CS_OWNDC
;
841 Private
->WindowsClass
.lpfnWndProc
= WinNtGopThreadWindowProc
;
842 Private
->WindowsClass
.cbClsExtra
= 0;
843 Private
->WindowsClass
.cbWndExtra
= 0;
844 Private
->WindowsClass
.hInstance
= NULL
;
845 Private
->WindowsClass
.hIcon
= Private
->WinNtThunk
->LoadIcon (NULL
, IDI_APPLICATION
);
846 Private
->WindowsClass
.hCursor
= Private
->WinNtThunk
->LoadCursor (NULL
, IDC_ARROW
);
847 Private
->WindowsClass
.hbrBackground
= (HBRUSH
) COLOR_WINDOW
;
848 Private
->WindowsClass
.lpszMenuName
= NULL
;
849 Private
->WindowsClass
.lpszClassName
= WIN_NT_GOP_CLASS_NAME
;
850 Private
->WindowsClass
.hIconSm
= Private
->WinNtThunk
->LoadIcon (NULL
, IDI_APPLICATION
);
853 // This call will fail after the first time, but thats O.K. since we only need
854 // WIN_NT_GOP_CLASS_NAME to exist to create the window.
856 // Note: Multiple instances of this DLL will use the same instance of this
857 // Class, including the callback function, unless the Class is unregistered and
858 // successfully registered again.
860 Atom
= Private
->WinNtThunk
->RegisterClassEx (&Private
->WindowsClass
);
863 // Setting Rect values to allow for the AdjustWindowRect to provide
864 // us the correct sizes for the client area when doing the CreateWindowEx
867 Rect
.bottom
= Private
->GraphicsOutput
.Mode
->Info
->VerticalResolution
;
869 Rect
.right
= Private
->GraphicsOutput
.Mode
->Info
->HorizontalResolution
;
871 Private
->WinNtThunk
->AdjustWindowRect (&Rect
, WS_OVERLAPPEDWINDOW
, 0);
873 Private
->WindowHandle
= Private
->WinNtThunk
->CreateWindowEx (
875 WIN_NT_GOP_CLASS_NAME
,
880 Rect
.right
- Rect
.left
,
881 Rect
.bottom
- Rect
.top
,
889 // The reset of this thread is the standard winows program. We need a sperate
890 // thread since we must process the message loop to make windows act like
894 Private
->WinNtThunk
->ShowWindow (Private
->WindowHandle
, SW_SHOW
);
895 Private
->WinNtThunk
->UpdateWindow (Private
->WindowHandle
);
898 // Let the main thread get some work done
900 Private
->WinNtThunk
->ReleaseSemaphore (Private
->ThreadInited
, 1, NULL
);
903 // This is the message loop that all Windows programs need.
905 while (Private
->WinNtThunk
->GetMessage (&Message
, Private
->WindowHandle
, 0, 0)) {
906 Private
->WinNtThunk
->TranslateMessage (&Message
);
907 Private
->WinNtThunk
->DispatchMessage (&Message
);
910 return Message
.wParam
;
915 TODO: Add function description
917 @param Private TODO: add argument description
918 @param HorizontalResolution TODO: add argument description
919 @param VerticalResolution TODO: add argument description
920 @param ColorDepth TODO: add argument description
921 @param RefreshRate TODO: add argument description
923 @return TODO: add return values
927 WinNtGopStartWindow (
928 IN GOP_PRIVATE_DATA
*Private
,
929 IN UINT32 HorizontalResolution
,
930 IN UINT32 VerticalResolution
,
931 IN UINT32 ColorDepth
,
932 IN UINT32 RefreshRate
938 mWinNt
= Private
->WinNtThunk
;
941 // Initialize a Thread Local Storge variable slot. We use TLS to get the
942 // correct Private data instance into the windows thread.
944 if (mTlsIndex
== TLS_OUT_OF_INDEXES
) {
945 ASSERT (0 == mTlsIndexUseCount
);
946 mTlsIndex
= Private
->WinNtThunk
->TlsAlloc ();
950 // always increase the use count!
955 // Register to be notified on exit boot services so we can destroy the window.
957 Status
= gBS
->CreateEventEx (
962 &gEfiEventExitBootServicesGuid
,
963 &mGopScreenExitBootServicesEvent
966 Private
->ThreadInited
= Private
->WinNtThunk
->CreateSemaphore (NULL
, 0, 1, NULL
);
967 Private
->ThreadHandle
= Private
->WinNtThunk
->CreateThread (
970 WinNtGopThreadWinMain
,
977 // The other thread has entered the windows message loop so we can
978 // continue our initialization.
980 Private
->WinNtThunk
->WaitForSingleObject (Private
->ThreadInited
, INFINITE
);
981 Private
->WinNtThunk
->CloseHandle (Private
->ThreadInited
);
993 // TODO: Private - add argument and description to function comment
994 // TODO: EFI_SUCCESS - add return value to function comment
996 WinNtGopConstructor (
997 GOP_PRIVATE_DATA
*Private
1000 Private
->ModeData
= mGopModeData
;
1002 Private
->GraphicsOutput
.QueryMode
= WinNtGopQuerytMode
;
1003 Private
->GraphicsOutput
.SetMode
= WinNtGopSetMode
;
1004 Private
->GraphicsOutput
.Blt
= WinNtGopBlt
;
1007 // Allocate buffer for Graphics Output Protocol mode information
1009 Private
->GraphicsOutput
.Mode
= AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_PROTOCOL_MODE
));
1010 if (Private
->GraphicsOutput
.Mode
== NULL
) {
1011 return EFI_OUT_OF_RESOURCES
;
1013 Private
->GraphicsOutput
.Mode
->Info
= AllocatePool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION
));
1014 if (Private
->GraphicsOutput
.Mode
->Info
== NULL
) {
1015 return EFI_OUT_OF_RESOURCES
;
1018 Private
->GraphicsOutput
.Mode
->MaxMode
= sizeof(mGopModeData
) / sizeof(GOP_MODE_DATA
);
1020 // Till now, we have no idea about the window size.
1022 Private
->GraphicsOutput
.Mode
->Mode
= GRAPHICS_OUTPUT_INVALIDE_MODE_NUMBER
;
1023 Private
->GraphicsOutput
.Mode
->Info
->Version
= 0;
1024 Private
->GraphicsOutput
.Mode
->Info
->HorizontalResolution
= 0;
1025 Private
->GraphicsOutput
.Mode
->Info
->VerticalResolution
= 0;
1026 Private
->GraphicsOutput
.Mode
->Info
->PixelFormat
= PixelBltOnly
;
1027 Private
->GraphicsOutput
.Mode
->SizeOfInfo
= sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION
);
1028 Private
->GraphicsOutput
.Mode
->FrameBufferBase
= (EFI_PHYSICAL_ADDRESS
) (UINTN
) NULL
;
1029 Private
->GraphicsOutput
.Mode
->FrameBufferSize
= 0;
1031 Private
->HardwareNeedsStarting
= TRUE
;
1032 Private
->FillLine
= NULL
;
1034 WinNtGopInitializeSimpleTextInForWindow (Private
);
1046 // TODO: Private - add argument and description to function comment
1047 // TODO: EFI_SUCCESS - add return value to function comment
1049 WinNtGopDestructor (
1050 GOP_PRIVATE_DATA
*Private
1053 UINT32 UnregisterReturn
;
1055 if (!Private
->HardwareNeedsStarting
) {
1057 // BugBug: Shutdown GOP Hardware and any child devices.
1059 Private
->WinNtThunk
->SendMessage (Private
->WindowHandle
, WM_DESTROY
, 0, 0);
1060 Private
->WinNtThunk
->CloseHandle (Private
->ThreadHandle
);
1062 mTlsIndexUseCount
--;
1065 // The callback function for another window could still be called,
1066 // so we need to make sure there are no more users of mTlsIndex.
1068 if (0 == mTlsIndexUseCount
) {
1069 ASSERT (TLS_OUT_OF_INDEXES
!= mTlsIndex
);
1071 Private
->WinNtThunk
->TlsFree (mTlsIndex
);
1072 mTlsIndex
= TLS_OUT_OF_INDEXES
;
1074 UnregisterReturn
= Private
->WinNtThunk
->UnregisterClass (
1075 Private
->WindowsClass
.lpszClassName
,
1076 Private
->WindowsClass
.hInstance
1080 WinNtGopDestroySimpleTextInForWindow (Private
);
1084 // Free graphics output protocol occupied resource
1086 if (Private
->GraphicsOutput
.Mode
!= NULL
) {
1087 if (Private
->GraphicsOutput
.Mode
->Info
!= NULL
) {
1088 FreePool (Private
->GraphicsOutput
.Mode
->Info
);
1090 FreePool (Private
->GraphicsOutput
.Mode
);
1098 This is the GOP screen's callback notification function for exit-boot-services.
1099 All we do here is call WinNtGopDestructor().
1101 @param Event not used
1102 @param Context pointer to the Private structure.
1115 Status
= WinNtGopDestructor (Context
);