The new dialog engine is now essentially complete and ready for testing. There could still be some error checking in the cPict class to make sure the required GWorld exists, though.

git-svn-id: http://openexile.googlecode.com/svn/trunk@76 4ebdad44-0ea0-11de-aab3-ff745001d230

osx/dialogxml/button.cpp

@@ -8,7 +8,7 @@
 
 #include <vector>
 #include <map>
-using namespace std;
+#include <stdexcept>
 
 #include "dialog.h"
 #include "graphtool.h"
@@ -21,12 +21,14 @@ void cButton::attachClickHandler(click_callback_t f) throw(){
 	onClick = f;
 }
 
-bool cButton::triggerClickHandler(cDialog& me, std::string id, eKeyMod mods){
+bool cButton::triggerClickHandler(cDialog& me, std::string id, eKeyMod mods, Point where){
 	if(onClick != NULL) return onClick(me,id,mods);
 	return false;
 }
 
-cButton::cButton(cDialog* parent) : cControl(parent) {}
+cButton::cButton(cDialog* parent) : cControl(parent,CTRL_BTN) {}
+
+cButton::cButton(cDialog* parent,eControlType t) : cControl(parent,t) {}
 
 bool cButton::isClickable(){
 	return true;
@@ -131,6 +133,11 @@ void cButton::init(){
 	OffsetRect(&btnRects[BTN_PUSH][1],30,0);
 }
 
+void cButton::finalize(){
+	for(int i = 0; i < 7; i++)
+		DisposeGWorld(buttons[i]);
+}
+
 Rect cLed::ledRects[3][2];
 
 void cLed::init(){
@@ -142,19 +149,41 @@ void cLed::init(){
 		}
 }
 
-cLed::cLed(cDialog* parent) : cButton(parent) {}
+cLed::cLed(cDialog* parent) : cButton(parent,CTRL_LED) {}
 
 void cLed::attachClickHandler(click_callback_t f) throw(){
 	onClick = f;
 }
 
-void cLed::attachFocusHandler(focus_callback_t __attribute__((unused))) throw(xHandlerNotSupported){
-	throw xHandlerNotSupported(true);
+void cLed::attachFocusHandler(focus_callback_t f) throw(){
+	onFocus = f;
 }
 
-bool cLed::triggerClickHandler(cDialog& me, std::string id, eKeyMod mods){
-	if(onClick != NULL) return onClick(me,id,mods);
-	return false;
+bool cLed::triggerFocusHandler(cDialog& me, std::string id, bool losing){
+	if(onFocus != NULL) return onFocus(me,id,losing);
+	return true;
+}
+
+bool cLed::triggerClickHandler(cDialog& me, std::string id, eKeyMod mods, Point where){
+	bool result;
+	eLedState oldState = state;
+	if(onClick != NULL) result = onClick(me,id,mods);
+	else{ // simple state toggle
+		switch(state){
+			case led_red:
+			case led_green:
+				state = led_off;
+				break;
+			case led_off:
+				state = led_red;
+		}
+		result = true;
+	}
+	if(!triggerFocusHandler(me,id, oldState != led_off)){
+		result = false;
+		state = oldState;
+	}
+	return result;
 }
 
 void cLed::setFormat(eFormat prop __attribute__((unused)), short val __attribute__((unused))) throw(xUnsupportedProp){
@@ -195,7 +224,7 @@ void cLed::draw(){
 	SetPort(old_port);
 }
 
-cLedGroup::cLedGroup(cDialog* parent) : cControl(parent) {}
+cLedGroup::cLedGroup(cDialog* parent) : cControl(parent,CTRL_GROUP) {}
 
 cButton::~cButton() {}
 
@@ -208,3 +237,131 @@ cLedGroup::~cLedGroup(){
 		iter++;
 	}
 }
+
+/** A click handler is called whenever a click is received, even on the currently selected element. */
+void cLedGroup::attachClickHandler(click_callback_t f) throw() {
+	onClick = f;
+}
+
+/** A focus handler is called when the currently selected element changes. */
+void cLedGroup::attachFocusHandler(focus_callback_t f) throw() {
+	onFocus = f;
+}
+
+void cLed::setState(eLedState to){
+	state = to;
+}
+
+eLedState cLed::getState(){
+	return state;
+}
+
+bool cLedGroup::triggerClickHandler(cDialog& me, std::string id, eKeyMod mods, Point where){
+	std::string which_clicked;
+	ledIter iter = choices.begin();
+	while(iter != choices.end()){
+		if(iter->second->visible && PtInRect(where,&iter->second->frame)){
+			if(iter->second->handleClick())
+				which_clicked = iter->first;
+		}
+		iter++;
+	}
+	
+	if(choices[which_clicked]->triggerClickHandler(me,curSelect,mods,where)){
+		eLedState a, b;
+		a = choices[curSelect]->getState();
+		b = choices[which_clicked]->getState();
+		choices[curSelect]->setState(led_off);
+		choices[which_clicked]->setState(led_red);
+		if(!choices[curSelect]->triggerFocusHandler(me,curSelect,true)){
+			choices[curSelect]->setState(a);
+			choices[which_clicked]->setState(b);
+			return false;
+		}
+		if(!choices[which_clicked]->triggerFocusHandler(me,curSelect,false)){
+			choices[curSelect]->setState(a);
+			choices[which_clicked]->setState(b);
+			return false;
+		}
+		curSelect = which_clicked;
+	}else return false;
+	
+	return triggerFocusHandler(me,id,false);
+}
+
+bool cLedGroup::triggerFocusHandler(cDialog& me, std::string id, bool losingFocus){
+	if(onFocus != NULL) return onFocus(me,id,losingFocus);
+	return true;
+}
+
+void cLedGroup::disable(std::string id) {
+	// TODO: Implement this
+}
+
+void cLedGroup::enable(std::string id) {
+	// TODO: Implement this
+}
+
+void cLedGroup::show(std::string id){
+	choices[id]->show();
+}
+
+void cLedGroup::hide(std::string id){
+	choices[id]->hide();
+}
+
+void cLedGroup::setFormat(eFormat prop __attribute__((unused)), short val __attribute__((unused))) throw(xUnsupportedProp) {
+	throw xUnsupportedProp(prop);
+}
+
+short cLedGroup::getFormat(eFormat prop __attribute__((unused))) throw(xUnsupportedProp) {
+	throw xUnsupportedProp(prop);
+}
+
+bool cLedGroup::isClickable(){
+	return true;
+}
+
+cLed& cLedGroup::operator[](std::string id){
+	ledIter iter = choices.find(id);
+	if(iter == choices.end()) throw std::invalid_argument(id + " does not exist in the ledgroup.");
+	return *(iter->second);
+}
+
+void cLedGroup::setSelection(std::string id){
+	ledIter iter = choices.find(id);
+	if(iter == choices.end()) throw std::invalid_argument(id + " does not exist in the ledgroup.");
+	
+	eLedState a, b;
+	a = choices[curSelect]->getState();
+	b = iter->second->getState();
+	choices[curSelect]->setState(led_off);
+	iter->second->setState(led_red);
+	if(!choices[curSelect]->triggerFocusHandler(*parent,curSelect,true)){
+		choices[curSelect]->setState(a);
+		iter->second->setState(b);
+		return;
+	}
+	if(!iter->second->triggerFocusHandler(*parent,curSelect,false)){
+		choices[curSelect]->setState(a);
+		iter->second->setState(b);
+		return;
+	}
+	curSelect = iter->first;
+}
+
+std::string cLedGroup::getSelection(){
+	return curSelect;
+}
+
+std::string cLedGroup::getPrevSelection(){
+	return prevSelect;
+}
+
+void cLedGroup::draw(){
+	ledIter iter = choices.begin();
+	while(iter != choices.end()){
+		iter->second->draw();
+		iter++;
+	}
+}

osx/dialogxml/button.h

@@ -35,25 +35,27 @@ enum eLedState {led_green = 0, led_red, led_off};
 class cButton : public cControl {
 public:
 	static void init();
+	static void finalize();
 	void attachClickHandler(click_callback_t f) throw();
 	void attachFocusHandler(focus_callback_t f) throw(xHandlerNotSupported);
-	bool triggerClickHandler(cDialog& me, std::string id, eKeyMod mods);
+	bool triggerClickHandler(cDialog& me, std::string id, eKeyMod mods, Point where);
 	//virtual void setPict(short pict, short type) = 0;
 	void setFormat(eFormat prop, short val) throw(xUnsupportedProp);
 	short getFormat(eFormat prop) throw(xUnsupportedProp);
-	cButton(cDialog* parent);
+	explicit cButton(cDialog* parent);
+	cButton(cDialog* parent,eControlType t);
 	bool isClickable();
 	virtual ~cButton();
 protected:
 	//friend class cDialog;
 	void draw();
+	eBtnType type;
+	click_callback_t onClick;
 private:
 	friend class cDialog;
-	click_callback_t onClick;
 	bool wrapLabel;
 	bool labelWithKey;
 	bool pressed;
-	eBtnType type;
 	std::string fromList;
 	static Rect btnRects[13][2];
 	static size_t btnGW[13];
@@ -65,22 +67,26 @@ class cLed : public cButton {
 public:
 	static void init();
 	void attachClickHandler(click_callback_t f) throw();
-	void attachFocusHandler(focus_callback_t f) throw(xHandlerNotSupported);
-	bool triggerClickHandler(cDialog& me, std::string id, eKeyMod mods);
+	void attachFocusHandler(focus_callback_t f) throw();
+	bool triggerClickHandler(cDialog& me, std::string id, eKeyMod mods, Point where);
+	bool triggerFocusHandler(cDialog& me, std::string id, bool losingFocus);
 	void setFormat(eFormat prop, short val) throw(xUnsupportedProp);
 	short getFormat(eFormat prop) throw(xUnsupportedProp);
-	cLed(cDialog* parent);
+	explicit cLed(cDialog* parent);
 	virtual ~cLed();
+	void setState(eLedState to);
+	eLedState getState();
 protected:
 	void draw();
 private:
 	friend class cDialog;
+	friend class cLedGroup;
 	eLedState state;
 	eTextFont textFont;
 	RGBColor color;
 	short textSize;
 	static Rect ledRects[3][2];
-	click_callback_t onClick;
+	focus_callback_t onFocus;
 };
 
 class cLedGroup : public cControl {
@@ -89,25 +95,32 @@ class cLedGroup : public cControl {
 	focus_callback_t onFocus;
 	std::map<std::string,cLed*> choices;
 	std::string fromList;
-	friend class cDialog;
+	std::string curSelect, prevSelect;
 public:
 	void attachClickHandler(click_callback_t f) throw(); // activated whenever a click is received, even on the currently active LED
 	void attachFocusHandler(focus_callback_t f) throw(); // activated only when the selection changes
-	bool triggerClickHandler(cDialog& me, std::string id, eKeyMod mods);
+	bool triggerClickHandler(cDialog& me, std::string id, eKeyMod mods, Point where);
 	bool triggerFocusHandler(cDialog& me, std::string id, bool losingFocus);
 	void setSelected(std::string id);
 	std::string getSelected();
 	void disable(std::string id);
 	void enable(std::string id);
+	using cControl::show;
+	using cControl::hide;
 	void hide(std::string id);
 	void show(std::string id);
 	void setFormat(eFormat prop, short val) throw(xUnsupportedProp);
 	short getFormat(eFormat prop) throw(xUnsupportedProp);
-	cLedGroup(cDialog* parent);
+	explicit cLedGroup(cDialog* parent);
 	bool isClickable();
 	virtual ~cLedGroup();
+	cLed& operator[](std::string id);
+	void setSelection(std::string id);
+	std::string getSelection();
+	std::string getPrevSelection(); // The id of the element that was last selected before the selection changed to the current selection.
 	typedef std::map<std::string,cLed*>::iterator ledIter;
 protected:
 	void draw();
+	friend class cDialog;
 };
 #endif

osx/dialogxml/control.cpp

@@ -12,56 +12,15 @@
 
 extern bool play_sounds;
 
-void cControl::setLabel(std::string l){
+void cControl::setText(std::string l){
 	lbl = l;
 	if(isVisible()) draw();
 }
 
-std::string cControl::getLabel(){
+std::string cControl::getText(){
 	return lbl;
 }
 
-static unsigned char applyShift(unsigned char c){
-	static const char afterShift[] = {
-		' ', '!', '"', '#', '$', '%', '&', '"', '(', ')', '*', '+', '<', '_', '>', '?',
-		')', '!', '@', '#', '$', '%', '^', '&', '*', '(', ':', ':', '<', '+', '>', '?',
-		'@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
-		'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '{', '|', '}', '^', '_',
-		'~', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
-		'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '{', '|', '}', '~',
-	};
-	return afterShift[c - ' '];
-}
-
-static unsigned char removeShift(unsigned char c){
-	static const char afterUnShift[] = {
-		' ', '1', '\'','3', '4', '5', '7', '\'','9', '0', '8', '=', ',', '-', '.', '/',
-		'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ';', ';', ',', '=', '.', '/',
-		'2', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
-		'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '[', '\\',']', '6', '-',
-		'`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
-		'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '[', '\\',']', '`',
-	};
-	return afterUnShift[c - ' '];
-}
-
-void cControl::setLabelToKey(){
-	if(key.spec); // TODO: Handle this case
-	else{
-		unsigned char c = key.c;
-		if(key.mod - mod_shift != key.mod) c = applyShift(c);
-		else c = removeShift(c);
-		if(key.mod - mod_ctrl != key.mod) lbl = "^" + c;
-		else if(key.mod - mod_alt != key.mod) lbl = "*" + c;
-		else lbl = c;
-	}
-	if(isVisible()) draw();
-}
-
-void cControl::attachKey(cKey key){
-	this->key = key;
-}
-
 const char* xHandlerNotSupported::focusMsg = "This control cannot handle focus events.\n";
 const char* xHandlerNotSupported::clickMsg = "This control cannot handle click events.\n";
 
@@ -227,11 +186,55 @@ bool cControl::handleClick(){
 	return clicked;
 }
 
-cControl::cControl(cDialog* p){
-	parent = p;
+static unsigned char applyShift(unsigned char c){
+	static const char afterShift[] = {
+		' ', '!', '"', '#', '$', '%', '&', '"', '(', ')', '*', '+', '<', '_', '>', '?',
+		')', '!', '@', '#', '$', '%', '^', '&', '*', '(', ':', ':', '<', '+', '>', '?',
+		'@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+		'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '{', '|', '}', '^', '_',
+		'~', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+		'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '{', '|', '}', '~',
+	};
+	return afterShift[c - ' '];
 }
 
-bool cControl::triggerClickHandler(cDialog& me __attribute__((unused)), std::string id __attribute__((unused)), eKeyMod mods __attribute__((unused))){
+static unsigned char removeShift(unsigned char c){
+	static const char afterUnShift[] = {
+		' ', '1', '\'','3', '4', '5', '7', '\'','9', '0', '8', '=', ',', '-', '.', '/',
+		'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ';', ';', ',', '=', '.', '/',
+		'2', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+		'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '[', '\\',']', '6', '-',
+		'`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+		'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '[', '\\',']', '`',
+	};
+	return afterUnShift[c - ' '];
+}
+
+void cControl::setTextToKey(){
+	if(key.spec); // TODO: Handle this case
+	else{
+		unsigned char c = key.c;
+		if(key.mod - mod_shift != key.mod) c = applyShift(c);
+		else c = removeShift(c);
+		if(key.mod - mod_ctrl != key.mod) lbl = "^" + c;
+		else if(key.mod - mod_alt != key.mod) lbl = "*" + c;
+		else lbl = c;
+	}
+	if(isVisible()) draw();
+}
+
+void cControl::attachKey(cKey key){
+	this->key = key;
+}
+
+void cControl::detachKey(){
+	this->key.spec = false;
+	this->key.c = 0;
+}
+
+cControl::cControl(cDialog* p, eControlType t) : parent(p), type(t) {}
+
+bool cControl::triggerClickHandler(cDialog& __attribute__((unused)), std::string __attribute__((unused)), eKeyMod __attribute__((unused)), Point __attribute__((unused))){
 	return true;
 }
 
@@ -296,3 +299,7 @@ bool cControl::foundSilom(){
 }
 
 cControl::~cControl() {}
+
+eControlType cControl::getType(){
+	return type;
+}

osx/dialogxml/control.h

@@ -53,6 +53,17 @@ enum eFormat {
 	TXT_WRAP,
 };
 
+enum eControlType {
+	CTRL_UNKNOWN,
+	CTRL_BTN,	// An ordinary push button
+	CTRL_LED,	// An LED (checkbox/radiobutton)
+	CTRL_PICT,	// A picture
+	CTRL_FIELD,	// An edit text field
+	CTRL_TEXT,	// A static text object
+	CTRL_GROUP,	// A LED radiobutton-like group
+	CTRL_STACK,	// A group of controls that display pages (not implemented yet)
+};
+
 enum eTextFont {DUNGEON, GENEVA, SILOM, MAIDENWORD};
 
 class cDialog;
@@ -81,35 +92,40 @@ class cControl {
 public:
 	static void init();
 	void attachKey(cKey key);
+	void detachKey();
+	void setTextToKey();
 	virtual void attachClickHandler(click_callback_t f) throw(xHandlerNotSupported) = 0;
 	virtual void attachFocusHandler(focus_callback_t f) throw(xHandlerNotSupported) = 0;
-	virtual bool triggerClickHandler(cDialog& me, std::string id, eKeyMod mods);
+	virtual bool triggerClickHandler(cDialog& me, std::string id, eKeyMod mods, Point where);
 	virtual bool triggerFocusHandler(cDialog& me, std::string id, bool losingFocus);
 	//virtual void setPict(short pict, short type) = 0;
 	virtual void show(); // cd_activate_item true
 	virtual void hide(); // cd_activate_item false
 	bool isVisible(); // cd_get_active
-	void setLabel(std::string l);
-	std::string getLabel();
-	void setLabelToKey();
+	eControlType getType();
+	virtual void setText(std::string l);
+	virtual std::string getText();
 	virtual void setFormat(eFormat prop, short val) throw(xUnsupportedProp) = 0;
 	virtual short getFormat(eFormat prop) throw(xUnsupportedProp) = 0;
 	virtual bool isClickable() = 0;
 	bool handleClick();
-	cControl(cDialog* p);
+	cControl(cDialog* p,eControlType t);
 	virtual ~cControl();
 protected:
 	cDialog* parent;
 	std::string lbl;
-	cKey key;
 	bool visible, depressed; // depressed is only applicable for clickable controls
 	Rect frame;
+	cKey key;
 	friend class cDialog;
+	friend class cLedGroup;
+	//friend class cStack;
 	virtual void draw() = 0;
 	static bool foundSilom();
 	static short font_nums[4];
 	void drawFrame(short amt, short med_or_lt);
 private:
+	eControlType type;
 	static bool found_silom;
 };
 

osx/dialogxml/dialog.cpp

@@ -12,6 +12,7 @@
 #include "dialog.h"
 #include "graphtool.h"
 #include "soundtool.h"
+#include <stdexcept>
 using namespace std;
 using namespace ticpp;
 
@@ -644,13 +645,17 @@ cDialog::cDialog(string path){
 	win = NewCWindow(NULL, &winRect, (unsigned char*) "", false, dBoxProc, IN_FRONT, false, 0);
 }
 
-void cDialog::init(){
+cDialog::_init::_init(){
 	cControl::init();
 	cButton::init();
 	cLed::init();
 	cPict::init();
 }
 
+cDialog::_init::~_init(){
+	cButton::finalize();
+}
+
 cDialog::~cDialog(){
 	ctrlIter iter = controls.begin();
 	while(iter != controls.end()){
@@ -787,7 +792,7 @@ void cDialog::run(){
 				break;
 		}
 		ctrlIter ctrl = controls.find(itemHit);
-		if(ctrl != controls.end()) ctrl->second->triggerClickHandler(*this,itemHit,key.mod);
+		if(ctrl != controls.end()) ctrl->second->triggerClickHandler(*this,itemHit,key.mod,currentEvent.where);
 	}
 	EndAppModalStateForWindow(win);
 	HideWindow(win);
@@ -918,3 +923,25 @@ void cDialog::draw(){
 	
 	SetPort(old_port);
 }
+
+cControl& cDialog::operator[](std::string id){
+	ctrlIter iter = controls.find(id);
+	if(iter != controls.end()) return *(iter->second);
+	
+	iter = controls.begin();
+	while(iter != controls.end()){
+		if(iter->second->getType() == CTRL_GROUP){
+			try{
+				cLedGroup* tmp = (cLedGroup*) (iter->second);
+				return tmp->operator[](id);
+			}catch(std::invalid_argument) {}
+		}else if(iter->second->getType() == CTRL_STACK){ // TODO: Implement stacks
+//			try{
+//			cStack* tmp = (cStack*) (iter->second);
+//			return tmp->operator[](id);
+//			}catch(std::invalid_argument) {}
+		}
+		iter++;
+	}
+	throw std::invalid_argument(id + " does not exist in the dialog.");
+}

osx/dialogxml/dialog.h

@@ -31,9 +31,13 @@ class cDialog {
 	cKey parseKey(std::string what);
 	WindowRef win;
 	cTextField* currentFocus;
+	class _init {
+		_init();
+		~_init();
+	};
+	static _init init;
 public:
 	static const short BG_LIGHT, BG_DARK;
-	static void init(); // must call this before constructing any dialogs
 	cDialog(std::string path); // cd_create_dialog
 	cDialog(std::string path,cDialog parent); // cd_create_dialog_parent_num
 	~cDialog(); // cd_kill_dialog
@@ -44,6 +48,7 @@ public:
 	void setBg(short n);
 	void setDefTextClr(RGBColor clr);
 	void toast();
+	cControl& operator[](std::string id);
 private:
 	void draw();
 	std::string process_keystroke(cKey keyHit);
@@ -57,6 +62,7 @@ private:
 	friend class cPict;
 	friend class cTextField;
 	friend class cTextMsg;
+	friend class _init;
 };
 
 class xBadNode : std::exception {

osx/dialogxml/field.cpp

@@ -63,7 +63,7 @@ bool cTextField::isClickable(){
 	return false;
 }
 
-cTextField::cTextField(cDialog* parent) : cControl(parent) {
+cTextField::cTextField(cDialog* parent) : cControl(parent,CTRL_FIELD) {
 	OSStatus err;
 	err = CreateEditTextControl(parent->win,&frame,NULL,false,true/*useInlineInput*/,NULL,&theField);
 }

osx/dialogxml/field.h

@@ -22,7 +22,7 @@ public:
 	void setText(std::string what);
 	short getTextAsNum();
 	void setTextToNum(short what);
-	cTextField(cDialog* parent);
+	explicit cTextField(cDialog* parent);
 	bool isClickable();
 	virtual ~cTextField();
 	void show();

osx/dialogxml/message.cpp

@@ -18,7 +18,7 @@ void cTextMsg::attachFocusHandler(focus_callback_t f __attribute__((unused))) th
 	throw xHandlerNotSupported(true);
 }
 
-bool cTextMsg::triggerClickHandler(cDialog& me, std::string id, eKeyMod mods){
+bool cTextMsg::triggerClickHandler(cDialog& me, std::string id, eKeyMod mods, Point where){
 	if(onClick != NULL) return onClick(me,id,mods);
 	return false;
 }
@@ -90,15 +90,7 @@ short cTextMsg::getFormat(eFormat prop) throw(xUnsupportedProp){
 	return 0;
 }
 
-std::string cTextMsg::getText(){
-	return getLabel();
-}
-
-void cTextMsg::setText(std::string what){
-	setLabel(what);
-}
-
-cTextMsg::cTextMsg(cDialog* parent) : cControl(parent) {}
+cTextMsg::cTextMsg(cDialog* parent) : cControl(parent,CTRL_TEXT) {}
 
 bool cTextMsg::isClickable(){
 	return clickable;

osx/dialogxml/message.h

@@ -15,12 +15,10 @@ class cTextMsg : public cControl {
 public:
 	void attachClickHandler(click_callback_t f) throw();
 	void attachFocusHandler(focus_callback_t f) throw(xHandlerNotSupported);
-	bool triggerClickHandler(cDialog& me, std::string id, eKeyMod mods);
+	bool triggerClickHandler(cDialog& me, std::string id, eKeyMod mods, Point where);
 	void setFormat(eFormat prop, short val) throw(xUnsupportedProp);
 	short getFormat(eFormat prop) throw(xUnsupportedProp);
-	std::string getText();
-	void setText(std::string what);
-	cTextMsg(cDialog* parent);
+	explicit cTextMsg(cDialog* parent);
 	bool isClickable();
 	virtual ~cTextMsg();
 protected:

osx/dialogxml/pict.cpp

@@ -71,7 +71,7 @@ void cPict::attachFocusHandler(focus_callback_t f __attribute__((unused))) throw
 	throw xHandlerNotSupported(true);
 }
 
-bool cPict::triggerClickHandler(cDialog& me, std::string id, eKeyMod mods){
+bool cPict::triggerClickHandler(cDialog& me, std::string id, eKeyMod mods, Point where){
 	if(onClick != NULL) return onClick(me,id,mods);
 	else return false;
 }
@@ -228,7 +228,7 @@ void cPict::setPict(short num, ePicType type){
 	if(isVisible()) draw();
 }
 
-cPict::cPict(cDialog* parent) : cControl(parent) {}
+cPict::cPict(cDialog* parent) : cControl(parent,CTRL_PICT) {}
 
 bool cPict::isClickable(){
 	return clickable;

osx/dialogxml/pict.h

@@ -89,13 +89,13 @@ public:
 	static void init();
 	void attachClickHandler(click_callback_t f) throw();
 	void attachFocusHandler(focus_callback_t f) throw(xHandlerNotSupported);
-	bool triggerClickHandler(cDialog& me, std::string id, eKeyMod mods);
+	bool triggerClickHandler(cDialog& me, std::string id, eKeyMod mods, Point where);
 	void setFormat(eFormat prop, short val) throw(xUnsupportedProp);
 	short getFormat(eFormat prop) throw(xUnsupportedProp);
 	static void setSheet(eSheetType type, short n, GWorldPtr sheet);
 	static bool isSheetSet(eSheetType type, size_t n);
 	void setPict(short num, ePicType type);
-	cPict(cDialog* parent);
+	explicit cPict(cDialog* parent);
 	bool isClickable();
 	static void advanceAnim();
 	virtual ~cPict();