Permalink
Switch branches/tags
Nothing to show
Find file
Fetching contributors…
Cannot retrieve contributors at this time
846 lines (665 sloc) 17.5 KB
// SCCS Id: @(#)qt_win.h 3.4 1999/11/19
// Copyright (c) Warwick Allison, 1999.
// NetHack may be freely redistributed. See license for details.
//
// Qt Binding for NetHack 3.4
//
// Unfortunately, this doesn't use Qt as well as I would like,
// primarily because NetHack is fundamentally a getkey-type
// program rather than being event driven (hence the ugly key
// and click buffer rather), but also because this is my first
// major application of Qt.
//
#ifndef qt_win_h
#define qt_win_h
#define QT_CLEAN_NAMESPACE
#include <qdialog.h>
#include <qpushbutton.h>
#include <qbuttongroup.h>
#include <qlabel.h>
#include <qlineedit.h>
#if defined(QWS)
#include <qpe/qpeapplication.h>
#else
#include <qapplication.h>
#endif
#include <qspinbox.h>
#include <qcheckbox.h>
#include <qfile.h>
#include <qlistbox.h>
#include <qlistview.h>
#include <qmessagebox.h>
#include <qpixmap.h>
#include <qimage.h>
#include <qarray.h>
#include <qcombobox.h>
#include <qscrollview.h>
#if QT_VERSION >= 300
#include <qttableview.h>
// Should stop using QTableView
#define QTableView QtTableView
#else
#include <qtableview.h>
#endif
#include <qmainwindow.h>
#include <qwidgetstack.h>
#ifdef KDE
#include <kapp.h>
#include <ktopwidget.h>
#endif
#include "qt_clust.h"
class QVBox;
class QMenuBar;
class QRadioButton;
class NhPSListView;
//////////////////////////////////////////////////////////////
//
// The beautiful, abstracted and well-modelled classes...
//
//////////////////////////////////////////////////////////////
class NetHackQtGlyphs;
class NetHackQtLineEdit : public QLineEdit {
public:
NetHackQtLineEdit();
NetHackQtLineEdit(QWidget* parent, const char* name);
void fakeEvent(int key, int ascii, int state);
};
class NetHackQtSettings : public QDialog {
Q_OBJECT
public:
// Size of window - used to decide default sizes
NetHackQtSettings(int width, int height);
NetHackQtGlyphs& glyphs();
const QFont& normalFont();
const QFont& normalFixedFont();
const QFont& largeFont();
bool ynInMessages();
signals:
void fontChanged();
void tilesChanged();
public slots:
void toggleGlyphSize();
void setGlyphSize(bool);
private:
QSpinBox tilewidth;
QSpinBox tileheight;
QLabel widthlbl;
QLabel heightlbl;
QCheckBox whichsize;
QSize othersize;
QComboBox fontsize;
QFont normal, normalfixed, large;
NetHackQtGlyphs* theglyphs;
private slots:
void resizeTiles();
};
class NetHackQtKeyBuffer {
public:
NetHackQtKeyBuffer();
bool Empty() const;
bool Full() const;
void Put(int k, int ascii, int state);
void Put(char a);
void Put(const char* str);
int GetKey();
int GetAscii();
int GetState();
int TopKey() const;
int TopAscii() const;
int TopState() const;
private:
enum { maxkey=64 };
int key[maxkey];
int ascii[maxkey];
int state[maxkey];
int in,out;
};
class NetHackQtClickBuffer {
public:
NetHackQtClickBuffer();
bool Empty() const;
bool Full() const;
void Put(int x, int y, int mod);
int NextX() const;
int NextY() const;
int NextMod() const;
void Get();
private:
enum { maxclick=64 };
struct ClickRec {
int x,y,mod;
} click[maxclick];
int in,out;
};
class NetHackQtSavedGameSelector : public QDialog {
public:
NetHackQtSavedGameSelector(const char** saved);
int choose();
};
class NetHackQtPlayerSelector : private QDialog {
Q_OBJECT
public:
enum { R_None=-1, R_Quit=-2, R_Rand=-3 };
NetHackQtPlayerSelector(NetHackQtKeyBuffer&);
protected:
virtual void done(int);
public slots:
void Quit();
void Random();
void selectName(const QString& n);
void selectRole();
void selectRace();
void setupOthers();
void selectGender(int);
void selectAlignment(int);
public:
bool Choose();
private:
NetHackQtKeyBuffer& keysource;
NhPSListView* role;
NhPSListView* race;
QRadioButton **gender;
QRadioButton **alignment;
bool fully_specified_role;
};
class NetHackQtStringRequestor : QDialog {
private:
QLabel prompt;
NetHackQtLineEdit input;
QPushButton* okay;
QPushButton* cancel;
NetHackQtKeyBuffer& keysource;
virtual void done(int);
public:
NetHackQtStringRequestor(NetHackQtKeyBuffer&, const char* p,const char* cancelstr="Cancel");
void SetDefault(const char*);
bool Get(char* buffer, int maxchar=80);
virtual void resizeEvent(QResizeEvent*);
};
class NetHackQtExtCmdRequestor : public QDialog {
Q_OBJECT
NetHackQtKeyBuffer& keysource;
public:
NetHackQtExtCmdRequestor(NetHackQtKeyBuffer& ks);
int get();
private slots:
void cancel();
void done(int i);
};
class NetHackQtWindow {
public:
NetHackQtWindow();
virtual ~NetHackQtWindow();
virtual QWidget* Widget() =0;
virtual void Clear();
virtual void Display(bool block);
virtual bool Destroy();
virtual void CursorTo(int x,int y);
virtual void PutStr(int attr, const char* text);
virtual void StartMenu();
virtual void AddMenu(int glyph, const ANY_P* identifier, char ch, char gch, int attr,
const char* str, bool presel);
virtual void EndMenu(const char* prompt);
virtual int SelectMenu(int how, MENU_ITEM_P **menu_list);
virtual void ClipAround(int x,int y);
virtual void PrintGlyph(int x,int y,int glyph);
virtual void UseRIP(int how);
int nhid;
};
class NetHackQtGlyphs {
public:
NetHackQtGlyphs();
int width() const { return size.width(); }
int height() const { return size.height(); }
void toggleSize();
void setSize(int w, int h);
void drawGlyph(QPainter&, int glyph, int pixelx, int pixely);
void drawCell(QPainter&, int glyph, int cellx, int celly);
private:
QImage img;
QPixmap pm,pm1, pm2;
QSize size;
int tiles_per_row;
};
class BlackScrollView : public QScrollView {
public:
BlackScrollView()
{
viewport()->setBackgroundColor(black);
}
};
class NetHackQtMapWindow : public QWidget, public NetHackQtWindow {
Q_OBJECT
private:
NetHackQtClickBuffer& clicksink;
unsigned short glyph[ROWNO][COLNO];
unsigned short& Glyph(int x, int y) { return glyph[y][x]; }
QPoint cursor;
BlackScrollView viewport;
QPixmap pet_annotation;
Clusterizer change;
QFont *rogue_font;
QString messages;
QRect messages_rect;
void Changed(int x,int y);
signals:
void resized();
private slots:
void updateTiles();
void moveMessages(int x, int y);
protected:
virtual void paintEvent(QPaintEvent*);
virtual void mousePressEvent(QMouseEvent*);
public:
NetHackQtMapWindow(NetHackQtClickBuffer& click_sink);
~NetHackQtMapWindow();
virtual QWidget* Widget();
virtual bool Destroy();
virtual void Clear();
virtual void Display(bool block);
virtual void CursorTo(int x,int y);
virtual void PutStr(int attr, const char* text);
virtual void ClipAround(int x,int y);
virtual void PrintGlyph(int x,int y,int glyph);
void Scroll(int dx, int dy);
// For messages
void displayMessages(bool block);
void putMessage(int attr, const char* text);
void clearMessages();
void clickCursor();
};
class NetHackQtScrollText;
class NetHackQtMessageWindow : QObject, public NetHackQtWindow {
Q_OBJECT
public:
NetHackQtMessageWindow();
~NetHackQtMessageWindow();
virtual QWidget* Widget();
virtual void Clear();
virtual void Display(bool block);
virtual void PutStr(int attr, const char* text);
void Scroll(int dx, int dy);
void setMap(NetHackQtMapWindow*);
private:
NetHackQtScrollText* list;
bool changed;
NetHackQtMapWindow* map;
private slots:
void updateFont();
};
class NetHackQtLabelledIcon : public QWidget {
public:
NetHackQtLabelledIcon(QWidget* parent, const char* label);
NetHackQtLabelledIcon(QWidget* parent, const char* label, const QPixmap& icon);
enum { NoNum=-99999 };
void setLabel(const char*, bool lower=TRUE); // a string
void setLabel(const char*, long, const char* tail=""); // a number
void setLabel(const char*, long show_value, long comparative_value, const char* tail="");
void setIcon(const QPixmap&);
virtual void setFont(const QFont&);
void highlightWhenChanging();
void lowIsGood();
void dissipateHighlight();
virtual void show();
protected:
void resizeEvent(QResizeEvent*);
private:
void initHighlight();
void setAlignments();
void highlight(const QPalette& highlight);
void unhighlight();
bool low_is_good;
int prev_value;
int turn_count; /* last time the value changed */
QPalette hl_good;
QPalette hl_bad;
QLabel* label;
QLabel* icon;
};
class NetHackQtStatusWindow : QWidget, public NetHackQtWindow {
Q_OBJECT
public:
NetHackQtStatusWindow();
virtual QWidget* Widget();
virtual void Clear();
virtual void Display(bool block);
virtual void CursorTo(int x,int y);
virtual void PutStr(int attr, const char* text);
void fadeHighlighting();
protected:
void resizeEvent(QResizeEvent*);
private slots:
void doUpdate();
private:
enum { hilight_time=1 };
QPixmap p_str;
QPixmap p_dex;
QPixmap p_con;
QPixmap p_int;
QPixmap p_wis;
QPixmap p_cha;
QPixmap p_chaotic;
QPixmap p_neutral;
QPixmap p_lawful;
QPixmap p_satiated;
QPixmap p_hungry;
QPixmap p_confused;
QPixmap p_sick_fp;
QPixmap p_sick_il;
QPixmap p_blind;
QPixmap p_stunned;
QPixmap p_hallu;
QPixmap p_encumber[5];
NetHackQtLabelledIcon name;
NetHackQtLabelledIcon dlevel;
NetHackQtLabelledIcon str;
NetHackQtLabelledIcon dex;
NetHackQtLabelledIcon con;
NetHackQtLabelledIcon intel;
NetHackQtLabelledIcon wis;
NetHackQtLabelledIcon cha;
NetHackQtLabelledIcon gold;
NetHackQtLabelledIcon hp;
NetHackQtLabelledIcon power;
NetHackQtLabelledIcon ac;
NetHackQtLabelledIcon level;
NetHackQtLabelledIcon exp;
NetHackQtLabelledIcon align;
NetHackQtLabelledIcon time;
NetHackQtLabelledIcon score;
NetHackQtLabelledIcon hunger;
NetHackQtLabelledIcon confused;
NetHackQtLabelledIcon sick_fp;
NetHackQtLabelledIcon sick_il;
NetHackQtLabelledIcon blind;
NetHackQtLabelledIcon stunned;
NetHackQtLabelledIcon hallu;
NetHackQtLabelledIcon encumber;
QFrame hline1;
QFrame hline2;
QFrame hline3;
int cursy;
bool first_set;
void nullOut();
void updateStats();
void checkTurnEvents();
};
class NetHackQtMenuDialog : public QDialog {
Q_OBJECT
public:
NetHackQtMenuDialog();
void Accept();
void Reject();
void SetResult(int);
virtual void done(int);
protected:
void resizeEvent(QResizeEvent*);
signals:
void Resized();
};
class NetHackQtMenuWindow : public QTableView, public NetHackQtWindow {
Q_OBJECT
public:
NetHackQtMenuWindow(NetHackQtKeyBuffer&);
~NetHackQtMenuWindow();
virtual QWidget* Widget();
virtual void StartMenu();
virtual void AddMenu(int glyph, const ANY_P* identifier, char ch, char gch, int attr,
const char* str, bool presel);
virtual void EndMenu(const char* prompt);
virtual int SelectMenu(int how, MENU_ITEM_P **menu_list);
public slots:
void All();
void ChooseNone();
void Invert();
void Search();
void Layout();
void ToggleSelect(int);
protected:
virtual void keyPressEvent(QKeyEvent*);
//virtual void mouseDoubleClickEvent(QMouseEvent*);
virtual void mousePressEvent(QMouseEvent*);
virtual void mouseReleaseEvent(QMouseEvent*);
virtual void mouseMoveEvent(QMouseEvent*);
virtual void focusOutEvent(QFocusEvent*);
virtual void focusInEvent(QFocusEvent*);
virtual void paintCell(QPainter*, int, int);
virtual int cellWidth(int col);
private:
struct MenuItem {
MenuItem();
~MenuItem();
int glyph;
ANY_P identifier;
int attr;
const char* str;
int count;
char ch;
bool selected;
bool Selectable() const { return identifier.a_void!=0; }
};
QArray<MenuItem> item;
int itemcount;
int str_width;
bool str_fixed;
int next_accel;
NetHackQtKeyBuffer& keysource;
NetHackQtMenuDialog* dialog;
QPushButton* ok;
QPushButton* cancel;
QPushButton* all;
QPushButton* none;
QPushButton* invert;
QPushButton* search;
QLabel prompt;
int how;
bool has_glyphs;
int pressed;
bool was_sel;
};
class NetHackQtTextListBox;
class NetHackQtRIP : public QWidget {
private:
static QPixmap* pixmap;
char** line;
int riplines;
public:
NetHackQtRIP(QWidget* parent);
void setLines(char** l, int n);
protected:
virtual void paintEvent(QPaintEvent* event);
QSize sizeHint() const;
};
class NetHackQtTextWindow : public QDialog, public NetHackQtWindow {
Q_OBJECT
public:
NetHackQtTextWindow(NetHackQtKeyBuffer&);
~NetHackQtTextWindow();
virtual QWidget* Widget();
virtual void Clear();
virtual bool Destroy();
virtual void Display(bool block);
virtual void PutStr(int attr, const char* text);
virtual void UseRIP(int how);
public slots:
void Search();
protected:
virtual void done(int);
virtual void keyPressEvent(QKeyEvent*);
private slots:
void doUpdate();
private:
NetHackQtKeyBuffer& keysource;
bool use_rip;
bool str_fixed;
QPushButton ok;
QPushButton search;
NetHackQtTextListBox* lines;
NetHackQtRIP rip;
};
class NetHackQtMenuOrTextWindow : public NetHackQtWindow {
private:
NetHackQtWindow* actual;
NetHackQtKeyBuffer& keysource;
public:
NetHackQtMenuOrTextWindow(NetHackQtKeyBuffer&);
virtual QWidget* Widget();
// Text
virtual void Clear();
virtual bool Destroy();
virtual void Display(bool block);
virtual void PutStr(int attr, const char* text);
// Menu
virtual void StartMenu();
virtual void AddMenu(int glyph, const ANY_P* identifier, char ch, char gch, int attr,
const char* str, bool presel);
virtual void EndMenu(const char* prompt);
virtual int SelectMenu(int how, MENU_ITEM_P **menu_list);
};
class NetHackQtDelay : QObject {
private:
int msec;
public:
NetHackQtDelay(int ms);
void wait();
virtual void timerEvent(QTimerEvent* timer);
};
class NetHackQtInvUsageWindow : public QWidget {
public:
NetHackQtInvUsageWindow(QWidget* parent);
virtual void paintEvent(QPaintEvent*);
private:
void drawWorn(QPainter& painter, obj*, int x, int y, bool canbe=TRUE);
};
// This class is the main widget for NetHack
//
// It is a collection of Message, Map, and Status windows. In the current
// version of nethack there is only one of each, and this class makes this
// assumption, not showing itself until all are inserted.
//
// This class simply knows how to layout such children sensibly.
//
// Since it is only responsible for layout, the class does not
// note the actual class of the windows.
//
#ifndef KDE
#include "qt_kde0.h"
#endif
class NetHackQtMainWindow : public KTopLevelWidget {
Q_OBJECT
public:
NetHackQtMainWindow(NetHackQtKeyBuffer&);
void AddMessageWindow(NetHackQtMessageWindow* window);
void AddMapWindow(NetHackQtMapWindow* window);
void AddStatusWindow(NetHackQtStatusWindow* window);
void RemoveWindow(NetHackQtWindow* window);
void updateInventory();
void fadeHighlighting();
public slots:
void doMenuItem(int);
void doKeys(const QString&);
protected:
virtual void resizeEvent(QResizeEvent*);
virtual void keyPressEvent(QKeyEvent*);
virtual void keyReleaseEvent(QKeyEvent* event);
virtual void closeEvent(QCloseEvent*);
private slots:
void layout();
void raiseMap();
void zoomMap();
void raiseMessages();
void raiseStatus();
private:
void ShowIfReady();
#ifdef KDE
KMenuBar* menubar;
#else
QMenuBar* menubar;
#endif
NetHackQtMessageWindow* message;
NetHackQtMapWindow* map;
NetHackQtStatusWindow* status;
NetHackQtInvUsageWindow* invusage;
NetHackQtKeyBuffer& keysink;
QWidgetStack* stack;
int dirkey;
const char* *macro;
};
class NetHackQtYnDialog : QDialog {
Q_OBJECT
private:
const char* question;
const char* choices;
char def;
NetHackQtKeyBuffer& keysource;
protected:
virtual void keyPressEvent(QKeyEvent*);
virtual void done(int);
private slots:
void doneItem(int);
public:
NetHackQtYnDialog(NetHackQtKeyBuffer& keysource,const char*,const char*,char);
char Exec();
};
#ifdef KDE
#define NetHackQtBindBase KApplication
#elif defined(QWS)
#define NetHackQtBindBase QPEApplication
#else
#define NetHackQtBindBase QApplication
#endif
class NetHackQtBind : NetHackQtBindBase {
private:
// Single-instance preservation...
NetHackQtBind(int& argc, char** argv);
static NetHackQtBind* instance;
static NetHackQtKeyBuffer keybuffer;
static NetHackQtClickBuffer clickbuffer;
static QWidget* splash;
static NetHackQtMainWindow* main;
public:
static void qt_init_nhwindows(int* argc, char** argv);
static void qt_player_selection();
static void qt_askname();
static void qt_get_nh_event();
static void qt_exit_nhwindows(const char *);
static void qt_suspend_nhwindows(const char *);
static void qt_resume_nhwindows();
static winid qt_create_nhwindow(int type);
static void qt_clear_nhwindow(winid wid);
static void qt_display_nhwindow(winid wid, BOOLEAN_P block);
static void qt_destroy_nhwindow(winid wid);
static void qt_curs(winid wid, int x, int y);
static void qt_putstr(winid wid, int attr, const char *text);
static void qt_display_file(const char *filename, BOOLEAN_P must_exist);
static void qt_start_menu(winid wid);
static void qt_add_menu(winid wid, int glyph,
const ANY_P * identifier, CHAR_P ch, CHAR_P gch, int attr,
const char *str, BOOLEAN_P presel);
static void qt_end_menu(winid wid, const char *prompt);
static int qt_select_menu(winid wid, int how, MENU_ITEM_P **menu_list);
static void qt_update_inventory();
static void qt_mark_synch();
static void qt_wait_synch();
static void qt_cliparound(int x, int y);
static void qt_cliparound_window(winid wid, int x, int y);
static void qt_print_glyph(winid wid,XCHAR_P x,XCHAR_P y,int glyph);
static void qt_raw_print(const char *str);
static void qt_raw_print_bold(const char *str);
static int qt_nhgetch();
static int qt_nh_poskey(int *x, int *y, int *mod);
static void qt_nhbell();
static int qt_doprev_message();
static char qt_yn_function(const char *question, const char *choices, CHAR_P def);
static void qt_getlin(const char *prompt, char *line);
static int qt_get_ext_cmd();
static void qt_number_pad(int);
static void qt_delay_output();
static void qt_start_screen();
static void qt_end_screen();
static void qt_outrip(winid wid, int how);
static int qt_kbhit();
private:
virtual bool notify(QObject *receiver, QEvent *event);
};
#endif