nethack/include/qt_win.h

// NetHack 3.5	qt_win.h	$Date$  $Revision$
//	SCCS Id: @(#)qt_win.h	3.5	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);
#ifdef SAFERHANGUP
	void timeout();
#endif

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