Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

drawscrn.c File Reference

#include "stdarg.h"
#include "stdio.h"
#include "ntddk.h"
#include "fsvga.h"
#include "fsvgalog.h"

Go to the source code of this file.

Defines

#define COMMON_LVB_MASK
#define CalcGRAMScanLine(WindowY, FontSizeY)   (WindowY * FontSizeY)
#define CalcGRAMOffs(WindowSize, DeviceExtension)
#define GetBytePerLine(DeviceExtension)

Functions

ULONG CalcGRAMSize (IN COORD WindowSize, IN PDEVICE_EXTENSION DeviceExtension)
PUCHAR CalcGRAMAddress (IN COORD WindowSize, IN PDEVICE_EXTENSION DeviceExtension)
BOOL IsGRAMRowOver (PUCHAR BufPtr, BOOL fDbcs, PDEVICE_EXTENSION DeviceExtension)
PUCHAR NextGRAMRow (PUCHAR BufPtr, PDEVICE_EXTENSION DeviceExtension)
VOID memcpyGRAM (IN PCHAR TargetPtr, IN PCHAR SourcePtr, IN ULONG Length)
VOID memcpyGRAMOver (IN PCHAR TargetPtr, IN PCHAR SourcePtr, IN ULONG Length, IN PUCHAR FrameBufPtr, IN PDEVICE_EXTENSION DeviceExtension)
VOID MoveGRAM (IN PCHAR TargetPtr, IN PCHAR SourcePtr, IN ULONG Length, IN PUCHAR FrameBufPtr, IN PDEVICE_EXTENSION DeviceExtension)
NTSTATUS FsgVgaInitializeHWFlags (PDEVICE_EXTENSION DeviceExtension)
NTSTATUS FsgCopyFrameBuffer (PDEVICE_EXTENSION DeviceExtension, PFSVIDEO_COPY_FRAME_BUFFER CopyFrameBuffer, ULONG inputBufferLength)
NTSTATUS FsgWriteToFrameBuffer (PDEVICE_EXTENSION DeviceExtension, PFSVIDEO_WRITE_TO_FRAME_BUFFER WriteFrameBuffer, ULONG inputBufferLength)
NTSTATUS FsgReverseMousePointer (PDEVICE_EXTENSION DeviceExtension, PFSVIDEO_REVERSE_MOUSE_POINTER MouseBuffer, ULONG inputBufferLength)
NTSTATUS FsgInvertCursor (PDEVICE_EXTENSION DeviceExtension, BOOL Invert)
NTSTATUS FsgWriteToScreen (PUCHAR FrameBuffer, PUCHAR BitmapBuffer, DWORD cjBytes, BOOL fDbcs, WORD Attributes1, WORD Attributes2, PDEVICE_EXTENSION DeviceExtension)
NTSTATUS FsgWriteToScreenCommonLVB (PUCHAR FrameBuffer, WORD Attributes, PDEVICE_EXTENSION DeviceExtension)
UCHAR AccessGRAM_WR (PUCHAR FrameBuffer, UCHAR write)
UCHAR AccessGRAM_RW (PUCHAR FrameBuffer, UCHAR write)
UCHAR AccessGRAM_AND (PUCHAR FrameBuffer, UCHAR write)


Define Documentation

#define CalcGRAMOffs WindowSize,
DeviceExtension   ) 
 

Value:

(DeviceExtension->EmulateInfo.StartAddress + \ CalcGRAMSize(WindowSize,DeviceExtension) \ )

Definition at line 61 of file drawscrn.c.

Referenced by CalcGRAMAddress().

#define CalcGRAMScanLine WindowY,
FontSizeY   )     (WindowY * FontSizeY)
 

Definition at line 47 of file drawscrn.c.

Referenced by CalcGRAMSize(), and FsgVgaInitializeHWFlags().

#define COMMON_LVB_MASK
 

Value:

(COMMON_LVB_GRID_HORIZONTAL | \ COMMON_LVB_GRID_LVERTICAL | \ COMMON_LVB_GRID_RVERTICAL | \ COMMON_LVB_REVERSE_VIDEO | \ COMMON_LVB_UNDERSCORE )

Definition at line 29 of file drawscrn.c.

Referenced by FsgWriteToScreen().

#define GetBytePerLine DeviceExtension   ) 
 

Value:

((DeviceExtension->Configuration.HardwareScroll & OFFSET_128_TO_NEXT_SLICE) ? \ (1024 / 8) : \ (640 / 8) \ )

Definition at line 76 of file drawscrn.c.

Referenced by FsgVgaInitializeHWFlags().


Function Documentation

UCHAR AccessGRAM_AND PUCHAR  FrameBuffer,
UCHAR  write
 

Definition at line 998 of file drawscrn.c.

Referenced by FsgInvertCursor(), and FsgReverseMousePointer().

01002 { 01003 return *FrameBuffer &= write; 01004 }

UCHAR AccessGRAM_RW PUCHAR  FrameBuffer,
UCHAR  write
 

Definition at line 986 of file drawscrn.c.

Referenced by FsgWriteToScreenCommonLVB().

00990 { 00991 UCHAR tmp; 00992 tmp = *FrameBuffer; 00993 *FrameBuffer = write; 00994 return tmp; 00995 }

UCHAR AccessGRAM_WR PUCHAR  FrameBuffer,
UCHAR  write
 

Definition at line 976 of file drawscrn.c.

Referenced by ColorSetDirect().

00980 { 00981 *FrameBuffer = write; 00982 return *FrameBuffer; 00983 }

PUCHAR CalcGRAMAddress IN COORD  WindowSize,
IN PDEVICE_EXTENSION  DeviceExtension
 

Definition at line 116 of file drawscrn.c.

References CalcGRAMOffs, and DWORD.

Referenced by FsgCopyFrameBuffer(), FsgInvertCursor(), FsgReverseMousePointer(), and FsgWriteToFrameBuffer().

00123 : 00124 00125 This routine calcurate a graphics buffer address. 00126 00127 Arguments: 00128 00129 WindowSize - Coord of window size. 00130 00131 DeviceExtension - Pointer to the miniport driver's device extension. 00132 00133 Return Value: 00134 00135 Returen to graphics buffer address. 00136 00137 --*/ 00138 { 00139 PUCHAR BufPtr = (PUCHAR)DeviceExtension->CurrentMode.VideoMemory.FrameBufferBase; 00140 00141 BufPtr += CalcGRAMOffs(WindowSize, DeviceExtension); 00142 if ((DWORD)(BufPtr - 00143 (PUCHAR)DeviceExtension->CurrentMode.VideoMemory.FrameBufferBase) 00144 >= DeviceExtension->EmulateInfo.LimitGRAM) 00145 return (BufPtr - DeviceExtension->EmulateInfo.LimitGRAM); 00146 else 00147 return BufPtr; 00148 }

ULONG CalcGRAMSize IN COORD  WindowSize,
IN PDEVICE_EXTENSION  DeviceExtension
 

Definition at line 85 of file drawscrn.c.

References CalcGRAMScanLine.

00092 : 00093 00094 This Macro calcurate a graphics buffer size. 00095 00096 Arguments: 00097 00098 WindowSize - Coord of window size. 00099 00100 DeviceExtension - Pointer to the miniport driver's device extension. 00101 00102 Return Value: 00103 00104 Returen to graphics buffer offset. 00105 00106 --*/ 00107 00108 { 00109 return WindowSize.X + 00110 CalcGRAMScanLine(WindowSize.Y, DeviceExtension->ScreenAndFont.FontSize.Y) * 00111 DeviceExtension->EmulateInfo.BytePerLine; 00112 }

NTSTATUS FsgCopyFrameBuffer PDEVICE_EXTENSION  DeviceExtension,
PFSVIDEO_COPY_FRAME_BUFFER  CopyFrameBuffer,
ULONG  inputBufferLength
 

Definition at line 437 of file drawscrn.c.

References CalcGRAMAddress(), _DEVICE_EXTENSION::CurrentMode, FALSE, FsgInvertCursor(), MoveGRAM(), _DEVICE_EXTENSION::ScreenAndFont, and TRUE.

Referenced by FsVgaCopyFrameBuffer().

00445 : 00446 00447 This routine copy the frame buffer. 00448 00449 Arguments: 00450 00451 DeviceExtension - Pointer to the miniport driver's device extension. 00452 00453 CopyFrameBuffer - Pointer to the structure containing the information about the copy frame buffer. 00454 00455 inputBufferLength - Length of the input buffer supplied by the user. 00456 00457 Return Value: 00458 00459 STATUS_INSUFFICIENT_BUFFER if the input buffer was not large enough 00460 for the input data. 00461 00462 STATUS_SUCCESS if the operation completed successfully. 00463 00464 --*/ 00465 00466 { 00467 PUCHAR SourcePtr, TargetPtr; 00468 00469 FsgInvertCursor(DeviceExtension,FALSE); 00470 00471 SourcePtr = CalcGRAMAddress (CopyFrameBuffer->SrcScreen.Position, 00472 DeviceExtension); 00473 TargetPtr = CalcGRAMAddress (CopyFrameBuffer->DestScreen.Position, 00474 DeviceExtension); 00475 MoveGRAM (TargetPtr, 00476 SourcePtr, 00477 CopyFrameBuffer->SrcScreen.nNumberOfChars * 00478 DeviceExtension->ScreenAndFont.FontSize.Y, 00479 DeviceExtension->CurrentMode.VideoMemory.FrameBufferBase, 00480 DeviceExtension 00481 ); 00482 00483 FsgInvertCursor(DeviceExtension,TRUE); 00484 00485 return STATUS_SUCCESS; 00486 }

NTSTATUS FsgInvertCursor PDEVICE_EXTENSION  DeviceExtension,
BOOL  Invert
 

Definition at line 702 of file drawscrn.c.

References AccessGRAM_AND(), BOOL, BYTE, CalcGRAMAddress(), _EMULATE_BUFFER_INFORMATION::CursorAttributes, _EMULATE_BUFFER_INFORMATION::CursorPosition, _DEVICE_EXTENSION::EmulateInfo, FALSE, NextGRAMRow(), _DEVICE_EXTENSION::ScreenAndFont, SetGRAMInvertMode(), SetGRAMWriteMode(), SHORT, _EMULATE_BUFFER_INFORMATION::ShowCursor, and TRUE.

Referenced by FsgCopyFrameBuffer(), FsgReverseMousePointer(), FsgWriteToFrameBuffer(), FsVgaSetCursorAttribute(), and FsVgaSetCursorPosition().

00709 : 00710 00711 This routine inverts the cursor. 00712 00713 Arguments: 00714 00715 DeviceExtension - Pointer to the miniport driver's device extension. 00716 00717 Invert - 00718 00719 Return Value: 00720 00721 STATUS_INSUFFICIENT_BUFFER if the input buffer was not large enough 00722 for the input data. 00723 00724 STATUS_SUCCESS if the operation completed successfully. 00725 00726 --*/ 00727 00728 { 00729 PUCHAR CurFrameBufPtr; 00730 COORD CursorPosition; 00731 COORD FontSize; 00732 SHORT i; 00733 SHORT TopScanLine; 00734 BOOL fOneMore = FALSE; 00735 00736 if (DeviceExtension->EmulateInfo.ShowCursor == Invert) 00737 return STATUS_SUCCESS; 00738 00739 DeviceExtension->EmulateInfo.ShowCursor = Invert; 00740 00741 if (!(DeviceExtension->EmulateInfo.CursorAttributes.Enable)) 00742 return STATUS_SUCCESS; 00743 00744 FontSize = DeviceExtension->ScreenAndFont.FontSize; 00745 if (DeviceExtension->ScreenAndFont.ScreenSize.Y > 25) 00746 { 00747 TopScanLine = ((DeviceExtension->EmulateInfo.CursorAttributes.Height + 8) * 100 / 8) - 100; 00748 } 00749 else 00750 { 00751 TopScanLine = ((DeviceExtension->EmulateInfo.CursorAttributes.Height + 16) * 100 / 16) - 100; 00752 } 00753 TopScanLine = (FontSize.Y * TopScanLine) / 100; 00754 00755 CursorPosition.X = DeviceExtension->EmulateInfo.CursorPosition.Coord.Column; 00756 CursorPosition.Y = DeviceExtension->EmulateInfo.CursorPosition.Coord.Row; 00757 if ( (0 <= CursorPosition.X && 00758 CursorPosition.X < DeviceExtension->ScreenAndFont.ScreenSize.X) && 00759 (0 <= CursorPosition.Y && 00760 CursorPosition.Y < DeviceExtension->ScreenAndFont.ScreenSize.Y) ) 00761 { 00762 switch (DeviceExtension->EmulateInfo.CursorPosition.dwType) 00763 { 00764 case CHAR_TYPE_LEADING: 00765 if (CursorPosition.X != DeviceExtension->ScreenAndFont.ScreenSize.X-1) 00766 { 00767 fOneMore = TRUE; 00768 } 00769 break; 00770 case CHAR_TYPE_TRAILING: 00771 if (CursorPosition.X != 0) 00772 { 00773 fOneMore = TRUE; 00774 CursorPosition.X--; 00775 } 00776 break; 00777 } 00778 00779 CurFrameBufPtr = CalcGRAMAddress (CursorPosition, 00780 DeviceExtension); 00781 00782 /* 00783 * CursorAttributes.Height is top scan lines. 00784 */ 00785 for (i = 0; i < TopScanLine; i++) 00786 { 00787 CurFrameBufPtr = NextGRAMRow(CurFrameBufPtr,DeviceExtension); 00788 } 00789 00790 // 00791 // Set invert mode of graphics register 00792 // 00793 SetGRAMInvertMode(DeviceExtension); 00794 00795 /* 00796 * CursorAttributes.Width is bottom scan lines. 00797 */ 00798 for ( ; i < FontSize.Y; i++) 00799 { 00800 AccessGRAM_AND(CurFrameBufPtr, (BYTE)-1); 00801 if (fOneMore) 00802 AccessGRAM_AND(CurFrameBufPtr+1, (BYTE)-1); 00803 CurFrameBufPtr = NextGRAMRow(CurFrameBufPtr,DeviceExtension); 00804 } 00805 00806 SetGRAMWriteMode(DeviceExtension); 00807 } 00808 00809 return STATUS_SUCCESS; 00810 }

NTSTATUS FsgReverseMousePointer PDEVICE_EXTENSION  DeviceExtension,
PFSVIDEO_REVERSE_MOUSE_POINTER  MouseBuffer,
ULONG  inputBufferLength
 

Definition at line 609 of file drawscrn.c.

References AccessGRAM_AND(), BOOL, BYTE, CalcGRAMAddress(), FALSE, FsgInvertCursor(), NextGRAMRow(), _DEVICE_EXTENSION::ScreenAndFont, SetGRAMInvertMode(), SetGRAMWriteMode(), SHORT, and TRUE.

Referenced by FsVgaReverseMousePointer().

00617 : 00618 00619 This routine reverse the frame buffer for mouse pointer. 00620 00621 Arguments: 00622 00623 DeviceExtension - Pointer to the miniport driver's device extension. 00624 00625 MouseBuffer - Pointer to the structure containing the information about the mouse frame buffer. 00626 00627 inputBufferLength - Length of the input buffer supplied by the user. 00628 00629 Return Value: 00630 00631 STATUS_INSUFFICIENT_BUFFER if the input buffer was not large enough 00632 for the input data. 00633 00634 STATUS_SUCCESS if the operation completed successfully. 00635 00636 --*/ 00637 00638 { 00639 00640 PUCHAR CurFrameBufPtr; 00641 COORD CursorPosition; 00642 COORD FontSize; 00643 SHORT i; 00644 BOOL fOneMore = FALSE; 00645 00646 FsgInvertCursor(DeviceExtension,FALSE); 00647 00648 FontSize = DeviceExtension->ScreenAndFont.FontSize; 00649 00650 CursorPosition.X = MouseBuffer->Screen.Position.X; 00651 CursorPosition.Y = MouseBuffer->Screen.Position.Y; 00652 if ( (0 <= CursorPosition.X && 00653 CursorPosition.X < MouseBuffer->Screen.ScreenSize.X) && 00654 (0 <= CursorPosition.Y && 00655 CursorPosition.Y < MouseBuffer->Screen.ScreenSize.Y) ) 00656 { 00657 switch (MouseBuffer->dwType) 00658 { 00659 case CHAR_TYPE_LEADING: 00660 if (CursorPosition.X != MouseBuffer->Screen.ScreenSize.X-1) 00661 { 00662 fOneMore = TRUE; 00663 } 00664 break; 00665 case CHAR_TYPE_TRAILING: 00666 if (CursorPosition.X != 0) 00667 { 00668 fOneMore = TRUE; 00669 CursorPosition.X--; 00670 } 00671 break; 00672 } 00673 00674 CurFrameBufPtr = CalcGRAMAddress (CursorPosition, 00675 DeviceExtension); 00676 00677 // 00678 // Set invert mode of graphics register 00679 // 00680 SetGRAMInvertMode(DeviceExtension); 00681 00682 /* 00683 * CursorAttributes.Width is bottom scan lines. 00684 */ 00685 for (i=0 ; i < FontSize.Y; i++) 00686 { 00687 AccessGRAM_AND(CurFrameBufPtr, (BYTE)-1); 00688 if (fOneMore) 00689 AccessGRAM_AND(CurFrameBufPtr+1, (BYTE)-1); 00690 CurFrameBufPtr = NextGRAMRow(CurFrameBufPtr,DeviceExtension); 00691 } 00692 00693 SetGRAMWriteMode(DeviceExtension); 00694 } 00695 00696 FsgInvertCursor(DeviceExtension,TRUE); 00697 00698 return STATUS_SUCCESS; 00699 }

NTSTATUS FsgVgaInitializeHWFlags PDEVICE_EXTENSION  DeviceExtension  ) 
 

Definition at line 387 of file drawscrn.c.

References BYTE, _EMULATE_BUFFER_INFORMATION::BytePerLine, CalcGRAMScanLine, _EMULATE_BUFFER_INFORMATION::ColorBg, _EMULATE_BUFFER_INFORMATION::ColorFg, _DEVICE_EXTENSION::Configuration, _EMULATE_BUFFER_INFORMATION::CursorAttributes, _EMULATE_BUFFER_INFORMATION::DeltaNextFontRow, _DEVICE_EXTENSION::EmulateInfo, FALSE, GetBytePerLine, GetHardwareScrollReg(), _FSVGA_CONFIGURATION_INFORMATION::HardwareScroll, Index, LIMIT_64K, _EMULATE_BUFFER_INFORMATION::LimitGRAM, _EMULATE_BUFFER_INFORMATION::MaxScanLine, _DEVICE_EXTENSION::ScreenAndFont, SetGRAMWriteMode(), _EMULATE_BUFFER_INFORMATION::ShowCursor, and USE_LINE_COMPARE.

Referenced by FsVgaSetScreenInformation().

00393 : 00394 00395 This routine initialize the hardware scrolls flag and any values. 00396 00397 Arguments: 00398 00399 EmulateInfo - Pointer to screen emulate information structure. 00400 00401 Return Value: 00402 00403 --*/ 00404 00405 { 00406 ULONG Index; 00407 00408 GetHardwareScrollReg(DeviceExtension); 00409 DeviceExtension->EmulateInfo.BytePerLine = 00410 (WORD)GetBytePerLine(DeviceExtension); 00411 DeviceExtension->EmulateInfo.MaxScanLine = 00412 (WORD)CalcGRAMScanLine(DeviceExtension->ScreenAndFont.ScreenSize.Y, 00413 DeviceExtension->ScreenAndFont.FontSize.Y); 00414 DeviceExtension->EmulateInfo.DeltaNextFontRow = 00415 DeviceExtension->EmulateInfo.BytePerLine * DeviceExtension->ScreenAndFont.FontSize.Y; 00416 00417 if (DeviceExtension->Configuration.HardwareScroll & USE_LINE_COMPARE) { 00418 DeviceExtension->EmulateInfo.LimitGRAM = 00419 DeviceExtension->EmulateInfo.MaxScanLine * DeviceExtension->EmulateInfo.BytePerLine; 00420 } 00421 else { 00422 DeviceExtension->EmulateInfo.LimitGRAM = LIMIT_64K; 00423 } 00424 00425 DeviceExtension->EmulateInfo.ColorFg = (BYTE)-1; 00426 DeviceExtension->EmulateInfo.ColorBg = (BYTE)-1; 00427 00428 DeviceExtension->EmulateInfo.CursorAttributes.Enable = 0; 00429 DeviceExtension->EmulateInfo.ShowCursor = FALSE; 00430 00431 SetGRAMWriteMode(DeviceExtension); 00432 00433 return STATUS_SUCCESS; 00434 }

NTSTATUS FsgWriteToFrameBuffer PDEVICE_EXTENSION  DeviceExtension,
PFSVIDEO_WRITE_TO_FRAME_BUFFER  WriteFrameBuffer,
ULONG  inputBufferLength
 

Definition at line 489 of file drawscrn.c.

References AlignCopyMemory(), BOOL, BYTE, BYTE_ALIGN, CalcBitmapBufferSize(), CalcGRAMAddress(), _EMULATE_BUFFER_INFORMATION::ColorBg, _EMULATE_BUFFER_INFORMATION::ColorFg, DWORD, _DEVICE_EXTENSION::EmulateInfo, ExAllocatePool, EXCEPTION_EXECUTE_HANDLER, ExFreePool(), FALSE, FsgInvertCursor(), FsgWriteToScreen(), NTSTATUS(), NULL, PagedPool, _DEVICE_EXTENSION::ScreenAndFont, Status, TRUE, and WORD_ALIGN.

Referenced by FsVgaWriteToFrameBuffer().

00497 : 00498 00499 This routine write the frame buffer. 00500 00501 Arguments: 00502 00503 DeviceExtension - Pointer to the miniport driver's device extension. 00504 00505 WriteFrameBuffer - Pointer to the structure containing the information about the write frame buffer. 00506 00507 inputBufferLength - Length of the input buffer supplied by the user. 00508 00509 Return Value: 00510 00511 STATUS_INSUFFICIENT_BUFFER if the input buffer was not large enough 00512 for the input data. 00513 00514 STATUS_SUCCESS if the operation completed successfully. 00515 00516 --*/ 00517 00518 { 00519 PCHAR_IMAGE_INFO pCharInfoUni = WriteFrameBuffer->SrcBuffer; 00520 PUCHAR TargetPtr; 00521 COORD Position = WriteFrameBuffer->DestScreen.Position; 00522 DWORD Length = WriteFrameBuffer->DestScreen.nNumberOfChars; 00523 COORD FontSize1 = DeviceExtension->ScreenAndFont.FontSize; 00524 COORD FontSize2; 00525 PVOID pCapBuffer = NULL; 00526 ULONG cCapBuffer = 0; 00527 BOOL fDbcs; 00528 NTSTATUS Status; 00529 00530 FsgInvertCursor(DeviceExtension,FALSE); 00531 00532 DeviceExtension->EmulateInfo.ColorFg = (BYTE)-1; 00533 DeviceExtension->EmulateInfo.ColorBg = (BYTE)-1; 00534 00535 FontSize2 = FontSize1; 00536 FontSize2.X *= 2; 00537 cCapBuffer = CalcBitmapBufferSize(FontSize2,BYTE_ALIGN); 00538 pCapBuffer = ExAllocatePool(PagedPool, cCapBuffer); 00539 00540 while (Length--) 00541 { 00542 if (pCharInfoUni->FontImageInfo.ImageBits != NULL) 00543 { 00544 try 00545 { 00546 fDbcs = pCharInfoUni->CharInfo.Attributes & COMMON_LVB_SBCSDBCS; 00547 AlignCopyMemory((PVOID)pCapBuffer, // pDestBits 00548 BYTE_ALIGN, // dwDestAlign 00549 pCharInfoUni->FontImageInfo.ImageBits,// pSrcBits 00550 WORD_ALIGN, // dwSrcAlign 00551 fDbcs ? FontSize2 : FontSize1); 00552 00553 TargetPtr = CalcGRAMAddress (Position, 00554 DeviceExtension); 00555 if (fDbcs) 00556 { 00557 if (Length) 00558 { 00559 FsgWriteToScreen(TargetPtr, pCapBuffer, 2, fDbcs, 00560 pCharInfoUni->CharInfo.Attributes, 00561 (pCharInfoUni+1)->CharInfo.Attributes, 00562 DeviceExtension); 00563 } 00564 else 00565 { 00566 FsgWriteToScreen(TargetPtr, pCapBuffer, 2, FALSE, 00567 pCharInfoUni->CharInfo.Attributes, 00568 (WORD)-1, 00569 DeviceExtension); 00570 } 00571 } 00572 else 00573 { 00574 FsgWriteToScreen(TargetPtr, pCapBuffer, 1, fDbcs, 00575 pCharInfoUni->CharInfo.Attributes, 00576 (WORD)-1, 00577 DeviceExtension); 00578 } 00579 00580 } 00581 except (EXCEPTION_EXECUTE_HANDLER) 00582 { 00583 } 00584 00585 } 00586 00587 if (fDbcs && Length) 00588 { 00589 Length--; 00590 Position.X += 2; 00591 pCharInfoUni += 2; 00592 } 00593 else 00594 { 00595 Position.X++; 00596 pCharInfoUni++; 00597 } 00598 } 00599 00600 FsgInvertCursor(DeviceExtension,TRUE); 00601 00602 if (pCapBuffer != NULL) 00603 ExFreePool(pCapBuffer); 00604 00605 return STATUS_SUCCESS; 00606 }

NTSTATUS FsgWriteToScreen PUCHAR  FrameBuffer,
PUCHAR  BitmapBuffer,
DWORD  cjBytes,
BOOL  fDbcs,
WORD  Attributes1,
WORD  Attributes2,
PDEVICE_EXTENSION  DeviceExtension
 

Definition at line 813 of file drawscrn.c.

References COMMON_LVB_MASK, _DEVICE_EXTENSION::Configuration, _FSVGA_CONFIGURATION_INFORMATION::EmulationMode, ENABLE_WORD_WRITE_VRAM, EXCEPTION_EXECUTE_HANDLER, FsgWriteToScreenCommonLVB(), Index, IsGRAMRowOver(), NextGRAMRow(), _DEVICE_EXTENSION::ScreenAndFont, and set_opaque_bkgnd_proc().

Referenced by FsgWriteToFrameBuffer().

00822 { 00823 WORD Index; 00824 PCHAR CurFrameBufPtrTmp; 00825 PCHAR CurFrameBufPtr2nd; 00826 PWORD CurFrameBufPtrWord; 00827 PUCHAR BitmapBufferTmp; 00828 00829 #ifdef LATER_HIGH_SPPED_VRAM_ACCESS // kazum 00830 if (! IsGRAMRowOver(FrameBuffer,fDBCS,DeviceExtension)) { 00831 if (!fDbcs) { 00832 if (cjBytes == 2) 00833 BitmapBuffer++; 00834 (*WriteGramInfo->pfnWriteFontToByteGRAM)(WriteGramInfo); 00835 } 00836 else if (cjBytes == 2 && fDBCS) { 00837 if (DeviceExtension->Configuration.EmulationMode & ENABLE_WORD_WRITE_VRAM) { 00838 (*WriteGramInfo->pfnWriteFontToFirstWordGRAM)(WriteGramInfo); 00839 } 00840 else { 00841 (*WriteGramInfo->pfnWriteFontToWordGRAM)(WriteGramInfo); 00842 } 00843 } 00844 } 00845 else 00846 #endif // LATER_HIGH_SPPED_VRAM_ACCESS // kazum 00847 try 00848 { 00849 set_opaque_bkgnd_proc(DeviceExtension,FrameBuffer,Attributes1); 00850 00851 if (!fDbcs) { 00852 CurFrameBufPtrTmp = FrameBuffer; 00853 if (cjBytes == 2) 00854 BitmapBuffer++; 00855 for (Index=0; Index < DeviceExtension->ScreenAndFont.FontSize.Y; Index++) { 00856 *CurFrameBufPtrTmp = *BitmapBuffer; 00857 BitmapBuffer += cjBytes; 00858 CurFrameBufPtrTmp=NextGRAMRow(CurFrameBufPtrTmp,DeviceExtension); 00859 } 00860 } 00861 else if (cjBytes == 2 && fDbcs) { 00862 if ((DeviceExtension->Configuration.EmulationMode & ENABLE_WORD_WRITE_VRAM) && 00863 !((ULONG)FrameBuffer & 1) && 00864 (Attributes2 != -1) && 00865 (Attributes1 == Attributes2) 00866 ) { 00867 CurFrameBufPtrWord = (PWORD)FrameBuffer; 00868 for (Index=0; Index < DeviceExtension->ScreenAndFont.FontSize.Y; Index++) { 00869 *CurFrameBufPtrWord = *((PWORD)BitmapBuffer); 00870 BitmapBuffer += cjBytes; 00871 CurFrameBufPtrWord=(PWORD)NextGRAMRow((PCHAR)CurFrameBufPtrWord,DeviceExtension); 00872 } 00873 } 00874 else { 00875 CurFrameBufPtrTmp = FrameBuffer; 00876 CurFrameBufPtr2nd = FrameBuffer + 1; 00877 BitmapBufferTmp = BitmapBuffer + 1; 00878 for (Index=0; Index < DeviceExtension->ScreenAndFont.FontSize.Y; Index++) { 00879 *CurFrameBufPtrTmp = *BitmapBuffer; 00880 BitmapBuffer += cjBytes; 00881 CurFrameBufPtrTmp=NextGRAMRow(CurFrameBufPtrTmp,DeviceExtension); 00882 } 00883 if (Attributes2 != -1 && 00884 Attributes1 != Attributes2) 00885 set_opaque_bkgnd_proc(DeviceExtension,FrameBuffer,Attributes2); 00886 for (Index=0; Index < DeviceExtension->ScreenAndFont.FontSize.Y; Index++) { 00887 *CurFrameBufPtr2nd = *BitmapBufferTmp; 00888 BitmapBufferTmp += cjBytes; 00889 CurFrameBufPtr2nd=NextGRAMRow(CurFrameBufPtr2nd,DeviceExtension); 00890 } 00891 } 00892 } 00893 } 00894 except (EXCEPTION_EXECUTE_HANDLER) 00895 { 00896 } 00897 00898 if (Attributes1 & COMMON_LVB_MASK) 00899 { 00900 FsgWriteToScreenCommonLVB(FrameBuffer, 00901 Attributes1, 00902 DeviceExtension); 00903 } 00904 if ((Attributes2 != (WORD)-1) && (Attributes2 & COMMON_LVB_MASK)) 00905 { 00906 FsgWriteToScreenCommonLVB(FrameBuffer+1, 00907 Attributes2, 00908 DeviceExtension); 00909 } 00910 00911 return STATUS_SUCCESS; 00912 }

NTSTATUS FsgWriteToScreenCommonLVB PUCHAR  FrameBuffer,
WORD  Attributes,
PDEVICE_EXTENSION  DeviceExtension
 

Definition at line 915 of file drawscrn.c.

References AccessGRAM_RW(), BYTE, _EMULATE_BUFFER_INFORMATION::ColorBg, _EMULATE_BUFFER_INFORMATION::ColorFg, ColorSetDirect(), ColorSetGridMask(), _DEVICE_EXTENSION::EmulateInfo, EXCEPTION_EXECUTE_HANDLER, Index, NextGRAMRow(), _DEVICE_EXTENSION::ScreenAndFont, set_opaque_bkgnd_proc(), and SetGRAMWriteMode().

Referenced by FsgWriteToScreen().

00920 { 00921 WORD Index; 00922 PUCHAR CurFrameBufPtrTmp; 00923 00924 try 00925 { 00926 if (Attributes & COMMON_LVB_UNDERSCORE) 00927 { 00928 set_opaque_bkgnd_proc(DeviceExtension,FrameBuffer,Attributes); 00929 CurFrameBufPtrTmp = FrameBuffer; 00930 for (Index=0; Index < DeviceExtension->ScreenAndFont.FontSize.Y - 1; Index++) 00931 CurFrameBufPtrTmp=NextGRAMRow(CurFrameBufPtrTmp,DeviceExtension); 00932 *CurFrameBufPtrTmp = 0xff; 00933 } 00934 00935 if (Attributes & COMMON_LVB_GRID_HORIZONTAL) 00936 { 00937 ColorSetDirect(DeviceExtension, FrameBuffer, 00938 FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED, 00939 0); 00940 *FrameBuffer = 0xff; 00941 } 00942 00943 if ( (Attributes & COMMON_LVB_GRID_LVERTICAL) || 00944 (Attributes & COMMON_LVB_GRID_RVERTICAL) ) 00945 { 00946 BYTE mask = ((Attributes & COMMON_LVB_GRID_LVERTICAL) ? 0x80 : 0) + 00947 ((Attributes & COMMON_LVB_GRID_RVERTICAL) ? 0x01 : 0); 00948 ColorSetGridMask(DeviceExtension, 00949 mask 00950 ); 00951 CurFrameBufPtrTmp = FrameBuffer; 00952 for (Index=0; Index < DeviceExtension->ScreenAndFont.FontSize.Y; Index++) { 00953 AccessGRAM_RW(CurFrameBufPtrTmp, mask); 00954 CurFrameBufPtrTmp=NextGRAMRow(CurFrameBufPtrTmp,DeviceExtension); 00955 } 00956 00957 SetGRAMWriteMode(DeviceExtension); 00958 } 00959 00960 DeviceExtension->EmulateInfo.ColorFg = (BYTE)-1; 00961 DeviceExtension->EmulateInfo.ColorBg = (BYTE)-1; 00962 00963 } 00964 except (EXCEPTION_EXECUTE_HANDLER) 00965 { 00966 } 00967 00968 return STATUS_SUCCESS; 00969 }

BOOL IsGRAMRowOver PUCHAR  BufPtr,
BOOL  fDbcs,
PDEVICE_EXTENSION  DeviceExtension
 

Definition at line 152 of file drawscrn.c.

References _DEVICE_EXTENSION::CurrentMode, _EMULATE_BUFFER_INFORMATION::DeltaNextFontRow, DWORD, _DEVICE_EXTENSION::EmulateInfo, FALSE, _EMULATE_BUFFER_INFORMATION::LimitGRAM, and TRUE.

Referenced by FsgWriteToScreen().

00160 : 00161 00162 This Routine check ROW overflow as GRAM limit line. 00163 00164 Arguments: 00165 00166 BufPtr - Pointer to graphics buffer. 00167 00168 fDbcs - Flag of DBCS(true) or SBCS(false). 00169 00170 Return Value: 00171 TRUE: if font box is overflow as GRAMlimit line. 00172 FALSE: not overflow. 00173 00174 --*/ 00175 00176 { 00177 if (fDbcs) 00178 { 00179 if ((DWORD)(BufPtr + 1 + 00180 DeviceExtension->EmulateInfo.DeltaNextFontRow - 00181 (PUCHAR)DeviceExtension->CurrentMode.VideoMemory.FrameBufferBase) 00182 >= DeviceExtension->EmulateInfo.LimitGRAM) 00183 return TRUE; 00184 else 00185 return FALSE; 00186 } 00187 else 00188 { 00189 if ((DWORD)(BufPtr + 00190 DeviceExtension->EmulateInfo.DeltaNextFontRow - 00191 (PUCHAR)DeviceExtension->CurrentMode.VideoMemory.FrameBufferBase) 00192 >= DeviceExtension->EmulateInfo.LimitGRAM) 00193 return TRUE; 00194 else 00195 return FALSE; 00196 } 00197 }

VOID memcpyGRAM IN PCHAR  TargetPtr,
IN PCHAR  SourcePtr,
IN ULONG  Length
 

Definition at line 233 of file drawscrn.c.

Referenced by memcpyGRAMOver(), and MoveGRAM().

00241 : 00242 00243 This routine is a memory copy for byte order. 00244 00245 Arguments: 00246 00247 TargetPtr - Pointer to target graphics buffer. 00248 00249 SourcePtr - Pointer to source graphics buffer. 00250 00251 Length - Fill length. 00252 00253 Return Value: 00254 00255 --*/ 00256 00257 { 00258 while (Length--) 00259 *TargetPtr++ = *SourcePtr++; 00260 }

VOID memcpyGRAMOver IN PCHAR  TargetPtr,
IN PCHAR  SourcePtr,
IN ULONG  Length,
IN PUCHAR  FrameBufPtr,
IN PDEVICE_EXTENSION  DeviceExtension
 

Definition at line 263 of file drawscrn.c.

References DWORD, and memcpyGRAM().

Referenced by MoveGRAM().

00273 : 00274 00275 This routine move a graphics buffer. 00276 00277 Arguments: 00278 00279 TargetPtr - Pointer to target graphics buffer. 00280 00281 SourcePtr - Pointer to source graphics buffer. 00282 00283 Length - Fill length. 00284 00285 Return Value: 00286 00287 --*/ 00288 00289 { 00290 ULONG tmpLen; 00291 00292 if ((DWORD)(SourcePtr + Length - FrameBufPtr) >= DeviceExtension->EmulateInfo.LimitGRAM) { 00293 tmpLen = DeviceExtension->EmulateInfo.LimitGRAM - (SourcePtr - FrameBufPtr); 00294 memcpyGRAM(TargetPtr, SourcePtr, tmpLen); 00295 TargetPtr += tmpLen; 00296 Length -= tmpLen; 00297 SourcePtr = FrameBufPtr; 00298 } 00299 00300 if ((DWORD)(TargetPtr + Length - FrameBufPtr) >= DeviceExtension->EmulateInfo.LimitGRAM) { 00301 tmpLen = DeviceExtension->EmulateInfo.LimitGRAM - (TargetPtr - FrameBufPtr); 00302 memcpyGRAM(TargetPtr, SourcePtr, tmpLen); 00303 SourcePtr += tmpLen; 00304 Length -= tmpLen; 00305 TargetPtr = FrameBufPtr; 00306 } 00307 00308 if (Length) { 00309 memcpyGRAM(TargetPtr, SourcePtr, Length); 00310 } 00311 }

VOID MoveGRAM IN PCHAR  TargetPtr,
IN PCHAR  SourcePtr,
IN ULONG  Length,
IN PUCHAR  FrameBufPtr,
IN PDEVICE_EXTENSION  DeviceExtension
 

Definition at line 314 of file drawscrn.c.

References DWORD, memcpyGRAM(), memcpyGRAMOver(), SetGRAMCopyMode(), and SetGRAMWriteMode().

Referenced by FsgCopyFrameBuffer().

00324 : 00325 00326 This routine move a graphics buffer. 00327 00328 Arguments: 00329 00330 TargetPtr - Pointer to target graphics buffer. 00331 00332 SourcePtr - Pointer to source graphics buffer. 00333 00334 Length - Fill length. 00335 00336 Return Value: 00337 00338 none. 00339 00340 --*/ 00341 { 00342 PCHAR tmpSrc; 00343 PCHAR tmpTrg; 00344 ULONG tmpLen; 00345 00346 // 00347 // Set copy mode of graphics register 00348 // 00349 00350 SetGRAMCopyMode(DeviceExtension); 00351 00352 if ((DWORD)(SourcePtr + Length - FrameBufPtr) >= DeviceExtension->EmulateInfo.LimitGRAM || 00353 (DWORD)(TargetPtr + Length - FrameBufPtr) >= DeviceExtension->EmulateInfo.LimitGRAM ) { 00354 if (SourcePtr > TargetPtr) { 00355 memcpyGRAMOver(TargetPtr,SourcePtr,Length,FrameBufPtr,DeviceExtension); 00356 } 00357 else if ((ULONG)(TargetPtr - SourcePtr) >= Length) { 00358 memcpyGRAMOver(TargetPtr,SourcePtr,Length,FrameBufPtr,DeviceExtension); 00359 } 00360 else { 00361 if ((DWORD)(SourcePtr + Length - FrameBufPtr) >= DeviceExtension->EmulateInfo.LimitGRAM) { 00362 tmpLen = SourcePtr + Length - FrameBufPtr - DeviceExtension->EmulateInfo.LimitGRAM; 00363 tmpTrg = TargetPtr + Length - tmpLen - DeviceExtension->EmulateInfo.LimitGRAM; 00364 memcpyGRAM(tmpTrg, FrameBufPtr, tmpLen); 00365 Length -= tmpLen; 00366 } 00367 if ((DWORD)(TargetPtr + Length - FrameBufPtr) >= DeviceExtension->EmulateInfo.LimitGRAM) { 00368 tmpLen = TargetPtr + Length - FrameBufPtr - DeviceExtension->EmulateInfo.LimitGRAM; 00369 tmpSrc = SourcePtr + Length - tmpLen; 00370 memcpyGRAM(FrameBufPtr, tmpSrc, tmpLen); 00371 Length -= tmpLen; 00372 } 00373 if (Length) { 00374 memcpyGRAM(TargetPtr, SourcePtr, Length); 00375 } 00376 } 00377 } 00378 else { 00379 memcpyGRAM(TargetPtr, SourcePtr, Length); 00380 } 00381 00382 SetGRAMWriteMode(DeviceExtension); 00383 }

PUCHAR NextGRAMRow PUCHAR  BufPtr,
PDEVICE_EXTENSION  DeviceExtension
 

Definition at line 200 of file drawscrn.c.

References _EMULATE_BUFFER_INFORMATION::BytePerLine, _DEVICE_EXTENSION::CurrentMode, DWORD, _DEVICE_EXTENSION::EmulateInfo, and _EMULATE_BUFFER_INFORMATION::LimitGRAM.

Referenced by FsgInvertCursor(), FsgReverseMousePointer(), FsgWriteToScreen(), and FsgWriteToScreenCommonLVB().

00207 : 00208 This Routine add next row a graphics buffer address. 00209 00210 Arguments: 00211 00212 BufPtr - Pointer to graphics buffer. 00213 00214 Return Value: 00215 00216 Returen to graphics buffer address. 00217 00218 --*/ 00219 00220 { 00221 if ((DWORD)(BufPtr + 00222 DeviceExtension->EmulateInfo.BytePerLine - 00223 (PUCHAR)DeviceExtension->CurrentMode.VideoMemory.FrameBufferBase) 00224 >= DeviceExtension->EmulateInfo.LimitGRAM) 00225 return (BufPtr + 00226 DeviceExtension->EmulateInfo.BytePerLine - 00227 DeviceExtension->EmulateInfo.LimitGRAM); 00228 else 00229 return (BufPtr + DeviceExtension->EmulateInfo.BytePerLine); 00230 }


Generated on Sat May 15 19:43:29 2004 for test by doxygen 1.3.7