761 lines
16 KiB
C
761 lines
16 KiB
C
/*++
|
|
|
|
Copyright (c) 1999 Intel Corporation
|
|
|
|
Module Name:
|
|
libFileBuffer.c
|
|
|
|
--*/
|
|
|
|
#ifndef _LIB_FILE_BUFFER
|
|
#define _LIB_FILE_BUFFER
|
|
|
|
#include "libMisc.h"
|
|
|
|
|
|
#define ABSOLUTE_MAX_COLUMNS 132
|
|
STATIC CHAR16 BlankLine[ABSOLUTE_MAX_COLUMNS];
|
|
|
|
STATIC EFI_STATUS FileBufferScrollUp (VOID);
|
|
STATIC EFI_STATUS FileBufferScrollDown (VOID);
|
|
STATIC EFI_STATUS FileBufferScrollLeft (VOID);
|
|
STATIC EFI_STATUS FileBufferScrollRight (VOID);
|
|
STATIC EFI_STATUS FileBufferPageUp (VOID);
|
|
STATIC EFI_STATUS FileBufferPageDown (VOID);
|
|
STATIC EFI_STATUS FileBufferHome (VOID);
|
|
STATIC EFI_STATUS FileBufferEnd (VOID);
|
|
|
|
STATIC EFI_STATUS FileBufferDoDelete (VOID);
|
|
STATIC EFI_STATUS FileBufferDoBackspace (VOID);
|
|
STATIC EFI_STATUS FileBufferDoHexInput (CHAR16);
|
|
|
|
STATIC EFI_STATUS FileBufferRefreshCurrentLine(VOID);
|
|
STATIC EFI_STATUS FileBufferRefreshDown (VOID);
|
|
|
|
STATIC EFI_STATUS FileBufferInit (VOID);
|
|
STATIC EFI_STATUS FileBufferCleanup (VOID);
|
|
STATIC EFI_STATUS FileBufferRefresh (VOID);
|
|
STATIC EFI_STATUS FileBufferHide (VOID);
|
|
STATIC EFI_STATUS FileBufferHandleInput (EFI_INPUT_KEY*);
|
|
|
|
STATIC EFI_STATUS FileBufferClearLine (UINTN);
|
|
STATIC EFI_STATUS FileBufferSetPosition (UINTN,UINTN);
|
|
STATIC EFI_STATUS FileBufferRestorePosition (VOID);
|
|
STATIC UINTN DisplayPosition();
|
|
|
|
|
|
EE_FILE_BUFFER FileBuffer = {
|
|
{0,0},
|
|
0x00,
|
|
0x00,
|
|
0x00,
|
|
0x00,
|
|
NULL,
|
|
FileBufferInit,
|
|
FileBufferCleanup,
|
|
FileBufferRefresh,
|
|
FileBufferHide,
|
|
FileBufferHandleInput,
|
|
FileBufferClearLine,
|
|
FileBufferSetPosition,
|
|
FileBufferRestorePosition,
|
|
};
|
|
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferInit (
|
|
VOID
|
|
)
|
|
{
|
|
UINTN i;
|
|
|
|
FileBuffer.DisplayPosition.Row = TEXT_START_ROW;
|
|
FileBuffer.DisplayPosition.Column = HEX_POSITION;
|
|
|
|
FileBuffer.MaxVisibleBytes = MAX_TEXT_ROWS * 0x10;
|
|
|
|
for (i = 0; i < ABSOLUTE_MAX_COLUMNS; i++) {
|
|
BlankLine[i] = ' ';
|
|
}
|
|
|
|
LineCreateNode(MainEditor.BufferImage->ListHead);
|
|
FileBuffer.CurrentLine = MainEditor.BufferImage->ListHead->Flink;
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferCleanup (
|
|
VOID
|
|
)
|
|
{
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
VOID
|
|
RefreshOffset (
|
|
VOID
|
|
)
|
|
{
|
|
PrintAt(0,FileBuffer.DisplayPosition.Row,L"%X",FileBuffer.Offset&0xfffffff0);
|
|
FileBufferRestorePosition();
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferRefresh (
|
|
VOID
|
|
)
|
|
{
|
|
UINTN i;
|
|
UINTN Limit;
|
|
LIST_ENTRY *Item;
|
|
UINTN Offset = 0x00;
|
|
UINTN Row;
|
|
|
|
Item = MainEditor.BufferImage->ListHead->Flink;
|
|
FileBuffer.HighVisibleOffset = FileBuffer.MaxVisibleBytes;
|
|
Row = FileBuffer.LowVisibleOffset / 0x10;
|
|
|
|
for (i = 0; i < Row && Item != MainEditor.BufferImage->ListHead; i++) {
|
|
Item = Item->Flink;
|
|
FileBuffer.HighVisibleOffset += 0x10;
|
|
Offset += 0x10;
|
|
}
|
|
|
|
Limit = FileBuffer.MaxVisibleBytes / 0x10;
|
|
|
|
i = TEXT_START_ROW;
|
|
|
|
for (i = TEXT_START_ROW; i <= Limit; i++) {
|
|
if (Item->Flink != MainEditor.BufferImage->ListHead) {
|
|
LinePrint (Item,Offset,i);
|
|
Offset += 0x10;
|
|
Item = Item->Flink;
|
|
} else {
|
|
FileBufferClearLine(i);
|
|
}
|
|
}
|
|
|
|
RefreshOffset();
|
|
|
|
FileBufferRestorePosition();
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferRefreshDown (
|
|
VOID
|
|
)
|
|
{
|
|
UINTN Limit;
|
|
LIST_ENTRY *Link;
|
|
UINTN i;
|
|
UINTN Offset;
|
|
|
|
Limit = FileBuffer.MaxVisibleBytes / 0x10;
|
|
Offset = FileBuffer.Offset & 0xfffffff0;
|
|
|
|
Link = FileBuffer.CurrentLine;
|
|
|
|
/* while (Link != MainEditor.BufferImage->ListHead) { */
|
|
for (i = FileBuffer.DisplayPosition.Row; i < TEXT_END_ROW; i++) {
|
|
if (Link->Flink != MainEditor.BufferImage->ListHead) {
|
|
LinePrint (Link,Offset,i);
|
|
Link = Link->Flink;
|
|
Offset += 0x10;
|
|
} else {
|
|
FileBufferClearLine(i);
|
|
}
|
|
}
|
|
|
|
FileBufferRestorePosition();
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferHandleInput (
|
|
IN EFI_INPUT_KEY* Key
|
|
)
|
|
{
|
|
|
|
switch (Key->ScanCode) {
|
|
case SCAN_CODE_NULL:
|
|
FileBufferDoHexInput (Key->UnicodeChar);
|
|
break;
|
|
case SCAN_CODE_UP:
|
|
FileBufferScrollUp();
|
|
break;
|
|
case SCAN_CODE_DOWN:
|
|
FileBufferScrollDown();
|
|
break;
|
|
case SCAN_CODE_RIGHT:
|
|
FileBufferScrollRight();
|
|
break;
|
|
case SCAN_CODE_LEFT:
|
|
FileBufferScrollLeft();
|
|
break;
|
|
case SCAN_CODE_PGUP:
|
|
FileBufferPageUp();
|
|
break;
|
|
case SCAN_CODE_PGDN:
|
|
FileBufferPageDown();
|
|
break;
|
|
case SCAN_CODE_DEL:
|
|
FileBufferDoDelete();
|
|
break;
|
|
case SCAN_CODE_HOME:
|
|
FileBufferHome();
|
|
break;
|
|
case SCAN_CODE_END:
|
|
FileBufferEnd();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferHide (
|
|
VOID
|
|
)
|
|
{
|
|
UINTN i;
|
|
UINTN NumLines;
|
|
|
|
NumLines = FileBuffer.MaxVisibleBytes / 0x10;
|
|
|
|
for (i = TEXT_START_ROW; i <= NumLines; i++) {
|
|
FileBufferClearLine(i);
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferRefreshCurrentLine (
|
|
VOID
|
|
)
|
|
{
|
|
UINTN Where;
|
|
|
|
Where = FileBuffer.DisplayPosition.Row;
|
|
|
|
LinePrint(FileBuffer.CurrentLine,(FileBuffer.Offset & 0xfffffff0),Where);
|
|
FileBufferRestorePosition();
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferRefreshCurrentDigit (
|
|
VOID
|
|
)
|
|
{
|
|
UINTN Row;
|
|
UINTN Pos;
|
|
|
|
Row = FileBuffer.DisplayPosition.Row;
|
|
Pos = FileBuffer.Offset % 0x10;
|
|
|
|
DigitPrint(FileBuffer.CurrentLine,Pos,Row);
|
|
FileBufferRestorePosition();
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferClearLine (
|
|
UINTN Line
|
|
)
|
|
{
|
|
BlankLine[MAX_TEXT_COLUMNS-1] = 0;
|
|
PrintAt(0,Line,BlankLine);
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferSetPosition (
|
|
IN UINTN Row,
|
|
IN UINTN Column
|
|
)
|
|
{
|
|
FileBuffer.DisplayPosition.Row = Row;
|
|
FileBuffer.DisplayPosition.Column = Column;
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferRestorePosition (
|
|
VOID
|
|
)
|
|
{
|
|
Out->SetCursorPosition (Out,FileBuffer.DisplayPosition.Column,FileBuffer.DisplayPosition.Row);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferScrollDown (
|
|
VOID
|
|
)
|
|
{
|
|
UINTN MaxBytes;
|
|
UINTN HighOffset;
|
|
UINTN CurrentRow;
|
|
UINTN CurrentOffset;
|
|
UINTN MaxRows;
|
|
UINTN HighRow;
|
|
UINTN NumBytes;
|
|
UINTN NumLines;
|
|
UINTN DisplayOffset;
|
|
EE_LINE *Line;
|
|
|
|
CurrentRow = FileBuffer.DisplayPosition.Row;
|
|
Line = LineCurrent();
|
|
|
|
MaxBytes = FileBuffer.MaxVisibleBytes;
|
|
HighOffset = FileBuffer.HighVisibleOffset;
|
|
|
|
MaxRows = TEXT_END_ROW;
|
|
HighRow = HighOffset/0x10;
|
|
|
|
NumBytes = MainEditor.BufferImage->NumBytes;
|
|
NumLines = NumBytes / 0x10;
|
|
|
|
if (Line->Link.Flink == MainEditor.BufferImage->ListHead->Blink) {
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
CurrentOffset = FileBuffer.Offset + 0x10;
|
|
FileBuffer.Offset = CurrentOffset;
|
|
|
|
if (CurrentRow == (MaxRows - 1)) {
|
|
FileBuffer.LowVisibleOffset += 0x10;
|
|
FileBuffer.HighVisibleOffset += 0x10;
|
|
CurrentRow = MaxRows - 1;
|
|
|
|
FileBuffer.Refresh();
|
|
} else if (CurrentRow == HighRow) {
|
|
return EFI_SUCCESS;
|
|
} else {
|
|
++CurrentRow;
|
|
}
|
|
|
|
Line = LineNext ();
|
|
|
|
if ((CurrentOffset % 0x10) < Line->Size) {
|
|
DisplayOffset = FileBuffer.DisplayPosition.Column;
|
|
} else {
|
|
CurrentOffset = NumBytes;
|
|
DisplayOffset = (Line->Size*3) + HEX_POSITION;
|
|
if (Line->Size > 0x07) {
|
|
++DisplayOffset;
|
|
}
|
|
}
|
|
|
|
|
|
FileBuffer.SetPosition(CurrentRow,DisplayOffset);
|
|
|
|
MainEditor.StatusBar->SetOffset(CurrentOffset);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferScrollUp (
|
|
VOID
|
|
)
|
|
{
|
|
UINTN CurrentRow;
|
|
UINTN MaxRows;
|
|
UINTN LowRow;
|
|
UINTN MaxBytes;
|
|
UINTN LowOffset;
|
|
UINTN CurrentOffset;
|
|
|
|
CurrentOffset = FileBuffer.Offset;
|
|
|
|
if ( CurrentOffset < 0x10 ) {
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
MaxBytes = FileBuffer.MaxVisibleBytes;
|
|
MaxRows = MaxBytes / 0x10;
|
|
LowOffset = FileBuffer.LowVisibleOffset;
|
|
LowRow = LowOffset / 0x10;
|
|
|
|
CurrentRow = FileBuffer.DisplayPosition.Row;
|
|
|
|
CurrentOffset -= 0x10;
|
|
FileBuffer.Offset -= 0x10;
|
|
|
|
if (CurrentRow == 1) {
|
|
FileBuffer.HighVisibleOffset -= 0x10;
|
|
FileBuffer.LowVisibleOffset -= 0x10;
|
|
CurrentRow = 1;
|
|
FileBuffer.Refresh();
|
|
} else {
|
|
CurrentRow--;
|
|
}
|
|
|
|
LinePrevious ();
|
|
|
|
FileBuffer.SetPosition(CurrentRow,FileBuffer.DisplayPosition.Column);
|
|
|
|
MainEditor.StatusBar->SetOffset(CurrentOffset);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferPageUp (
|
|
VOID
|
|
)
|
|
{
|
|
UINTN MaxBytes;
|
|
UINTN LowOffset;
|
|
UINTN CurrentOffset;
|
|
BOOLEAN Refresh = FALSE;
|
|
|
|
CurrentOffset = FileBuffer.Offset;
|
|
MaxBytes = FileBuffer.MaxVisibleBytes;
|
|
LowOffset = FileBuffer.LowVisibleOffset;
|
|
|
|
if (LowOffset <= MaxBytes) {
|
|
FileBuffer.HighVisibleOffset = MaxBytes - 0x10;
|
|
FileBuffer.LowVisibleOffset = 0x00;
|
|
|
|
if (LowOffset > 0x00) {
|
|
if (CurrentOffset < MaxBytes) {
|
|
FileBuffer.Offset = 0x00;
|
|
} else {
|
|
FileBuffer.Offset -= (MaxBytes - 0x10);
|
|
}
|
|
} else {
|
|
FileBuffer.Offset = 0x00;
|
|
}
|
|
|
|
Refresh = TRUE;
|
|
|
|
FileBuffer.DisplayPosition.Row = FileBuffer.Offset/0x10 + TEXT_START_ROW;
|
|
} else {
|
|
FileBuffer.HighVisibleOffset = LowOffset - 0x10;
|
|
FileBuffer.LowVisibleOffset -= (MaxBytes - 0x10);
|
|
FileBuffer.Offset -= (MaxBytes - 0x10);
|
|
Refresh = TRUE;
|
|
}
|
|
|
|
CurrentOffset -= FileBuffer.Offset;
|
|
CurrentOffset /= 0x10;
|
|
LineRetreat(CurrentOffset);
|
|
|
|
if (Refresh) {
|
|
FileBufferRefresh();
|
|
}
|
|
FileBuffer.DisplayPosition.Column = DisplayPosition();
|
|
|
|
MainEditor.StatusBar->SetOffset(FileBuffer.Offset);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferPageDown (
|
|
VOID
|
|
)
|
|
{
|
|
UINTN NumBytes;
|
|
UINTN MaxBytes;
|
|
UINTN HighOffset;
|
|
UINTN CurrentOffset;
|
|
|
|
NumBytes = MainEditor.BufferImage->NumBytes;
|
|
MaxBytes = FileBuffer.MaxVisibleBytes;
|
|
HighOffset = FileBuffer.HighVisibleOffset;
|
|
CurrentOffset = FileBuffer.Offset;
|
|
|
|
FileBuffer.Offset = min(NumBytes,CurrentOffset+MaxBytes-0x10);
|
|
if (HighOffset < NumBytes) {
|
|
FileBuffer.LowVisibleOffset = HighOffset-0x10;
|
|
FileBuffer.HighVisibleOffset += (MaxBytes - 0x10);
|
|
FileBuffer.Refresh();
|
|
LineAdvance((FileBuffer.Offset-CurrentOffset)/0x10);
|
|
} else if (FileBuffer.Offset >= NumBytes-1) {
|
|
FileBuffer.Offset &= 0xfffffff0;
|
|
FileBuffer.Offset |= ((NumBytes-1) & 0x00000001f);
|
|
FileBuffer.CurrentLine = LineLast()->Link.Blink;
|
|
}
|
|
|
|
FileBuffer.DisplayPosition.Column = DisplayPosition();
|
|
FileBuffer.DisplayPosition.Row = (FileBuffer.Offset-FileBuffer.LowVisibleOffset)/0x10 + TEXT_START_ROW;
|
|
|
|
MainEditor.StatusBar->SetOffset (FileBuffer.Offset);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferScrollLeft (
|
|
VOID
|
|
)
|
|
{
|
|
UINTN LineOffset;
|
|
|
|
LineOffset = FileBuffer.Offset % 0x10;
|
|
|
|
if (FileBuffer.Offset == 0x00) {
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
if (LineOffset == 0x00) {
|
|
FileBufferScrollUp ();
|
|
FileBuffer.Offset += 0x10;
|
|
LineOffset = 0x0f;
|
|
} else {
|
|
--LineOffset;
|
|
}
|
|
FileBuffer.DisplayPosition.Column = HEX_POSITION + (LineOffset*3);
|
|
if (LineOffset > 0x07) {
|
|
++FileBuffer.DisplayPosition.Column;
|
|
}
|
|
--FileBuffer.Offset;
|
|
|
|
MainEditor.StatusBar->SetOffset(FileBuffer.Offset);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferScrollRight (
|
|
VOID
|
|
)
|
|
{
|
|
UINTN CurrentOffset;
|
|
UINTN LineOffset;
|
|
EE_LINE *Line;
|
|
|
|
Line = LineCurrent();
|
|
CurrentOffset = FileBuffer.Offset;
|
|
LineOffset = CurrentOffset % 0x10;
|
|
|
|
if (CurrentOffset >= MainEditor.BufferImage->NumBytes){
|
|
return EFI_SUCCESS;
|
|
}
|
|
if (LineOffset > Line->Size) {
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
if (LineOffset == 0x0f) {
|
|
FileBufferScrollDown();
|
|
FileBuffer.Offset &= 0xfffffff0;
|
|
FileBuffer.DisplayPosition.Column = HEX_POSITION;
|
|
RefreshOffset();
|
|
} else {
|
|
++LineOffset;
|
|
FileBuffer.DisplayPosition.Column = HEX_POSITION + (LineOffset*3);
|
|
if (LineOffset > 0x07) {
|
|
++FileBuffer.DisplayPosition.Column;
|
|
}
|
|
++FileBuffer.Offset;
|
|
}
|
|
|
|
MainEditor.StatusBar->SetOffset(FileBuffer.Offset);
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferHome (
|
|
VOID
|
|
)
|
|
{
|
|
FileBuffer.DisplayPosition.Column = HEX_POSITION;
|
|
FileBuffer.Offset &= 0xfffffff0;
|
|
|
|
MainEditor.StatusBar->SetOffset(FileBuffer.Offset);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferEnd (
|
|
VOID
|
|
)
|
|
{
|
|
EE_LINE *Line;
|
|
|
|
Line = LineCurrent();
|
|
FileBuffer.Offset &= 0xfffffff0;
|
|
if (Line->Size > 0) {
|
|
FileBuffer.Offset |= ((Line->Size-1) & 0x0000000f);
|
|
}
|
|
FileBuffer.DisplayPosition.Column = DisplayPosition();
|
|
MainEditor.StatusBar->SetOffset(FileBuffer.Offset);
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferDoHexInput (
|
|
IN CHAR16 Char
|
|
)
|
|
{
|
|
EE_LINE *Line;
|
|
UINTN LineOffset;
|
|
UINTN Pos;
|
|
UINTN Num;
|
|
|
|
if (Char == CHAR_BS) {
|
|
FileBufferDoBackspace();
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
if (Char >= 'A' && Char <= 'F') {
|
|
Num = Char - 'A' + 0xa;
|
|
} else if (Char >= 'a' && Char <= 'f') {
|
|
Num = Char - 'a' + 0xa;
|
|
} else if (Char >= '0' && Char <= '9') {
|
|
Num = Char - '0';
|
|
} else {
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
LineOffset = FileBuffer.Offset % 0x10;
|
|
Pos = FileBuffer.DisplayPosition.Column - HEX_POSITION;
|
|
if (LineOffset > 0x07) {
|
|
Pos -= (0x07*3)+1;
|
|
}
|
|
|
|
if (FileBuffer.CurrentLine == MainEditor.BufferImage->ListHead->Blink) {
|
|
Line = LineCreateNode(MainEditor.BufferImage->ListHead);
|
|
FileBuffer.CurrentLine = Line->Link.Blink;
|
|
}
|
|
|
|
Line = LineCurrent();
|
|
|
|
Line->Buffer[LineOffset] <<= 4;
|
|
Line->Buffer[LineOffset] |= Num;
|
|
|
|
|
|
if (FileBuffer.Offset == MainEditor.BufferImage->NumBytes) {
|
|
++Line->Size;
|
|
++MainEditor.BufferImage->NumBytes;
|
|
} else if (FileBuffer.Offset == (MainEditor.BufferImage->NumBytes - 1)) {
|
|
if ((Pos%3) != 0 && Line->Size == 0x10) {
|
|
Line = LineCreateNode(MainEditor.BufferImage->ListHead);
|
|
}
|
|
}
|
|
|
|
FileBufferRefreshCurrentDigit();
|
|
|
|
if ((Pos % 3) != 0) {
|
|
FileBufferScrollRight();
|
|
} else {
|
|
++FileBuffer.DisplayPosition.Column;
|
|
}
|
|
|
|
FileBufferRestorePosition();
|
|
|
|
FileModification();
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferDoBackspace (
|
|
VOID
|
|
)
|
|
{
|
|
UINTN LinePos;
|
|
|
|
if (FileBuffer.Offset == 0x00) {
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
FileBufferScrollLeft();
|
|
LinePos = FileBuffer.Offset % 0x10;
|
|
|
|
LineDeleteAt(FileBuffer.CurrentLine,LinePos,1);
|
|
|
|
FileBufferRefreshDown();
|
|
FileModification();
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
EFI_STATUS
|
|
FileBufferDoDelete (
|
|
VOID
|
|
)
|
|
{
|
|
LIST_ENTRY *Link;
|
|
UINTN LinePos;
|
|
|
|
if (FileBuffer.Offset == MainEditor.BufferImage->NumBytes) {
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
LinePos = FileBuffer.Offset % 0x10;
|
|
Link = FileBuffer.CurrentLine;
|
|
|
|
LineDeleteAt(Link,LinePos,1);
|
|
|
|
if (FileBuffer.Offset == MainEditor.BufferImage->NumBytes) {
|
|
FileBufferScrollLeft();
|
|
}
|
|
|
|
FileBufferRefreshDown();
|
|
FileModification();
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
STATIC
|
|
UINTN
|
|
DisplayPosition (
|
|
VOID
|
|
)
|
|
{
|
|
EE_LINE *Line;
|
|
UINTN Pos = 0;
|
|
|
|
Line = LineCurrent();
|
|
Pos = FileBuffer.Offset & 0x0000000f;
|
|
Pos = Pos * 3 + HEX_POSITION;
|
|
|
|
if (Line->Size > 0x07) {
|
|
Pos++;
|
|
}
|
|
|
|
return Pos;
|
|
}
|
|
|
|
#endif /* _LIB_FILE_BUFFER */
|