/*
PIP - Platform Independent Primitives
Console output/input
Copyright (C) 2011 Ivan Pelipenko peri4@rambler.ru
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
*/
#ifndef PICONSOLE_H
#define PICONSOLE_H
#include "pikbdlistener.h"
#include "piprotocol.h"
#include "pisystemmonitor.h"
#ifndef WINDOWS
# include
# include
#endif
class PIConsole: public PIThread
{
public:
PIConsole(bool startNow = true, KBFunc slot = 0);
~PIConsole();
enum Format {Normal = 0x01,
Bold = 0x02,
Faint = 0x04,
Italic = 0x08,
Underline = 0x10,
Blink = 0x20,
Inverse = 0x40,
Black = 0x100,
Red = 0x200,
Green = 0x400,
Yellow = 0x800,
Blue = 0x1000,
Magenta = 0x2000,
Cyan = 0x4000,
White = 0x8000,
BackBlack = 0x10000,
BackRed = 0x20000,
BackGreen = 0x40000,
BackYellow = 0x80000,
BackBlue = 0x100000,
BackMagenta = 0x200000,
BackCyan = 0x400000,
BackWhite = 0x800000,
Dec = 0x1000000,
Hex = 0x2000000,
Oct = 0x4000000,
Scientific = 0x8000000};
void addString(const PIString & name, int column = 1, PIFlags format = PIConsole::Normal);
void addVariable(const PIString & name, PIString * ptr, int column = 1, PIFlags format = PIConsole::Normal);
void addVariable(const PIString & name, char * ptr, int column = 1, PIFlags format = PIConsole::Normal);
void addVariable(const PIString & name, bool * ptr, int column = 1, PIFlags format = PIConsole::Normal);
void addVariable(const PIString & name, short * ptr, int column = 1, PIFlags format = PIConsole::Normal);
void addVariable(const PIString & name, int * ptr, int column = 1, PIFlags format = PIConsole::Normal);
void addVariable(const PIString & name, long * ptr, int column = 1, PIFlags format = PIConsole::Normal);
void addVariable(const PIString & name, llong * ptr, int column = 1, PIFlags format = PIConsole::Normal);
void addVariable(const PIString & name, uchar * ptr, int column = 1, PIFlags format = PIConsole::Normal);
void addVariable(const PIString & name, ushort * ptr, int column = 1, PIFlags format = PIConsole::Normal);
void addVariable(const PIString & name, uint * ptr, int column = 1, PIFlags format = PIConsole::Normal);
void addVariable(const PIString & name, ulong * ptr, int column = 1, PIFlags format = PIConsole::Normal);
void addVariable(const PIString & name, ullong * ptr, int column = 1, PIFlags format = PIConsole::Normal);
void addVariable(const PIString & name, float * ptr, int column = 1, PIFlags format = PIConsole::Normal);
void addVariable(const PIString & name, double * ptr, int column = 1, PIFlags format = PIConsole::Normal);
void addVariable(const PIString & name, PIProtocol * ptr, int column = 1, PIFlags format = PIConsole::Normal);
void addVariable(const PIString & name, PISystemMonitor * ptr, int column = 1, PIFlags format = PIConsole::Normal);
void addBitVariable(const PIString & name, void * ptr, int fromBit, int bitCount, int column = 1, PIFlags format = PIConsole::Normal);
void addEmptyLine(int column = 1, uint count = 1);
PIString getString(int x, int y);
short getShort(int x, int y) {return getString(x, y).toShort();}
int getInt(int x, int y) {return getString(x, y).toInt();}
float getFloat(int x, int y) {return getString(x, y).toFloat();}
double getDouble(int x, int y) {return getString(x, y).toDouble();}
PIString getString(const PIString & name);
short getShort(const PIString & name) {return getString(name).toShort();}
int getInt(const PIString & name) {return getString(name).toInt();}
float getFloat(const PIString & name) {return getString(name).toFloat();}
double getDouble(const PIString & name) {return getString(name).toDouble();}
uint tabsCount() const {return tabs.size();}
PIString currentTab() const {return tabs[cur_tab].name;}
int addTab(const PIString & name, char bind_key = 0);
void removeTab(uint index);
void removeTab(const PIString & name);
bool setTab(uint index);
bool setTab(const PIString & name);
bool setTabBindKey(uint index, char bind_key);
bool setTabBindKey(const PIString & name, char bind_key);
void clearTabs(bool clearScreen = true) {if (clearScreen && isRunning()) {toUpperLeft(); clearScreenLower();} tabs.clear();}
void addCustomStatus(const PIString & str) {tabs[cur_tab].status = str;}
void clearCustomStatus() {tabs[cur_tab].status.clear();}
EVENT_HANDLER0(PIConsole, void, clearVariables) {clearVariables(true);}
EVENT_HANDLER1(PIConsole, void, clearVariables, bool, clearScreen) {if (clearScreen && isRunning()) {toUpperLeft(); clearScreenLower();} vars().clear();}
EVENT_HANDLER0(PIConsole, void, waitForFinish) {WAIT_FOR_EXIT}
EVENT_HANDLER0(PIConsole, void, start) {start(false);}
EVENT_HANDLER1(PIConsole, void, start, bool, wait) {PIThread::start(40); if (wait) waitForFinish();}
EVENT_HANDLER0(PIConsole, void, stop) {stop(false);}
EVENT_HANDLER1(PIConsole, void, stop, bool, clear);
PIString fstr(PIFlags f);
void enableExitCapture(char key = 'Q') {listener->enableExitCapture(key);}
void disableExitCapture() {listener->disableExitCapture();}
bool exitCaptured() const {return listener->exitCaptured();}
char exitKey() const {return listener->exitKey();}
private:
void begin();
void run();
void fillLabels();
#ifdef WINDOWS
void getWinCurCoord() {GetConsoleScreenBufferInfo(hOut, &csbi); ccoord = csbi.dwCursorPosition;}
COORD & getWinCoord(int dx = 0, int dy = 0) {getWinCurCoord(); ccoord.X += dx; ccoord.Y += dy; return ccoord;}
void toUpperLeft() {SetConsoleCursorPosition(hOut, ulcoord);}
void moveRight(int n = 1) {SetConsoleCursorPosition(hOut, getWinCoord(n));}
void moveLeft(int n = 1) {SetConsoleCursorPosition(hOut, getWinCoord(-n));}
void moveTo(int x = 0, int y = 0) {ccoord.X = x; ccoord.Y = y; SetConsoleCursorPosition(hOut, ccoord);}
void clearScreen() {FillConsoleOutputAttribute(hOut, dattr, width * (height + 1), ulcoord, &written);
FillConsoleOutputCharacter(hOut, ' ', width * (height + 1), ulcoord, &written);}
void clearScreenLower() {getWinCurCoord(); FillConsoleOutputAttribute(hOut, dattr, width * height - width * ccoord.Y + ccoord.X, ccoord, &written);
FillConsoleOutputCharacter(hOut, ' ', width * height - width * ccoord.Y + ccoord.X, ccoord, &written);}
void clearLine() {getWinCurCoord(); FillConsoleOutputAttribute(hOut, dattr, width - ccoord.X, ccoord, &written);
FillConsoleOutputCharacter(hOut, ' ', width - ccoord.X, ccoord, &written);}
void newLine() {getWinCurCoord(); ccoord.X = 0; ccoord.Y++; SetConsoleCursorPosition(hOut, ccoord);}
void hideCursor() {curinfo.bVisible = false; SetConsoleCursorInfo(hOut, &curinfo);}
void showCursor() {curinfo.bVisible = true; SetConsoleCursorInfo(hOut, &curinfo);}
#else
void toUpperLeft() {printf("\e[H");}
void moveRight(int n = 1) {if (n > 0) printf("\e[%dC", n);}
void moveLeft(int n = 1) {if (n > 0) printf("\e[%dD", n);}
void moveTo(int x = 0, int y = 0) {printf("\e[%d;%dH", y, x);}
void clearScreen() {printf("\e[H\e[J");}
void clearScreenLower() {printf("\e[J");}
void clearLine() {printf("\e[K");}
void newLine() {printf("\eE");}
void hideCursor() {printf("\e[?25l");}
void showCursor() {printf("\e[?25h");}
#endif
void status();
void checkColumn(uint col) {if (vars().size() < col) {vars().resize(col);}}
int bitsValue(void * src, int offset, int count);
inline void printLine(const PIString & str, int dx = 0, PIFlags format = PIConsole::Normal);
inline int printValue(const PIString & str, PIFlags format = PIConsole::Normal);
inline int printValue(const char * str, PIFlags format = PIConsole::Normal);
inline int printValue(const bool value, PIFlags format = PIConsole::Normal);
inline int printValue(const int value, PIFlags format = PIConsole::Normal);
inline int printValue(const long value, PIFlags format = PIConsole::Normal);
inline int printValue(const llong value, PIFlags format = PIConsole::Normal);
inline int printValue(const float value, PIFlags format = PIConsole::Normal);
inline int printValue(const double value, PIFlags format = PIConsole::Normal);
inline int printValue(const char value, PIFlags format = PIConsole::Normal);
inline int printValue(const short value, PIFlags format = PIConsole::Normal);
inline int printValue(const uchar value, PIFlags format = PIConsole::Normal);
inline int printValue(const ushort value, PIFlags format = PIConsole::Normal);
inline int printValue(const uint value, PIFlags format = PIConsole::Normal);
inline int printValue(const ulong value, PIFlags format = PIConsole::Normal);
inline int printValue(const ullong value, PIFlags format = PIConsole::Normal);
static void key_event(char key, void * t);
struct Variable {
PIString name;
PIFlags format;
int nx;
int ny;
int type;
int offset;
int bitFrom;
int bitCount;
union {
PIString * s;
bool * b;
short * sh;
int * i;
long * l;
llong * ll;
float * f;
double * d;
char * c;
uchar * uc;
ushort * ush;
uint * ui;
ulong * ul;
ullong * ull;
void * ptr;
};
void operator =(const Variable & src) {name = src.name; format = src.format; type = src.type; offset = src.offset;
bitFrom = src.bitFrom; bitCount = src.bitCount; c = src.c; nx = src.nx; ny = src.ny;}
};
struct Tab {
PIVector > variables;
PIString name;
PIString status;
char key;
Tab() {;}
Tab(PIString n, char k) {name = n; key = k;}
~Tab() {;}
};
PIVector > & vars() {return tabs[cur_tab].variables;}
inline int couts(const string v);
inline int couts(const char * v);
inline int couts(const bool v);
inline int couts(const char v);
inline int couts(const short v);
inline int couts(const int v);
inline int couts(const long v);
inline int couts(const llong v);
inline int couts(const uchar v);
inline int couts(const ushort v);
inline int couts(const uint v);
inline int couts(const ulong v);
inline int couts(const ullong v);
inline int couts(const float v);
inline int couts(const double v);
#ifdef WINDOWS
void * hOut;
CONSOLE_SCREEN_BUFFER_INFO sbi, csbi;
CONSOLE_CURSOR_INFO curinfo;
COORD ccoord, ulcoord;
WORD dattr;
DWORD smode, written;
#else
struct termios sterm, vterm;
#endif
PIVector tabs;
Variable tv;
PIKbdListener * listener;
KBFunc ret_func;
int width, height, pwidth, pheight, ret, col_wid, num_format;
uint my;
uint cur_tab, col_cnt;
};
#endif // PICONSOLE_H