/*
* system.h
*
* Turbo Vision - Version 2.0
*
* Copyright (c) 1994 by Borland International
* All Rights Reserved.
*
* Modified by Sergio Sigala <sergio@sigala.it>
*/
#if !defined( __EVENT_CODES )
#define __EVENT_CODES
/** \file system.h
* system.h
*/
/* Event codes */
/** \var evMouseDown
* Mouse button pressed.
* @see TEvent::what
*/
const int evMouseDown = 0x0001;
/** \var evMouseUp
* Mouse button released.
* @see TEvent::what
*/
const int evMouseUp = 0x0002;
/** \var evMouseMove
* Mouse changed location.
* @see TEvent::what
*/
const int evMouseMove = 0x0004;
/** \var evMouseAuto
* Periodic event while mouse button held down.
* @see TEvent::what
*/
const int evMouseAuto = 0x0008;
/** \var evKeyDown
* Key pressed.
* @see TEvent::what
*/
const int evKeyDown = 0x0010;
/** \var evCommand
* Command event.
* @see TEvent::what
*/
const int evCommand = 0x0100;
/** \var evBroadcast
* Broadcast event.
* @see TEvent::what
*/
const int evBroadcast = 0x0200;
/* Event masks */
/** \var evNothing
* Event already handled.
* @see TEvent::what
*/
const int evNothing = 0x0000;
/** \var evMouse
* Mouse event.
* @see TEvent::what
*/
const int evMouse = 0x000f;
/** \var evKeyboard
* Keyboard event.
* @see TEvent::what
*/
const int evKeyboard = 0x0010;
/** \var evMessage
* Message (command, broadcast, or user-defined) event.
* @see TEvent::what
*/
const int evMessage = 0xFF00;
/* Mouse button state masks */
const int mbLeftButton = 0x01;
const int mbRightButton = 0x02;
/* Mouse event flags */
const int meMouseMoved = 0x01;
const int meDoubleClick = 0x02;
#endif // __EVENT_CODES
#if defined( Uses_TEvent ) && !defined( __TEvent )
#define __TEvent
/**
* Stores mouse events.
*
* This structure holds the data that characterizes a mouse event: button
* number, whether double-clicked, and the coordinates of the point where the
* click was detected.
* @see TEvent
* @see TEventQueue
* @short Information about mouse events
*/
struct MouseEventType
{
/**
* This is the position where the event happened.
*/
TPoint where;
/**
* Helps to specify the event.
*
* This bitmap variable is set to meDoubleClick if a double-click event
* happened. If the mouse is simply moved its value is meMouseMoved.
* Otherwise its value is 0.
*
* <pre>
* Flag Value Meaning
*
* meMouseMoved 0x01 Set if mouse is moved
* meDoubleClick 0x02 Set if a button was double clicked
* </pre>
*/
ulong eventFlags; // Replacement for doubleClick.
/**
* This bitmap variable stores the status of the control keys when the
* event happened. The following values define keyboard states, and can be
* used when examining the keyboard shift state:
*
* <pre>
* Flag Value Meaning
*
* kbRightShift 0x0001 Set if the Right Shift key is currently down
* kbLeftShift 0x0002 Set if the Left Shift key is currently down
* kbCtrlShift 0x0004 Set if the Ctrl key is currently down
* kbAltShift 0x0008 Set if the Alt key is currently down
* kbScrollState 0x0010 Set if the keyboard is in the Scroll Lock state
* kbNumState 0x0020 Set if the keyboard is in the Num Lock state
* kbCapsState 0x0040 Set if the keyboard is in the Caps Lock state
* kbInsState 0x0080 Set if the keyboard is in the Ins Lock state
* </pre>
*
* Its value is 0 if none of these keys was pressed. Warning: this
* information is not reliable. Its value depends on your operating system
* and libraries (gpm, ncurses). Usually only a subset of these flags are
* detected. See file `system.cc' for details.
*/
ulong controlKeyState;
/**
* This variable reports the status of the mouse buttons when the event
* happened. It's a combination of the following constants:
*
* <pre>
* Flag Value Meaning
*
* mbLeftButton 0x01 Set if left button was pressed
* mbRightButton 0x02 Set if right button was pressed
* </pre>
*
* These constants are useful when examining the buttons data member. For
* example:
*
* <pre>
* if ((event.what == @ref evMouseDown) && (event.buttons == mbLeftButton))
* doLeftButtonDownAction();
* </pre>
*
* Note: you can swap left and right buttons by setting variable
* @ref TEventQueue::mouseReverse to True. See the `demo' program for more
* information.
*/
uchar buttons;
};
#include <tvision/myendian.h>
/**
* This structure stores information about a key.
* @see KeyDownEvent
* @see TEvent
* @short Information about a key
*/
struct CharScanType
{
#if (BYTE_ORDER == LITTLE_ENDIAN)
/**
* This is the character code.
*
* Its value is non-zero if the key has a standard code, like ASCII
* characters. The value is zero if the key falls in the special key
* class, like arrows, page up, etc.
*/
uchar charCode;
/**
* This is the scan code.
*
* Its value is non-zero if the key falls in the special key class. The
* value is zero if the key is an ASCII character.
*/
uchar scanCode;
#elif (BYTE_ORDER == BIG_ENDIAN)
/**
* @internal
*/
uchar scanCode;
/**
* @internal
*/
uchar charCode;
#else
#error architecture not supported by this library
#endif
};
/**
* This structure stores information about key presses.
*
* The KeyDownEvent structure is a union of keyCode (a ushort) and charScan
* (of type struct @ref CharScanType). These two members represent two ways of
* viewing the same data: either as a scan code or as a key code.
*
* Scan codes are what your program receives from the keyboard, while key
* codes are usually needed in a switch statement.
*
* See file `tkeys.h' for a list of keycodes.
* @see TEvent
* @short Information about key presses
*/
struct KeyDownEvent
{
union //____keyUnion
{
/**
* This is the key code.
*
* It is the concatenation of the scan code and the character code.
* @see CharScanType
*/
ushort keyCode;
/**
* The same as above, but splitted in its two components.
* @see CharScanType
*/
CharScanType charScan;
};
/**
* Stores the status of the control keys when the event happened. The
* following values define keyboard states, and can be used when
* examining the keyboard shift state:
*
* <pre>
* Constant Value Meaning
*
* kbRightShift 0x0001 Set if the Right Shift key is currently down
* kbLeftShift 0x0002 Set if the Left Shift key is currently down
* kbCtrlShift 0x0004 Set if the Ctrl key is currently down
* kbAltShift 0x0008 Set if the Alt key is currently down
* kbScrollState 0x0010 Set if the keyboard is in the Scroll Lock state
* kbNumState 0x0020 Set if the keyboard is in the Num Lock state
* kbCapsState 0x0040 Set if the keyboard is in the Caps Lock state
* kbInsState 0x0080 Set if the keyboard is in the Ins Lock state
* </pre>
*
* Its value is 0 if none of these keys was pressed. Warning: this
* information is not reliable. Its value depends on your operating system
* and libraries (gpm, ncurses). Usually only a subset of these flags are
* detected. See file `system.cc' for details.
*/
ulong controlKeyState;
};
/**
* This structure stores information about message events.
*
* A message event is a command, specified by the command field, together with
* one of several additional pieces of information, ranging from a single byte
* of data to a generic pointer.
*
* This arrangement allows for great flexibility when TVision objects need to
* transmit and receive messages to and from other TVision objects.
* @see TEvent
* @short Information about message events
*/
struct MessageEvent
{
/**
* Is the code of the command.
*
* See `views.h' for a list of standard commands. Other commands are
* defined in `colorsel.h', `dialogs.h', `editors.h', `outline.h' and
* `stddlg.h'.
*/
ushort command;
union //____pointerUnion
{
/**
* A generic pointer.
*
* I suggest you to pay attention to these fields. Use always the same
* type in the sender and in the receivers of the message. Otherwise
* you may experiment portability problems.
*/
void *infoPtr;
/**
* A signed long.
*/
long infoLong;
/**
* An unsigned short.
*/
ushort infoWord;
/**
* A signed short.
*/
short infoInt;
/**
* An unsigned byte.
*/
uchar infoByte;
/**
* A signed character.
*/
char infoChar;
};
};
/**
* TEvent holds a union of objects of type:
*
* @ref KeyDownEvent
* @ref MessageEvent
* @ref MouseEventType
*
* keyed by the what field. The @ref TView::handleEvent() member functions and
* its derived classes take a TEvent object as argument and respond with the
* appropriate action.
* @short Information about events
*/
struct TEvent
{
/**
* This field reports the event's type. Some mnemonics are defined to
* indicate types of events to TVision event handlers. The following
* evXXXX constants are used in several places: in the what data member
* of an TEvent structure, in the @ref TView::eventMask data member of a
* view object, and in the @ref positionalEvents and @ref focusedEvents
* variables.
*
* The following event values designate standard event types:
*
* <pre>
* Constant Value Meaning
*
* @ref evMouseDown 0x0001 Mouse button pressed
* @ref evMouseUp 0x0002 Mouse button released
* @ref evMouseMove 0x0004 Mouse changed location
* @ref evMouseAuto 0x0008 Periodic event while mouse button held down
* @ref evKeyDown 0x0010 Key pressed
* @ref evCommand 0x0100 Command event
* @ref evBroadcast 0x0200 Broadcast event
* </pre>
*
* The following constants can be used to mask types of events:
*
* <pre>
* Constant Value Meaning
*
* @ref evNothing 0x0000 Event already handled
* @ref evMouse 0x000F Mouse event
* @ref evKeyboard 0x0010 Keyboard event
* @ref evMessage 0xFF00 Message (command, broadcast, or user-defined) event
* </pre>
*
* The above standard event masks can be used to determine whether an
* event belongs to a particular "family" of events. For example:
*
* <pre>
* if ((event.what & @ref evMouse) != 0) doMouseEvent();
* </pre>
*/
ushort what;
union //____eventUnion
{
/**
* Undocumented.
*/
MouseEventType mouse;
/**
* Undocumented.
*/
KeyDownEvent keyDown;
/**
* Undocumented.
*/
MessageEvent message;
};
};
#endif // Uses_TEvent
#if defined( Uses_TEventQueue ) && !defined( __TEventQueue )
#define __TEventQueue
/**
* Stores some information about mouse.
*
* The inner details will seldom be of interest in normal applications. It
* will usually be sufficient to know how the TEvent structure interacts with
* @ref TView::handleEvent() and its derivatives.
*
* Some old stuff is removed.
* @see MouseEventType
* @short Information about mouse
*/
class TEventQueue
{
public:
/**
* In this time interval button presses are recognized as double-click
* events.
*
* Not used in this port. It is still here only for backward compatibility
* (the `demo' program uses it). See `system.cc' for details.
*/
static ushort doubleDelay;
/**
* If set to True left and right mouse buttons are swapped. See the `demo'
* program for more information.
*/
static Boolean mouseReverse;
};
#endif // Uses_TEventQueue
#if defined( Uses_TScreen ) && !defined( __TScreen )
#define __TScreen
/**
* TDisplay provides low-level video functions for its derived class TScreen.
*
* These, and the other system classes in `system.h', are used internally by
* TVision and you would not need to use them explicitly for normal
* applications.
*
* Some old stuff is removed.
* @short Display information
*/
class TDisplay
{
public:
/**
* Mnemonics for the video modes used by TDisplay.
*
* This port uses smCO80 and smMono only.
*/
enum videoModes
{
smBW80 = 0x0002,
smCO80 = 0x0003,
smMono = 0x0007,
smFont8x8 = 0x0100
};
};
#include <sys/types.h>
/**
* A low-level class used to interface to the system.
*
* TScreen provides low-level video attributes and functions. This class is
* used internally by TVision. You do not need to use it explicitly for normal
* applications.
*
* Since this class was rewritten in the porting process, it is not a standard
* class and you should not use it. Otherwise you may end with a non-portable
* program.
* @short The interface to the system
*/
class TScreen: public TDisplay
{
public:
/**
* Constructor.
*
* Reads enviroment variables, acquires screen size, opens mouse and
* screen devices, catches some useful signals and starts an interval
* timer.
*/
TScreen();
/**
* Destructor.
*
* Releases the resources allocated by the constructor.
*/
~TScreen();
/**
* Returns the first available event.
*/
static void getEvent(TEvent &event);
/**
* Emits a beep.
*/
static void makeBeep();
/**
* Puts an event in the event queue.
*
* Do not use it, use @ref TProgram::putEvent() if you need.
*/
static void putEvent(TEvent &event);
/**
* Recovers the execution of the application.
*
* Resumes the execution of the process after the user stopped it.
* Called by @ref TApplication::resume(). You should call the latter
* method.
*/
static void resume();
/**
* Stops the execution of the application.
*
* Suspends execution of the process.
* Called by @ref TApplication::suspend(). You should call the latter
* method.
*/
static void suspend();
/**
* Shows or hides the cursor.
*
* Flag `show' specifies the operation to perform.
*/
static void drawCursor(int show);
/**
* Shows or hides the mouse pointer.
*
* Flag `show' specifies the operation to perform.
*/
static void drawMouse(int show);
/**
* Moves the cursor to another place.
*
* Parameters `x' and `y' are 0-based.
*/
static void moveCursor(int x, int y);
/**
* Writes a row of character & attribute pairs on the screen.
*
* `dst' is the destination position, `src' is a pointer to the source
* buffer and `len' is the size of the buffer expressed as the number
* of pairs.
*/
static void writeRow(int dst, ushort *src, int len);
/**
* Holds the current screen mode.
*
* It is initialized by the constructor if this class. It is read by
* @ref TProgram::initScreen().
* @see TDisplay
*/
static ushort screenMode;
/**
* Holds the current screen width.
*
* It is initialized by the constructor of this class.
*/
static uchar screenWidth;
/**
* Holds the current screen height.
*
* It is initialized by the constructor of this class.
*/
static uchar screenHeight;
/**
* Holds the current screen buffer address.
*
* It is initialized by the constructor of this class.
*/
static ushort *screenBuffer;
/**
* File descriptor set to watch for read operations.
*
* This set is used to watch for incoming mouse and keyboard data.
* Do not FD_ZERO() it in your program. However, FD_SET() and FD_CLR()
* are OK.
*/
static fd_set fdSetRead;
/**
* File descriptor set to watch for write operations.
*
* This set is used in @ref select() within getEvent(). It is empty by
* default and can be used freely.
*/
static fd_set fdSetWrite;
/**
* File descriptor set to watch for I/O exceptions.
*
* This set is used in select() within @ref getEvent(). It is empty by
* default and can be used freely.
*/
static fd_set fdSetExcept;
/**
* File descriptor set to indicate read() availability.
*
* This set is returned by select() within @ref getEvent(). It can be
* tested to handle operations on files mentioned in @ref fdSetRead.
*/
static fd_set fdActualRead;
/**
* File descriptor set to indicate write() completion.
*
* This set is returned by select() within @ref getEvent(). It can be
* tested to handle operations on files mentioned in @ref fdSetWrite.
*/
static fd_set fdActualWrite;
/**
* File descriptor set to indicate I/O exceptions.
*
* This set is returned by select() within @ref getEvent(). It can be
* tested to handle exceptions on files mentioned in @ref fdSetExcept.
*/
static fd_set fdActualExcept;
};
#endif // Uses_TScreen
syntax highlighted by Code2HTML, v. 0.9.1