Source:Qt win.h

Below is the full text to include/qt_win.h from NetHack 3.4.3. To link to a particular line, write [[qt_win.h#line123 ]], for example. 1.   //	SCCS Id: @(#)qt_win.h	3.4	1999/11/19 2.   // Copyright (c) Warwick Allison, 1999. 3.   // NetHack may be freely redistributed. See license for details. 4.   //

5.   // Qt Binding for NetHack 3.4 6.   //  7.    // Unfortunately, this doesn't use Qt as well as I would like, 8.   // primarily because NetHack is fundamentally a getkey-type 9.   // program rather than being event driven (hence the ugly key  10.   // and click buffer rather), but also because this is my first 11.  // major application of Qt. 12.  //  13.    14.   #ifndef qt_win_h 15.  #define qt_win_h 16.   17.   #define QT_CLEAN_NAMESPACE 18.   19.   #include   20. #include  21. #include  22. #include  23. #include  24. #if defined(QWS) 25.  #include   26. #else 27.  #include   28. #endif 29.  #include   30. #include  31. #include  32. #include  33. #include  34. #include  35. #include  36. #include  37. #include  38. #include <qcombobox.h> 39. #include <qscrollview.h> 40. #if QT_VERSION >= 300 41.  #include <qttableview.h>  42. // Should stop using QTableView 43.  #define QTableView QtTableView 44.  #else 45.  #include <qtableview.h>  46. #endif 47.  #include <qmainwindow.h>  48. #include <qwidgetstack.h> 49. 50.  #ifdef KDE 51.  #include <kapp.h>  52. #include <ktopwidget.h> 53. #endif 54.   55.   #include "qt_clust.h"  56. 57.  class QVBox; 58.  class QMenuBar; 59.  class QRadioButton; 60.  class NhPSListView; 61.   62.   //////////////////////////////////////////////////////////////  63.   //  64.   //  The beautiful, abstracted and well-modelled classes...  65. // 66.   //////////////////////////////////////////////////////////////  67.    68.   class NetHackQtGlyphs; 69.   70.   class NetHackQtLineEdit : public QLineEdit { 71.  public: 72.  	NetHackQtLineEdit; 73.  	NetHackQtLineEdit(QWidget* parent, const char* name); 74.   75.   	void fakeEvent(int key, int ascii, int state); 76.  };  77.    78.   class NetHackQtSettings : public QDialog { 79.  	Q_OBJECT 80.  public: 81.  	// Size of window - used to decide default sizes 82.  	NetHackQtSettings(int width, int height); 83.   84.   	NetHackQtGlyphs& glyphs; 85.  	const QFont& normalFont; 86.  	const QFont& normalFixedFont; 87.  	const QFont& largeFont; 88.   89.   	bool ynInMessages; 90.   91.   signals: 92.  	void fontChanged; 93.  	void tilesChanged; 94.   95.   public slots: 96.  	void toggleGlyphSize; 97.  	void setGlyphSize(bool); 98.   99.   private: 100. 	QSpinBox tilewidth; 101. 	QSpinBox tileheight; 102. 	QLabel widthlbl; 103. 	QLabel heightlbl; 104. 	QCheckBox whichsize; 105. 	QSize othersize; 106.  107.  	QComboBox fontsize; 108.  109.  	QFont normal, normalfixed, large; 110.  111.  	NetHackQtGlyphs* theglyphs; 112.  113.  private slots: 114. 	void resizeTiles; 115. };  116.   117.  class NetHackQtKeyBuffer { 118. public: 119. 	NetHackQtKeyBuffer; 120.  121.  	bool Empty const; 122. 	bool Full const; 123.  124.  	void Put(int k, int ascii, int state); 125. 	void Put(char a); 126. 	void Put(const char* str); 127. 	int GetKey; 128. 	int GetAscii; 129. 	int GetState; 130.  131.  	int TopKey const; 132. 	int TopAscii const; 133. 	int TopState const; 134.  135.  private: 136. 	enum { maxkey=64 }; 137. 	int key[maxkey]; 138. 	int ascii[maxkey]; 139. 	int state[maxkey]; 140. 	int in,out; 141. };  142.   143.  class NetHackQtClickBuffer { 144. public: 145. 	NetHackQtClickBuffer; 146.  147.  	bool Empty const; 148. 	bool Full const; 149.  150.  	void Put(int x, int y, int mod); 151.  152.  	int NextX const; 153. 	int NextY const; 154. 	int NextMod const; 155.  156.  	void Get; 157.  158.  private: 159. 	enum { maxclick=64 }; 160. 	struct ClickRec { 161. 		int x,y,mod; 162. 	} click[maxclick]; 163. 	int in,out; 164. };  165.   166.   167.  class NetHackQtSavedGameSelector : public QDialog { 168. public: 169. 	NetHackQtSavedGameSelector(const char** saved); 170.  171.  	int choose; 172. };  173.   174.  class NetHackQtPlayerSelector : private QDialog { 175. 	Q_OBJECT 176. public: 177. 	enum { R_None=-1, R_Quit=-2, R_Rand=-3 }; 178.  179.  	NetHackQtPlayerSelector(NetHackQtKeyBuffer&); 180.  181.  protected: 182. 	virtual void done(int); 183.  184.  public slots: 185. 	void Quit; 186. 	void Random; 187.  188.  	void selectName(const QString& n); 189. 	void selectRole; 190. 	void selectRace; 191. 	void setupOthers; 192. 	void selectGender(int); 193. 	void selectAlignment(int); 194.  195.  public: 196. 	bool Choose; 197.  198.  private: 199. 	NetHackQtKeyBuffer& keysource; 200. 	NhPSListView* role; 201. 	NhPSListView* race; 202. 	QRadioButton **gender; 203. 	QRadioButton **alignment; 204. 	bool fully_specified_role; 205. };  206.   207.  class NetHackQtStringRequestor : QDialog { 208. private: 209. 	QLabel prompt; 210. 	NetHackQtLineEdit input; 211. 	QPushButton* okay; 212. 	QPushButton* cancel; 213. 	NetHackQtKeyBuffer& keysource; 214.  215.  	virtual void done(int); 216.  217.  public: 218. 	NetHackQtStringRequestor(NetHackQtKeyBuffer&, const char* p,const char* cancelstr="Cancel"); 219. 	void SetDefault(const char*); 220. 	bool Get(char* buffer, int maxchar=80); 221. 	virtual void resizeEvent(QResizeEvent*); 222. };  223.   224.  class NetHackQtExtCmdRequestor : public QDialog { 225.     Q_OBJECT 226.  227.      NetHackQtKeyBuffer& keysource; 228.  229.  public: 230.     NetHackQtExtCmdRequestor(NetHackQtKeyBuffer& ks); 231.     int get; 232.  233.  private slots: 234.     void cancel; 235.     void done(int i); 236. };  237.   238.   239.  class NetHackQtWindow { 240. public: 241. 	NetHackQtWindow; 242. 	virtual ~NetHackQtWindow; 243.  244.  	virtual QWidget* Widget =0; 245.  246.  	virtual void Clear; 247. 	virtual void Display(bool block); 248. 	virtual bool Destroy; 249. 	virtual void CursorTo(int x,int y); 250. 	virtual void PutStr(int attr, const char* text); 251. 	virtual void StartMenu; 252. 	virtual void AddMenu(int glyph, const ANY_P* identifier, char ch, char gch, int attr,  253.  			const char* str, bool presel); 254. 	virtual void EndMenu(const char* prompt); 255. 	virtual int SelectMenu(int how, MENU_ITEM_P **menu_list); 256. 	virtual void ClipAround(int x,int y); 257. 	virtual void PrintGlyph(int x,int y,int glyph); 258. 	virtual void UseRIP(int how); 259.  260.  	int nhid; 261. };  262.   263.  class NetHackQtGlyphs { 264. public: 265. 	NetHackQtGlyphs; 266.  267.  	int width const { return size.width; } 268. 	int height const { return size.height; } 269. 	void toggleSize; 270. 	void setSize(int w, int h); 271.  272.  	void drawGlyph(QPainter&, int glyph, int pixelx, int pixely); 273. 	void drawCell(QPainter&, int glyph, int cellx, int celly); 274.  275.  private: 276. 	QImage img; 277. 	QPixmap pm,pm1, pm2; 278. 	QSize size; 279. 	int tiles_per_row; 280. };  281.   282.  class BlackScrollView : public QScrollView { 283. public: 284.     BlackScrollView 285.     {  286.  	viewport->setBackgroundColor(black); 287.     }  288.  };  289.   290.  class NetHackQtMapWindow : public QWidget, public NetHackQtWindow { 291. 	Q_OBJECT 292. private: 293. 	NetHackQtClickBuffer& clicksink; 294. 	unsigned short glyph[ROWNO][COLNO]; 295. 	unsigned short& Glyph(int x, int y) { return glyph[y][x]; } 296. 	QPoint cursor; 297. 	BlackScrollView viewport; 298. 	QPixmap pet_annotation; 299. 	Clusterizer change; 300. 	QFont *rogue_font; 301. 	QString messages; 302. 	QRect messages_rect; 303.  304.  	void Changed(int x,int y); 305.  306.  signals: 307. 	void resized; 308.  309.  private slots: 310. 	void updateTiles; 311. 	void moveMessages(int x, int y); 312.  313.  protected: 314. 	virtual void paintEvent(QPaintEvent*); 315. 	virtual void mousePressEvent(QMouseEvent*); 316.  317.  public: 318. 	NetHackQtMapWindow(NetHackQtClickBuffer& click_sink); 319. 	~NetHackQtMapWindow; 320.  321.  	virtual QWidget* Widget; 322. 	virtual bool Destroy; 323.  324.  	virtual void Clear; 325. 	virtual void Display(bool block); 326. 	virtual void CursorTo(int x,int y); 327. 	virtual void PutStr(int attr, const char* text); 328. 	virtual void ClipAround(int x,int y); 329. 	virtual void PrintGlyph(int x,int y,int glyph); 330.  331.  	void Scroll(int dx, int dy); 332.  333.  	// For messages 334. 	void displayMessages(bool block); 335. 	void putMessage(int attr, const char* text); 336. 	void clearMessages; 337.  338.  	void clickCursor; 339. };  340.   341.  class NetHackQtScrollText; 342. class NetHackQtMessageWindow : QObject, public NetHackQtWindow { 343. 	Q_OBJECT 344. public: 345. 	NetHackQtMessageWindow; 346. 	~NetHackQtMessageWindow; 347.  348.  	virtual QWidget* Widget; 349. 	virtual void Clear; 350. 	virtual void Display(bool block); 351. 	virtual void PutStr(int attr, const char* text); 352.  353.  	void Scroll(int dx, int dy); 354.  355.  	void setMap(NetHackQtMapWindow*); 356.  357.  private: 358. 	NetHackQtScrollText* list; 359. 	bool changed; 360. 	NetHackQtMapWindow* map; 361.  362.  private slots: 363. 	void updateFont; 364. };  365.   366.  class NetHackQtLabelledIcon : public QWidget { 367. public: 368. 	NetHackQtLabelledIcon(QWidget* parent, const char* label); 369. 	NetHackQtLabelledIcon(QWidget* parent, const char* label, const QPixmap& icon); 370.  371.  	enum { NoNum=-99999 }; 372. 	void setLabel(const char*, bool lower=TRUE); // a string 373. 	void setLabel(const char*, long, const char* tail=""); // a number 374. 	void setLabel(const char*, long show_value, long comparative_value, const char* tail=""); 375. 	void setIcon(const QPixmap&); 376. 	virtual void setFont(const QFont&); 377.  378.  	void highlightWhenChanging; 379. 	void lowIsGood; 380. 	void dissipateHighlight; 381.  382.  	virtual void show; 383.  384.  protected: 385. 	void resizeEvent(QResizeEvent*); 386.  387.  private: 388. 	void initHighlight; 389. 	void setAlignments; 390. 	void highlight(const QPalette& highlight); 391. 	void unhighlight; 392.  393.  	bool low_is_good; 394. 	int prev_value; 395. 	int turn_count;		/* last time the value changed */ 396. 	QPalette hl_good; 397. 	QPalette hl_bad; 398.  399.  	QLabel* label; 400. 	QLabel* icon; 401. };  402.   403.  class NetHackQtStatusWindow : QWidget, public NetHackQtWindow { 404. 	Q_OBJECT 405. public: 406. 	NetHackQtStatusWindow; 407.  408.  	virtual QWidget* Widget; 409.  410.  	virtual void Clear; 411. 	virtual void Display(bool block); 412. 	virtual void CursorTo(int x,int y); 413. 	virtual void PutStr(int attr, const char* text); 414.  415.  	void fadeHighlighting; 416.  417.  protected: 418. 	void resizeEvent(QResizeEvent*); 419.  420.  private slots: 421. 	void doUpdate; 422.  423.  private: 424. 	enum { hilight_time=1 }; 425.  426.  	QPixmap p_str; 427. 	QPixmap p_dex; 428. 	QPixmap p_con; 429. 	QPixmap p_int; 430. 	QPixmap p_wis; 431. 	QPixmap p_cha; 432.  433.  	QPixmap p_chaotic; 434. 	QPixmap p_neutral; 435. 	QPixmap p_lawful; 436.  437.  	QPixmap p_satiated; 438. 	QPixmap p_hungry; 439.  440.  	QPixmap p_confused; 441. 	QPixmap p_sick_fp; 442. 	QPixmap p_sick_il; 443. 	QPixmap p_blind; 444. 	QPixmap p_stunned; 445. 	QPixmap p_hallu; 446.  447.  	QPixmap p_encumber[5]; 448.  449.  	NetHackQtLabelledIcon name; 450. 	NetHackQtLabelledIcon dlevel; 451.  452.  	NetHackQtLabelledIcon str; 453. 	NetHackQtLabelledIcon dex; 454. 	NetHackQtLabelledIcon con; 455. 	NetHackQtLabelledIcon intel; 456. 	NetHackQtLabelledIcon wis; 457. 	NetHackQtLabelledIcon cha; 458.  459.  	NetHackQtLabelledIcon gold; 460. 	NetHackQtLabelledIcon hp; 461. 	NetHackQtLabelledIcon power; 462. 	NetHackQtLabelledIcon ac; 463. 	NetHackQtLabelledIcon level; 464. 	NetHackQtLabelledIcon exp; 465. 	NetHackQtLabelledIcon align; 466.  467.  	NetHackQtLabelledIcon time; 468. 	NetHackQtLabelledIcon score; 469.  470.  	NetHackQtLabelledIcon hunger; 471. 	NetHackQtLabelledIcon confused; 472. 	NetHackQtLabelledIcon sick_fp; 473. 	NetHackQtLabelledIcon sick_il; 474. 	NetHackQtLabelledIcon blind; 475. 	NetHackQtLabelledIcon stunned; 476. 	NetHackQtLabelledIcon hallu; 477. 	NetHackQtLabelledIcon encumber; 478.  479.  	QFrame hline1; 480. 	QFrame hline2; 481. 	QFrame hline3; 482.  483.  	int cursy; 484.  485.  	bool first_set; 486.  487.  	void nullOut; 488. 	void updateStats; 489. 	void checkTurnEvents; 490. };  491.   492.  class NetHackQtMenuDialog : public QDialog { 493. 	Q_OBJECT 494. public: 495. 	NetHackQtMenuDialog; 496.  497.  	void Accept; 498. 	void Reject; 499. 	void SetResult(int); 500.  501.  	virtual void done(int); 502.  503.  protected: 504. 	void resizeEvent(QResizeEvent*); 505.  506.  signals: 507. 	void Resized; 508. };  509.   510.   511.  class NetHackQtMenuWindow : public QTableView, public NetHackQtWindow { 512. 	Q_OBJECT 513. public: 514. 	NetHackQtMenuWindow(NetHackQtKeyBuffer&); 515. 	~NetHackQtMenuWindow; 516.  517.  	virtual QWidget* Widget; 518.  519.  	virtual void StartMenu; 520. 	virtual void AddMenu(int glyph, const ANY_P* identifier, char ch, char gch, int attr,  521.  			const char* str, bool presel); 522. 	virtual void EndMenu(const char* prompt); 523. 	virtual int SelectMenu(int how, MENU_ITEM_P **menu_list); 524.  525.  public slots: 526. 	void All; 527. 	void ChooseNone; 528. 	void Invert; 529. 	void Search; 530.  531.  	void Layout; 532. 	void ToggleSelect(int); 533.  534.  protected: 535. 	virtual void keyPressEvent(QKeyEvent*); 536. 	//virtual void mouseDoubleClickEvent(QMouseEvent*); 537. 	virtual void mousePressEvent(QMouseEvent*); 538. 	virtual void mouseReleaseEvent(QMouseEvent*); 539. 	virtual void mouseMoveEvent(QMouseEvent*); 540. 	virtual void focusOutEvent(QFocusEvent*); 541. 	virtual void focusInEvent(QFocusEvent*); 542.  543.  	virtual void paintCell(QPainter*, int, int); 544. 	virtual int cellWidth(int col); 545.  546.  private: 547. 	struct MenuItem { 548. 		MenuItem; 549. 		~MenuItem; 550.  551.  		int glyph; 552. 		ANY_P identifier; 553. 		int attr; 554. 		const char* str; 555. 		int count; 556. 		char ch; 557. 		bool selected; 558.  559.  		bool Selectable const { return identifier.a_void!=0; } 560. 	};  561.   562.  	QArray<MenuItem> item; 563.  564.  	int itemcount; 565. 	int str_width; 566. 	bool str_fixed; 567. 	int next_accel; 568.  569.  	NetHackQtKeyBuffer& keysource; 570.  571.  	NetHackQtMenuDialog* dialog; 572.  573.  	QPushButton* ok; 574. 	QPushButton* cancel; 575. 	QPushButton* all; 576. 	QPushButton* none; 577. 	QPushButton* invert; 578. 	QPushButton* search; 579. 	QLabel prompt; 580.  581.  	int how; 582.  583.  	bool has_glyphs; 584.  585.  	int pressed; 586. 	bool was_sel; 587. };  588.   589.  class NetHackQtTextListBox; 590.  591.  class NetHackQtRIP : public QWidget { 592. private: 593. 	static QPixmap* pixmap; 594. 	char** line; 595. 	int riplines; 596.  597.  public: 598. 	NetHackQtRIP(QWidget* parent); 599.  600.  	void setLines(char** l, int n); 601.  602.  protected: 603. 	virtual void paintEvent(QPaintEvent* event); 604. 	QSize sizeHint const; 605. };  606.   607.   608.  class NetHackQtTextWindow : public QDialog, public NetHackQtWindow { 609. 	Q_OBJECT 610. public: 611. 	NetHackQtTextWindow(NetHackQtKeyBuffer&); 612. 	~NetHackQtTextWindow; 613.  614.  	virtual QWidget* Widget; 615.  616.  	virtual void Clear; 617. 	virtual bool Destroy; 618. 	virtual void Display(bool block); 619. 	virtual void PutStr(int attr, const char* text); 620. 	virtual void UseRIP(int how); 621.  622.  public slots: 623. 	void Search; 624.  625.  protected: 626. 	virtual void done(int); 627. 	virtual void keyPressEvent(QKeyEvent*); 628.  629.  private slots: 630. 	void doUpdate; 631.  632.  private: 633. 	NetHackQtKeyBuffer& keysource; 634.  635.  	bool use_rip; 636. 	bool str_fixed; 637.  638.  	QPushButton ok; 639. 	QPushButton search; 640. 	NetHackQtTextListBox* lines; 641.  642.  	NetHackQtRIP rip; 643. };  644.   645.  class NetHackQtMenuOrTextWindow : public NetHackQtWindow { 646. private: 647. 	NetHackQtWindow* actual; 648. 	NetHackQtKeyBuffer& keysource; 649.  650.  public: 651. 	NetHackQtMenuOrTextWindow(NetHackQtKeyBuffer&); 652.  653.  	virtual QWidget* Widget; 654.  655.  	// Text 656. 	virtual void Clear; 657. 	virtual bool Destroy; 658. 	virtual void Display(bool block); 659. 	virtual void PutStr(int attr, const char* text); 660.  661.  	// Menu 662. 	virtual void StartMenu; 663. 	virtual void AddMenu(int glyph, const ANY_P* identifier, char ch, char gch, int attr,  664.  			const char* str, bool presel); 665. 	virtual void EndMenu(const char* prompt); 666. 	virtual int SelectMenu(int how, MENU_ITEM_P **menu_list); 667.  668.  };  669.   670.  class NetHackQtDelay : QObject { 671. private: 672. 	int msec; 673.  674.  public: 675. 	NetHackQtDelay(int ms); 676. 	void wait; 677. 	virtual void timerEvent(QTimerEvent* timer); 678. };  679.   680.   681.  class NetHackQtInvUsageWindow : public QWidget { 682. public: 683. 	NetHackQtInvUsageWindow(QWidget* parent); 684. 	virtual void paintEvent(QPaintEvent*); 685. private: 686. 	void drawWorn(QPainter& painter, obj*, int x, int y, bool canbe=TRUE); 687. };  688.   689.  // This class is the main widget for NetHack 690. //  691.  // It is a collection of Message, Map, and Status windows. In the current 692. // version of nethack there is only one of each, and this class makes this 693. // assumption, not showing itself until all are inserted. 694. //  695.  // This class simply knows how to layout such children sensibly. 696. //  697.  // Since it is only responsible for layout, the class does not 698. // note the actual class of the windows. 699. //  700.  #ifndef KDE 701. #include "qt_kde0.h"  702. #endif 703.  704.  class NetHackQtMainWindow : public KTopLevelWidget { 705. 	Q_OBJECT 706. public: 707. 	NetHackQtMainWindow(NetHackQtKeyBuffer&); 708.  709.  	void AddMessageWindow(NetHackQtMessageWindow* window); 710. 	void AddMapWindow(NetHackQtMapWindow* window); 711. 	void AddStatusWindow(NetHackQtStatusWindow* window); 712. 	void RemoveWindow(NetHackQtWindow* window); 713. 	void updateInventory; 714.  715.  	void fadeHighlighting; 716.  717.  public slots: 718. 	void doMenuItem(int); 719. 	void doKeys(const QString&); 720.  721.  protected: 722. 	virtual void resizeEvent(QResizeEvent*); 723. 	virtual void keyPressEvent(QKeyEvent*); 724. 	virtual void keyReleaseEvent(QKeyEvent* event); 725. 	virtual void closeEvent(QCloseEvent*); 726.  727.  private slots: 728. 	void layout; 729. 	void raiseMap; 730. 	void zoomMap; 731. 	void raiseMessages; 732. 	void raiseStatus; 733.  734.  private: 735. 	void ShowIfReady; 736.  737.  #ifdef KDE 738. 	KMenuBar* menubar; 739. #else 740. 	QMenuBar* menubar; 741. #endif 742. 	NetHackQtMessageWindow* message; 743. 	NetHackQtMapWindow* map; 744. 	NetHackQtStatusWindow* status; 745. 	NetHackQtInvUsageWindow* invusage; 746.  747.  	NetHackQtKeyBuffer& keysink; 748. 	QWidgetStack* stack; 749. 	int dirkey; 750.  751.  	const char* *macro; 752. };  753.   754.  class NetHackQtYnDialog : QDialog { 755. 	Q_OBJECT 756. private: 757. 	const char* question; 758. 	const char* choices; 759. 	char def; 760. 	NetHackQtKeyBuffer& keysource; 761.  762.  protected: 763. 	virtual void keyPressEvent(QKeyEvent*); 764. 	virtual void done(int); 765.  766.  private slots: 767. 	void doneItem(int); 768.  769.  public: 770. 	NetHackQtYnDialog(NetHackQtKeyBuffer& keysource,const char*,const char*,char); 771.  772.  	char Exec; 773. };  774.   775.  #ifdef KDE 776. #define NetHackQtBindBase KApplication 777. #elif defined(QWS) 778. #define NetHackQtBindBase QPEApplication 779. #else 780. #define NetHackQtBindBase QApplication 781. #endif 782.  783.  class NetHackQtBind : NetHackQtBindBase { 784. private: 785. 	// Single-instance preservation...  786. NetHackQtBind(int& argc, char** argv); 787.  788.  	static NetHackQtBind* instance; 789.  790.  	static NetHackQtKeyBuffer keybuffer; 791. 	static NetHackQtClickBuffer clickbuffer; 792.  793.  	static QWidget* splash; 794. 	static NetHackQtMainWindow* main; 795.  796.  public: 797. 	static void qt_init_nhwindows(int* argc, char** argv); 798. 	static void qt_player_selection; 799. 	static void qt_askname; 800. 	static void qt_get_nh_event; 801. 	static void qt_exit_nhwindows(const char *); 802. 	static void qt_suspend_nhwindows(const char *); 803. 	static void qt_resume_nhwindows; 804. 	static winid qt_create_nhwindow(int type); 805. 	static void qt_clear_nhwindow(winid wid); 806. 	static void qt_display_nhwindow(winid wid, BOOLEAN_P block); 807. 	static void qt_destroy_nhwindow(winid wid); 808. 	static void qt_curs(winid wid, int x, int y); 809. 	static void qt_putstr(winid wid, int attr, const char *text); 810. 	static void qt_display_file(const char *filename, BOOLEAN_P must_exist); 811. 	static void qt_start_menu(winid wid); 812. 	static void qt_add_menu(winid wid, int glyph,  813.  		const ANY_P * identifier, CHAR_P ch, CHAR_P gch, int attr,  814.  		const char *str, BOOLEAN_P presel); 815. 	static void qt_end_menu(winid wid, const char *prompt); 816. 	static int qt_select_menu(winid wid, int how, MENU_ITEM_P **menu_list); 817. 	static void qt_update_inventory; 818. 	static void qt_mark_synch; 819. 	static void qt_wait_synch; 820.  821.  	static void qt_cliparound(int x, int y); 822. 	static void qt_cliparound_window(winid wid, int x, int y); 823. 	static void qt_print_glyph(winid wid,XCHAR_P x,XCHAR_P y,int glyph); 824. 	static void qt_raw_print(const char *str); 825. 	static void qt_raw_print_bold(const char *str); 826. 	static int qt_nhgetch; 827. 	static int qt_nh_poskey(int *x, int *y, int *mod); 828. 	static void qt_nhbell; 829. 	static int qt_doprev_message; 830. 	static char qt_yn_function(const char *question, const char *choices, CHAR_P def); 831. 	static void qt_getlin(const char *prompt, char *line); 832. 	static int qt_get_ext_cmd; 833. 	static void qt_number_pad(int); 834. 	static void qt_delay_output; 835. 	static void qt_start_screen; 836. 	static void qt_end_screen; 837.  838.  	static void qt_outrip(winid wid, int how); 839. 	static int qt_kbhit; 840.  841.  private: 842. 	virtual bool notify(QObject *receiver, QEvent *event); 843. };  844.   845.  #endif