As we all know that the best computers in the world are the C64 and C128. They have their GUI too - the excellent GEOS. GEOS seems very difficult and cryptic for many people, from programmer's point of view. That's not true. The designers of GEOS created a flexible and powerful system, which is easy to use and program.
Coding GEOS in C? That's something new. It is possible now - with Ulrich von Bassewitz's cc65 package and my GEOSLib you are able to create GEOS applications in no time.
GEOSLib supports a subset of the standard cc65 libraries. Whenever possible native Kernal functions
are used (e.g. memset
is an alias for FillRam
), however not all are supported. E.g.
string functions like strcmp
, strcpy
are doubled with native CmpString
,
CopyString
because the latter can handle only 256 byte strings. Keep this in mind when
you write your program. If you don't need long strings simply use functions from the Kernal,
the resulting code will be smaller.
dio
- direct disk access is available, but you might have problems with devices other
than 1541, 1571 or 1581. RAM drives emulating these should work.
conio
- simple console input-output is available for command line applications.
This implementation assumes that one character does fit in 8x8 cell, so output with
default BSW font, which is has 9 points, might be a bit messy. There is no color support in
GEOS 2.0 so color functions are disabled. Both 40 and 80 column modes are supported
and automatically detected.
tgi
- TGI driver for GEOS that supports both 40 and 80 column modes but mode can not be
changed between tgi_init
and tgi_done
.
joy
- JOY driver for GEOS that supports only joystick, not current pointing device.
It is safe to use these standard includes and their contents:
assert.h, conio.h, dio.h, errno.h, em.h, geos.h, joystick.h, modload.h, mouse.h, stdlib.h, string.h, tgi.h, time.h
For time.h
functions clock()
and clock_gettime()
note that the resolution is one second.
Functions from the headers above are either standard C library functions or cc65-specific, in either case they are not GEOS specific and so they are not described here.
I am an assembler programmer and GEOSLib was designed in such way that cc65 could emit the best
available code (well, the best as for machine :-). Many of the void foo (void)
functions are
just raw calls to the Kernal (assembled just as jsr _foo
), look in gsym.h
, where you
can find many definitions of standard GEOS locations. Access to these addresses is optimized by
cc65 to simple lda
and sta
. Don't be afraid to use C syntax.
You don't need a C64 or C128 for development. The only hardware requirement is a PC capable of running cc65. You do however need C64 or C128 emulator and GEOS disk images (.d64) to test your programs.
The software needed:
VICE and cc65 are portable - they run on variety of platforms - DOS, Win32 and UNIX. GEOSLib only needs cc65.
Update: starting from v2.5.0 GEOSLib is a part of the cc65 package as its GEOS support library.
I want to thank Uz for his cc65 package, Alexander Boyce for his excellent GEOS Programmer's Reference Guide and BSW for GEOS.
GEOSLib is covered by the same license as cc65. You can find the whole text among documentation. I would really appreciate if you would like to send me your comments, suggestions, questions, changes, bug reports etc. I will also appreciate if you will just give me a sign that you are using GEOSLib - not especially something big and important, mail me even if you are just playing with it.
You can send postcards with hellos to:
Maciej Witkowiak, ul. Slowackiego 6/57, 77-400 ZLOTOW
POLAND
e-mail<EMAIL_ADDRESS>This chapter describes some rules you ought to obey, and how to use GEOSLib.
Apart from this file, which merely describes only standard GEOS library
functions, you should read the grc65
(GEOS resource compiler) documentation.
There is information about necessary resource files (each GEOS application
needs at least one) and the build process - what should be done and in what
order. Please also read the cc65 documentation on how to compile C, assembler
and link everything together.
All in all, you just need to place
#include <geos.h>
at the top of your source.
As a general rule read the sources of the example programs and read the headers. These are the most reliable sources of knowledge ;-). You will also find there many C macros representing various arguments passed to the functions. Please use them. You will find your sources easier to understand, and it will be easier to find bugs.
All types used in GEOSLib are unsigned
.
Screen coordinates are given in pixels unless stated differently.
Contrary to a typical GEOS assembly program which has a main function called after loading that
setups the screen, menus, icons etc. exiting from the main
function in C is equivalent to
calling exit()
. These two are the only safe methods of terminating applications. DO NOT
USE EnterDeskTop
! Your data may be lost as library destructors and functions registered
with atexit
are not called.
For GEOS GUI applications the recommended program structure is to have everything initialized
in the main
function and at the end of it a call to the MainLoop()
function. WARNING! This
function never returns, any code between MainLoop();
and the end of main
will not
be executed. You have to call exit()
explicitly somewhere in your code (e.g. in a menu
handler or via DialogBox action).
Whenever possible use definitions from gsym.h
. The resulting code is translated by cc65 into
series of lda
and sta
, so you can't do it better :-).
Don't hesitate to use library functions. Everything was written with size and speed in mind. In
fact many calls are just redirections to the GEOS Kernal which results in a simple jsr
.
The main
function receives the standard argc
and argv
parameters. There are
always either 1 or 3 parameters. The DOS application name is always set as argv[0]
.
If present, argv[1]
and argv[2]
will be set to the data filename and data diskname (it only
works if the user double-clicks on a data file associated with your application). Note that it is up
to your application to determine which of the available (up to four) disk drives has the disk
with given diskname inside. If this fails your program should ask to insert the proper disk into
one of available drives.
You might wonder why I have chosen a sometimes weird order of arguments in functions. I just
wanted to avoid unnecessary pushing and popping of arguments from the stack because cc65 can pass a single
unsigned int
through CPU registers.
Do not try to compile in strict ANSI mode. The library uses cc65 extensions which are not available in ANSI.
It is possible to use dynamically loaded modules, three such modules are provided: A GEOS TGI driver, a GEOS EMD driver (for VDC extended memory) and a GEOS JOY driver. Just make sure that their filenames appear UPPERCASE in DeskTop. There are no more special recommendations, read the cc65 documentation about modules and the demo programs source code.
Functions here are sorted more or less in the way they appear in the header files. This way I am able
to keep functions covering similar tasks near each other. All function names are identical to those
from the geosSym
file provided with the GeoProgrammer package. Only my extensions to geosSym
are covered by new names, but I tried to keep them in the naming convention.
This section covers the drawing package of GEOS along with text output routines.
void SetNewMode (void)
This function is intended for use by GEOS 128 only, and will exhibit undefined behavior on the
C64. It will toggle between the 40 column screen mode and the 80 column screen mode. Many C128 GEOS
programs implement a "Switch 40/80" submenu option under the geos
menu.
void SetPattern (char pattern)
This function sets the current pattern to the given. There are 32 different patterns in GEOS. You can see them together in the filling box in GeoPaint.
void GraphicsString (const void *myGString)
One of the more powerfull routines of GEOS. This function calls other graphic functions depending on the given command string. See the structures chapter for a more detailed description.
Parameters to those functions are grouped in the struct window drawWindow
. To speed up things and
reduce overhead this structure is bound to zero page locations, where all rectangle functions
expect their parameters. You can modify the data directly (e.g. drawWindow.top=10
) or via the
InitDrawWindow
function. Contents of drawWindow
are guaranteed not to change when only
using graphics functions. In other cases you should keep your data in separate struct window
and use InitDrawWindow
before the first call to one of the rectangle functions.
void InitDrawWindow (struct window *myWindow)
This function only copies the contents of myWindow
into the system area of drawWindow
. Use it
if for some reason you have to keep your window data out of the zero page space.
void Rectangle (void)
This draws on screen a rectangle filled with the current pattern.
void FrameRectangle (char pattern)
This one draws a frame with the given bit pattern (not a pattern from the GEOS palette).
void InvertRectangle (void)
Just as the name says...
void ImprintRectangle (void)
void RecoverRectangle (void)
These two functions are for copying parts of the screen to (Imprint
) and from (Recover
) the
backbuffer of the screen. For example when drawing a new menu box GEOS first uses
ImprintRectangle
to save the area under the box, and restores it by RecoverRectangle
upon
destroying the menu.
The GEOS drawing package is optimized so there are different functions for drawing vertical and horizontal lines.
void HorizontalLine (char pattern, char y, unsigned xStart, unsigned xEnd)
This function draws a horizontal line using the given pattern. Note that pattern
is not a pattern
number as set in SetPattern
but a true bit pattern.
void InvertLine (char y, unsigned xStart, unsigned xEnd)
There is only a horizontal version.
void RecoverLine (char y, unsigned xStart, unsigned xEnd)
This function recovers a single line. It is utilized by RecoverRectangle
. See its description
for more details.
void VerticalLine (char pattern, char yStart, char yEnd, unsigned x)
This function draws a vertical line using the given pattern. Note that pattern
is not a pattern
number as set in SetPattern
but a true bit pattern.
void DrawLine (char mode, struct window *myWindow)
The top
parameters of struct window
describe the starting point of the line, while
bottom
ones are for the ending point. If mode
is DRAW_DRAW
then the current pattern from
SetPattern
is used for drawing. If mode
is DRAW_ERASE
then the line is erased from the
screen. If mode
is DRAW_COPY
then the line is copied from/to back/frontbuffer, according to
the dispBufferOn
setting.
The parameters to these two functions are passed by a pointer to an own struct pixel
filled with
proper values.
void DrawPoint (char mode, struct pixel *myPixel)
Depending on mode
(see DrawLine
) draws/erases/copies a single point
on the screen.
char TestPoint (struct pixel *myPixel)
This function tests if the given pixel is set and returns true
(non-zero) or false
(zero).
void PutChar (char character, char y, unsigned x)
This function outputs a single character using the current style and font to the screen.
void PutString (char *myString, char y, unsigned x)
Same as PutChar
except the fact that you can output a whole NULL
-terminated string.
See ggraph.h
for the list of tokens that you can also place in the string - like CBOLDON
or
COUTLINEON
.
void PutDecimal (char parameter, unsigned value, char y, unsigned x)
This function converts value
to its decimal representation and outputs it to the screen.
The parameter
is the field width in pixels (range 1-31) and the mode bits. Depending on them
the string can be filled with zeroes (the string is always 5 characters long) or not and left or right
justified to the given pixel. See ggraph.h
for predefined values for parameter
.
char GetCharWidth (char character)
This function returns the real width (in pixels) of the given character with the current font. It can be used for counting the length of a string on the screen, allowing for indentation or justification.
void LoadCharSet (struct fontdesc *myFont)
This function forces GEOS to use the given font. myFont
should be casted from a
pointer to the start of the area where a record from a font file (VLIR structure) was loaded.
void UseSystemFont (void)
This function forces GEOS to use the built-in BSW font.
I'm not quite sure how these functions are working (except BitmapUp
) so you should
probably look into the library sources and compare it with your knowledge. Please let me know
if something is wrong or broken.
void BitmapUp (struct iconpic *myPic)
This function unpacks the bitmap and places it on the screen - just as you set it in the
struct iconpic
pointer which you pass. See gstruct.h
for a description of this
structure. Note that you can only use packed GEOS bitmaps - a simple Photo Scrap is in this format.
void BitmapClip (char skipLeft, char skipRight, unsigned skipTop, struct iconpic *myPic)
This function acts similar to BitmapUp
but you can also define which parts of the bitmap are
to be drawn - you give the number of columns (8-pixel) to skip on the right and left of the bitmap,
and the number of rows to skip from the top if it.
void BitOtherClip (void *proc1, void *proc2, char skipLeft, char skip Right, unsigned skipTop,
struct iconpic *myPic)
Similar to the previous one with some extension. proc1
is called before reading a byte (it
returns in .A the next value), and proc2
is called every time the parser reads a byte which is
not a piece of a pattern (byte of code greater than 219). Both procedures should be written
separately in assembler and declared as __fastcall__
returning char.
Here you will find information about functions related with menus and icons.
Menus are essential for a GUI. GEOS can handle only one menu at a time, but each menu can call another one, which results in a submenu tree. There can be up to 8 menu levels, each one with up to 32 items.
Menus are initialized with DoMenu
and then the Kernal takes care of everything. Your code
(called from an event handler) should be a function without parameters, returning void. You should
use DoPreviousMenu
or GotoFirstMenu
at least once in its code to have the screen clean.
void DoMenu (struct menu *myMenu)
This function initializes the GEOS menu processor and exits. See DoMenu structure
for more
information about it. Know that many GEOS applications just initialize the screen, menu and
exit to the main Kernal loop, this proves the power of DoMenu
.
void ReDoMenu (void)
This simply redraws the menu at the lowest level. It works like calling DoMenu
again with
the same parameters.
void RecoverMenu (void)
This function erases the current menu from the screen. It doesn't change the menu level.
void RecoverAllMenus (void)
This calls RecoverMenu
and erases all menus from the screen. Then the menu level is
set to 0 (topmost).
void DoPreviousMenu (void)
This functions causes the menu processor to go back one menu level. You should use it in menu handler code to have the screen clean.
void GotoFirstMenu (void)
This one jumps back to the topmost menu. If there is only a menu and one submenu it works the
same as DoPreviousMenu
.
Icons are working similar to menus except the fact that there is only one level. Icons are
defined as a screen area filled with a bitmap, but if you would setup icons and erase the
screen they would still be active and clicking in the place where formerly an icon was would cause
an effect. Similarly if you would setup icons and then turn them off with ClearMouseMode
the bitmap would still be on the screen but clicking on it would not cause any action.
There is only one, but powerful icon function.
void DoIcons (struct icontab *myIconTab)
This function initializes all icons that are present on the screen at once. For more information
look at the Icons
chapter in this manual.
This chapter covers the most powerful GEOS user interface function - DoDlgBox
.
char DoDlgBox (char *dialogString)
This function returns one byte. It can be the value of one of six standard icons (see gdlgbox.h
)
or whatever the closing routine passes. Register r0L
also contains this value.
Read the structures chapter for the specs of the dialogString
.
char RstrFrmDialogue
This function is called from within DoDlgBox event. It immediately closes the DialogBox and returns the owner ID (or whatever caller has in the .A register).
To simplify the usage of DoDlgBox from C I wrote some helper functions - wrappers for DoDlgBox, with predefined data. In one word - these are standard DialogBoxes you can see in almost every GEOS application.
char DlgBoxYesNo (char *line1, char *line2)
char DlgBoxOkCancel (char *line1, char *line2)
void DlgBoxOk (char *line1, char *line2)
These function show two lines of text in a standard-sized DialogBox. You can read the code of the
pressed icon from the return value. E.g. for DlgBoxYesNo
it can only be YES
or NO
.
You can pass an empty string or NULL to get a blank line.
char DlgBoxGetString (char *string, char strlen, char *line1, char *line2)
This function prompts the user to enter a string of at most strlen
characters. It is returned
in string
. The two given lines of text are shown above the input line. Please remember
that there is also a CANCEL
icon in the DialogBox and you should test if user confirmed his
input or gave up. The string
is also shown so you can place a default input there or remember
to place NULL
at start.
char DlgBoxFileSelect (char *class, char filetype, char *filename)
This routine is the standard file selector. It can return OPEN
, CANCEL
or disk error
on reading the directory or opening the disk.
There is also a DISK
icon shown, but it is handled internally. You pass as input parameters
filetype
and a pointer to a string containing the first part of a file's class. If this string is
empty (NULL
at the start), then all files with given filetype will be shown.
At present this file selector handles only first 16 files of given type and supports only one (current) drive.
char MessageBox (char mode, const char *format, ...)
This function is a more general one. It works very much like printf
in a
box. The only difference is the mode
parameter which allows for placing
default icons (see gdlgbox.h
for list of possible MB_
values).
Any too wide text will be clipped to the size of the default window. If mode
is invalid or equal to MB_EMPTY
then the window will be closed
after a click. Otherwise the user must choose an icon.
Note: Use it if you really need (or if you use it in many places) as it adds quite amount of code to your program.
Note: the formatted text cannot exceed 255 bytes in length, there is no check for that.
You will find here functions related to sprite and mouse drawing and handling.
These cover the mouse - as a general pointing device, but expect users to utilize as different devices as a digital or analog joystick, a mouse, a lightpen or a koalapad (whatever it is).
void StartMouseMode (void)
This function initializes the mouse vectors - mouseVector
and mouseFaultVec
, and then
calls MouseUp
.
void ClearMouseMode (void)
This function disables all mouse activities - icons and menus stop to respond to mouse events, but they are not cleared from the screen.
void MouseUp (void)
void MouseOff (void)
The first function turns the mouse pointer on. It appears on the next IRQ. The second one does the opposite - it turns off the pointer, but its position is still updated by the input driver.
char IsMseInRegion (struct window *myWindow)
This function tests if the mouse pointer is actually in the given range of the screen. See gsprite.h
for
a description of the bits in the return values - they describe the position in detail.
You are free to use any of the eight sprites, but keep in mind that sprite 0 is actually the mouse pointer and sprite 1 can be overwritten when using a text prompt. You don't have to worry about 40/80 column issues because GEOS128 has a pretty good sprite emulator for the VDC.
void DrawSprite (char sprite, char *mySprite)
This function initializes the sprite data. mySprite
is a 63-byte table with bitmap data, which
is copied to the system sprite area (at sprpic
- see gsym.h
). Hardware sprite registers are
not initialized and the sprite is not yet visible.
void PosSprite (char sprite, struct pixel *myPixel)
This function positions the sprite on the screen. The given coordinates are screen ones - they are converted to sprite coordinates by GEOS. Due to this you cannot use this function to position your sprite off the left or top to the screen.
void EnablSprite (char sprite)
void DisablSprite (char sprite)
These two functions are responsible for making the sprite visible or not.
void InitTextPrompt (char height)
This function initializes sprite 1 for a text prompt with given height
. This parameter can be in
range 1-48.
void PromptOn (struct pixel *myPixel)
void PromptOff (void)
The first function places a text prompt in given place and enables blinking. The second one is pretty self-explanatory.
char GetNextChar (void)
This function gets the next character from the keyboard queue. If the queue is empty it returns
NULL
, otherwise you receive the true ASCII code of a character or the value of a special (function)
key. See gsprite.h
for the list of them.
This chapter covers rather low-level disk routines. You should use them with care, because you may easily corrupt data on disks. Also remember that contemporary GEOS supports many various devices and sticking to 1541 track layout (e.g. expecting the directory on track 18) might be dangerous.
For some purposes you might consider using the dio.h
interface to disk access. It is native.
All GEOS disk functions return an error code in the X register. In some cases this is returned by the
GEOSLib function (if its type is char
), but in all cases the last error is saved in the __oserror
location. If it is nonzero - an error occured. See gdisk.h
for the list of possible errorcodes.
You need to include errno.h
to get __oserror
, together with the standard errno
. The
latter gives less verbose, but still usable information and can be used with strerror
.
Probably you will get more information using _stroserror
in a similar way.
For passing parameters use almost always a pointer to your data e.g. ReadBuff (&myTrSe)
.
These functions take a single data sector (256 bytes) to read or write on the disk.
char ReadBuff (struct tr_se *myTrSe)
char WriteBuff (struct tr_se *myTrSe)
These functions read and write a sector placed at diskBlkBuf
.
char GetBlock (struct tr_se *myTrSe, char *buffer)
char ReadBlock (struct tr_se *myTrSe, char *buffer)
These two functions read a single block directly to the 256 byte array placed at buffer
.
The difference between them is that GetBlock
initializes TurboDos in the drive if it was not
enabled. ReadBlock
assumes that it is already enabled thus being slightly faster.
char PutBlock (struct tr_se *myTrSe, char *buffer)
char WriteBlock (struct tr_se *myTrSe, char *buffer)
char VerWriteBlock (struct tr_se *myTrSe, char *buffer)
Similar to previous but needed for writing the disk. VerWriteBlock
verifies the data after
writing. In case of an error five tries are attempted before an error code is returned.
The functions described here operate on curDirHeader
where the current disk header is stored.
On larger (than 1541) capacity drives the second part of the directory header is in dir2Head
.
void GetPtrCurDkNm (char *diskName)
This function fills the given character string with the name of current disk. It is converted to C
standard - the string is terminated with NULL
character instead of code 160 as in Commodore DOS.
Note that the passed pointer must point to an array of at least 17 bytes.
char GetDirHead (void)
char PutDirHead (void)
These functions read and write the directory header. You should use GetDirHead
before
using any functions described below, and you should use PutDirHead
to save the changes on the
disk. Otherwise they will be lost. Operating area is the curDirHead
.
unsigned CalcBlksFree (void)
This function returns the number of free blocks on the current disk. It is counted using data in
curDirHead
so you must initialize the disk before calling it.
char ChkDkGEOS (void)
This functions checks curDirHead
for the GEOS Format identifier. It returns either true or false,
and also sets isGEOS
properly. You must initialize the disk before using this.
char SetGEOSDisk (void)
This function initializes disk for use with GEOS. It sets the indicator in directory header and allocates a sector for the directory of border files. You don't need to initialize the disk before using.
char FindBAMBit (struct tr_se *myTrSe)
This function returns the bit value from the BAM (Block Allocation Map) for the given sector. The bit is set if the sector is free to use. The returned value is always zero if the sector is already allocated. In fact, this function could be used in a following way:
#define BlockInUse FindBAMBit
...
if (!BlockInUse(&myTrSe)) {
... block not allocated ...
}
Anyway, I feel that this function is too low-level.
char BlkAlloc (struct tr_se output[], unsigned length)
char NxtBlkAlloc (struct tr_se *myTrSe, struct tr_se output[], unsigned length)
Both functions allocate enough disk sectors to fit length
bytes in them. You
find the output in output
which is a table of struct tr_se
. The last entry will have the
track equal to 0 and sector equal to 255. The simplest way of using them is to use
predefined space in the GEOS data space and pass fileTrScTab
, which is a predefined table.
The difference between those two is that NextBlkAlloc
starts allocating from the given sector,
and BlkAlloc
starts from the first nonused sector.
You need to use PutDirHead
later to save any changes in BAM.
char FreeBlock (struct tr_se *myTrSe)
Simply deallocates a block in the BAM. You need to update the BAM with PutDirHead
.
struct tr_se SetNextFree (struct tr_se *myTrSe)
This function finds the first free sector starting from given track and sector and allocates it.
It might return the same argument if the given block is not allocated. I wanted it to be type
clean, but this made the usage a bit tricky. To assign a value to your own struct tr_se
you have to
cast both variables to unsigned
. E.g.
struct tr_se myTrSe;
...
(unsigned)myTrSe=(unsigned)SetNextFree(&otherTrSe);
In this example otherTrSe
can be replaced by myTrSe
.
Note: you must use casting to have the correct values.
Functions described here are more usable in Kernal or drivers code, less common in applications, but who knows, maybe someone will need them.
void EnterTurbo (void)
void ExitTurbo (void)
void PurgeTurbo (void)
These functions are the interface to the GEOS TurboDos feature which makes slow Commodore drives a bit
more usable. EnterTurbo
enables TurboDos unless it is already enabled. If not, then you will
have to wait a bit to transfer the TurboDos code into disk drive RAM. ExitTurbo
disables TurboDos.
This is useful for sending some DOS commands to a drive e.g. for formatting. Note that before any
interaction with the Kernal in ROM you have to call InitForIO
. You don't have to worry about speed.
EnterTurbo
will only enable TurboDos (no code transfer) if TurboDos was disabled with
ExitTurbo
. PurgeTurbo
acts differently from ExitTurbo
- it not only disables TurboDos,
but also removes it from drive RAM (not quite true, but it works like that). After using
PurgeTurbo
the next call to EnterTurbo
will reload drive RAM.
char ChangeDiskDevice (char newDevice)
This function changes the device number of the current device (in fact drives only) to the given one. It is
usable for swapping drives. There's no check if the given newDevice
already exist, so if you want
to change the logical number of drive 8 to 9 and you already have a drive number 9 then GEOS will probably
hang on disk access. Use safe, large numbers. Note that the safe IEC range is 8-30.
GEOS has two functions for initialization ('logging in' as they say on CP/M) of a disk.
char OpenDisk (void)
This function initializes everything for a new disk. It loads and enables TurboDos if needed.
Then the disk is initialized with NewDisk
. Next, GetDirHead
initializes curDirHead
.
Disk names are compared and if they differ then the disk cache on REU is cleared. Finally the format is
checked with ChkDkGEOS
and the disk name is updated in the internal tables.
char NewDisk (void)
This function is similar to the DOS command I. It clears the REU cache and enables TurboDos if needed.
This section covers the GEOS file interface.
The functions described here are common for SEQ and VLIR structures.
struct filehandle *Get1stDirEntry (void)
struct filehandle *GetNxtDirEntry (void)
Those two functions are best suited for scanning the whole directory for particular files. Note that
the returned filehandles describe all file slots in the directory -- even those with deleted files.
The return value is NULL
if there are no more slots, or if there was a disk error. The
_oserror
variable is non-zero if it was a disk error (see geos/gdisk.h
). The current
directory track and sector numbers are in r1L
and r1H
. The sector data itself is in
diskBlkBuf
.
char FindFile (char *fName)
This function scans the whole directory for the given filename. It returns either 0 (success), 5
(FILE_NOT_FOUND, defined in geos/gdisk.h
), or any other fatal disk read error. After a successful
FindFile()
, you will have struct filehandle
at dirEntryBuf
filled with the file's data, and
other registers set as described in GetNxtDirEntry()
.
char FindFTypes (char *buffer, char fType, char fMaxNum, char *classTxt)
This function scans the directory and fills a table at buffer
with char [17]
entries.
fType
is the GEOS type of the searched files and classTxt
is a string for the Class field in the file
header. Class matches if the given string is equal or shorter than that found in the file's header block.
If you want just to find all files with the given GEOS type you should pass an empty string or NULL
as
classTxt
. Be warned that for searching NON_GEOS
files you must pass NULL
as classTxt
.
fMaxNum
is the maximal number of files to find, thus the buffer
must provide an area of size
equal to 17 * fMaxNum
. This function returns the number of found files, ranging from 0 to number
passed as fMaxNum
. The return value can be also restored from r7H
.
char DeleteFile (char *fName)
This function deletes a file by its name. It works for SEQ and VLIR files.
char RenameFile (char *oldName, char *newName)
I think it is obvious...
char GetFHdrInfo (struct filehandle *myFile)
This function loads the file header into the fileHeader
buffer. Using after e.g. FindFile
you can pass the address of dirEntryBuf
.
Functions described here are common for SEQ and VLIR structures because the arguments passed are the starting track and sector which may point either to the start of a chain for VLIR or the data for SEQ.
char __fastcall__ GetFile(char flag, const char *fname, const char *loadaddr, const char *datadname, const char *datafname)
This routine loads and runs a given file fname
. The file must be one of following types:
SYSTEM, DESK_ACC, APPLICATION, APPL_DATA, PRINTER,
or INPUT_DEVICE
. The execution
address is taken from the file header. If it is zero, then the file is only loaded. Only the first chain
from VLIR files is loaded. If flag
has bit 0 set then the load address is taken from loadaddr
and not from the file header. In this case APPLICATION
files will be only loaded, not executed.
This does not apply to DESK_ACC
. If either bit 6 or 7 of flag
are set, then 16 bytes from
datadname
are copied to dataDiskName
and 16 bytes from datafname
go to dataFileName
thus becoming parameters for the new application. Pass NULL
for any unused parameter.
char ReadFile (struct tr_se *myTrSe, char *buffer, unsigned fLength)
This function reads at most fLength
bytes into buffer
from chained sectors starting at
myTrSe
.
char ReadByte (void)
This function returns the next byte from a file. Before the first call to it you must load r5
with NULL
, r4
with the sector buffer address and r1
with the track and sector of the
first block of a file.
Remember to not modify r1
, r4
and r5
. These registers must be preserved between
calls to ReadByte
.
The returned value is valid only if there was no error. The end of file is marked as BFR_OVERFLOW
in __oserror
, this is set when trying to read one byte after the end of file, in this case the
returned value is invalid.
char SaveFile (char skip, struct fileheader *myHeader)
SaveFile
will take care of everything needed to create a GEOS file, no matter if VLIR of SEQ
structure. All you need to do is to place the data in the proper place and prepare a header which will
contain all information about a file. The skip
parameter says how many directory pages you
want to skip before searching for a free slot for the directory entry. In most cases you will put
0
there.
You have to declare a struct fileheader
and fill it with proper values. There is only one
difference - the first two bytes which are a link to a nonexistent next sector are replaced by a
pointer to the DOS filename of the file.
When saving sequential files the two most important fields in struct fileheader
are fileheader.load_address
and fileheader.end_address
.
char FreeFile (struct tr_se myTable[])
This function deallocates all sectors contained in the passed table.
char FollowChain(struct tr_se *myTrSe, char *buffer)
This function fills a struct tr_se
table at buffer
with the sector numbers for a chain of
sectors starting with myTrSe
. You can pass such data (buffer
) to e.g. FreeFile
.
Here is information about VLIR files (later called RecordFiles) and functions.
A VLIR structure file consists of up to 127 SEQ-like files called records. Each record is like one
SEQ structure file. Records are grouped together, described by a common name - the VLIR file name and
an own number. Each record pointed to by its number is described by the starting track and sector numbers.
VLIR structures allow records to be empty (tr_se
of such record is equal to {NULL,$ff}
),
or even non-exist ({NULL,NULL}
). Any other numbers represent the starting track and sector of
a particular file.
In GEOS there can be only one file opened at a time. Upon opening a VLIR file some information
about it is copied into memory. You can retrieve the records table at fileTrScTab
(table of
128 struct tr_se
) and from VLIRInfo
(struct VLIR_info
).
E.g. the size of whole VLIR file can be retrieved by reading VLIRInfo.fileSize
.
char OpenRecordFile (char *fName)
This function finds and opens a given file. An error is returned if the file is not found or if it is not
in VLIR format. Information in VLIRInfo
is initialized. VLIR track and sector table is
loaded at fileTrScTab
and will be valid until a call to CloseRecordFile
so don't modify it.
You should call PointRecord
before trying to do something with the file.
char CloseRecordFile (void)
This function calls UpdateRecordFile
and clears internal GEOS variables.
char UpdateRecordFile (void)
This function will check the VLIRInfo.fileWritten
flag and if it is set, then curDirHead
is
updated along with size and date stamps in the directory entry.
char PointRecord (char recordNumber)
This function will setup internal variables (and VLIRInfo.curRecord
) and return the track and
sector of the given record in r1
. Note that the data may not be valid (if the record is non-existing
you will get 0,0 and if it is empty - 255,0).
char NextRecord (void)
char PreviousRecord (void)
These two work like PointRecord
. Names are self-explanatory.
char AppendRecord (void)
This function will append an empty record (pair of 255,0) to the current VLIR track and sector
table. It will also set VLIRInfo.curRecord
to its number.
char DeleteRecord (void)
This function will remove the current record from the table, and move all current+1 records one place
back (in the table). Note that there's no BAM update and you must call UpdateRecordFile
to
commit changes.
char InsertRecord (void)
This function will insert an empty record in place of VLIRInfo.curRecord
and move all following
records in the table one place forward (contents of VLIRInfo.curRecord
after a call to InsertRecord
can be found in VLIRInfo.curRecord + 1
).
char ReadRecord (char *buffer, unsigned fLength)
char WriteRecord (char *buffer, unsigned fLength)
This function will load or save at most fLength
bytes from the currently pointed record into or from
buffer
.
The functions covered in this section are common for the whole C world - copying memory parts and
strings is one of the main computer tasks. GEOS also has an interface to do this. These functions
are replacements for those like memset, memcpy, strcpy
etc. from standard libraries.
If you are dealing with short strings (up to 255 characters) you should use these functions
instead of standard ones, e.g. CopyString
instead of strcpy
. It will work faster.
However some of them have slightly different calling conventions (order of arguments to be specific), so please check their syntax here before a direct replacement.
Please note that the memory areas described here as strings are up to 255 characters (without
counting the terminating NULL
), and regions can cover the whole 64K of memory.
void CopyString (char *dest, char *src)
This function copies the string from src
to dest
, until it reaches NULL
. The NULL
is also copied.
char CmpString (char *s1, char *s2)
This function compares the strings s1
to s2
for equality - this is case sensitive, and both
strings have to have the same length. It returns either true
(non-zero) or false
(zero).
void CopyFString (char length, char *dest, char *src)
char CmpFString (char length, char *s1, char *s2)
These two are similar to CopyString
and CmpString
except the fact, that you provide
the length of the copied or compared strings. The strings can also contain several NULL
characters - they are not treated as delimiters.
unsigned CRC (char *src, unsigned length)
This function calculates the CRC checksum for the given memory range. I don't know if it is compatible with standard CRC routines.
void *FillRam (char *dest, char value, unsigned length)
void *ClearRam (char *dest, unsigned length)
Both functions are filling the given memory range. ClearRam
fills with 0s
, while
FillRam
uses the given value
. Be warned that these functions destroy r0, r1 and
r2L
registers. The functions are aliases for memset
and bzero
, respectively.
void *MoveData (char *dest, char *src, unsigned length)
This functions copies one memory region to another. There are checks for an overlap and the
non-destructive method is chosen. Be warned that this function destroys contents of the
r0, r1 and r2
registers. This function is an alias for memcpy
.
void InitRam (char *table)
This function allows to initialize multiple memory locations with single bytes or strings.
This is done with a table
where everything is defined. See the structures chapter for a description of
InitRam's
command string.
void StashRAM (char bank, unsigned length, char *reuAddress, char *cpuAddress)
void FetchRAM (char bank, unsigned length, char *reuAddress, char *cpuAddress)
void SwapRAM (char bank, unsigned length, char *reuAddress, char *cpuAddress)
char VerifyRAM (char bank, unsigned length, char *reuAddress, char *cpuAddress)
These functions are the interface to a REU - Ram Expansion Unit. I think that they are self-explanatory.
You can check for REU presence by taking the value of ramExpSize
. You have to do it before
using any of these functions.
Weird? Not at all. GEOS has some limited multitasking ability. You can set up a chain of functions called in specified intervals and you can put the main program to sleep without disturbing other tasks and making the user interface unresponsive.
void InitProcesses (char number, struct process *processTab)
This is the main initialization routine. After calling it processes are set up, but not
enabled. The parameters for InitProcesses
are:
number
- number of processesprocessTab
- a table of struct process
, with size equal to number
A single task is described by an entry in processTab
, it contains two values - a pointer
to
the task function and a number of jiffies
which describe the delay between calls to task. On PAL
systems there are 50 jiffies per second, while on NTSC there are 60.
The maximum number of tasks is 20. Be warned that GEOS doesn't check if parameters are valid and
if processTab
would be too large it would overwrite existing data in GEOS space.
There's one important thing - the last entry in processTab
has to be NULL,NULL
, so the
maximum size of processTab
is equal to 21.
See the description of process
structure for a more detailed discussion on this.
void RestartProcess (char processNumber)
void EnableProcess (char processNumber)
These two functions start the task counter. RestartProcess
should be called for each process
after InitProcesses
, because it resets all flags and counters and it starts the counters.
RestartProcess
enables the counters and sets their initial value to that given in processTab
.
EnableProcess
forces the given process to execute by simulating the timer expiring.
void BlockProcess (char processNumber)
void UnblockProcess (char processNumber)
BlockProcess
disables the execution of the given process, but this does not disable the timers.
It means that if you call UnblockProcess
before the timer runs out, the process will be executed.
UnblockProcess
does the opposite.
void FreezeProcess (char processNumber)
void UnfreezeProcess (char processNumber)
FreezeProcess
disables timer for given process. UnfreezeProcess
does the opposite.
This is not equal to RestartProcess
as timers are not reloaded with initial value.
void Sleep (unsigned jiffies)
This function is a multitasking sleep - the program is halted, but it doesn't block other functions
e.g. callbacks from menus and icons.
The only argument here is the number of jiffies to wait until the app will wake up. It depends on the
video mode (PAL or NTSC) how many jiffies there are per second (50 or 60, respectively).
If you don't want to worry about it and need only full second resolution, call the standard
sleep
function from unistd.h
.
void FirstInit (void)
This function initializes some GEOS variables and mouse parameters. This is called on GEOS boot up. You shouldn't use this unless you know what you are doing.
void InitForIO (void)
void DoneWithIO (void)
These functions are called by some disk routines. You should call them only if you want to do something with IO registers or call one of the Kernal ROM routines. Note that this is rather an expensive way of turning off IRQs and enabling IO.
void MainLoop (void)
Returns control to the system. Any code between call to MainLoop
and the end of current
function will never be executed. When in MainLoop
the system waits for your action - using
icons, keyboard or menus to force some specific action from the program. You have to define
proper handlers before that.
void EnterDeskTop (void)
This is an alias for exit(0)
so you will never burn yourself. Anyway, you should not
use it. Always use exit()
instead. Library destructors and functions registered with
atexit()
are called.
void ToBASIC (void)
This one is another way of terminating an application - forcing GEOS to shutdown and exit to BASIC. I was considering whether to include it or not, but maybe someone will need it - which I doubt.
WARNING: library destructors and functions registered with atexit()
will not be called
so it is quite unsafe way to terminate your program.
void Panic (void)
This calls system's Panic
handler - it shows a dialog box with the message
System error at:xxxx
where xxxx
is last known execution address (caller). By default this is bound to the BRK
instruction, but it might be usable in debugging as kind of assert
. (Note that assert
is available as a separate function and will give you more information than that).
The system is halted after a call to Panic
which means that library destructors will not be
called and some data may be lost (no wonder you're panicking).
void CallRoutine (void *myFunct)
This is a system caller routine. You need to provide a pointer to a function and it will be immediately
called, unless the pointer is equal to NULL
. This is the main functionality of this function -
you don't need to check if the pointer is valid.
unsigned GetSerialNumber (void)
This function returns the serial number of the system. It might be used for copy-protection. However, please remember that Free Software is a true power and you are using it right now.
char GetRandom (void)
This function returns a random number. It can be also read from random
e.g.
a=random;
but by calling this function you are sure that the results will be always different.
random
is updated once a frame (50Hz PAL) and on every call to GetRandom
.
Note that this is not the same as the rand
function from the standard library. GetRandom
will give you unpredictable results (if IRQs occur between calls to it) while
rand
conforms to the standard and for a given seed (srand
) always returns with the
same sequence of values.
void SetDevice (char device)
This function sets the current device to the given. It might be used together with InitForIO
,
DoneWithIO
and some Kernal routines. Unless the new device is a disk drive this only sets
new value in curDevice
, in the other case new disk driver is loaded from REU or internal RAM.
char get_ostype (void)
This function returns the GEOS Kernal version combined (by logical OR) with the machine type. Read
gsys.h
for definitions of the returned values.
char get_tv (void)
This function returns the PAL/NTSC flag combined (by logical OR) with the 40/80 columns flag. This is
not the best way to check if the screen has 40 or 80 columns since a PAL/NTSC check is always
performed and it can take as long as a full raster frame. If you just want to know if the
screen has 40 or 80 columns use the expression graphMode & 0x80
which returns 0
for
40 columns and 0x80
for 80 columns. Remember that this value can be changed during
runtime. It is unclear if this will work for GEOS 64 so you probably do not want to test
anything if not running under GEOS128. Use get_ostype
to check it. Read gsys.h
for
definitions of the returned values.
To simplify usage and optimize passing parameters to functions I have declared several structures
which describe the most common objects. Some of these structures are bound to static addresses in
the GEOS data space ($8000-$8fff
), so you can use their fields directly in an optimized way.
Please see gsym.h
to find them. All structures are defined in gstruct.h
and you may
find also some comments there.
A simple structure describing a point on the screen.
This structure describes a font in one pointsize. There is the current font - struct fontdesc
bound to curFontDesc
. You can also force GEOS to use your own fonts by calling
LoadCharSet
. You just need to open a VLIR font file and load one record - one pointsize -
somewhere. At the start of this area you already have all data for fontdesc
so you can
pass a pointer to the load address of that pointsize to LoadCharSet
. (Note that although
it has 'Load' in the name, that function loads only GEOS internal data structures, not data
from disk).
This widely used structure holds the description of a region of the screen. It describes the top-left and bottom-right corners of a window.
Maybe the name isn't the best - it has nothing with DoIcons
but with bitmap functions -
BitmapUp
for example. This structure holds the parameters needed to properly decode and show
a bitmap on the screen. The bitmap has to be encoded - if you have some non-GEOS bitmaps simply
convert them to Photo Scraps - this is the format used by all GEOS bitmap functions - DoIcons
too.
These structures describe click boxes (icons) that can be placed on screen or in a dialog box.
This is the definition of a single click box. Please see gstruct.h
for a description of its fields.
This is the toplevel description of icons to be placed and enabled on the screen. This structure has the following fields:
char number
- total number of icons declared herestruct pixel mousepos
- after finishing DoIcons
the mouse pointer will be placed in
this point allowing you to have a hint for the user what the default action isstruct icondef tab[]
- this table of size equal to icontab.number
contains
descriptions for all iconsThis simple structure holds the track and sector number of something. Do not expect the track to be in range 1-35, as GEOS can support many various and weird devices. For example my C128 256K expansion is utilized as RAMDisk with a layout of 4 tracks of 128 sectors each. However assuming that a track number equal to 0 is illegal might be wise.
This is a placeholder for a file datestamp. This structure is also present in struct filehandle
.
GEOS is not Y2K compliant, so if the current file has in filehandle.date.year
a value less than 86
you can safely assume that it is e.g. 2004 and not 1904.
This is the main file descriptor. It is either an entry in the directory (returned from file functions)
or its copy in dirEntryBuf
. This is optimized so you can safely get to the file's year e.g.
by testing dirEntryBuf.date.year
- it will be compiled to simple LDA, STA
.
This structure holds the fileheader description. You can load a file's header into the fileHeader
fixed area using GetFHdrInfo
. (note that fileHeader
is a place in memory while
fileheader
is a structure).
You will also need your own fileheader for SaveFile
.
This structure is defined only for system_date
. It is slightly different from f_date
so I prepared this one. You can e.g. get or set the current time using system_date.s_hour
and
system_date.s_minute
. Accesses to these will be optimized to simple LDA
and STA
pair.
You should declare a table of that type to prepare data for InitProcesses
. The maximum number
of processes is 20, and the last entry has to be equal to {NULL,NULL}
, so this table may hold
only 21 entries. The first member of this structure (pointer
) holds the pointer to the called
function (void returning void), you will probably have to cast that pointer into unsigned int
.
The second field jiffies
holds the amount of time between calls to that function.
On PAL systems there are 50 jiffies per second, while NTSC have 60 of them.
GEOSLib uses cc65 non-ANSI extensions to easily initialize data in memory. This is done with a kind of array of unspecified length and unspecified type. Here is how it works:
void example = {
(char)3, (unsigned)3, (char)0 };
Which will be compiled to following string of bytes:
_example:
.byte 3
.word 3
.byte 0
As you see this way it is possible to define data of any type in any order. You must remember to
cast each member to proper type.
DoMenu
is responsible for everything concerned with menu processing. Many, many GEOS programs
are just initializing the screen and menu and returning to MainLoop
. In GEOSLib it is the same as
returning from main
function without using exit(0)
.
A menu is described by two types of data - menu descriptors and menu items. A descriptor contains information about the following menu items, and items contain names of entries and either pointers to functions to execute or, in case of nested menus, pointers to submenu descriptors. Note that submenu descriptor can be top-level descriptor, there's no difference in structure, just in the content.
Here is how a single descriptor looks like:
void myMenu = {
(char)top, (char)bottom, // this is the size of the menubox
(unsigned)left, (unsigned)right, // counting all items in the current descriptor
(char)number_of_items | type_of_menu, // number of following items ORed with
// type of this menu, it can be either
// HORIZONTAL or VERTICAL if you will have also bit 6 set then menu won't be closed
// after moving mouse pointer outside the menubox. You can have at most 31 items.
This is followed by number_of_items
of following item description.
...
"menuitemname", (char)item_type, (unsigned)pointer,
"nextitemname", (char)item_type, (unsigned)pointer,
...
"lastitemname", (char)item_type, (unsigned)pointer };
// Note that there isn't ending <tt/NULL/ or something like that.
pointer
is a pointer to something, what it points for depends from item_type
. This one
can have following values:
MENU_ACTION
- a function pointed by pointer
will be called after clicking on the menu item
SUB_MENU
- pointer
points to next menu descriptor - a submenu
Both of them can be ORed with DYN_SUB_MENU
and then the pointer
points to a function
which will return in r0
the needed pointer (to function to execute or a submenu).
For creating nested menus (you can have at most 8 levels of submenus) you need to declare such a structure for each submenu and top level menu.
DoDlgBox
is together with DoMenu
one of the most powerful routines in GEOS. It is
responsible for creating dialog boxes, that is windows which task is to interact with the user.
The format of the command string is following:
(window size and position)
(commands and parameters)
NULL
There is a custom type defined for the command string: dlgBoxStr
.
The first element can be specified in two ways - by using the default size and position or specifying your own. The first case results in
const dlgBoxStr example = {
DB_DEFPOS (pattern_of_shadow),
... // commands
DB_END };
And the own size and position would be:
const dlgBoxStr example = {
DB_SETPOS (pattern, top, bottom, left, right)
... // commands
DB_END };
The next element of the DoDlgBox
command string are the commands themselves. The first six commands are
default icons and the number of the selected icon will be returned from window processor. The icons are
OK, CANCEL, YES, NO, OPEN
, and DISK
. You can use predefined macros for using them, e.g.:
...
DB_ICON(OK, DBI_X_0, DBI_Y_0),
...
Note that the position is counted from top left corner of window, not entire screen and that the 'x'
position is counted in cards (8-pixel) and not in pixels. This is also true for all following commands.
DBI_X_0
and DBI_Y_0
are predefined (see gdlgbox.h
for more), the default positions
which will cause icons to appear on a default window exactly where you would expect them.
DB_TXTSTR (x, y, text)
will cause to show the given text in the window.
DB_VARSTR (x, y, ptr)
works as above, but here you are passing a pointer to a zero page location
where the address of the text is stored. This is useful for information windows where only the text content
is variable. Consider following:
char text = "foo";
...
r15=(unsigned)text; // in code just before call to DoDlgBox
...
DB_VARSTR (TXT_LN_X, TXT_LN_1_Y, &r15),
...
will cause the word ''foo'' to appear in the window, but you may store the pointer to any text in
r15
(in this case) before the call to DoDlgBox.
DB_GETSTR(x, y, ptr, length)
- will add a input-from-keyboard feature. ptr
works as in the
previous example and points to the location where the text is to be stored. Note that the contents of this
location will be shown upon creating the window. length
is the maximum number of characters to input.
DB_SYSOPV(ptr)
- this sets otherPressVec
to the given pointer. It is called on every keypress.
DB_GRPHSTR(ptr)
- the data for this command is a pointer for GraphicsString
commands.
DB_GETFILES(x, y)
- for a standard window you should pass 4 for both x and y. This function
draws a file selection box and searches the current drive for files. Before the call to DoDlgBox
you
must load r7L
with the GEOS filetype of searched files and r10
with the class text. In r5
you have to load a pointer to a char[17]
where the selected filename will be copied. It works
like FindFTypes
but is limited to first 16 files.
DB_OPVEC(ptr)
- this sets a new pointer for the button press function, if you pass
RstrFrmDialogue
here you will cause the window to close after pressing mouse button.
DB_USRICON(x, y, ptr)
- places a single user icon (click box) on the window, ptr
points at a
struct icondef
but fields x
and y
are not used here. You can have at most 8 click
boxes in a window, this is an internal limit of the GEOS Kernal.
DB_USRROUT(ptr)
- this command causes to immediately call the user routine pointed by ptr
.
GraphicsString
is a very powerful routine to initialize the whole screen at once. There are
predefined macros for all commands, names are self-explanatory, see them in ggraph.h
. The last
command has to be GSTR_END
. There is a custom type defined for the command string: graphicStr
.
Here is an example for clearing the screen:
const graphicStr example = {
MOVEPENTO(0,0),
NEWPATTERN(0),
RECTANGLETO(319,199)
GSTR_END };
This type of data is used to initialize one or more bytes in different locations at once. The format is the following:
void example = {
(unsigned)address_to_store_values_at,
(char)number_of_bytes_that_follow,
(char)data,(char)data (...)
// more such definitions
(unsigned)NULL // address of 0 ends the table
};
It is possible to intercept events and hook into the GEOS Kernal using vectors. Here is a little example:
void_func oldVector;
void NewVectorHandler(void) {
// do something and at the end call the old vector routine
oldVector();
}
void hook_into_system(void) {
oldVector = mouseVector;
mouseVector = NewVectorHandler;
}
void remove_hook(void) {
mouseVector = oldVector;
}
In your main
function you should call hook_into_system()
but after all calls to the GEOS
Kernal (like DoMenu
, DoIcons
, etc.) - right before passing control to the MainLoop()
.
Be warned that vectors are most likely to be changed by the GEOS Kernal also via other functions (like
GotoFirstMenu
, DoDlgBox
and its derivatives etc.). It depends on what Kernal functions
you use and which vectors you altered. Unfortunately there is no exact list for GEOS 2.0, a complete
list for GEOS 1.x can be found in A. Boyce's Programmers' Reference Guide mentioned before. Most of the
information contained there should be still valid for GEOS 2.0. When calling a function that restores
the vector you should add a hook_into_system()
call right after it.
It is critical to restore old vector values before exiting the program. If you have more than one
place where you call exit()
then it might be worth to register remove_hook
function to
be called upon exiting with atexit(&remove_hook);
call. This way you will ensure that
such destructor will be always called.
That little example above intercepts mouseVector
. The NewVectorHandler
function will be
called every time the mouse button changes status. Other important vectors you should know about
are:
appMain
- this is called from within the MainLoop
system loopkeyVector
- called whenever a keypress occursintTopVector
- called at the start of the IRQ routineintBotVector
- called at the end of the IRQ routine


Page Links: First Previous 1 2 3 4 Last Index Page
| DozyWannabe 18th Oct 2013, 22:40 permalink Post: 1737 |
Quote:
Quote:
CONCORDE SST : CONCORDE B
Quote:
Quote:
Last edited by DozyWannabe; 18th Oct 2013 at 23:02 . |
||||
| bertpig 10th Dec 2013, 11:44 permalink Post: 1766 |
Superb aircraft, superb thread
I would like to know how susceptible both the clever intakes and the Olympus engines were to damage from bird ingestion, and if it ever happened in flight. I assume the answer might lie in the positioning of the ramps at takeoff and bird inhabited altitudes? Also, a theme throughout the thread has been that the two projects of the era that people wanted to work on were Apollo and Concorde. My question is; were there any companies (and particularly individuals) who were lucky enough to work in some part (large or small) on both of these marvels of engineering? I would also be very interested to hear: i) From the pilots - what the "worst" (both subjectively and objectively if you like) situation or failure was that you trained for in the sim or on a real aircraft. ii) From the engineers - the "Concorde factor" aside, how was she to work on and how did her systems compare in terms of ease of maintenance to regular passenger aircraft of the day? What were the jobs/events most and least looked forward to? iii) Any more about the de-tune facility in some of the pictures posted earlier - was its sole function to hold the bird in place and quieten the engine noise, or did it serve any other purpose (e.g. did it contain any measuring instruments). Disclaimer: Not a pilot/engineer. |
||||
| Slatye 13th Jan 2014, 11:19 permalink Post: 1781 |
Getting somewhat closer to the topic - does anyone know what the Tu-144 used for computing? The NASA report on the Tu-144LL says that they had a digital controls for the engines, but since those were new engines the control system was probably a good deal more modern than the original. I can't see any mention of how the intakes were controlled, or what the original engines used.
And really on-topic, was there any work done towards updating this for Concorde-B? Or did they never get that far? Or was the plan to just keep using exactly the same stuff, since it was already working so well? |
||||
| pattern_is_full 16th Jul 2016, 17:01 permalink Post: 1944 |
According to this, 5500-6000 feet/1700 meters
Heritage Concorde IIRC from one of the previous posts here, the strong differential required also defined the normal descent/deceleration timing and distance. Power could only be reduced to 94% (N1 or N2, I forget which) or there would not be enough "bleed" air available to maintain the cabin altitude at TOD. (although I could have misinterpreted that - it may have had more to do with maintaining the oblique inlet shocks, or hydraulics, or some such.) |


2.
The Complete Blood Count contains 9 blood elements, each element has a differentrange and value [See example below]
and they all have different measurment units. Therefore
normalization is an important step for the visualization.
What is normalization?
3.
Normalization is the process of converting irregular values to more standardized
values by using simple math equations. [See example below] that explains the concept of normalization, each bar has a different
length, weight, and unique characteristics. Imagine fitting these bars in one template, it's not possible without using normalization.
After normalization, they all have the same length and weight with maintaining the characteristics. In our case, to make the test results easier to read, we need to
normalize the values and
the units.
Why is it necessary?
5.
As a result of normalization, all the elements now share the same
normal range, the thickness of the polygon
determines the noraml range for that blood component, any value outside the ring is considered
above normal or
under normal
I'm Ready


The ant nest is in the sand. Pam sits on the sand. Sam spots Pam as she sits on the sand. Sam and Pam sit on the sand. Sam has a packet of crisps and a can of pop. Sam and Pam dip into the packet of crisps and sip from the can of pop. Ants attack Sam's packet of crisps. Pam stamps on the ants and the packet of crisps. Sam sits. Pam stands. No ants, no crisps!
in-context


SpaceScout project is a demo for a flight sim in space.
Very peaceful so far, the objective is to find some lost beacons in an asteroid minefield, with a help of your wingman.
Features a force-shield activated on asteroid impact, some custom physic engine and an efficient TrailRenderer.
The neat skybox was generated using Space-3D project, thanks a lot to wwwTyro.
Toon Shading Demo display customizable spaceships using Toon lightning and outline post-process (Sobel algorithm)


| Aggressive Mode : |
Delay:
seconds ~
seconds
|
| Trap Check : |
Delay:
seconds ~
seconds
|
| Play King Reward Sound : |
|
| Auto Solve King Reward : |
Delay:
seconds ~
seconds
|
| Save King Reward Image : |
|
| Remember Location : |
|
| Best Weapon for
:
|
|
| Best Base for
:
|
|
| Support Me : |
|
| (Changes above this line only take place after user save the preference) |
|
|
| Special Feature : |
|
| Map Hunting : |
|
| Uncaught Mouse : |
|
| Selected Mouse : |
|
| Catch Logic : |
|
| After caught : |
|
| Leave Map After Caught : |
|
|
|
| Event or Location : |
|
| Sub-Location : |
|
| Trap Setup : |
|
| Sub-Location : |
|
| Trap Setup : |
|
| Auto Choose Portal : |
|
| Choose Portal : |
After Chamber Cleaver Caught
|
| Portal Priority
:
|
|
| Portal Priority - Cursed
:
|
|
| Min Time Sand When
: |
Before Enter AC
|
| Min Runic String Cheese : |
Before Enter AC
|
| Enter Minigame with Curse(s) : |
|
| Sub-Location : |
|
| Master Trap Setup : |
|
| Conditional Trap Setup
:
|
|
| Force Activate Quantum : |
If Remaining Loot/Obelisk Charge ≤ :
|
| Force Deactivate Quantum : |
If Remaining Loot/Obelisk Charge ≤ :
|
| Trap Setup for
:
|
|
| Deactivate Tower When HP Full : |
|
| Trap Setup at
:
|
|
| Load Crate : |
When Crate ≥ :
|
| Use Repellent : |
When Repellent ≥ :
|
| Stoke Engine : |
At Fuel Nuggests Batch Size:
|
| Faction to Focus : |
|
| Next Faction to Focus : |
|
| Trap Setup for Rage
:
|
|
| Min Rage to Hunt MBW : |
|
| Trap Setup When
:
|
|
| Trap Setup for
:
|
|
| Side to Focus : |
|
| First Side Trap Setup for
:
|
|
| Second Side Trap Setup for
:
|
|
| Trap Setup For
:
|
|
| Disarm Bait : |
After Amplifier Fully Charged
|
| Auto Fill in
:
|
|
| Auto Pour in
:
|
|
| After Poured in
:
|
|
| After Curse Lifted in
:
|
|
| Trap Setup
Salt Charging :
|
Salt Charge :
|
| Trap Setup When
:
|
|
| Always Turbo Boost : |
|
| Min AA to Fly (≥) : |
|
| Min Firework to Fly (≥) : |
|
| Land after Firework Run Out : |
|
| SC Custom Algorithm : |
|
| Use Smart Jet : |
|
| District to Focus : |
|
| Security Disarm : |
At Last
Hunt(s) in Hallway Near 100 Total Clues
|
| Arm Other Base : |
If Compass Magnet Charm is armed
|
| Disarm Compass Magnet : |
If Dead End Clue ≤ :
|
| Priorities (Focus-District Clues < 15) : |
|
| Priorities (15 < Focus-District Clues < 60) : |
|
| Priorities (Focus-District Clues > 60) : |
|
| Open Non-Focus Door : |
Choosing Type:
|
| Weapon Type in Farming : |
|
| Trap Setup When : |
|
| Wave : |
|
| Trap Setup : |
|
| Trap Setup
Clear Warden :
|
|
| Soldier Type to Focus : |
Priorities:
|
| Streak : |
|
| Last Soldier Type : |
Include Artillery:
|
| Disarm Warpath Charm : |
When Support Retreated
|
| Hunt At : |
Mist Tier
|
| Toggle Canister Every : |
Hunt(s)
|
| Trap Setup : |
|
|
|


Click and drag a photo to an album above. You can also Shift + Click to select and drag multiple photos.
Click on an album to view the photos that you added.
You can also use the slider at the bottom to adjust the size of the image to help fit them on your screen.


Avoid unnecessary temporaries when converting primitives to Strings
This rule is deprecated, use {rule:squid:S1158} instead.


Ant Script Library: asl-repo-ivy.xml
Overview
Sorry, this module hasn't been fully documented yet. Please view the source code to see what properties and targets are used.
Properties
| Name | Default Value | Description |
|---|---|---|
|
|
|
|
|
Targets
repo-report
TBD
-repo-cachepath
TBD
repo-cleancache
TBD
repo-retrieve
TBD
repo-resolve
TBD
-repo-configure-ivy
TBD
Is there a problem or mistake on this page? Do you want to contribute some changes? Send me an email at joe@exubero.com.


--- layout: post title: Jim Weirich on the Rails podcast categories: - sightings author: marcel published: true date: 2006-02-28 06:12:00.000000000 +00:00 ---
Jim Weirich has been using Ruby for ages. He’s one of the early-adopter all-stars from the days before Rails. Rails programmers will be familiar with his wildly popular and influencial Rake and Builder projects. He’s also one of the main developers of RubyGems, which is scheduled to be included with Ruby in an upcoming release.
The enthusiasm he brings to his work and talking about his work make it clear that he has a genuine love for programming. On top of it all, cliches aside, he’s one of the nicest people you’ll ever meet.
So what a treat to have him on the
Ruby on Rails podcast. Have a listen.
Cheers to Geoffrey Grosenbach for snagging yet another great guest.


{% extends 'base.html' %} {% block nav %} Back {% endblock %} {% block content %}
Are you sure you want to delete all blog content of {{ request.user.email }}?


HOME
AIRCREW
New employee
Manage
CITY
Add City
Manage Cities
TRIP
BOOK
MORE
Merchandise
Extras
Media


Single Russian Brides
Looking for serious relationships? Then you are in the right place to start with! EraDating is an international online dating website that has already united thousands of people all over the world. Here you will meet the most beautiful and charming Ukrainian and Russian brides who will capture your attention.
Join the site community right now and you will get all the advantages of online dating that can be fun and playful as well. At EraDating you will be able to reveal your personality and originality, meet a lot of interesting people and make true friends. Browse through hundreds of Russian brides' profiles that are provided with sparkling photos and essays. And you will definitely find your special one who is worthy of your heart!
At the touch of love everyone becomes a poet! Don't waste your time - find your muse!
=$row['name'] ?>
if (strlen($row['body'])>150) { echo stripslashes (substr( $row['body'], 0, 150)).' ...'; } else { echo stripslashes ($row['body']); } ?>
} // while ?>


'3BlackChicks Review...'
 Let one teeny bit of nonsense be shown on screen - like, say, the portrayal of an Honest Politician - and WHOOSH; the air just squirts right outta my Disbelief's Suspension, sending it tumbling...
The Story (WARNING: **spoilers contained below**): The Clinton era is over, yet there's another Democratic White House - with Yet Another Sex Scandal on its hands: this time, involving an ex-Republican of the female persuasion.
The Vice-President Of The United States has died, and President Jackson Evans (Jeff Bridges) searches for a replacement amongst his Democratic party. A candidate, Governor Jack Hathaway (William L. Petersen), is proposed after he heroically tries to rescue a woman whose car crashes into the river in which he's fishing. But the shadow of Ted Kennedy is cast much too wide for Hathaway to escape, and Evans and his Chief Of Staff, Kermit Newman (Sam Elliott), reject Hathaway on the basis of possible misperception and potential innuendo.
Wanting someone who Looks Good above all, Evans - much to the dismay of Newman and fellow staffer Jerry Tolliver (Saul Rubinek) - decides on naming Senator Laine Hanson (Joan Allen) as his new VP. Insisting that the reason for not wanting Hanson in the number two spot has nothing to do with her gender, but that she certainly wouldn't be appointed "just because" she's a woman, young Democratic Senator Reginald Webster (Christian Slater) seeks out Shelly Runyon (Gary Oldman), the Republican chairman running the VP confirmation committee, asking if he could be part of Runyon's committee. Before the conformation hearings begin (using tactics that "even the FBI wouldn't touch"), Runyon and Webster discover that Hanson may have had a Sordid Past: as a college freshman, she was rumored to have been part of a fraternity/sorority gang-bang. Armed with that knowledge, Webster, and especially Runyon, set out to destroy any chance of Hanson ever seeing the White House from the Seat Of Power.
The Upshot: Like NURSE BETTY before it, THE CONTENDER was chock full of good performances leading to a dead-end. Joan Allen, one of the best parts of the movie PLEASANTVILLE, was excellent as the downtrodden, too-good-to-be-true Senator Hanson [which reminds me: if she was already a Senator, why did the scandal not break when she was running for that office? Silly me, asking logical questions again]. Gary Oldman, as the sleazy slimy Shelly Runyon, sent chills down my spine. Once again, he submersed himself fully into a role in which he acts and looks completely different from his previous roles; why his name isn't brought up when his contemporaries like Streep and DeNiro are mentioned, is beyond me. In two strong supporting roles, Christian Slater's naive junior Senator, and especially Sam Elliott as Kermit [Kermit? WTF???] Newman, often Own the scenes they're in. And even though Jeff Bridges' food-obsessed version of the President was too comical for me to get behind, he was Clinton-esque enough to be believable throughout the first 100 or so minutes of this flick.
So why'd THE CONTENDER fail to get the 3BC equivalent of two thumbs up? This movie was like the best passage in dancehall tune: the passage itself may be great, but in the end, the song just repeats one phrase over and over.
The "one-phrase" in "Contender" split itself in two: on the low octave, it's "Republicans Are Bad, Mean/And Ugly Too"; and in the high register, it's "Look At The Honest Politician Done Wrong/And Taking It Up The Wazoo". And both notes, hit repeatedly and fair loudly, were enough to deaden my eardrum. Especially with that "Honest Politician" bit. The light went out on that search a long time ago.
THE CONTENDER was a slow-starter, picked up with a twist near the three-quarters mark, and comes complete with a Big! Speech! reminiscent of Michael Douglas' turn in THE AMERICAN PRESIDENT. In this, it's very much like the political campaign of the GoreBush morph Borg: it looks like it's saying something Real, but it's really just mouthing the words without any real feeling.
The "Black Factor" [ObDisclaimer: We Are Not A Monolith]: Setting aside the fact that, unless I misremember, the only speaking part a Black actor got in THE CONTENDER was that of a White House waiter [and how's that for a rosy outlook of Our role in the Democratic future?], let's focus on The Female Factor and how it comes back to The Black Factor, shall we?
What peaked my curiosity most is that, in some ways, the words "Female" and "Black" could be used interchangeably in this movie; couldn't you just hear those Senators saying "I don't mind that he's Black, but I won't vote for him simply because of that!", or even better, "This is what comes of Affirmative Action!", and meaning the same thing aimed at a White woman or a Black man? And yes, I know that there are actually Black women in relatively high-ranking political positions; but get real: besides that nutcase that the equally nutcased Pat Buchanon has as a running-mate, do you really think that an American presidential candidate is anywhere near ready for a Black woman as the Vice button-pusher?
Terms being somewhat interchangeable or not, though, I doubt that a political movie that did interchange them would ever be made. Unless it was a Black movie. Make that, a Black comedy. Starring the Wayans Brothers as Stepin and Fetchit.
Bammer's Bottom Line: My lack of respect for the whole of American Politicians having informed my Suspension Of Disbelief that it was time to give up the ghost, I just couldn't take this movie at face value. THE CONTENDER was a pretender to the throne. An idealistic pretender, sure; but I defy anyone to find a Senator Laine Hanson hiding out inside any of the corrupted charlatans who are our elected representatives. grumble.
THE CONTENDER (rating: flashing yellowlight): Hey, I think I'm on to something: "The Pretender" is a much better title for a portrayal of an Honest Politician, eh?
Rose "Bams" Cooper /~\ Webchick and Editor, /','\ 3BlackChicks Review /','`'\ Movie Reviews With Flava! /',',','/`, Copyright Rose Cooper, 2000 `~-._'c / EMAIL<EMAIL_ADDRESS>`\ ( http://www.3blackchicks.com/ /====\
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Simulation of Plan Strain, Plot
Deformation can be applied to objects, drawn on the screen (lines, quadrangles, ellipses) or to bitmaps. The bitmap can be loaded from either the clipboard or from a file. The format must be *.bmp.
The deformation can be shearing or flattening. The angle of shear is chosen from the scroll box. Gamma (= tangent of the shear angle) is calculated. Input for falttening strain is in percent of vertical shortening. Shearing can be either affin or non affin . Input for non affin deformation is the factor of encreasing deformation.


This project aims to analyse the sorting algorithm to be specific. Where user have option to write his/her algorithm in any one of the language (C or Java) and completes the program. The template provided by application accepts the input and pass the arr as parameter to the function which is to be completed by user.
The user written code is sent to the server where it is written onto a file and respective compiler is triggered to execute the program about 5 times with different set and number of input and the execution time is logged every time. Then all the data is sent back to client where a String parser parse the response and creates an array of the execution time
Technologies used in developing this project are:
Front End:
	1. HTML
	2. CSS
	3. Javascript
Back End:
	1. PHP
	2. Javascript


Container Class
Contains content and maintains state
Constructor
Container
()
Item Index
Methods
- addEventToStorage
- appendContent!~YUIDOC_LINE~!param value The content to append.
- getContent
- getHeight
- getHeight
- init
- load
- observe
- off
- on
- one
- prepend Content!~YUIDOC_LINE~!param value The content to prepend.
- removeEventFromStorage
- setContent!~YUIDOC_LINE~!param value The content to set.
- setHeight
- setWidth
- trigger
- unobserve
Methods
addEventToStorage
-
event
-
method
Adds an event, or a string of joined events to the eventStore
Parameters:
-
event
StringThe event(s) to add
-
method
StringThe method (ex: 'on', 'one')
appendContent!~YUIDOC_LINE~!param value The content to append.
()
Function
public
Appends content to the Container
Returns:
getContent
()
Array
public
Returns the contents of the Container
Returns:
getHeight
()
Integer
public
Returns the computed width of the Container; result has no units
Returns:
getHeight
()
Integer
public
Returns the computed height of the Container; result has no units
Returns:
init
-
$element
-
settings
Constructor
Parameters:
-
$element
ObjectJQuery object for the element wrapped by the component
-
settings
ObjectConfiguration settings
load
-
$target
-
source
-
method
Loads content and then triggers an update event. Called on load event.
Parameters:
-
$target
ObjectJquery object for the event target
-
source
String | ObjectThe source to load or obtain a URL from, or the selector or node to use for local content
-
method
Stringthe method to be used when inserting content
Returns:
observe
-
$observer
Observe events from $observer
Parameters:
-
$observer
ArrayA jQuery collection to be observed
off
()
public
Unbinds event listeners of a type
on
()
public
Creates an event listener for a type
one
()
public
Creates an event listener for a type, fires exactly once.
prepend Content!~YUIDOC_LINE~!param value The content to prepend.
()
Function
public
Prepend content to the Container
Returns:
removeEventFromStorage
-
event
Removes an event, or a string of joined events from the eventStore
Parameters:
-
event
StringThe event(s) to remove
setContent!~YUIDOC_LINE~!param value The content to set.
()
Object
public
Sets the content of the Container replacing current content
Returns:
setHeight
-
value
Sets the height of the Container.
Parameters:
-
value
IntegerThe height in pixels to set
Returns:
setWidth
-
value
Sets the width of the Container
Parameters:
-
value
IntegerThe width in pixels to set
Returns:
trigger
()
public
Fires a custom event
unobserve
-
$observer
Unobserve events from $observer
Parameters:
-
$observer
ArrayA jQuery collection to be unobserved
Properties
autoHeight
Boolean
When true the $element's height is set to the content height.
Default: false
autoWidth
Boolean
When true the $element's width is set to the content width.
Default: false
cache
Object
public
A cache to store the height and width of the $element
Container
Object
private
Instance of Container
content
String
A CSS selctor for an element to be used as a content source.
Default: null
content
String
private
The content of the container
defaults
Object
private
final
Default configuration values
frame
Boolean
Set to true if the content should be loaded in an iframe
Default: false
notify
String
A selector that matches nodes to notify of events
observe
String
A selector that matches nodes to observe
states
String | Array
The default state or states to be applied to the Container. This can be an Array of strings or comma-delimited string representing multiple states. It can also be a string representing a single state
Default: null
target
Object
public
A jquery object to inject content into
target
String
A selector that specifies a target within the Container to inject content.
Default: null
url
String
A URL to be used as a content source.
Default: null


make your website beautyful by using ui-lib
Copyright 2019, ui-lib. All Rights Reserved.
Design By Anjan Ray


Try out our Premium Member services: Virtual Legal Assistant, Query Alert Service and an ad-free experience. Free for one month and pay only if you like it.
IN THE HIGH COURT OF JUDICATURE AT MADRAS Dated:09.08.2017 Coram THE HONOURABLE Mr. JUSTICE M.VENUGOPAL AND THE HONOURABLE Mr. JUSTICE P.D.AUDIKESAVALU W.P.No.24593 of 2003 and WPMP Nos.30265 and 30266 of 2003 M/s Kathiresan Blue Metals, rep. By its Proprietor Mr.M.Kathiresan, Yogampal Illam, New Colony, Singampuneri, Sivagangai District .. Petitioner Vs. 1. The Tamilnadu Pollution Control Board, Rep. By the District Environmental Engineer, Survey No.Part 668 and 669, SIDCO Industrial Estate, Kappalur, Madurai 8 2. Rama Natarajan (R2 impleaded as per order dated 21.08.2006 by PSJ & SMKJ in WPMP No.30016 of 2015 in W.P.No.24593 of 2003) ..Respondents Prayer: Writ Petition filed under Article 226 of the Constitution of India praying for issuance of Writ of Certiorarified Mandamus by calling for the records 1st Respondent's proceedings bearing Letter No.DEE/TNPCB/MDU/SVG/2002 dated 19.09.2002 pertaining to the Petitioner's stone crushing unit situated at Sukkampatty Road, South Singampuneri, Thirupatthur Taluk, Sivagangai District quash the same and direct the 1st Respondent to issue consent under Water (Prevention and control of Pollution) Act, 1974 and under the AIR (Prevention and Control of Pollution) Act, 1981 by reconsidering the Petitioner's application dated 09.04.2001. For Petitioner : Mr.K.Ramakrishna Reddy For Respondents : No appearance. O R D E R
[Order of the Court was made by M.VENUGOPAL, J.] The Learned Counsel for the Petitioner has made an endorsement in W.P.No.24593 of 2003 to the following effect: This Writ Petition has become infructuous in view of the subsequent amendment of Rules. However, may be dismissed as infructuous. Recording the aforesaid fact and the endorsement so made, this Writ Petition is disposed of as infructuous one. Consequently, connected miscellaneous petitions are closed. No costs.
(M.V., J.) (P.D.A., J.) 09.08.2017 Index :Yes / No Internet :Yes / No ssd M.VENUGOPAL, J.
and P.D.AUDIKESAVALU, J.
ssd To
1. The Tamilnadu Pollution Control Board, Rep. By the District Environmental Engineer, Survey No.Part 668 and 669, SIDCO Industrial Estate, Kappalur, Madurai 8
2. Rama Natarajan W.P.No.24593 of 2003 and WPMP Nos.30265 and 30266 of 2003 09.08.2017


|
Brooklyn | |||||||
| PREV NEXT | FRAMES NO FRAMES |
| Class Summary | |
|---|---|
| ApidocEndpoint | |
| ApidocHelpMessageBodyWriter | subclassed for convenience |
| ApidocResource | like Swagger ApiListing (and based on that) but: supports singletons as well as classes; supports simpler Apidoc annotation (doesn't repeat path, in common case); doesn't support listingPath/Class that swagger does (but describes in under /apidoc/name.of.Class does not support auth filters |
| Annotation Type Summary | |
|---|---|
| Apidoc | like Swagger Api annotation (and treated similarly) but doesn't require path to be repeated, and supports a name |
Brooklyn Multi-Cloud Application Management Platform
brooklyncentral.github.com. Apache License. © 2012.


|
blowbox
|
Base class for every element that should be rendered. More...
#include <d3d11_render_element.h>
Public Member Functions | |
| D3D11RenderElement () | |
| Default D3D11RenderElement constructor. | |
| D3D11RenderElement (lua_State *L) | |
| D3D11RenderElement lua constructor. More... | |
| virtual | ~D3D11RenderElement () |
| Default D3D11RenderElement destructor. | |
| const XMVECTOR & | GetPosition () const |
| const float & | GetX () const |
| const float & | GetY () const |
| const float & | GetZ () const |
| const XMVECTOR & | GetRotation () const |
| const XMVECTOR & | GetScale () const |
| const XMVECTOR & | GetOffset () const |
| const double & | GetAlpha () const |
| D3D11Texture * | GetTexture () |
| D3D11Shader * | GetShader () |
| D3D11VertexBuffer * | GetVertexBuffer () |
| const RENDER_ELEMENT_TYPE & | GetType () |
| Gets this element's type. | |
| void | SetPosition (float x, float y, float z) |
| Sets the position of the element. More... | |
| void | SetPosition (double x, double y, double z) |
| Sets the position of the element. More... | |
| void | SetX (float x) |
| Sets the x position of the element. More... | |
| void | SetX (double x) |
| Sets the x position of the element. More... | |
| void | SetY (float y) |
| Sets the x position of the element. More... | |
| void | SetY (double y) |
| Sets the x position of the element. More... | |
| void | SetZ (float z) |
| Sets the x position of the element. More... | |
| void | SetZ (double z) |
| Sets the x position of the element. More... | |
| void | SetRotation (float x, float y, float z) |
| Sets the rotation of the element. More... | |
| void | SetRotation (double x, double y, double z) |
| Sets the rotation of the element. More... | |
| void | SetScale (float x, float y, float z) |
| Sets the scaling of the element. More... | |
| void | SetScale (double x, double y, double z) |
| Sets the scaling of the element. More... | |
| void | SetOffset (float x, float y, float z) |
| Sets the offset of the element. More... | |
| void | SetOffset (double x, double y, double z) |
| Sets the offset of the element. More... | |
| void | SetAlpha (double alpha) |
| Set the alpha of the element. More... | |
| void | SetAlpha (float alpha) |
| Set the alpha of the element. More... | |
| void | SetTexture (std::string path) |
| Set the texture of the element. More... | |
| void | SetShader (std::string path) |
| Set the shader of the element. More... | |
| void | CalculatePosition () |
| Parses the private XMFLOAT3 position_ struct to an XMVECTOR. | |
| void | CalculateRotation () |
| Parses the private XMFLOAT3 rotation_ struct to an XMVECTOR. | |
| void | CalculateScaling () |
| Parses the private XMFLOAT3 scaling_ struct to an XMVECTOR. | |
| void | CalculateOffset () |
| Parses the private XMFLOAT3 offset_ struct to an XMVECTOR. | |
| XMMATRIX & | GetWorld () |
| Retrieves the world matrix. | |
| const TEXTURE_FILTERING_TYPE & | GetFilteringType () const |
| Retrieves the sampler type. | |
| D3D11RasterizerState * | GetRasterizerState () |
| Retrieves the D3D11RasterizerState of this object. | |
| D3D11BlendState * | GetBlendState () |
| Retrieves the D3D11BlendState of this object. | |
| Public Member Functions inherited from blowbox::LuaClass | |
| LuaClass () | |
| Default LuaClass constructor. | |
| LuaClass (lua_State *L) | |
| LuaClass' lua constructor. | |
| ~LuaClass () | |
| Default LuaClass destructor. | |
Static Public Member Functions | |
| static int | LuaSetPosition (lua_State *L) |
| Sets the position of this object. More... | |
| static int | LuaGetPosition (lua_State *L) |
| Gets the position of this object. More... | |
| static int | LuaSetPosition2D (lua_State *L) |
| Sets the position of this object in 2D space. More... | |
| static int | LuaGetPosition2D (lua_State *L) |
| Gets the position of this object in 2D space. More... | |
| static int | LuaSetX (lua_State *L) |
| Sets the x position of this object. More... | |
| static int | LuaGetX (lua_State *L) |
| Gets the x position of this object. More... | |
| static int | LuaSetY (lua_State *L) |
| Sets the y position of this object. More... | |
| static int | LuaGetY (lua_State *L) |
| Gets the y position of this object. More... | |
| static int | LuaSetZ (lua_State *L) |
| Sets the z position of this object. More... | |
| static int | LuaGetZ (lua_State *L) |
| Gets the z position of this object. More... | |
| static int | LuaSetRotation (lua_State *L) |
| Sets the rotation of this object. More... | |
| static int | LuaGetRotation (lua_State *L) |
| Gets the rotation of this object. More... | |
| static int | LuaSetRotation2D (lua_State *L) |
| Sets the rotation of this object in 2D space. More... | |
| static int | LuaGetRotation2D (lua_State *L) |
| Gets the rotation of this object in 2D space. More... | |
| static int | LuaSetScale (lua_State *L) |
| Sets the scale of this object. More... | |
| static int | LuaGetScale (lua_State *L) |
| Gets the scale of this object. More... | |
| static int | LuaSetScale2D (lua_State *L) |
| Sets the scale of this object in 2D space. More... | |
| static int | LuaGetScale2D (lua_State *L) |
| Gets the scale of this object in 2D space. More... | |
| static int | LuaSetOffset (lua_State *L) |
| Sets the offset of this object. More... | |
| static int | LuaGetOffset (lua_State *L) |
| Gets the offset of this object. More... | |
| static int | LuaSetOffset2D (lua_State *L) |
| Sets the offset of this object in 2D space. More... | |
| static int | LuaGetOffset2D (lua_State *L) |
| Gets the offset of this object in 2D space. More... | |
| static int | LuaSetAlpha (lua_State *L) |
| Sets the alpha of this object. More... | |
| static int | LuaGetAlpha (lua_State *L) |
| Gets the alpha of this object. More... | |
| static int | LuaSetTexture (lua_State *L) |
| Sets the texture of this object. More... | |
| static int | LuaGetTexture (lua_State *L) |
| Gets the texture of this object. More... | |
| static int | LuaSetShader (lua_State *L) |
| Sets the texture of this object. More... | |
| static int | LuaGetShader (lua_State *L) |
| Gets the texture of this object. More... | |
| static int | LuaSetFiltering (lua_State *L) |
| Sets the filtering of this object. More... | |
| static int | LuaGetFiltering (lua_State *L) |
| Gets the filtering of this object. More... | |
| static int | LuaSetBlend (lua_State *L) |
| Sets the blend of this object. More... | |
| static int | LuaGetBlend (lua_State *L) |
| Gets the blend of this object. More... | |
| Static Public Member Functions inherited from blowbox::LuaClass | |
| template<typename T > | |
| static int | LuaConstructor (lua_State *L) |
| The LuaConstructor used by any userdata which is "new"-able. More... | |
| template<typename T > | |
| static int | LuaDestructor (lua_State *L) |
| The LuaDestructor used by any userdata which is "new"-able and also needs to be garbage collected. More... | |
| template<typename T > | |
| static int | LuaToString (lua_State *L) |
| The LuaToString function that is set in the metatables of generated objects. More... | |
| template<typename T > | |
| static int | LuaIndex (lua_State *L) |
| The LuaIndex metamethod. More... | |
| static void | LuaRegisterFunctions (lua_State *L) |
| Registers functions of this class. More... | |
Protected Attributes | |
| XMFLOAT3 | position_ |
| XMVECTOR | v_position_ |
| XMFLOAT3 | rotation_ |
| XMVECTOR | v_rotation_ |
| XMFLOAT3 | scaling_ |
| XMVECTOR | v_scaling_ |
| XMFLOAT3 | offset_ |
| XMVECTOR | v_offset_ |
| XMMATRIX | world_matrix_ |
| double | alpha_ |
| D3D11Texture * | texture_ |
| D3D11Shader * | shader_ |
| SharedPtr< D3D11VertexBuffer > | vertex_buffer_ |
| SharedPtr< D3D11RasterizerState > | rasterizer_state_ |
| SharedPtr< D3D11BlendState > | blend_state_ |
| TEXTURE_FILTERING_TYPE | texture_filtering_ |
| RENDER_ELEMENT_TYPE | type_ |
| D3D11RenderQueue * | render_queue_ |
Base class for every element that should be rendered.
| blowbox::D3D11RenderElement::D3D11RenderElement | ( | lua_State * | L | ) |
D3D11RenderElement lua constructor.
| [in] | L | (lua_State* L) |
| const double & blowbox::D3D11RenderElement::GetAlpha | ( | ) | const |
| const XMVECTOR & blowbox::D3D11RenderElement::GetOffset | ( | ) | const |
| const XMVECTOR & blowbox::D3D11RenderElement::GetPosition | ( | ) | const |
| const XMVECTOR & blowbox::D3D11RenderElement::GetRotation | ( | ) | const |
| const XMVECTOR & blowbox::D3D11RenderElement::GetScale | ( | ) | const |
| D3D11Shader * blowbox::D3D11RenderElement::GetShader | ( | ) |
| D3D11Texture * blowbox::D3D11RenderElement::GetTexture | ( | ) |
| D3D11VertexBuffer * blowbox::D3D11RenderElement::GetVertexBuffer | ( | ) |
| const float & blowbox::D3D11RenderElement::GetX | ( | ) | const |
| const float & blowbox::D3D11RenderElement::GetY | ( | ) | const |
| const float & blowbox::D3D11RenderElement::GetZ | ( | ) | const |
|
static |
Gets the alpha of this object.
| [in] | L | (lua_State* L) |
|
static |
Gets the blend of this object.
| [in] | L | (lua_State* L) |
|
static |
Gets the filtering of this object.
| [in] | L | (lua_State* L) |
|
static |
Gets the offset of this object.
| [in] | L | (lua_State* L) |
|
static |
Gets the offset of this object in 2D space.
| [in] | L | (lua_State* L) |
|
static |
Gets the position of this object.
| [in] | L | (lua_State* L) |
|
static |
Gets the position of this object in 2D space.
| [in] | L | (lua_State* L) |
|
static |
Gets the rotation of this object.
| [in] | L | (lua_State* L) |
|
static |
Gets the rotation of this object in 2D space.
| [in] | L | (lua_State* L) |
|
static |
Gets the scale of this object.
| [in] | L | (lua_State* L) |
|
static |
Gets the scale of this object in 2D space.
| [in] | L | (lua_State* L) |
|
static |
Gets the texture of this object.
| [in] | L | (lua_State* L) |
|
static |
Gets the texture of this object.
| [in] | L | (lua_State* L) |
|
static |
Gets the x position of this object.
| [in] | L | (lua_State* L) |
|
static |
Gets the y position of this object.
| [in] | L | (lua_State* L) |
|
static |
Gets the z position of this object.
| [in] | L | (lua_State* L) |
|
static |
Sets the alpha of this object.
| [in] | L | (lua_State* L) |
|
static |
Sets the blend of this object.
| [in] | L | (lua_State* L) |
|
static |
Sets the filtering of this object.
| [in] | L | (lua_State* L) |
|
static |
Sets the offset of this object.
| [in] | L | (lua_State* L) |
|
static |
Sets the offset of this object in 2D space.
| [in] | L | (lua_State* L) |
|
static |
Sets the position of this object.
| [in] | L | (lua_State* L) |
|
static |
Sets the position of this object in 2D space.
| [in] | L | (lua_State* L) |
|
static |
Sets the rotation of this object.
| [in] | L | (lua_State* L) |
|
static |
Sets the rotation of this object in 2D space.
| [in] | L | (lua_State* L) |
|
static |
Sets the scale of this object.
| [in] | L | (lua_State* L) |
|
static |
Sets the scale of this object in 2D space.
| [in] | L | (lua_State* L) |
|
static |
Sets the texture of this object.
| [in] | L | (lua_State* L) |
|
static |
Sets the texture of this object.
| [in] | L | (lua_State* L) |
|
static |
Sets the x position of this object.
| [in] | L | (lua_State* L) |
|
static |
Sets the y position of this object.
| [in] | L | (lua_State* L) |
|
static |
Sets the z position of this object.
| [in] | L | (lua_State* L) |
| void blowbox::D3D11RenderElement::SetAlpha | ( | double | alpha | ) |
Set the alpha of the element.
| [in] | alpha | (double) the alpha |
| void blowbox::D3D11RenderElement::SetAlpha | ( | float | alpha | ) |
Set the alpha of the element.
| [in] | alpha | (float) the alpha |
| void blowbox::D3D11RenderElement::SetOffset | ( | float | x, |
| float | y, | ||
| float | z | ||
| ) |
Sets the offset of the element.
| [in] | x | (float) The x offset of the element |
| [in] | y | (float) The y offset of the element |
| [in] | z | (float) The z offset of the element |
| void blowbox::D3D11RenderElement::SetOffset | ( | double | x, |
| double | y, | ||
| double | z | ||
| ) |
Sets the offset of the element.
| [in] | x | (double) The x offset of the element |
| [in] | y | (double) The y offset of the element |
| [in] | z | (double) The z offset of the element |
| void blowbox::D3D11RenderElement::SetPosition | ( | float | x, |
| float | y, | ||
| float | z | ||
| ) |
Sets the position of the element.
| [in] | x | (float) The x position |
| [in] | y | (float) The y position |
| [in] | z | (float) The z position |
| void blowbox::D3D11RenderElement::SetPosition | ( | double | x, |
| double | y, | ||
| double | z | ||
| ) |
Sets the position of the element.
| [in] | x | (double) The x position |
| [in] | y | (double) The y position |
| [in] | z | (double) The z position |
| void blowbox::D3D11RenderElement::SetRotation | ( | float | x, |
| float | y, | ||
| float | z | ||
| ) |
Sets the rotation of the element.
| [in] | x | (float) The x rotation of the element |
| [in] | y | (float) The y rotation of the element |
| [in] | z | (float) The z rotation of the element |
| void blowbox::D3D11RenderElement::SetRotation | ( | double | x, |
| double | y, | ||
| double | z | ||
| ) |
Sets the rotation of the element.
| [in] | x | (double) The x rotation of the element |
| [in] | y | (double) The y rotation of the element |
| [in] | z | (double) The z rotation of the element |
| void blowbox::D3D11RenderElement::SetScale | ( | float | x, |
| float | y, | ||
| float | z | ||
| ) |
Sets the scaling of the element.
| [in] | x | (float) The x scaling of the element |
| [in] | y | (float) The y scaling of the element |
| [in] | z | (float) The z scaling of the element |
| void blowbox::D3D11RenderElement::SetScale | ( | double | x, |
| double | y, | ||
| double | z | ||
| ) |
Sets the scaling of the element.
| [in] | x | (double) The x scaling of the element |
| [in] | y | (double) The y scaling of the element |
| [in] | z | (double) The z scaling of the element |
| void blowbox::D3D11RenderElement::SetShader | ( | std::string | path | ) |
Set the shader of the element.
| [in] | path | (std::string) The path to the shader |
| void blowbox::D3D11RenderElement::SetTexture | ( | std::string | path | ) |
Set the texture of the element.
| [in] | path | (std::string) The path to the texture |
| void blowbox::D3D11RenderElement::SetX | ( | float | x | ) |
Sets the x position of the element.
| [in] | x | (float) The x position |
| void blowbox::D3D11RenderElement::SetX | ( | double | x | ) |
Sets the x position of the element.
| [in] | x | (double) The x position |
| void blowbox::D3D11RenderElement::SetY | ( | float | y | ) |
Sets the x position of the element.
| [in] | y | (float) The y position |
| void blowbox::D3D11RenderElement::SetY | ( | double | y | ) |
Sets the x position of the element.
| [in] | y | (double) The y position |
| void blowbox::D3D11RenderElement::SetZ | ( | float | z | ) |
Sets the x position of the element.
| [in] | z | (float) The z position |
| void blowbox::D3D11RenderElement::SetZ | ( | double | z | ) |
Sets the x position of the element.
| [in] | z | (double) The z position |