Spexeah/Asuro
Spexeah/Asuro
3
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Asuro/src/console.pas
Kieron Morris c5bafa9fa9 Added pasdoc generation to the pipeline 
Added documentation generation to the pipeline, this can be retreived as an artifact and deployed on the webserver from master.
2021-07-05 16:00:00 +01:00

2710 lines
89 KiB
ObjectPascal
Raw Blame History

// Copyright 2021 Kieron Morris
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
{
Console - Provides Screen/Window management & drawing.
@author(Kieron Morris <kjm@kieronmorris.me>)
}
unit console;
interface
uses
util,
bios_data_area,
multiboot,
fonts,
tracer;
type
{ 4-bit nibble representing a color. }
TColor = ( Black = $0,
Blue = $1,
Green = $2,
Aqua = $3,
Red = $4,
Purple = $5,
Yellow = $6,
White = $7,
Gray = $8,
lBlue = $9,
lGreen = $A,
lAqua = $B,
lRed = $C,
lPurple = $D,
lYellow = $E,
lWhite = $F );
{ Window Manager Events. }
TEventType = ( EVENT_DRAW,
EVENT_MOUSE_CLICK,
EVENT_MOUSE_MOVE,
EVENT_MOUSE_DOWN,
EVENT_MOUSE_UP,
EVENT_KEY_PRESSED,
EVENT_CLOSE,
EVENT_MINIMIZE,
EVENT_FOCUS,
EVENT_LOSE_FOCUS );
{ Properties pertaining to the raw screen matrix. }
TConsoleProperties = record
Default_Attribute : uint32; //< Attribute (Colors) to use when no override defined.
Width : uint32;
Height : uint32;
BitsPerPixel : uint8;
MAX_CELL_X : uint32;
MAX_CELL_Y : uint32;
end;
PConsoleProperties = ^TConsoleProperties;
{! Default Buffer Specific }
{
Initialize the Frame Buffer & Window Manager ready for use.
}
procedure init();
{
Clear the Frame Buffer.
}
procedure clear();
{
Set the default set of attributes to be used when drawing to the screen.
@param(attribute A 32-bit value representing the Foreground & Background colors.)
}
procedure setdefaultattribute(attribute : uint32);
{
@bold(Text mode only!) - Disable the cursor/text-caret.
@deprecated
}
procedure disable_cursor;
{
Write a single 8-bit character to the screen.
@param(character An 8-bit value representing an ASCII character.)
}
procedure writechar(character : char);
{
Write a single 8-bit character to the screen, followed by starting a new line.
@param(character An 8-bit value representing an ASCII character.)
}
procedure writecharln(character : char);
{
Write a single 8-bit character to the screen, specifying custom color attributes.
@param(character An 8-bit value representing an ASCII character.)
@param(attributes A 32-bit value representing the colors for the background and foreground.)
}
procedure writecharex(character : char; attributes: uint32);
{
Write a single 8-bit character to the screen, followed by starting a new line, specifying custom color attributes.
@param(character An 8-bit value representing an ASCII character.)
@param(attributes A 32-bit value representing the colors for the background and foreground.)
}
procedure writecharlnex(character : char; attributes: uint32);
{
Simple console write for debugging.
@param(identifier A NULL terminated string with the name of the module printing the output.)
@param(str A NULL terminated string with the debug message.)
}
procedure Output(identifier : PChar; str : PChar);
{
Simple console writeln for debugging.
@param(identifier A NULL terminated string with the name of the module printing the output.)
@param(str A NULL terminated string with the debug message.)
}
procedure Outputln(identifier : PChar; str : PChar);
{
Write a NULL terminated string to the console.
@param(str A NULL terminated string with the debug message.)
}
procedure writestring(str: PChar);
{
Write a NULL terminated string to the console, followed by a new-line.
@param(str A NULL terminated string with the debug message.)
}
procedure writestringln(str: PChar);
{
Write a NULL terminated string to the console, with the specified attributes.
@param(str A NULL terminated string with the debug message.)
@param(attributes A 32-bit representation of the background/foreground colors.)
}
procedure writestringex(str: PChar; attributes: uint32);
{
Write a NULL terminated string + new-line to the console, with the specified attributes.
@param(str A NULL terminated string with the debug message.)
@param(attributes A 32-bit representation of the background/foreground colors.)
}
procedure writestringlnex(str: PChar; attributes: uint32);
{
Write a 32-bit value to the console.
@param(i A 32-bit value.)
}
procedure writeint(i: Integer);
{
Write a 32-bit value to the console followed by a new-line.
@param(i A 32-bit value.)
}
procedure writeintln(i: Integer);
{
Write a 32-bit value to the console, with the specified attributes.
@param(i A 32-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
}
procedure writeintex(i: Integer; attributes: uint32);
{
Write a 32-bit value + new-line to the console, with the specified attributes.
@param(i A 32-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
}
procedure writeintlnex(i: Integer; attributes: uint32);
{
Write an 8-bit Hex Pair to the console.
@param(b An 8-bit value.)
}
procedure writehexpair(b : uint8);
{
Write a 32-bit value as Hex Pairs to the console.
@param(i A 32-bit value.)
}
procedure writehex(i: DWORD);
{
Write a 32-bit value as Hex Pairs to the console, followed by a new-line.
@param(i A 32-bit value.)
}
procedure writehexln(i: DWORD);
{
Write a 32-bit value as Hex Pairs to the console, with the specified attributes.
@param(b A 32-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
}
procedure writehexex(i : DWORD; attributes: uint32);
{
Write a 32-bit value as Hex Pairs + new-line to the console, with the specified attributes.
@param(b A 32-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
}
procedure writehexlnex(i: DWORD; attributes: uint32);
{
Write an 8-bit value as binary to the console.
@param(b An 8-bit value.)
}
procedure writebin8(b : uint8);
{
Write an 8-bit value as binary to the console, followed by a new-line.
@param(b An 8-bit value.)
}
procedure writebin8ln(b : uint8);
{
Write an 8-bit value as binary to the console, with the specified attributes.
@param(b An 8-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
}
procedure writebin8ex(b : uint8; attributes: uint32);
{
Write an 8-bit value as binary + new-line to the console, with the specified attributes.
@param(b An 8-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
}
procedure writebin8lnex(b : uint8; attributes: uint32);
{
Write a 16-bit value as binary to the console.
@param(b A 16-bit value.)
}
procedure writebin16(b : uint16);
{
Write an 16-bit value as binary to the console, followed by a new-line.
@param(b A 16-bit value.)
}
procedure writebin16ln(b : uint16);
{
Write a 16-bit value as binary to the console, with the specified attributes.
@param(b A 16-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
}
procedure writebin16ex(b : uint16; attributes: uint32);
{
Write a 16-bit value as binary + new-line to the console, with the specified attributes.
@param(b A 16-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
}
procedure writebin16lnex(b : uint16; attributes: uint32);
{
Write a 32-bit value as binary to the console.
@param(b A 32-bit value.)
}
procedure writebin32(b : uint32);
{
Write an 32-bit value as binary to the console, followed by a new-line.
@param(b A 32-bit value.)
}
procedure writebin32ln(b : uint32);
{
Write a 32-bit value as binary to the console, with the specified attributes.
@param(b A 32-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
}
procedure writebin32ex(b : uint32; attributes: uint32);
{
Write a 32-bit value as binary + new-line to the console, with the specified attributes.
@param(b A 32-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
}
procedure writebin32lnex(b : uint32; attributes: uint32);
{
Move the caret back 1 position and remove the character within the cell the caret occupies.
}
procedure backspace;
{
Combine two 16-bit values representing Foreground and Background respectively, into a 32-bit value representing an attribute.
@param(Foreground A 16-bit value representing the foreground color.)
@param(Background A 16-bit value representing the background color.)
@returns(A 32-bit value representing an attribute set. (uint32) )
}
function combinecolors(Foreground, Background : uint16) : uint32;
{ Increment the cursor one cell to the right (x+1). }
procedure _increment_x();
{ Increment the cursor one cell down (y+1). }
procedure _increment_y();
{ Increment the cursor one cell to the right (x+1), wrapping to the next line and performing a Y-Axis scroll when when needed. }
procedure _safeincrement_x();
{ Increment the cursor one cell down (y+1), performing a Y-Axis roll when when needed. }
procedure _safeincrement_y();
{ Increment the cursor one cell down and reposition it at the first X Cell (y+1, x=0),performing a Y-Axis scroll when needed. }
procedure _newline();
{! Window Specific }
{
Clear a Window Canvas.
@param(WND A Window Handle.)
}
procedure clearWND(WND : uint32);
{
Clear a Window Canvas, with the specified attributes.
@param(WND A Window Handle.)
@param(Attributes A 32-bit value representing an attribute set.)
}
procedure clearWNDEx(WND : uint32; attributes : uint32);
{
Write an ASCII character to a specified Window.
@param(Character An 8-bit value representing an ASCII character.)
@param(WND A 32-bit handle to a Window.)
}
procedure writecharWND(character : char; WND : uint32);
{
Write a single 8-bit character to a Window, followed by starting a new line.
@param(character An 8-bit value representing an ASCII character.)
@param(WND A 32-bit handle to a Window.)
}
procedure writecharlnWND(character : char; WND : uint32);
{
Write a single 8-bit character to a Window, specifying custom color attributes.
@param(character An 8-bit value representing an ASCII character.)
@param(attributes A 32-bit value representing the colors for the background and foreground.)
@param(WND A 32-bit handle to a Window.)
}
procedure writecharexWND(character : char; attributes: uint32; WND : uint32);
{
Write a single 8-bit character to a Window, followed by starting a new line, specifying custom color attributes.
@param(character An 8-bit value representing an ASCII character.)
@param(attributes A 32-bit value representing the colors for the background and foreground.)
@param(WND A 32-bit handle to a Window.)
}
procedure writecharlnexWND(character : char; attributes: uint32; WND : uint32);
{
Simple console write for debugging to a Window.
@param(identifier A NULL terminated string with the name of the module printing the output.)
@param(str A NULL terminated string with the debug message.)
@param(WND A 32-bit handle to a Window.)
}
procedure OutputWND(identifier : PChar; str : PChar; WND : uint32);
{
Simple console writeln for debugging to a Window.
@param(identifier A NULL terminated string with the name of the module printing the output.)
@param(str A NULL terminated string with the debug message.)
@param(WND A 32-bit handle to a Window.)
}
procedure OutputlnWND(identifier : PChar; str : PChar; WND : uint32);
{
Write a NULL terminated string to a Window.
@param(str A NULL terminated string with the debug message.)
@param(WND A 32-bit handle to a Window.)
}
procedure writestringWND(str: PChar; WND : uint32);
{
Write a NULL terminated string to a Window, followed by a new-line.
@param(str A NULL terminated string with the debug message.)
@param(WND A 32-bit handle to a Window.)
}
procedure writestringlnWND(str: PChar; WND : uint32);
{
Write a NULL terminated string to a Window, with the specified attributes.
@param(str A NULL terminated string with the debug message.)
@param(attributes A 32-bit representation of the background/foreground colors.)
@param(WND A 32-bit handle to a Window.)
}
procedure writestringexWND(str: PChar; attributes: uint32; WND : uint32);
{
Write a NULL terminated string + new-line to a Window, with the specified attributes.
@param(str A NULL terminated string with the debug message.)
@param(attributes A 32-bit representation of the background/foreground colors.)
@param(WND A 32-bit handle to a Window.)
}
procedure writestringlnexWND(str: PChar; attributes: uint32; WND : uint32);
{
Write a 32-bit value to a Window.
@param(i A 32-bit value.)
@param(WND A 32-bit handle to a Window.)
}
procedure writeintWND(i: Integer; WND : uint32);
{
Write a 32-bit value to a Window followed by a new-line.
@param(i A 32-bit value.)
@param(WND A 32-bit handle to a Window.)
}
procedure writeintlnWND(i: Integer; WND : uint32);
{
Write a 32-bit value to a Window, with the specified attributes.
@param(i A 32-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
@param(WND A 32-bit handle to a Window.)
}
procedure writeintexWND(i: Integer; attributes: uint32; WND : uint32);
{
Write a 32-bit value + new-line to a Window, with the specified attributes.
@param(i A 32-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
@param(WND A 32-bit handle to a Window.)
}
procedure writeintlnexWND(i: Integer; attributes: uint32; WND : uint32);
{
Write an 8-bit Hex Pair to a Window.
@param(b An 8-bit value.)
@param(WND A 32-bit handle to a Window.)
}
procedure writehexpairWND(b : uint8; WND : uint32);
{
Write an 8-bit Hex Pair to a Window, with the specified attributes.
@param(b An 8-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
@param(WND A 32-bit handle to a Window.)
}
procedure writehexpairExWND(b : uint8; Attributes : uint32; WND : uint32);
{
Write a 32-bit value as Hex Pairs to a Window.
@param(i A 32-bit value.)
@param(WND A 32-bit handle to a Window.)
}
procedure writehexWND(i: DWORD; WND : uint32);
{
Write a 32-bit value as Hex Pairs to a Window, followed by a new-line.
@param(i A 32-bit value.)
@param(WND A 32-bit handle to a Window.)
}
procedure writehexlnWND(i: DWORD; WND : uint32);
{
Write a 32-bit value as Hex Pairs to a Window, with the specified attributes.
@param(b A 32-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
@param(WND A 32-bit handle to a Window.)
}
procedure writehexexWND(i : DWORD; attributes: uint32; WND : uint32);
{
Write a 32-bit value as Hex Pairs + new-line to a Window, with the specified attributes.
@param(b A 32-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
@param(WND A 32-bit handle to a Window.)
}
procedure writehexlnexWND(i: DWORD; attributes: uint32; WND : uint32);
{
Write an 8-bit value as binary to a Window.
@param(b An 8-bit value.)
@param(WND A 32-bit handle to a Window.)
}
procedure writebin8WND(b : uint8; WND : uint32);
{
Write an 8-bit value as binary to a Window, followed by a new-line.
@param(b An 8-bit value.)
@param(WND A 32-bit handle to a Window.)
}
procedure writebin8lnWND(b : uint8; WND : uint32);
{
Write an 8-bit value as binary to a Window, with the specified attributes.
@param(b An 8-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
@param(WND A 32-bit handle to a Window.)
}
procedure writebin8exWND(b : uint8; attributes: uint32; WND : uint32);
{
Write an 8-bit value as binary + new-line to a Window, with the specified attributes.
@param(b An 8-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
@param(WND A 32-bit handle to a Window.)
}
procedure writebin8lnexWND(b : uint8; attributes: uint32; WND : uint32);
{
Write a 16-bit value as binary to a Window.
@param(b A 16-bit value.)
@param(WND A 32-bit handle to a Window.)
}
procedure writebin16WND(b : uint16; WND : uint32);
{
Write an 16-bit value as binary to a Window, followed by a new-line.
@param(b A 16-bit value.)
@param(WND A 32-bit handle to a Window.)
}
procedure writebin16lnWND(b : uint16; WND : uint32);
{
Write a 16-bit value as binary to a Window, with the specified attributes.
@param(b A 16-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
@param(WND A 32-bit handle to a Window.)
}
procedure writebin16exWND(b : uint16; attributes: uint32; WND : uint32);
{
Write a 16-bit value as binary + new-line to a Window, with the specified attributes.
@param(b A 16-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
@param(WND A 32-bit handle to a Window.)
}
procedure writebin16lnexWND(b : uint16; attributes: uint32; WND : uint32);
{
Write a 32-bit value as binary to a Window.
@param(b A 32-bit value.)
@param(WND A 32-bit handle to a Window.)
}
procedure writebin32WND(b : uint32; WND : uint32);
{
Write an 32-bit value as binary to a Window, followed by a new-line.
@param(b A 32-bit value.)
@param(WND A 32-bit handle to a Window.)
}
procedure writebin32lnWND(b : uint32; WND : uint32);
{
Write a 32-bit value as binary to a Window, with the specified attributes.
@param(b A 32-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
@param(WND A 32-bit handle to a Window.)
}
procedure writebin32exWND(b : uint32; attributes: uint32; WND : uint32);
{
Write a 32-bit value as binary + new-line to a Window, with the specified attributes.
@param(b A 32-bit value.)
@param(attributes A 32-bit representation of the background/foreground colors.)
@param(WND A 32-bit handle to a Window.)
}
procedure writebin32lnexWND(b : uint32; attributes: uint32; WND : uint32);
{
Move a caret belonging to a Window back 1 position and remove the character within the cell the caret occupies.
@param(WND A 32-bit handle to a Window.)
}
procedure backspaceWND(WND : uint32);
{
Set the caret belonging to a Window to a specified position.
@param(X The new Horizontal position.)
@param(Y The new Vertical postion.)
@param(WND A 32-bit handle to a Window.)
}
procedure setCursorPosWND(x : uint32; y : uint32; WND : HWND);
{
Increment the cursor within a Window one cell to the right (x+1).
@param(WND A 32-bit handle to a Window.)
}
procedure _increment_x_WND(WND : uint32);
{
Increment the cursor within a Window one cell down (y+1).
@param(WND A 32-bit handle to a Window.)
}
procedure _increment_y_WND(WND : uint32);
{
Increment the cursor one cell down (y+1), performing a Y-Axis roll when when needed.
@param(WND A 32-bit handle to a Window.)
}
procedure _safeincrement_y_WND(WND : uint32);
{
Increment the cursor within a Window one cell to the right (x+1), wrapping to the next line and performing a Y-Axis scroll when when needed.
@param(WND A 32-bit handle to a Window.)
}
procedure _safeincrement_x_WND(WND : uint32);
{
Increment the cursor within a Window one cell down and reposition it at the first X Cell (y+1, x=0),performing a Y-Axis scroll when needed.
@param(WND A 32-bit handle to a Window.)
}
procedure _newlineWND(WND : uint32);
{! Drawing }
{
Draw an ASCII char to raw screen space conforming to cell constraints.
@param(C An 8-bit ASCII Character.)
@param(X An 8-bit Horizontal Cell position.)
@param(Y An 8-bit Vertical Cell Position.)
@param(fgcolor The 16-bit color of the Character.)
@param(bgcolor The 16-bit background color of the cell.)
}
procedure outputChar(c : char; x : uint8; y : uint8; fgcolor : uint16; bgcolor : uint16);
{
Draw an ASCII char to raw screen space.
@param(C An 8-bit ASCII Character.)
@param(X A 32-bit Horizontal Screen position.)
@param(Y A 32-bit Vertical Screen Position.)
@param(fgcolor The 16-bit color of the Character.)
@param(bgcolor The 16-bit background color of the cell.)
}
procedure outputCharToScreenSpace(c : char; x : uint32; y : uint32; fgcolor : uint16);
{
Draw an ASCII char without a background to raw screen space conforming to cell constraints.
@param(C An 8-bit ASCII Character.)
@param(X An 8-bit Horizontal Cell position.)
@param(Y An 8-bit Vertical Cell Position.)
@param(fgcolor The 16-bit color of the Character.)
}
procedure outputCharTransparent(c : char; x : uint8; y : uint8; fgcolor : uint16);
{
Get 16-bits of pixel information from the screen position(x,y).
@param(X A 32-bit Horizontal Screen position.)
@param(Y A 32-bit Vertical Screen Position.)
@returns(16-bits of Pixel Information)
}
function getPixel(x : uint32; y : uint32) : uint16;
{
Draw 16-bits of pixel information at the screen position(x,y).
@param(X A 32-bit Horizontal Screen position.)
@param(Y A 32-bit Vertical Screen Position.)
@param(color 16-bits of Pixel Information)
}
procedure drawPixel(x : uint32; y : uint32; color : uint16);
{
Get 32-bits of pixel information from the screen position(x,y).
@param(X A 32-bit Horizontal Screen position.)
@param(Y A 32-bit Vertical Screen Position.)
@returns(32-bits of Pixel Information)
}
function getPixel32(x : uint32; y : uint32) : uint32;
{
Draw 32-bits of pixel information at the screen position(x,y).
@param(X A 32-bit Horizontal Screen position.)
@param(Y A 32-bit Vertical Screen Position.)
@param(color 32-bits of Pixel Information)
}
procedure drawPixel32(x : uint32; y : uint32; pixel : uint32);
{
Get 64-bits of pixel information from the screen position(x,y).
@param(X A 32-bit Horizontal Screen position.)
@param(Y A 32-bit Vertical Screen Position.)
@returns(64-bits of Pixel Information)
}
function getPixel64(x : uint32; y : uint32) : uint64;
{
Draw 64-bits of pixel information at the screen position(x,y).
@param(X A 32-bit Horizontal Screen position.)
@param(Y A 32-bit Vertical Screen Position.)
@param(color 64-bits of Pixel Information)
}
procedure drawPixel64(x : uint32; y : uint32; pixel : uint64);
{! Windows Methods }
{
Set the position of the mouse cursor relative to screen space.
@param(X A 32-bit Horizontal Screen Position.)
@param(Y A 32-bit Vertical Screen Position.)
}
procedure setMousePosition(x : uint32; y : uint32);
{
Redraw all of the Window adhearing to Z-Order.
}
procedure redrawWindows;
{
Toggle the visibility of a Window.
@param(WND A 32-bit handle to a Window.)
}
procedure toggleWNDVisible(WND : uint32);
{
Change a Windows visibility.
@param(WND A 32-bit handle to a Window.)
@param(Visible @true or @false.)
}
procedure setWNDVisible(WND : uint32; visible : boolean);
{
Close all open Windows and release handles.
}
procedure closeAllWindows;
{
Spawn a new Window at cell(x,y) with specified Width, Height and Title.
@param(X 32-bit Horizontal Cell for the top-left corner of the Window.)
@param(Y 32-bit Vertical Cell for the top-left corner of the Window.)
@param(Width 32-bit Width of the Window in Cells.)
@param(Height 32-bit Height of the Window in Cells.)
@param(Title NULL Terminated String used as the Title for the Window.)
@returns(A 32-bit Handle for the new Window.)
}
function newWindow(x : uint32; y : uint32; Width : uint32; Height : uint32; Title : PChar) : HWND;
{
Register an Event Handler to a Window
@param(WND Handle for the Window the event should be registered against.)
@param(Event Type of event to register.)
@param(Handler Procedure to be called upon the event firing.)
@returns(@true for success @false for failure.)
}
function registerEventHandler(WND : HWND; Event : TEventType; Handler : void) : boolean;
{
Forcefully close all Windows
}
procedure forceQuitAll;
{
Close a Window specified by its Handle
@param(WND The handle to the target Window.)
}
procedure closeWindow(WND : HWND);
{
Enable or disable the drawing of the borders surrounding a Window.
@param(WND A 32-bit Handle to the target Window.)
@param(Enabled @true for borders to be shown, @false for borders to be hidden.)
}
procedure bordersEnabled(WND : HWND; enabled : boolean);
{
Set a specified Window as a Shell Window (Window cannot be moved or closed).
@param(WND 32-bit Handle for the target Window.)
@param(b @true to set Target as a Shell Window, @false to set Target as a normal Window.)
}
procedure SetShellWindow(WND : HWND; b : boolean);
{
Get the title of a specified Window.
@param(WND 32-bit Handle for the target Window.)
@returns(NULL Terminated PChar.)
}
function getWindowName(WND : HWND) : pchar;
{
Enable or disable the mouse.
@param(b @true for mouse enabled, @false for mouse disabled.)
}
procedure mouseEnabled(b : boolean);
{
Callback for a MouseDown event.
}
procedure _MouseDown();
{
Callback for a MouseUp event.
}
procedure _MouseUp();
{
Callback for a MouseClick event.
@param(Left @true for a Left-Click, @false for a Right-Click.)
}
procedure _MouseClick(left : boolean);
{
Set the attributes used for drawing the border around Windows.
@param(Colors A 32-bit value representing the attributes (background/foreground).)
}
procedure setWindowColors(colors : uint32);
{
Get a Pointer to the attribute used for Window Borders.
@returns(A 32-bit pointer to the Borders Attribute.)
}
function getWindowColorPtr : puint32;
function getMaxCellW : uint32;
function getMaxCellH : uint32;
function getConsoleProperties : PConsoleProperties;
const
MAX_WINDOWS = 255; //< Maximum number of Windows open.
DefaultWND = 0; //< The Window assigned for output when no Window is specified. (Default).
implementation
uses
lmemorymanager, strings, keyboard, serial, terminal;
type
{ Unrasterized representation of a character. }
TCharacter = bitpacked record
Character : Char; //< ASCII Character
attributes : uint32; //< 32-bit Representation of Background/Foreground Colors.
visible : boolean; //< Character is visible when rasterized. @true or @false.
end;
{ Pointer to an Unrasterized Character. }
PCharacter = ^TCharacter;
{ Unrasterized screen matrix. }
TVideoMemory = Array[0..1999] of TCharacter;
{ Pointer to the Unrasterized screen matrix. }
PVideoMemory = ^TVideoMemory;
{ Font Mask }
TMask = Array[0..63] of Array[0..159] of uint32;
{ 2D Unrasterized Matrix }
T2DVideoMemory = Array[0..63] of Array[0..159] of TCharacter;
{ Pointer to 2D Unrasterized Matrix }
P2DVideoMemory = ^T2DVideoMemory;
TMouseCoord = record
X : sint32;
Y : sint32;
end;
TCoord = record
X : Byte;
Y : Byte;
end;
TDrawHook = procedure();
TMouseClickHook = procedure(x : uint32; y : uint32; left : boolean);
TMouseMoveHook = procedure(x : uint32; y : uint32);
TMouseDownHook = procedure(x : uint32; y : uint32);
TMouseUpHook = procedure(x : uint32; y : uint32);
TKeyPressedHook = procedure(info : TKeyInfo);
TCloseHook = procedure();
TMinimizeHook = procedure();
TFocusHook = procedure();
TLoseFocusHook = procedure();
THooks = record
OnDraw : TDrawHook; //Implemented
OnMouseClick : TMouseClickHook; //Implemented
OnMouseMove : TMouseMoveHook;
OnMouseDown : TMouseDownHook;
OnMouseUp : TMouseUpHook;
OnKeyPressed : TKeyPressedHook; //Implemented
OnClose : TCloseHook; //Implemented
OnMinimize : TMinimizeHook;
OnFocus : TFocusHook; //Implemented
OnLoseFocus : TLoseFocusHook; //Implemented
end;
TWindow = record
visible : boolean;
buffer : T2DVideoMemory;
row_dirty : Array[0..63] of Boolean;
WND_X : uint32;
WND_Y : uint32;
WND_W : uint32;
WND_H : uint32;
Cursor : TCoord;
WND_NAME : PChar;
Hooks : THooks;
Closed : boolean;
Border : boolean;
ShellWND : boolean;
end;
PWindow = ^TWindow;
TWindows = Array[0..MAX_WINDOWS-1] of PWindow;
TZOrder = Array[0..MAX_WINDOWS-1] of uint32;
TBackOrder = Array[0..MAX_WINDOWS-1] of uint32;
TFrontOrder = Array[0..MAX_WINDOWS-1] of uint32;
TWindowManager = record
Windows : TWindows;
Z_Order : TZOrder;
Back_Order : TBackOrder;
Front_Order : TFrontOrder;
MousePos : TMouseCoord;
MousePrev : TMouseCoord;
end;
TMouseDirt = record
TopLeft : TMouseCoord;
BottomRight : TMouseCoord;
end;
var
Console_Properties : TConsoleProperties; //Generic Properties
Console_Real : T2DVideoMemory; //The real state of the Console/TUI
Console_Matrix : T2DVideoMemory; //The next buffer to be written
Console_Cursor : TCoord; //The text cursor position
WindowManager : TWindowManager; //Window Manager
Ready : Boolean = false; //Is the unit ready for use?
MouseDrawActive : Boolean = false; //Is the Mouse currently being updated?
mouse_dirt : TMouseDirt; //Character Cell(s) the mouse occupies, these need to be rewritten on mouse move.
Window_Border : TCharacter;
Default_Char : TCharacter;
WindowTitleMask : TMask;
WindowMask : TMask;
ExitMask : TMask;
MouseDown : Boolean;
WindowMovePos : TMouseCoord;
MovingWindow : uint32;
UnhandledClick : Boolean = false;
UnhandledClickLeft : Boolean = false;
MouseCursorEnabled : Boolean = true;
OpenTerminal : Boolean = false;
function getMaxCellW : uint32;
begin
getMaxCellW:= Console_Properties.MAX_CELL_X;
end;
function getMaxCellH : uint32;
begin
getMaxCellH:= Console_Properties.MAX_CELL_Y;
end;
function getConsoleProperties : PConsoleProperties;
begin
getConsoleProperties:= PConsoleProperties(@Console_Properties);
end;
function getWindowColorPtr : puint32;
begin
getWindowColorPtr:= @Window_Border.Attributes;
end;
procedure setWindowColors(colors : uint32);
begin
Window_Border.Attributes:= colors;
end;
procedure mouseEnabled(b : boolean);
begin
MouseCursorEnabled:= b;
end;
procedure _MouseDown();
begin
MouseDown:= true;
end;
procedure _MouseUp();
begin
MouseDown:= false;
end;
procedure _MouseClick(left : boolean);
begin
if not UnhandledClick then begin
UnhandledClick:= true;
UnhandledClickLeft:= left;
end;
end;
procedure AddToZOrder(WND : HWND);
var
idx : uint32;
i : uint32;
Window : PWindow;
begin
idx:= MAX_WINDOWS;
for i:=0 to MAX_WINDOWS-1 do begin
if WindowManager.Z_Order[i] = WND then begin
break;
end;
if WindowManager.Z_Order[i] = MAX_WINDOWS then begin
idx:= i;
break;
end;
end;
if idx <> MAX_WINDOWS then begin
WindowManager.Z_Order[idx]:= WND;
end;
end;
procedure RemoveFromZOrder(WND : HWND);
var
i : uint32;
idx : uint32;
begin
idx:= MAX_WINDOWS;
for i:=0 to MAX_WINDOWS-1 do begin
if WindowManager.Z_Order[i] = WND then begin
WindowManager.Z_Order[i]:= MAX_WINDOWS;
idx:= i;
break;
end;
end;
if idx <> MAX_WINDOWS then begin
for i:=idx to MAX_WINDOWS-2 do begin
WindowManager.Z_Order[i]:= WindowManager.Z_Order[i+1];
end;
WindowManager.Z_Order[MAX_WINDOWS-1]:= MAX_WINDOWS;
end;
end;
procedure FocusZOrder(WND : HWND);
var
i : uint32;
idx : uint32;
old, new : HWND;
wold, wnew : PWindow;
begin
idx:= MAX_WINDOWS;
for i:=0 to MAX_WINDOWS-1 do begin
if WindowManager.Z_Order[i] = WND then begin
idx:= i;
break;
end;
end;
if idx <> MAX_WINDOWS then begin
old:= WindowManager.Z_Order[0];
new:= WND;
for i:=idx downto 1 do begin
WindowManager.Z_Order[i]:= WindowManager.Z_Order[i-1];
end;
WindowManager.Z_Order[0]:= WND;
if old <> new then begin
wold:= WindowManager.Windows[old];
wnew:= WindowManager.Windows[new];
if wold <> nil then begin
if wold^.Hooks.OnLoseFocus <> nil then wold^.Hooks.OnLoseFocus();
end;
if wnew <> nil then begin
if wnew^.Hooks.OnFocus <> nil then wnew^.Hooks.OnFocus();
end;
end;
end;
end;
function getWindowName(WND : HWND) : pchar;
var
Window : PWindow;
begin
getWindowName:= nil;
Window:= WindowManager.Windows[WND];
if Window <> nil then begin
if Window^.ShellWND then begin
getWindowName:= Window^.WND_NAME;
end;
end;
end;
procedure SetShellWindow(WND : HWND; b : boolean);
var
Window : PWindow;
begin
Window:= WindowManager.Windows[WND];
if Window <> nil then begin
Window^.ShellWND:= b;
end;
end;
procedure bordersEnabled(WND : HWND; enabled : boolean);
var
Window : PWindow;
begin
Window:= WindowManager.Windows[WND];
if Window <> nil then begin
Window^.Border:= enabled;
end;
end;
procedure setCursorPosWND(x : uint32; y : uint32; WND : HWND);
var
Window : PWindow;
begin
Window:= WindowManager.Windows[WND];
if Window <> nil then begin
while x > Console_Properties.MAX_CELL_X-1 do dec(x);
while y > Console_Properties.MAX_CELL_Y-1 do dec(y);
Window^.Cursor.x:= x;
Window^.Cursor.y:= y;
end;
end;
procedure setWindowPosition(WND : HWND; x, y : sint32);
var
Window : PWindow;
nx, ny : sint32;
begin
Window:= WindowManager.Windows[WND];
If Window <> nil then begin
nx:= x;
ny:= y;
if Window^.Border then begin
if nx < 2 then nx:= 2;
if ny < 1 then ny:= 1;
while (nx + Window^.WND_W + 2) > Console_Properties.MAX_CELL_X do begin
dec(nx);
end;
while (ny + Window^.WND_H + 1) > Console_Properties.MAX_CELL_Y do begin
dec(ny);
end;
end else begin
if nx < 0 then nx:= 0;
if ny < 0 then ny:= 0;
while (nx + Window^.WND_W) > Console_Properties.MAX_CELL_X do begin
dec(nx);
end;
while (ny + Window^.WND_H) > Console_Properties.MAX_CELL_Y do begin
dec(ny);
end;
end;
Window^.WND_X:= nx;
Window^.WND_Y:= ny;
end;
end;
function registerEventHandler(WND : HWND; Event : TEventType; Handler : void) : boolean;
begin
registerEventHandler:= true;
if WindowManager.Windows[WND] <> nil then begin
case Event of
EVENT_DRAW : WindowManager.Windows[WND]^.Hooks.OnDraw:= TDrawHook(Handler);
EVENT_MOUSE_CLICK : WindowManager.Windows[WND]^.Hooks.OnMouseClick:= TMouseClickHook(Handler);
EVENT_MOUSE_MOVE : WindowManager.Windows[WND]^.Hooks.OnMouseMove:= TMouseMoveHook(Handler);
EVENT_MOUSE_DOWN : WindowManager.Windows[WND]^.Hooks.OnMouseDown:= TMouseDownHook(Handler);
EVENT_MOUSE_UP : WindowManager.Windows[WND]^.Hooks.OnMouseUp:= TMouseUpHook(Handler);
EVENT_KEY_PRESSED : WindowManager.Windows[WND]^.Hooks.OnKeyPressed:= TKeyPressedHook(Handler);
EVENT_CLOSE : WindowManager.Windows[WND]^.Hooks.OnClose:= TCloseHook(Handler);
EVENT_MINIMIZE : WindowManager.Windows[WND]^.Hooks.OnMinimize:= TMinimizeHook(Handler);
EVENT_FOCUS : WindowManager.Windows[WND]^.Hooks.OnFocus:= TFocusHook(Handler);
EVENT_LOSE_FOCUS : WindowManager.Windows[WND]^.Hooks.OnLoseFocus:= TLoseFocusHook(Handler);
else registerEventHandler:= false;
end;
end else begin
registerEventHandler:= false;
end;
end;
function newWindow(x : uint32; y : uint32; Width : uint32; Height : uint32; Title : PChar) : HWND;
var
idx : uint32;
WND : PWindow;
begin
tracer.push_trace('console.newWindow');
newWindow:= 0;
for idx:=1 to MAX_WINDOWS-1 do begin
if WindowManager.Windows[idx] = nil then begin
newWindow:= idx;
break;
end;
end;
if newWindow <> 0 then begin
WND:= PWindow(kalloc(sizeof(TWindow)));
WND^.WND_NAME:= StringCopy(Title);
WND^.WND_X:= x;
WND^.WND_Y:= y;
WND^.WND_W:= Width;
WND^.WND_H:= Height;
WND^.Cursor.x:= 0;
WND^.Cursor.y:= 0;
WND^.visible:= true;
WND^.Closed:= false;
WND^.Border:= true;
WND^.ShellWND:= true;
WND^.Hooks.OnDraw := nil;
WND^.Hooks.OnMouseClick := nil;
WND^.Hooks.OnMouseMove := nil;
WND^.Hooks.OnMouseDown := nil;
WND^.Hooks.OnMouseUp := nil;
WND^.Hooks.OnKeyPressed := nil;
WND^.Hooks.OnClose := nil;
WND^.Hooks.OnMinimize := nil;
WND^.Hooks.OnFocus := nil;
WND^.Hooks.OnLoseFocus := nil;
WindowManager.Windows[newWindow]:= WND;
AddToZOrder(newWindow);
FocusZOrder(newWindow);
end;
end;
//If Packet.x_sign then Packet.x_movement:= sint16(Packet.x_movement OR $FF00);
//If Packet.y_sign then Packet.y_movement:= sint16(Packet.y_movement OR $FF00);
procedure forceQuitAll;
var
i : uint32;
WND : PWindow;
begin
for i:=1 to MAX_WINDOWS-1 do begin
if WindowManager.Windows[i] <> nil then begin
WND:= WindowManager.Windows[i];
WindowManager.Windows[i]:= nil;
kfree(void(WND^.WND_NAME));
kfree(void(WND));
end;
end;
end;
procedure _closeWindow(WND : HWND);
var
WNDCopy : PWindow;
begin
if WindowManager.Windows[WND] <> nil then begin
RemoveFromZOrder(WND);
WNDCopy:= WindowManager.Windows[WND];
WindowManager.Windows[WND]:= nil;
if WNDCopy^.Hooks.OnClose <> nil then WNDCopy^.Hooks.OnClose();
kfree(void(WNDCopy^.WND_NAME));
kfree(void(WNDCopy));
end;
end;
procedure closeWindow(WND : HWND);
begin
if WindowManager.Windows[WND] <> nil then begin
WindowManager.Windows[WND]^.Closed:= True;
end;
end;
procedure closeAllWindows;
var
i : uint32;
begin
for i:=1 to MAX_WINDOWS-1 do begin
setWNDVisible(i, false);
end;
end;
procedure setWNDVisible(WND : uint32; visible : boolean);
begin
if WindowManager.Windows[WND] <> nil then begin
WindowManager.Windows[WND]^.visible:= visible;
end;
end;
procedure toggleWNDVisible(WND : uint32);
begin
if WindowManager.Windows[DefaultWND] <> nil then begin
WindowManager.Windows[WND]^.visible:= not WindowManager.Windows[WND]^.visible;
end;
end;
function MouseYToTile(Y : uint32) : uint32;
begin
MouseYToTile:= Y div 16;
end;
function MouseXToTile(X : uint32) : uint32;
begin
MouseXToTile:= X div 8;
end;
procedure drawMouse;
var
x, y : uint32;
MX, MY : uint32;
begin
MouseDrawActive:= true;
MX:= WindowManager.MousePos.X;
MY:= WindowManager.MousePos.Y;
WindowManager.MousePrev.x:= MX;
WindowManager.MousePrev.y:= MY;
mouse_dirt.TopLeft.x:= (MX div 8) - 2;
mouse_dirt.TopLeft.y:= (MY div 16) - 2;
mouse_dirt.BottomRight.x:= (MX div 8) + 2;
mouse_dirt.BottomRight.y:= (MY div 16) + 2;
if mouse_dirt.TopLeft.x < 0 then mouse_dirt.TopLeft.x:= 0;
if mouse_dirt.TopLeft.y < 0 then mouse_dirt.TopLeft.y:= 0;
if mouse_dirt.BottomRight.x > Console_Properties.MAX_CELL_X then mouse_dirt.BottomRight.x:= Console_Properties.MAX_CELL_X;
if mouse_dirt.BottomRight.y > Console_Properties.MAX_CELL_Y then mouse_dirt.BottomRight.y:= Console_Properties.MAX_CELL_Y;
MouseDrawActive:= false;
end;
procedure redrawMatrix;
var
x, y, w: uint32;
begin
if (WindowManager.MousePos.x <> WindowManager.MousePrev.x) OR (WindowManager.MousePos.y <> WindowManager.MousePrev.y) then begin
for y:=mouse_dirt.TopLeft.y to mouse_dirt.BottomRight.y do begin
for x:=mouse_dirt.TopLeft.x to mouse_dirt.BottomRight.x do begin
Console_Real[y][x].character:= char(1);
end;
end;
drawMouse;
end;
for y:=0 to Console_Properties.MAX_CELL_Y do begin
for x:=0 to Console_Properties.MAX_CELL_X do begin
if (Console_Matrix[y][x].character <> Console_Real[y][x].character) or (Console_Matrix[y][x].attributes <> Console_Real[y][x].attributes) then begin
OutputChar(Console_Matrix[y][x].Character, x, y, Console_Matrix[y][x].Attributes SHR 16, Console_Matrix[y][x].Attributes AND $FFFF);
Console_Real[y][x]:= Console_Matrix[y][x];
end;
end;
end;
if MouseCursorEnabled then outputCharToScreenSpace(char(0), WindowManager.MousePrev.x, WindowManager.MousePrev.y, $FFFF);
end;
procedure setMousePosition(x : uint32; y : uint32);
begin
if MouseDrawActive then exit;
WindowManager.MousePos.X:= x;
WindowManager.MousePos.Y:= y;
end;
procedure redrawWindows;
var
x, y, w : uint32;
WXL, WYL : sint32;
WXR, WYR : sint32;
STRC : uint32;
MIDP, STARTP : uint32;
deltax, deltay : sint32;
SelectedWindow : uint32;
begin
if OpenTerminal then begin
terminal.run;
OpenTerminal:= false;
end;
{ Clear the Console_Matrix }
for y:=0 to Console_Properties.MAX_CELL_Y do begin
for x:=0 to Console_Properties.MAX_CELL_X do begin
Console_Matrix[y][x]:= Default_Char;
end;
end;
{ Redraw all of the Windows to the Matrix taking into account Z_Order and borders }
for w:=MAX_WINDOWS-1 downto 0 do begin
if WindowManager.Z_Order[w] = MAX_WINDOWS then continue;
if WindowManager.Windows[WindowManager.Z_Order[w]] <> nil then begin
if WindowManager.Windows[WindowManager.Z_Order[w]]^.Hooks.OnDraw <> nil then WindowManager.Windows[WindowManager.Z_Order[w]]^.Hooks.OnDraw();
If WindowManager.Windows[WindowManager.Z_Order[w]]^.visible then begin
if WindowManager.Windows[WindowManager.Z_Order[w]]^.Border then begin
WXL:= WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_X - 1;
WYL:= WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_Y - 1;
WXR:= WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_X + WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_W + 1;
WYR:= WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_Y + WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_H + 1;
for y:=WYL to WYR do begin
Console_Matrix[y][WXL]:= Window_Border;
Console_Matrix[y][WXL-1]:= Window_Border;
Console_Matrix[y][WXR]:= Window_Border;
Console_Matrix[y][WXR+1]:= Window_Border;
Console_Real[y][WXL].Character:= char(3);
Console_Real[y][WXL-1].Character:= char(3);
Console_Real[y][WXR].Character:= char(3);
Console_Real[y][WXR+1].Character:= char(3);
end;
STRC:= 0;
MIDP:= (WXR + WXL) div 2;
STARTP:= MIDP - (StringSize(WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_NAME) div 2) - 1;
for x:=WXL to WXR do begin
Console_Matrix[WYL][x]:= Window_Border;
WindowTitleMask[WYL][x]:= WindowManager.Z_Order[w];
if (STRC = StringSize(WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_NAME)) and (w = 0) then begin
console_Matrix[WYL][x].character:= '*';
inc(STRC);
end;
if (x >= STARTP) and (STRC < StringSize(WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_NAME)) then begin
Console_Matrix[WYL][x].character:= WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_NAME[STRC];
inc(STRC);
end;
if x = WXR then begin
Console_Matrix[WYL][x].character:= 'x';
ExitMask[WYL][x]:= WindowManager.Z_Order[w];
end;
Console_Matrix[WYR][x]:= Window_Border;
Console_Real[WYL][x].Character:= char(3);
Console_Real[WYR][x].Character:= char(3);
end;
end;
for y:=WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_Y to WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_Y + WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_H do begin
if y > Console_Properties.MAX_CELL_Y then break;
for x:=WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_X to WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_X + WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_W do begin
if x > Console_Properties.MAX_CELL_X then break;
Console_Matrix[y][x]:= WindowManager.Windows[WindowManager.Z_Order[w]]^.buffer[y - WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_Y][x - WindowManager.Windows[WindowManager.Z_Order[w]]^.WND_X];
WindowTitleMask[y][x]:= 0;
WindowMask[y][x]:= WindowManager.Z_Order[w];
ExitMask[y][x]:= 0;
end;
end;
end;
end;
end;
{ Handle any Clicks that have happened since last redraw }
if UnhandledClick then begin
if UnhandledClickLeft then begin
SelectedWindow:= ExitMask[MouseYToTile(WindowManager.MousePrev.Y)][MouseXToTile(WindowManager.MousePrev.X)];
if SelectedWindow <> 0 then begin
closeWindow(SelectedWindow);
end else begin
SelectedWindow:= WindowTitleMask[MouseYToTile(WindowManager.MousePrev.Y)][MouseXToTile(WindowManager.MousePrev.X)];
if SelectedWindow <> 0 then begin
if WindowManager.Windows[SelectedWindow] <> nil then begin
if WindowManager.Windows[SelectedWindow]^.ShellWND then FocusZOrder(SelectedWindow);
end;
end else begin
SelectedWindow:= WindowMask[MouseYToTile(WindowManager.MousePrev.Y)][MouseXToTile(WindowManager.MousePrev.X)];
if (SelectedWindow <> 0) and (WindowManager.Windows[SelectedWindow] <> nil) then begin
if (WindowManager.Z_Order[0] = SelectedWindow) or (WindowManager.Windows[SelectedWindow]^.ShellWND = false) then begin
if WindowManager.Windows[SelectedWindow]^.Hooks.OnMouseClick <> nil then begin
deltax:= MouseXToTile(WindowManager.MousePrev.X) - WindowManager.Windows[SelectedWindow]^.WND_X;
deltay:= MouseYToTile(WindowManager.MousePrev.Y) - WindowManager.Windows[SelectedWindow]^.WND_Y;
WindowManager.Windows[SelectedWindow]^.Hooks.OnMouseClick(deltax, deltay, true);
end;
end;
if (WindowManager.Z_Order[0] <> SelectedWindow) and (WindowManager.Windows[SelectedWindow]^.ShellWND) then begin
FocusZOrder(SelectedWindow);
end;
end;
end;
end;
{SelectedWindow:= WindowMask[MouseYToTile(WindowManager.MousePrev.Y)][MouseXToTile(WindowManager.MousePrev.X)];
if (SelectedWindow <> 0) and (WindowManager.Windows[SelectedWindow] <> nil) then begin
//OnClickHandler(Left)
if (WindowManager.Z_Order[0] = SelectedWindow) or (WindowManager.Windows[SelectedWindow]^.ShellWND = false) then begin
if WindowManager.Windows[SelectedWindow]^.Hooks.OnMouseClick <> nil then begin
deltax:= MouseXToTile(WindowManager.MousePrev.X) - WindowManager.Windows[SelectedWindow]^.WND_X;
deltay:= MouseYToTile(WindowManager.MousePrev.Y) - WindowManager.Windows[SelectedWindow]^.WND_Y;
WindowManager.Windows[SelectedWindow]^.Hooks.OnMouseClick(deltax, deltay, true);
end;
end;
if (WindowManager.Z_Order[0] <> SelectedWindow) and (WindowManager.Windows[SelectedWindow]^.ShellWND) then begin
FocusZOrder(SelectedWindow);
end;
end else begin
SelectedWindow:= WindowTitleMask[MouseYToTile(WindowManager.MousePrev.Y)][MouseXToTile(WindowManager.MousePrev.X)];
if SelectedWindow <> 0 then begin
if WindowManager.Windows[SelectedWindow] <> nil then begin
if WindowManager.Windows[SelectedWindow]^.ShellWND then FocusZOrder(SelectedWindow);
end;
end;
SelectedWindow:= ExitMask[MouseYToTile(WindowManager.MousePrev.Y)][MouseXToTile(WindowManager.MousePrev.X)];
if SelectedWindow <> 0 then begin
closeWindow(SelectedWindow);
end;
end;}
end;
if not UnhandledClickLeft then begin
SelectedWindow:= WindowMask[MouseYToTile(WindowManager.MousePrev.Y)][MouseXToTile(WindowManager.MousePrev.X)];
if (SelectedWindow <> 0) and (WindowManager.Windows[SelectedWindow] <> nil) then begin
if (WindowManager.Z_Order[0] = SelectedWindow) or (WindowManager.Windows[SelectedWindow]^.ShellWND = false) then begin
if WindowManager.Windows[SelectedWindow]^.Hooks.OnMouseClick <> nil then begin
deltax:= MouseXToTile(WindowManager.MousePrev.X) - WindowManager.Windows[SelectedWindow]^.WND_X;
deltay:= MouseYToTile(WindowManager.MousePrev.Y) - WindowManager.Windows[SelectedWindow]^.WND_Y;
WindowManager.Windows[SelectedWindow]^.Hooks.OnMouseClick(deltax, deltay, false);
end;
end;
end;
end;
UnhandledClick:= false;
end;
{ Handle Moving Windows using MouseDown and Delta positions }
if MouseDown then begin
if MovingWindow = 0 then begin
MovingWindow:= WindowTitleMask[MouseYToTile(WindowManager.MousePrev.Y)][MouseXToTile(WindowManager.MousePrev.X)];
if MovingWindow <> 0 then begin
WindowMovePos.x:= MouseXToTile(WindowManager.MousePrev.X);
WindowMovePos.y:= MouseYToTile(WindowManager.MousePrev.Y);
end else begin
MovingWindow:= MAX_WINDOWS;
end;
end;
if MovingWindow <> MAX_WINDOWS then begin
if WindowManager.Windows[MovingWindow] <> nil then begin
deltax:= WindowMovePos.x - MouseXToTile(WindowManager.MousePrev.X);
deltay:= WindowMovePos.y - MouseYToTile(WindowManager.MousePrev.Y);
WindowMovePos.x:= MouseXToTile(WindowManager.MousePrev.X);
WindowMovePos.y:= MouseYToTile(WindowManager.MousePrev.Y);
setWindowPosition(MovingWindow, WindowManager.Windows[MovingWindow]^.WND_X - deltax, WindowManager.Windows[MovingWindow]^.WND_Y - deltay);
FocusZOrder(MovingWindow);
end;
end;
end else begin
MovingWindow:= 0;
end;
{ Console_Matrix -> Actual Screen Buffer }
redrawMatrix;
{ Handle any closed Windows ready for next redraw }
for w:=0 to MAX_WINDOWS-1 do begin
if WindowManager.Windows[w] <> nil then begin
if WindowManager.Windows[w]^.Closed then _closeWindow(w);
end;
end;
end;
procedure initWindows;
var
x, y, w : uint32;
WND : PWindow;
begin
Default_Char.Character:= ' ';
Default_Char.attributes:= Console_Properties.Default_Attribute;
Default_Char.visible:= true;
Window_Border.Character:= ' ';
Window_Border.Attributes:= console.combinecolors($01C3, $07EE);
Window_Border.visible:= true;
For w:=0 to MAX_WINDOWS-1 do begin
WindowManager.Windows[w]:= nil;
WindowManager.Z_Order[w]:= MAX_WINDOWS;
end;
WND:= PWindow(kalloc(sizeof(TWindow)));
WND^.WND_NAME:= 'Asuro';
WND^.WND_X:= 0;
WND^.WND_Y:= 0;
WND^.WND_W:= Console_Properties.MAX_CELL_X;
WND^.WND_H:= Console_Properties.MAX_CELL_Y;
WND^.Cursor.x:= 0;
WND^.Cursor.y:= 0;
WND^.visible:= true;
WND^.Closed:= false;
WND^.Border:= false;
WND^.ShellWND:= false;
WND^.Hooks.OnDraw:= nil;
WND^.Hooks.OnMouseClick:= nil;
WND^.Hooks.OnMouseMove:= nil;
WND^.Hooks.OnMouseDown:= nil;
WND^.Hooks.OnMouseUp:= nil;
WND^.Hooks.OnKeyPressed:= nil;
WND^.Hooks.OnClose:= nil;
WND^.Hooks.OnMinimize:= nil;
WND^.Hooks.OnFocus:= nil;
WND^.Hooks.OnLoseFocus:= nil;
WindowManager.Windows[0]:= WND;
AddToZOrder(0);
FocusZOrder(0);
end;
function getPixel(x : uint32; y : uint32) : uint16;
var
dest : puint16;
begin
if not ready then exit;
dest:= puint16(multibootinfo^.framebuffer_addr);
dest:= dest + (y * Console_Properties.Width) + x;
getPixel:= dest^;
end;
procedure drawPixel(x : uint32; y : uint32; color : uint16);
var
dest : puint16;
begin
if not ready then exit;
dest:= puint16(multibootinfo^.framebuffer_addr);
dest:= dest + (y * Console_Properties.Width) + x;
dest^:= color;
end;
function getPixel32(x : uint32; y : uint32) : uint32;
var
dest : puint16;
dest32 : puint32;
begin
if not ready then exit;
dest:= puint16(multibootinfo^.framebuffer_addr);
dest:= dest + (y * Console_Properties.Width) + x;
dest32:= puint32(dest);
getPixel32:= dest32[0];
end;
procedure drawPixel32(x : uint32; y : uint32; pixel : uint32);
var
dest : puint16;
dest32 : puint32;
begin
if not ready then exit;
dest:= puint16(multibootinfo^.framebuffer_addr);
dest:= dest + (y * Console_Properties.Width) + x;
dest32:= puint32(dest);
dest32[0]:= pixel;
end;
function getPixel64(x : uint32; y : uint32) : uint64;
var
dest : puint16;
dest64 : puint64;
begin
if not ready then exit;
dest:= puint16(multibootinfo^.framebuffer_addr);
dest:= dest + (y * Console_Properties.Width) + x;
dest64:= puint64(dest);
getPixel64:= dest64^;
end;
procedure drawPixel64(x : uint32; y : uint32; pixel : uint64);
var
dest : puint16;
dest64 : puint64;
begin
if not ready then exit;
dest:= puint16(multibootinfo^.framebuffer_addr);
dest:= dest + (y * Console_Properties.Width) + x;
dest64:= puint64(dest);
dest64^:= pixel;
end;
procedure outputCharToScreenSpace(c : char; x : uint32; y : uint32; fgcolor : uint16);
var
dest : puint16;
dest32 : puint32;
fgcolor32, bgcolor32 : uint32;
mask : puint32;
i : uint32;
begin
if not ready then exit;
fgcolor32:= fgcolor OR (fgcolor SHL 16);
mask:= puint32(@Std_Mask[uint32(c) * (16 * 8)]);
dest:= puint16(multibootinfo^.framebuffer_addr);
//dest:= puint16(windowmanager.getBuffer(0));
dest:= dest + (y * Console_Properties.Width) + x;
dest32:= puint32(dest);
for i:=0 to 15 do begin
dest32[(i*(Console_Properties.Width div 2))+0]:= (dest32[(i*(Console_Properties.Width div 2))+0] AND NOT(mask[(i*4)+0])) OR (fgcolor32 AND mask[(i*4)+0]);
dest32[(i*(Console_Properties.Width div 2))+1]:= (dest32[(i*(Console_Properties.Width div 2))+1] AND NOT(mask[(i*4)+1])) OR (fgcolor32 AND mask[(i*4)+1]);
dest32[(i*(Console_Properties.Width div 2))+2]:= (dest32[(i*(Console_Properties.Width div 2))+2] AND NOT(mask[(i*4)+2])) OR (fgcolor32 AND mask[(i*4)+2]);
dest32[(i*(Console_Properties.Width div 2))+3]:= (dest32[(i*(Console_Properties.Width div 2))+3] AND NOT(mask[(i*4)+3])) OR (fgcolor32 AND mask[(i*4)+3]);
end;
//windowmanager.redraw;
end;
procedure outputCharTransparent(c : char; x : uint8; y : uint8; fgcolor : uint16);
var
dest : puint16;
dest32 : puint32;
fgcolor32, bgcolor32 : uint32;
mask : puint32;
i : uint32;
begin
if not ready then exit;
fgcolor32:= fgcolor OR (fgcolor SHL 16);
mask:= puint32(@Std_Mask[uint32(c) * (16 * 8)]);
dest:= puint16(multibootinfo^.framebuffer_addr);
//dest:= puint16(windowmanager.getBuffer(0));
dest:= dest + (y*(Console_Properties.Width * 16)) + (x * 8);
dest32:= puint32(dest);
for i:=0 to 15 do begin
dest32[(i*(Console_Properties.Width div 2))+0]:= (dest32[(i*(Console_Properties.Width div 2))+0] AND NOT(mask[(i*4)+0])) OR (fgcolor32 AND mask[(i*4)+0]);
dest32[(i*(Console_Properties.Width div 2))+1]:= (dest32[(i*(Console_Properties.Width div 2))+1] AND NOT(mask[(i*4)+1])) OR (fgcolor32 AND mask[(i*4)+1]);
dest32[(i*(Console_Properties.Width div 2))+2]:= (dest32[(i*(Console_Properties.Width div 2))+2] AND NOT(mask[(i*4)+2])) OR (fgcolor32 AND mask[(i*4)+2]);
dest32[(i*(Console_Properties.Width div 2))+3]:= (dest32[(i*(Console_Properties.Width div 2))+3] AND NOT(mask[(i*4)+3])) OR (fgcolor32 AND mask[(i*4)+3]);
end;
//windowmanager.redraw;
end;
procedure outputChar(c : char; x : uint8; y : uint8; fgcolor : uint16; bgcolor : uint16);
var
dest : puint16;
dest32 : puint32;
fgcolor32, bgcolor32 : uint32;
mask : puint32;
i : uint32;
begin
if not ready then exit;
fgcolor32:= fgcolor OR (fgcolor SHL 16);
bgcolor32:= bgcolor OR (bgcolor SHL 16);
mask:= puint32(@Std_Mask[uint32(c) * (16 * 8)]);
dest:= puint16(multibootinfo^.framebuffer_addr);
//dest:= puint16(windowmanager.getBuffer(0));
dest:= dest + (y*(Console_Properties.Width * 16)) + (x * 8);
dest32:= puint32(dest);
for i:=0 to 15 do begin
dest32[(i*(Console_Properties.Width div 2))+0]:= (bgcolor32 AND NOT(mask[(i*4)+0])) OR (fgcolor32 AND mask[(i*4)+0]);
dest32[(i*(Console_Properties.Width div 2))+1]:= (bgcolor32 AND NOT(mask[(i*4)+1])) OR (fgcolor32 AND mask[(i*4)+1]);
dest32[(i*(Console_Properties.Width div 2))+2]:= (bgcolor32 AND NOT(mask[(i*4)+2])) OR (fgcolor32 AND mask[(i*4)+2]);
dest32[(i*(Console_Properties.Width div 2))+3]:= (bgcolor32 AND NOT(mask[(i*4)+3])) OR (fgcolor32 AND mask[(i*4)+3]);
end;
//windowmanager.redraw;
end;
procedure disable_cursor;
begin
outb($3D4, $0A);
outb($3D5, $20);
end;
procedure keyhook(key_info : TKeyInfo);
begin
if (key_info.CTRL_DOWN) and (key_info.ALT_DOWN) then begin
case key_info.key_code of
uint8('c'):OpenTerminal:=true;
uint8('r'):resetSystem;
end;
end else begin
if WindowManager.Z_Order[0] <> MAX_WINDOWS then begin
if WindowManager.Windows[WindowManager.Z_Order[0]] <> nil then begin
if WindowManager.Windows[WindowManager.Z_Order[0]]^.Hooks.OnKeyPressed <> nil then WindowManager.Windows[WindowManager.Z_Order[0]]^.Hooks.OnKeyPressed(key_info);
end;
end;
end;
end;
procedure init(); [public, alias: 'console_init'];
var
fb: puint32;
Begin
fb:= puint32(uint32(multibootinfo^.framebuffer_addr));
Console_Properties.Width:= multibootinfo^.framebuffer_width;
Console_Properties.Height:= multibootinfo^.framebuffer_height;
Console_Properties.BitsPerPixel:= multibootinfo^.framebuffer_bpp;
Console_Properties.MAX_CELL_X:= (Console_Properties.Width div 8) - 1;
Console_Properties.MAX_CELL_Y:= (Console_Properties.Height div 16) - 1;
If Console_Properties.BitsPerPixel <> 16 then while true do begin
end;
kpalloc(uint32(fb));
keyboard.hook(@keyhook);
initWindows;
Console_Properties.Default_Attribute:= console.combinecolors($FFFF, $0000);
console.clear();
Ready:= True;
end;
{ Default Console Write Functions }
procedure clear(); [public, alias: 'console_clear'];
var
x,y: Byte;
begin
if WindowManager.Windows[DefaultWND] <> nil then begin
for y:=0 to Console_Properties.MAX_CELL_Y do begin
for x:=0 to Console_Properties.MAX_CELL_X do begin
WindowManager.Windows[DefaultWND]^.Buffer[y][x].Character:= ' ';
WindowManager.Windows[DefaultWND]^.Buffer[y][x].Attributes:= Console_Properties.Default_Attribute;
WindowManager.Windows[DefaultWND]^.row_dirty[y]:= true;
//Console_Matrix[y][x].Character:= ' ';
//Console_Matrix[y][x].Attributes:= Console_Properties.Default_Attribute;
//OutputChar(Console_Matrix[y][x].Character, x, y, Console_Matrix[y][x].Attributes SHR 16, Console_Matrix[y][x].Attributes AND $FFFF);
end;
end;
WindowManager.Windows[DefaultWND]^.Cursor.X:= 0;
WindowManager.Windows[DefaultWND]^.Cursor.Y:= 0;
//redrawWindows;
end;
//Console_Cursor.X:= 0;
//Console_Cursor.Y:= 0;
end;
procedure writebin8ex(b : uint8; attributes: uint32);
var
Mask : PMask;
i : uint8;
begin
Mask:= PMask(@b);
for i:=0 to 7 do begin
If Mask^[7-i] then writecharex('1', attributes) else writecharex('0', attributes);
end;
end;
procedure writebin16ex(b : uint16; attributes: uint32);
var
Mask : PMask;
i,j : uint8;
begin
for j:=1 downto 0 do begin
Mask:= PMask(uint32(@b) + (1 * j));
for i:=0 to 7 do begin
If Mask^[7-i] then writecharex('1', attributes) else writecharex('0', attributes);
end;
end;
end;
procedure writebin32ex(b : uint32; attributes: uint32);
var
Mask : PMask;
i,j : uint8;
begin
for j:=3 downto 0 do begin
Mask:= PMask(uint32(@b) + (1 * j));
for i:=0 to 7 do begin
If Mask^[7-i] then writecharex('1', attributes) else writecharex('0', attributes);
end;
end;
end;
procedure writebin8(b : uint8);
begin
writebin8ex(b, Console_Properties.Default_Attribute);
end;
procedure writebin16(b : uint16);
begin
writebin16ex(b, Console_Properties.Default_Attribute);
end;
procedure writebin32(b : uint32);
begin
writebin32ex(b, Console_Properties.Default_Attribute);
end;
procedure writebin8lnex(b : uint8; attributes: uint32);
begin
writebin8ex(b, attributes);
console._safeincrement_y();
end;
procedure writebin16lnex(b : uint16; attributes: uint32);
begin
writebin16ex(b, attributes);
console._safeincrement_y();
end;
procedure writebin32lnex(b : uint32; attributes: uint32);
begin
writebin32ex(b, attributes);
console._safeincrement_y();
end;
procedure writebin8ln(b : uint8);
begin
writebin8lnex(b, Console_Properties.Default_Attribute);
end;
procedure writebin16ln(b : uint16);
begin
writebin16lnex(b, Console_Properties.Default_Attribute);
end;
procedure writebin32ln(b : uint32);
begin
writebin32lnex(b, Console_Properties.Default_Attribute);
end;
procedure setdefaultattribute(attribute: uint32); [public, alias: 'console_setdefaultattribute'];
begin
Console_Properties.Default_Attribute:= attribute;
end;
procedure writechar(character: char); [public, alias: 'console_writechar'];
begin
console.writecharex(character, Console_Properties.Default_Attribute);
end;
procedure writestring(str: PChar); [public, alias: 'console_writestring'];
begin
console.writestringex(str, Console_Properties.Default_Attribute);
end;
procedure writeint(i: Integer); [public, alias: 'console_writeint'];
begin
console.writeintex(i, Console_Properties.Default_Attribute);
end;
procedure writecharln(character: char); [public, alias: 'console_writecharln'];
begin
console.writecharlnex(character, Console_Properties.Default_Attribute);
end;
procedure writestringln(str: PChar); [public, alias: 'console_writestringln'];
begin
console.writestringlnex(str, Console_Properties.Default_Attribute);
end;
procedure writeintln(i: Integer); [public, alias: 'console_writeintln'];
begin
console.writeintlnex(i, Console_Properties.Default_Attribute);
end;
procedure writecharex(character: char; attributes: uint32); [public, alias: 'console_writecharex'];
begin
serial.send(COM1, uint8(character), 10000);
if WindowManager.Windows[DefaultWND] <> nil then begin
WindowManager.Windows[DefaultWND]^.Buffer[WindowManager.Windows[DefaultWND]^.Cursor.Y][WindowManager.Windows[DefaultWND]^.Cursor.X].Character:= character;
WindowManager.Windows[DefaultWND]^.Buffer[WindowManager.Windows[DefaultWND]^.Cursor.Y][WindowManager.Windows[DefaultWND]^.Cursor.X].Attributes:= attributes;
//outputChar(character, Console_Cursor.X, Console_Cursor.Y, attributes SHR 16, attributes AND $FFFF);
//Console_Matrix[Console_Cursor.Y][Console_Cursor.X].Character:= character;
//Console_Matrix[Console_Cursor.Y][Console_Cursor.X].Attributes:= attributes;
WindowManager.Windows[DefaultWND]^.row_dirty[WindowManager.Windows[DefaultWND]^.Cursor.Y]:= true;
console._safeincrement_x();
end;
end;
procedure writehexpair(b : uint8);
var
bn : Array[0..1] of uint8;
i : uint8;
begin
bn[0]:= b SHR 4;
bn[1]:= b AND $0F;
for i:=0 to 1 do begin
case bn[i] of
0:writestring('0');
1:writestring('1');
2:writestring('2');
3:writestring('3');
4:writestring('4');
5:writestring('5');
6:writestring('6');
7:writestring('7');
8:writestring('8');
9:writestring('9');
10:writestring('A');
11:writestring('B');
12:writestring('C');
13:writestring('D');
14:writestring('E');
15:writestring('F');
end;
end;
end;
procedure writehexex(i : dword; attributes: uint32); [public, alias: 'console_writehexex'];
var
Hex : Array[0..7] of Byte;
Res : DWORD;
Rem : DWORD;
c : Integer;
begin
for c:=0 to 7 do begin
Hex[c]:= 0;
end;
c:=0;
Res:= i;
Rem:= Res mod 16;
while Res > 0 do begin
Hex[c]:= Rem;
Res:= Res div 16;
Rem:= Res mod 16;
c:=c+1;
end;
writestringex('0x', attributes);
for c:=7 downto 0 do begin
if Hex[c] <> 255 then begin
case Hex[c] of
0:writecharex('0', attributes);
1:writecharex('1', attributes);
2:writecharex('2', attributes);
3:writecharex('3', attributes);
4:writecharex('4', attributes);
5:writecharex('5', attributes);
6:writecharex('6', attributes);
7:writecharex('7', attributes);
8:writecharex('8', attributes);
9:writecharex('9', attributes);
10:writecharex('A', attributes);
11:writecharex('B', attributes);
12:writecharex('C', attributes);
13:writecharex('D', attributes);
14:writecharex('E', attributes);
15:writecharex('F', attributes);
else writecharex('?', attributes);
end;
end;
end;
end;
procedure writehex(i : dword); [public, alias: 'console_writehex'];
begin
console.writehexex(i, Console_Properties.Default_Attribute);
end;
procedure writehexlnex(i : dword; attributes: uint32);
begin
console.writehexex(i, attributes);
console._safeincrement_y();
end;
procedure writehexln(i : dword);
begin
writehexlnex(i, Console_Properties.Default_Attribute);
end;
procedure Output(identifier : PChar; str : PChar);
begin
writestring('[');
writestring(identifier);
writestring('] ');
writestring(str);
redrawWindows;
end;
procedure Outputln(identifier : PChar; str : PChar);
begin
Output(identifier, str);
writestringln(' ');
end;
procedure writestringex(str: PChar; attributes: uint32); [public, alias: 'console_writestringex'];
var
i : integer;
begin
i:= 0;
while (str[i] <> #0) do begin
console.writecharex(str[i], attributes);
i:=i+1;
end;
end;
procedure writeintex(i: Integer; attributes: uint32); [public, alias: 'console_writeintex'];
var
buffer: array [0..11] of Char;
str: PChar;
digit: DWORD;
minus: Boolean;
begin
str := @buffer[11];
str^ := #0;
if (i < 0) then begin
digit := -i;
minus := True;
end else begin
digit := i;
minus := False;
end;
repeat
Dec(str);
str^ := Char((digit mod 10) + Byte('0'));
digit := digit div 10;
until (digit = 0);
if (minus) then begin
Dec(str);
str^ := '-';
end;
console.writestringex(str, attributes);
end;
procedure writecharlnex(character: char; attributes: uint32); [public, alias: 'console_writecharlnex'];
begin
console.writecharex(character, attributes);
console._safeincrement_y();
end;
procedure writestringlnex(str: PChar; attributes: uint32); [public, alias: 'console_writestringlnex'];
begin
console.writestringex(str, attributes);
console._safeincrement_y();
end;
procedure writeintlnex(i: Integer; attributes: uint32); [public, alias: 'console_writeintlnex'];
begin
console.writeintex(i, attributes);
console._safeincrement_y();
end;
function combinecolors(Foreground, Background: uint16): uint32;
begin
combinecolors:= (uint32(Foreground) SHL 16) OR Background;
end;
procedure _update_cursor(); [public, alias: '_console_update_cursor'];
var
pos : word;
b : byte;
begin
//pos:= (Console_Cursor.Y * 80) + Console_Cursor.X;
//outb($3D4, $0F);
//b:= pos and $00FF;
//outb($3D5, b);
//outb($3D4, $0E);
//b:= pos shr 8;
//outb($3D5, b);
if CONSOLE_SLOW_REDRAW then redrawWindows;
//sleep(1);
end;
procedure backspace;
begin
if WindowManager.Windows[DefaultWND] <> nil then begin
Dec(WindowManager.Windows[DefaultWND]^.Cursor.X);
writechar(' ');
Dec(WindowManager.Windows[DefaultWND]^.Cursor.X);
_update_cursor();
end;
end;
procedure _increment_x(); [public, alias: '_console_increment_x'];
begin
if WindowManager.Windows[DefaultWND] <> nil then begin
WindowManager.Windows[DefaultWND]^.Cursor.X:= WindowManager.Windows[DefaultWND]^.Cursor.X+1;
If WindowManager.Windows[DefaultWND]^.Cursor.X > WindowManager.Windows[DefaultWND]^.WND_W-1 then WindowManager.Windows[DefaultWND]^.Cursor.X:= 0;
console._update_cursor;
end;
//Console_Cursor.X:= Console_Cursor.X+1;
//If Console_Cursor.X > 159 then Console_Cursor.X:= 0;
//console._update_cursor;
end;
procedure _increment_y(); [public, alias: '_console_increment_y'];
begin
if WindowManager.Windows[DefaultWND] <> nil then begin
WindowManager.Windows[DefaultWND]^.Cursor.Y:= WindowManager.Windows[DefaultWND]^.Cursor.Y+1;
If WindowManager.Windows[DefaultWND]^.Cursor.Y > WindowManager.Windows[DefaultWND]^.WND_H-1 then begin
console._newline();
WindowManager.Windows[DefaultWND]^.Cursor.Y:= WindowManager.Windows[DefaultWND]^.WND_H-1;
end;
console._update_cursor;
end;
//Console_Cursor.Y:= Console_Cursor.Y+1;
//If Console_Cursor.Y > 63 then begin
// console._newline();
// Console_Cursor.Y:= 63;
//end;
//console._update_cursor;
end;
procedure _safeincrement_x(); [public, alias: '_console_safeincrement_x'];
begin
if WindowManager.Windows[DefaultWND] <> nil then begin
WindowManager.Windows[DefaultWND]^.Cursor.X:= WindowManager.Windows[DefaultWND]^.Cursor.X+1;
if WindowManager.Windows[DefaultWND]^.Cursor.X > WindowManager.Windows[DefaultWND]^.WND_W-1 then begin
console._safeincrement_y();
end;
console._update_cursor;
end;
//Console_Cursor.X:= Console_Cursor.X+1;
//If Console_Cursor.X > 159 then begin
// console._safeincrement_y();
//end;
//console._update_cursor;
end;
procedure _safeincrement_y(); [public, alias: '_console_safeincrement_y'];
begin
serial.send(COM1, uint8(13), 10000);
serial.send(COM1, uint8(10), 10000);
if WindowManager.Windows[DefaultWND] <> nil then begin
WindowManager.Windows[DefaultWND]^.Cursor.Y:= WindowManager.Windows[DefaultWND]^.Cursor.Y+1;
if WindowManager.Windows[DefaultWND]^.Cursor.Y > WindowManager.Windows[DefaultWND]^.WND_H-1 then begin
console._newline();
WindowManager.Windows[DefaultWND]^.Cursor.Y:= WindowManager.Windows[DefaultWND]^.WND_H-1;
end;
WindowManager.Windows[DefaultWND]^.Cursor.X:= 0;
console._update_cursor;
end;
//Console_Cursor.Y:= Console_Cursor.Y+1;
//If Console_Cursor.Y > 63 then begin
// console._newline();
// Console_Cursor.Y:= 63;
//end;
//Console_Cursor.X:= 0;
//console._update_cursor;
end;
procedure _newline(); [public, alias: '_console_newline'];
var
x, y : byte;
begin
if WindowManager.Windows[DefaultWND] <> nil then begin
if WindowManager.Windows[DefaultWND]^.WND_W = 0 then exit;
if WindowManager.Windows[DefaultWND]^.WND_H = 0 then exit;
for x:=0 to WindowManager.Windows[DefaultWND]^.WND_W do begin
for y:=0 to WindowManager.Windows[DefaultWND]^.WND_H-1 do begin
WindowManager.Windows[DefaultWND]^.buffer[y][x]:= WindowManager.Windows[DefaultWND]^.buffer[y+1][x];
WindowManager.Windows[DefaultWND]^.row_dirty[y]:= true;
//Console_Matrix[y][x]:= Console_Matrix[y+1][x];
end;
end;
for x:=0 to WindowManager.Windows[DefaultWND]^.WND_W do begin
WindowManager.Windows[DefaultWND]^.buffer[WindowManager.Windows[DefaultWND]^.WND_H-1][x].Character:= ' ';
WindowManager.Windows[DefaultWND]^.buffer[WindowManager.Windows[DefaultWND]^.WND_H-1][x].Attributes:= $FFFF0000;
//Console_Matrix[63][x].Character:= ' ';
//Console_Matrix[63][x].Attributes:= $FFFF0000;
end;
//for y:=0 to 63 do begin
// for x:=0 to 159 do begin
// OutputChar(Console_Matrix[y][x].Character, x, y, Console_Matrix[y][x].Attributes SHR 16, Console_Matrix[y][x].Attributes AND $FFFF);
// end;
//end;
console._update_cursor;
end;
end;
{ WND Specific Console Draw Functions }
procedure clearWND(WND : uint32);
var
x,y: Byte;
begin
if WindowManager.Windows[WND] <> nil then begin
for y:=0 to Console_Properties.MAX_CELL_Y do begin
for x:=0 to Console_Properties.MAX_CELL_X do begin
WindowManager.Windows[WND]^.Buffer[y][x].Character:= ' ';
WindowManager.Windows[WND]^.Buffer[y][x].Attributes:= Console_Properties.Default_Attribute;
WindowManager.Windows[WND]^.row_dirty[y]:= true;
//Console_Matrix[y][x].Character:= ' ';
//Console_Matrix[y][x].Attributes:= Console_Properties.Default_Attribute;
//OutputChar(Console_Matrix[y][x].Character, x, y, Console_Matrix[y][x].Attributes SHR 16, Console_Matrix[y][x].Attributes AND $FFFF);
end;
end;
WindowManager.Windows[WND]^.Cursor.X:= 0;
WindowManager.Windows[WND]^.Cursor.Y:= 0;
//redrawWindows;
end;
//Console_Cursor.X:= 0;
//Console_Cursor.Y:= 0;
end;
procedure clearWNDEx(WND : uint32; attributes : uint32);
var
x,y: Byte;
begin
if WindowManager.Windows[WND] <> nil then begin
for y:=0 to Console_Properties.MAX_CELL_Y do begin
for x:=0 to Console_Properties.MAX_CELL_X do begin
WindowManager.Windows[WND]^.Buffer[y][x].Character:= ' ';
WindowManager.Windows[WND]^.Buffer[y][x].Attributes:= attributes;
WindowManager.Windows[WND]^.row_dirty[y]:= true;
end;
end;
WindowManager.Windows[WND]^.Cursor.X:= 0;
WindowManager.Windows[WND]^.Cursor.Y:= 0;
end;
end;
procedure writebin8exWND(b : uint8; attributes: uint32; WND : uint32);
var
Mask : PMask;
i : uint8;
begin
Mask:= PMask(@b);
for i:=0 to 7 do begin
If Mask^[7-i] then writecharexWND('1', attributes, WND) else writecharexWND('0', attributes, WND);
end;
end;
procedure writebin16exWND(b : uint16; attributes: uint32; WND : uint32);
var
Mask : PMask;
i,j : uint8;
begin
for j:=1 downto 0 do begin
Mask:= PMask(uint32(@b) + (1 * j));
for i:=0 to 7 do begin
If Mask^[7-i] then writecharexWND('1', attributes, WND) else writecharexWND('0', attributes, WND);
end;
end;
end;
procedure writebin32exWND(b : uint32; attributes: uint32; WND : uint32);
var
Mask : PMask;
i,j : uint8;
begin
for j:=3 downto 0 do begin
Mask:= PMask(uint32(@b) + (1 * j));
for i:=0 to 7 do begin
If Mask^[7-i] then writecharexWND('1', attributes, WND) else writecharexWND('0', attributes, WND);
end;
end;
end;
procedure writebin8WND(b : uint8; WND : uint32);
begin
writebin8exWND(b, Console_Properties.Default_Attribute, WND);
end;
procedure writebin16WND(b : uint16; WND : uint32);
begin
writebin16exWND(b, Console_Properties.Default_Attribute, WND);
end;
procedure writebin32WND(b : uint32; WND : uint32);
begin
writebin32exWND(b, Console_Properties.Default_Attribute, WND);
end;
procedure writebin8lnexWND(b : uint8; attributes: uint32; WND : uint32);
begin
writebin8exWND(b, attributes, WND);
console._safeincrement_y_WND(WND);
end;
procedure writebin16lnexWND(b : uint16; attributes: uint32; WND : uint32);
begin
writebin16exWND(b, attributes, WND);
console._safeincrement_y_WND(WND);
end;
procedure writebin32lnexWND(b : uint32; attributes: uint32; WND : uint32);
begin
writebin32exWND(b, attributes, WND);
console._safeincrement_y_WND(WND);
end;
procedure writebin8lnWND(b : uint8; WND : uint32);
begin
writebin8lnexWND(b, Console_Properties.Default_Attribute, WND);
end;
procedure writebin16lnWND(b : uint16; WND : uint32);
begin
writebin16lnexWND(b, Console_Properties.Default_Attribute, WND);
end;
procedure writebin32lnWND(b : uint32; WND : uint32);
begin
writebin32lnexWND(b, Console_Properties.Default_Attribute, WND);
end;
{procedure setdefaultattribute(attribute: uint32); [public, alias: 'console_setdefaultattribute'];
begin
Console_Properties.Default_Attribute:= attribute;
end;}
procedure writecharWND(character: char; WND : uint32);
begin
console.writecharexWND(character, Console_Properties.Default_Attribute, WND);
end;
procedure writestringWND(str: PChar; WND : uint32);
begin
console.writestringexWND(str, Console_Properties.Default_Attribute, WND);
end;
procedure writeintWND(i: Integer; WND : uint32);
begin
console.writeintexWND(i, Console_Properties.Default_Attribute, WND);
end;
procedure writecharlnWND(character: char; WND : uint32);
begin
console.writecharlnexWND(character, Console_Properties.Default_Attribute, WND);
end;
procedure writestringlnWND(str: PChar; WND : uint32);
begin
console.writestringlnexWND(str, Console_Properties.Default_Attribute, WND);
end;
procedure writeintlnWND(i: Integer; WND : uint32);
begin
console.writeintlnexWND(i, Console_Properties.Default_Attribute, WND);
end;
procedure writecharexWND(character: char; attributes: uint32; WND : uint32);
begin
if WindowManager.Windows[WND] <> nil then begin
WindowManager.Windows[WND]^.Buffer[WindowManager.Windows[WND]^.Cursor.Y][WindowManager.Windows[WND]^.Cursor.X].Character:= character;
WindowManager.Windows[WND]^.Buffer[WindowManager.Windows[WND]^.Cursor.Y][WindowManager.Windows[WND]^.Cursor.X].Attributes:= attributes;
//outputChar(character, Console_Cursor.X, Console_Cursor.Y, attributes SHR 16, attributes AND $FFFF);
//Console_Matrix[Console_Cursor.Y][Console_Cursor.X].Character:= character;
//Console_Matrix[Console_Cursor.Y][Console_Cursor.X].Attributes:= attributes;
WindowManager.Windows[WND]^.row_dirty[WindowManager.Windows[WND]^.Cursor.Y]:= true;
console._safeincrement_x_WND(WND);
end;
end;
procedure writehexpairWND(b : uint8; WND : uint32);
begin
writehexpairExWND(b, Console_Properties.Default_Attribute, WND);
end;
procedure writehexpairExWND(b : uint8; Attributes : uint32; WND : uint32);
var
bn : Array[0..1] of uint8;
i : uint8;
begin
bn[0]:= b SHR 4;
bn[1]:= b AND $0F;
for i:=0 to 1 do begin
case bn[i] of
0 :writestringExWND('0', Attributes, WND);
1 :writestringExWND('1', Attributes, WND);
2 :writestringExWND('2', Attributes, WND);
3 :writestringExWND('3', Attributes, WND);
4 :writestringExWND('4', Attributes, WND);
5 :writestringExWND('5', Attributes, WND);
6 :writestringExWND('6', Attributes, WND);
7 :writestringExWND('7', Attributes, WND);
8 :writestringExWND('8', Attributes, WND);
9 :writestringExWND('9', Attributes, WND);
10:writestringExWND('A', Attributes, WND);
11:writestringExWND('B', Attributes, WND);
12:writestringExWND('C', Attributes, WND);
13:writestringExWND('D', Attributes, WND);
14:writestringExWND('E', Attributes, WND);
15:writestringExWND('F', Attributes, WND);
end;
end;
end;
procedure writehexexWND(i : dword; attributes: uint32; WND : uint32);
var
Hex : Array[0..7] of Byte;
Res : DWORD;
Rem : DWORD;
c : Integer;
begin
for c:=0 to 7 do begin
Hex[c]:= 0;
end;
c:=0;
Res:= i;
Rem:= Res mod 16;
while Res > 0 do begin
Hex[c]:= Rem;
Res:= Res div 16;
Rem:= Res mod 16;
c:=c+1;
end;
writestringexWND('0x', attributes, WND);
for c:=7 downto 0 do begin
if Hex[c] <> 255 then begin
case Hex[c] of
0:writecharexWND('0', attributes, WND);
1:writecharexWND('1', attributes, WND);
2:writecharexWND('2', attributes, WND);
3:writecharexWND('3', attributes, WND);
4:writecharexWND('4', attributes, WND);
5:writecharexWND('5', attributes, WND);
6:writecharexWND('6', attributes, WND);
7:writecharexWND('7', attributes, WND);
8:writecharexWND('8', attributes, WND);
9:writecharexWND('9', attributes, WND);
10:writecharexWND('A', attributes, WND);
11:writecharexWND('B', attributes, WND);
12:writecharexWND('C', attributes, WND);
13:writecharexWND('D', attributes, WND);
14:writecharexWND('E', attributes, WND);
15:writecharexWND('F', attributes, WND);
else writecharexWND('?', attributes, WND);
end;
end;
end;
end;
procedure writehexWND(i : dword; WND : uint32);
begin
console.writehexexWND(i, Console_Properties.Default_Attribute, WND);
end;
procedure writehexlnexWND(i : dword; attributes: uint32; WND : uint32);
begin
console.writehexexWND(i, attributes, WND);
console._safeincrement_y_WND(WND);
end;
procedure writehexlnWND(i : dword; WND : uint32);
begin
writehexlnexWND(i, Console_Properties.Default_Attribute, WND);
end;
procedure OutputWND(identifier : PChar; str : PChar; WND : uint32);
begin
writestringWND('[', WND);
writestringWND(identifier, WND);
writestringWND('] ', WND);
writestringWND(str, WND);
end;
procedure OutputlnWND(identifier : PChar; str : PChar; WND : uint32);
begin
OutputWND(identifier, str, WND);
writestringlnWND(' ', WND);
end;
procedure writestringexWND(str: PChar; attributes: uint32; WND : uint32);
var
i : integer;
begin
i:= 0;
while (str[i] <> #0) do begin
console.writecharexWND(str[i], attributes, WND);
i:=i+1;
end;
end;
procedure writeintexWND(i: Integer; attributes: uint32; WND : uint32);
var
buffer: array [0..11] of Char;
str: PChar;
digit: DWORD;
minus: Boolean;
begin
str := @buffer[11];
str^ := #0;
if (i < 0) then begin
digit := -i;
minus := True;
end else begin
digit := i;
minus := False;
end;
repeat
Dec(str);
str^ := Char((digit mod 10) + Byte('0'));
digit := digit div 10;
until (digit = 0);
if (minus) then begin
Dec(str);
str^ := '-';
end;
console.writestringexWND(str, attributes, WND);
end;
procedure writecharlnexWND(character: char; attributes: uint32; WND : uint32);
begin
console.writecharexWND(character, attributes, WND);
console._safeincrement_y_WND(WND);
end;
procedure writestringlnexWND(str: PChar; attributes: uint32; WND : uint32);
begin
console.writestringexWND(str, attributes, WND);
console._safeincrement_y_WND(WND);
end;
procedure writeintlnexWND(i: Integer; attributes: uint32; WND : uint32);
begin
console.writeintexWND(i, attributes, WND);
console._safeincrement_y_WND(WND);
end;
procedure backspaceWND(WND : uint32);
begin
if WindowManager.Windows[WND] <> nil then begin
Dec(WindowManager.Windows[WND]^.Cursor.X);
writecharWND(' ', WND);
Dec(WindowManager.Windows[WND]^.Cursor.X);
_update_cursor();
end;
end;
procedure _increment_x_WND(WND : uint32);
begin
if WindowManager.Windows[WND] <> nil then begin
WindowManager.Windows[WND]^.Cursor.X:= WindowManager.Windows[WND]^.Cursor.X+1;
If WindowManager.Windows[WND]^.Cursor.X > WindowManager.Windows[WND]^.WND_W-1 then WindowManager.Windows[WND]^.Cursor.X:= 0;
console._update_cursor;
end;
//Console_Cursor.X:= Console_Cursor.X+1;
//If Console_Cursor.X > 159 then Console_Cursor.X:= 0;
//console._update_cursor;
end;
procedure _increment_y_WND(WND : uint32);
begin
if WindowManager.Windows[WND] <> nil then begin
WindowManager.Windows[WND]^.Cursor.Y:= WindowManager.Windows[WND]^.Cursor.Y+1;
If WindowManager.Windows[WND]^.Cursor.Y > WindowManager.Windows[WND]^.WND_H-1 then begin
console._newlineWND(WND);
WindowManager.Windows[WND]^.Cursor.Y:= WindowManager.Windows[WND]^.WND_H-1;
end;
console._update_cursor;
end;
//Console_Cursor.Y:= Console_Cursor.Y+1;
//If Console_Cursor.Y > 63 then begin
// console._newline();
// Console_Cursor.Y:= 63;
//end;
//console._update_cursor;
end;
procedure _safeincrement_x_WND(WND : uint32);
begin
if WindowManager.Windows[WND] <> nil then begin
WindowManager.Windows[WND]^.Cursor.X:= WindowManager.Windows[WND]^.Cursor.X+1;
if WindowManager.Windows[WND]^.Cursor.X > WindowManager.Windows[WND]^.WND_W-1 then begin
console._safeincrement_y_WND(WND);
end;
console._update_cursor;
end;
//Console_Cursor.X:= Console_Cursor.X+1;
//If Console_Cursor.X > 159 then begin
// console._safeincrement_y();
//end;
//console._update_cursor;
end;
procedure _safeincrement_y_WND(WND : uint32);
begin
if WindowManager.Windows[WND] <> nil then begin
WindowManager.Windows[WND]^.Cursor.Y:= WindowManager.Windows[WND]^.Cursor.Y+1;
if WindowManager.Windows[WND]^.Cursor.Y > WindowManager.Windows[WND]^.WND_H-1 then begin
console._newlineWND(WND);
WindowManager.Windows[WND]^.Cursor.Y:= WindowManager.Windows[WND]^.WND_H-1;
end;
WindowManager.Windows[WND]^.Cursor.X:= 0;
console._update_cursor;
end;
//Console_Cursor.Y:= Console_Cursor.Y+1;
//If Console_Cursor.Y > 63 then begin
// console._newline();
// Console_Cursor.Y:= 63;
//end;
//Console_Cursor.X:= 0;
//console._update_cursor;
end;
procedure _newlineWND(WND : uint32);
var
x, y : byte;
begin
if WindowManager.Windows[WND] <> nil then begin
if WindowManager.Windows[WND]^.WND_W = 0 then exit;
if WindowManager.Windows[WND]^.WND_H = 0 then exit;
for x:=0 to WindowManager.Windows[WND]^.WND_W do begin
for y:=0 to WindowManager.Windows[WND]^.WND_H-1 do begin
WindowManager.Windows[WND]^.buffer[y][x]:= WindowManager.Windows[WND]^.buffer[y+1][x];
WindowManager.Windows[WND]^.row_dirty[y]:= true;
//Console_Matrix[y][x]:= Console_Matrix[y+1][x];
end;
end;
for x:=0 to WindowManager.Windows[WND]^.WND_W do begin
WindowManager.Windows[WND]^.buffer[WindowManager.Windows[WND]^.WND_H-1][x].Character:= ' ';
WindowManager.Windows[WND]^.buffer[WindowManager.Windows[WND]^.WND_H-1][x].Attributes:= $FFFF0000;
//Console_Matrix[63][x].Character:= ' ';
//Console_Matrix[63][x].Attributes:= $FFFF0000;
end;
//for y:=0 to 63 do begin
// for x:=0 to 159 do begin
// OutputChar(Console_Matrix[y][x].Character, x, y, Console_Matrix[y][x].Attributes SHR 16, Console_Matrix[y][x].Attributes AND $FFFF);
// end;
//end;
console._update_cursor;
end;
end;
end.
Reference in New Issue View Git Blame Copy Permalink