- klavesy sa daju po zmene hned pouzit a program sa nemusi restartovat

- oprava chyby, vo funkcii na ukladanie bol preklep a do konfiguracneho suboru sa klavesy na strielanie a menu 
zbrani ukladal do kluca s preklepom TUX_RIGHT_MOVE_SHOOT namiesto TUX_RIGHT_SHOOT



git-svn-id: http://opensvn.csie.org/tuxanci_ng@178 0ee4d065-81f0-4d1e-b06c-ff20ad07cc3e

4 files changed, 98 insertions, 62 deletions

diff --git a/src/base/modules.h b/src/base/modules.h
index 5ad0287..1437c52 100644
--- a/src/base/modules.h
+++ b/src/base/modules.h
@@ -30,7 +30,7 @@ typedef struct export_fce_s
 #endif
 
 	int (*fce_getNetTypeGame)();
-	int (*fce_loadDepModule)(void *name);
+	int (*fce_loadDepModule)(char *name);
 #ifndef __WIN32__
 	void (*fce_addToExportFce)(char *name, void *function);
 #else
diff --git a/src/screen/screen_settingKeys.c b/src/screen/screen_settingKeys.c
index 4825a2f..e4003ce 100644
--- a/src/screen/screen_settingKeys.c
+++ b/src/screen/screen_settingKeys.c
@@ -1,4 +1,3 @@
-

 #include <stdio.h>

 #include <stdlib.h>

 #include <assert.h>

@@ -73,13 +72,41 @@ void startScreenSettingKeys()
 	playMusic("menu", MUSIC_GROUP_BASE);

 #endif

 }

+

+static void setKeytableFromConfigFile(textFile_t *configFile)

+{

+	char val[STR_SIZE];

+

+	loadValueFromConfigFile(configFile, "TUX_RIGHT_MOVE_UP", val, STR_SIZE, "273");

+	keytable[ KEY_TUX_RIGHT_MOVE_UP ] = atoi(val);

+	loadValueFromConfigFile(configFile, "TUX_RIGHT_MOVE_RIGHT", val, STR_SIZE, "275");

+	keytable[ KEY_TUX_RIGHT_MOVE_RIGHT ] = atoi(val);

+	loadValueFromConfigFile(configFile, "TUX_RIGHT_MOVE_LEFT", val, STR_SIZE, "276");

+	keytable[ KEY_TUX_RIGHT_MOVE_LEFT ] = atoi(val);

+	loadValueFromConfigFile(configFile, "TUX_RIGHT_MOVE_DOWN", val, STR_SIZE, "274");

+	keytable[ KEY_TUX_RIGHT_MOVE_DOWN ] = atoi(val);

+	loadValueFromConfigFile(configFile, "TUX_RIGHT_SHOOT", val, STR_SIZE, "48");

+	keytable[ KEY_TUX_RIGHT_SHOOT ] = atoi(val);

+	loadValueFromConfigFile(configFile, "TUX_RIGHT_SWITCH_WEAPON", val, STR_SIZE, "49");

+	keytable[ KEY_TUX_RIGHT_SWITCH_WEAPON ] = atoi(val);

+	loadValueFromConfigFile(configFile, "TUX_LEFT_MOVE_UP", val, STR_SIZE, "119");

+	keytable[ KEY_TUX_LEFT_MOVE_UP ] = atoi(val);

+	loadValueFromConfigFile(configFile, "TUX_LEFT_MOVE_RIGHT", val, STR_SIZE, "100");

+	keytable[ KEY_TUX_LEFT_MOVE_RIGHT ] = atoi(val);

+	loadValueFromConfigFile(configFile, "TUX_LEFT_MOVE_LEFT", val, STR_SIZE, "97");

+	keytable[ KEY_TUX_LEFT_MOVE_LEFT ] = atoi(val);

+	loadValueFromConfigFile(configFile, "TUX_LEFT_MOVE_DOWN", val, STR_SIZE, "115");

+	keytable[ KEY_TUX_LEFT_MOVE_DOWN ] = atoi(val);

+	loadValueFromConfigFile(configFile, "TUX_LEFT_SHOOT", val, STR_SIZE, "113");

+	keytable[ KEY_TUX_LEFT_SHOOT ] = atoi(val);

+	loadValueFromConfigFile(configFile, "TUX_LEFT_SWITCH_WEAPON", val, STR_SIZE, "9");

+	keytable[ KEY_TUX_LEFT_SWITCH_WEAPON ] = atoi(val);

+}

+

 void initKeyTable()

 {

 	char path[STR_PATH_SIZE];

-	char val[STR_SIZE];

-/*

-	int i;

-*/

+

 	sprintf(path, "%s/keycontrol.conf", getHomeDirector());

 	keycontrolFile = loadTextFile(path);

 

@@ -93,30 +120,8 @@ void initKeyTable()
 		fprintf(stderr, "Don't create %s\n", path);

 		return;

 	}

-	loadValueFromConfigFile(keycontrolFile, "TUX_RIGHT_MOVE_UP", val, STR_SIZE, "273");

-	keytable[ KEY_TUX_RIGHT_MOVE_UP ] = atoi(val);

-	loadValueFromConfigFile(keycontrolFile, "TUX_RIGHT_MOVE_RIGHT", val, STR_SIZE, "275");

-	keytable[ KEY_TUX_RIGHT_MOVE_RIGHT ] = atoi(val);

-	loadValueFromConfigFile(keycontrolFile, "TUX_RIGHT_MOVE_LEFT", val, STR_SIZE, "276");

-	keytable[ KEY_TUX_RIGHT_MOVE_LEFT ] = atoi(val);

-	loadValueFromConfigFile(keycontrolFile, "TUX_RIGHT_MOVE_DOWN", val, STR_SIZE, "274");

-	keytable[ KEY_TUX_RIGHT_MOVE_DOWN ] = atoi(val);

-	loadValueFromConfigFile(keycontrolFile, "TUX_RIGHT_SHOOT", val, STR_SIZE, "48");

-	keytable[ KEY_TUX_RIGHT_SHOOT ] = atoi(val);

-	loadValueFromConfigFile(keycontrolFile, "TUX_RIGHT_SWITCH_WEAPON", val, STR_SIZE, "49");

-	keytable[ KEY_TUX_RIGHT_SWITCH_WEAPON ] = atoi(val);

-	loadValueFromConfigFile(keycontrolFile, "TUX_LEFT_MOVE_UP", val, STR_SIZE, "119");

-	keytable[ KEY_TUX_LEFT_MOVE_UP ] = atoi(val);

-	loadValueFromConfigFile(keycontrolFile, "TUX_LEFT_MOVE_RIGHT", val, STR_SIZE, "100");

-	keytable[ KEY_TUX_LEFT_MOVE_RIGHT ] = atoi(val);

-	loadValueFromConfigFile(keycontrolFile, "TUX_LEFT_MOVE_LEFT", val, STR_SIZE, "97");

-	keytable[ KEY_TUX_LEFT_MOVE_LEFT ] = atoi(val);

-	loadValueFromConfigFile(keycontrolFile, "TUX_LEFT_MOVE_DOWN", val, STR_SIZE, "115");

-	keytable[ KEY_TUX_LEFT_MOVE_DOWN ] = atoi(val);

-	loadValueFromConfigFile(keycontrolFile, "TUX_LEFT_SHOOT", val, STR_SIZE, "113");

-	keytable[ KEY_TUX_LEFT_SHOOT ] = atoi(val);

-	loadValueFromConfigFile(keycontrolFile, "TUX_LEFT_SWITCH_WEAPON", val, STR_SIZE, "9");

-	keytable[ KEY_TUX_LEFT_SWITCH_WEAPON ] = atoi(val);

+

+	setKeytableFromConfigFile(keycontrolFile);

 

 /*

 	for( i = 0 ; i < KEY_LENGTH ; i++)

@@ -124,8 +129,8 @@ void initKeyTable()
 		printf("keytable[%d] = %d\n", i, keytable[i]);

 	}

 */

-	saveTextFile(keycontrolFile);

 }

+

 int getKey(int n)

 {

 	assert( n >= 0 && n < KEY_LENGTH );

@@ -134,6 +139,7 @@ int getKey(int n)
 

 	return keytable[n];

 }

+

 void drawScreenSettingKeys()

 {

 	drawWidgetImage(image_backgorund);

@@ -167,6 +173,24 @@ void drawScreenSettingKeys()
 	drawWidgetCatchkey(tux_left_keyswitch_val);

 	drawWidgetCatchkey(tux_left_keyfire_val);

 }

+

+static void refreshKeytable()

+{

+	keytable[6] = getWidgetCatchKey(tux_left_keyup_val);

+	keytable[9] = getWidgetCatchKey(tux_left_keydown_val);

+	keytable[8] = getWidgetCatchKey(tux_left_keyleft_val);

+	keytable[7] = getWidgetCatchKey(tux_left_keyright_val);

+	keytable[10] = getWidgetCatchKey(tux_left_keyfire_val);

+	keytable[11] = getWidgetCatchKey(tux_left_keyswitch_val);

+

+	keytable[0] = getWidgetCatchKey(tux_right_keyup_val);

+	keytable[3] = getWidgetCatchKey(tux_right_keydown_val);

+	keytable[2] = getWidgetCatchKey(tux_right_keyleft_val);

+	keytable[1] = getWidgetCatchKey(tux_right_keyright_val);

+	keytable[4] = getWidgetCatchKey(tux_right_keyfire_val);

+	keytable[5] = getWidgetCatchKey(tux_right_keyswitch_val);

+}

+

 static void eventWidget(void *p)

 {

 	widget_button_t *button;

@@ -174,9 +198,11 @@ static void eventWidget(void *p)
 	

 	button = (widget_button_t *)(p);

 	catcher = (widget_catchkey_t *)(p);

+

 	if(button == button_back) {

 		setScreen("setting");

 	}

+

 	//events on value

 	if( (catcher == tux_left_keyup_val) ||

 		(catcher == tux_left_keydown_val) ||

@@ -193,8 +219,12 @@ static void eventWidget(void *p)
 		// draw press any key picture

 		// check if there is no other key with new value (what to revert if yes?)

 		// allow ony one key per time change HOW THE HELL IS THIS EVEN POSSIBLE

+

+		//printf("catcher->key = %d\n", catcher->key);

+		refreshKeytable();

 	}

 }

+

 void eventScreenSettingKeys()

 {

 	eventWidgetButton(button_back);

@@ -239,19 +269,19 @@ void initScreenSettingKeys()
 	tux_right_keyfire =  newWidgetLabel(getMyText("KEY_FIRE"), WINDOW_SIZE_X/2 + tux_left_keyup->x, tux_left_keyright->y + 20, WIDGET_LABEL_LEFT);

 	tux_right_keyswitch =  newWidgetLabel(getMyText("KEY_SWITCH"), WINDOW_SIZE_X/2 + tux_left_keyup->x, tux_left_keyfire->y + 20, WIDGET_LABEL_LEFT);

 

-	tux_left_keyup_val =  newWidgetCatchkey(keytable[6], tux_left_keyup->x+200, tux_left->y+50);

-	tux_left_keydown_val =  newWidgetCatchkey(keytable[9], tux_left_keyup_val->x, tux_left_keyup->y + 20);

-	tux_left_keyleft_val =  newWidgetCatchkey(keytable[8], tux_left_keyup_val->x, tux_left_keydown->y + 20);

-	tux_left_keyright_val =  newWidgetCatchkey(keytable[7], tux_left_keyup_val->x, tux_left_keyleft->y + 20);

-	tux_left_keyfire_val =  newWidgetCatchkey(keytable[10], tux_left_keyup_val->x, tux_left_keyright->y + 20);

-	tux_left_keyswitch_val =  newWidgetCatchkey(keytable[11], tux_left_keyup_val->x, tux_left_keyfire->y + 20);

+	tux_left_keyup_val =  newWidgetCatchkey(keytable[6], tux_left_keyup->x+200, tux_left->y+50, eventWidget);

+	tux_left_keydown_val =  newWidgetCatchkey(keytable[9], tux_left_keyup_val->x, tux_left_keyup->y + 20, eventWidget);

+	tux_left_keyleft_val =  newWidgetCatchkey(keytable[8], tux_left_keyup_val->x, tux_left_keydown->y + 20, eventWidget);

+	tux_left_keyright_val =  newWidgetCatchkey(keytable[7], tux_left_keyup_val->x, tux_left_keyleft->y + 20, eventWidget);

+	tux_left_keyfire_val =  newWidgetCatchkey(keytable[10], tux_left_keyup_val->x, tux_left_keyright->y + 20, eventWidget);

+	tux_left_keyswitch_val =  newWidgetCatchkey(keytable[11], tux_left_keyup_val->x, tux_left_keyfire->y + 20, eventWidget);

 	

-	tux_right_keyup_val =  newWidgetCatchkey(keytable[0], WINDOW_SIZE_X/2 + tux_left_keyup_val->x, tux_left->y+50);

-	tux_right_keydown_val =  newWidgetCatchkey(keytable[3], WINDOW_SIZE_X/2 + tux_left_keyup_val->x, tux_left_keyup->y + 20);

-	tux_right_keyleft_val =  newWidgetCatchkey(keytable[2], WINDOW_SIZE_X/2 + tux_left_keyup_val->x, tux_right_keydown->y + 20);

-	tux_right_keyright_val =  newWidgetCatchkey(keytable[1], WINDOW_SIZE_X/2 + tux_left_keyup_val->x, tux_right_keyleft->y + 20);

-	tux_right_keyfire_val =  newWidgetCatchkey(keytable[4], WINDOW_SIZE_X/2 + tux_left_keyup_val->x, tux_left_keyright->y + 20);

-	tux_right_keyswitch_val =  newWidgetCatchkey(keytable[5], WINDOW_SIZE_X/2 + tux_left_keyup_val->x, tux_left_keyfire->y + 20);	

+	tux_right_keyup_val =  newWidgetCatchkey(keytable[0], WINDOW_SIZE_X/2 + tux_left_keyup_val->x, tux_left->y+50, eventWidget);

+	tux_right_keydown_val =  newWidgetCatchkey(keytable[3], WINDOW_SIZE_X/2 + tux_left_keyup_val->x, tux_left_keyup->y + 20, eventWidget);

+	tux_right_keyleft_val =  newWidgetCatchkey(keytable[2], WINDOW_SIZE_X/2 + tux_left_keyup_val->x, tux_right_keydown->y + 20, eventWidget);

+	tux_right_keyright_val =  newWidgetCatchkey(keytable[1], WINDOW_SIZE_X/2 + tux_left_keyup_val->x, tux_right_keyleft->y + 20, eventWidget);

+	tux_right_keyfire_val =  newWidgetCatchkey(keytable[4], WINDOW_SIZE_X/2 + tux_left_keyup_val->x, tux_left_keyright->y + 20, eventWidget);

+	tux_right_keyswitch_val =  newWidgetCatchkey(keytable[5], WINDOW_SIZE_X/2 + tux_left_keyup_val->x, tux_left_keyfire->y + 20, eventWidget);	

 

 	registerScreen( newScreen("settingKeys", startScreenSettingKeys, eventScreenSettingKeys,

 		drawScreenSettingKeys, stopScreenSettingKeys) );	

@@ -260,40 +290,43 @@ void quitKeyTable()
 {

 	destroyTextFile(keycontrolFile);

 }

-void saveKeyTable() {

+

+void saveKeyTable(textFile_t *configFile) {

 	char str[STR_SIZE];

 	sprintf(str,"%d",tux_left_keyup_val->key);

-	setValueInConfigFile(keycontrolFile, "TUX_LEFT_MOVE_UP", str);

+	setValueInConfigFile(configFile, "TUX_LEFT_MOVE_UP", str);

 	sprintf(str,"%d",tux_left_keydown_val->key);

-	setValueInConfigFile(keycontrolFile, "TUX_LEFT_MOVE_DOWN", str);

+	setValueInConfigFile(configFile, "TUX_LEFT_MOVE_DOWN", str);

 	sprintf(str,"%d",tux_left_keyleft_val->key);

-	setValueInConfigFile(keycontrolFile, "TUX_LEFT_MOVE_LEFT", str);

+	setValueInConfigFile(configFile, "TUX_LEFT_MOVE_LEFT", str);

 	sprintf(str,"%d",tux_left_keyright_val->key);

-	setValueInConfigFile(keycontrolFile, "TUX_LEFT_MOVE_RIGHT", str);

+	setValueInConfigFile(configFile, "TUX_LEFT_MOVE_RIGHT", str);

 	sprintf(str,"%d",tux_left_keyfire_val->key);

-	setValueInConfigFile(keycontrolFile, "TUX_LEFT_MOVE_SHOOT", str);

+	setValueInConfigFile(configFile, "TUX_LEFT_SHOOT", str);

 	sprintf(str,"%d",tux_left_keyswitch_val->key);

-	setValueInConfigFile(keycontrolFile, "TUX_LEFT_MOVE_SWITCH_WEAPON ", str);

+	setValueInConfigFile(configFile, "TUX_LEFT_SWITCH_WEAPON", str);

 	

 	sprintf(str,"%d",tux_right_keyup_val->key);

-	setValueInConfigFile(keycontrolFile, "TUX_RIGHT_MOVE_UP", str);

+	setValueInConfigFile(configFile, "TUX_RIGHT_MOVE_UP", str);

 	sprintf(str,"%d",tux_right_keydown_val->key);

-	setValueInConfigFile(keycontrolFile, "TUX_RIGHT_MOVE_DOWN", str);

+	setValueInConfigFile(configFile, "TUX_RIGHT_MOVE_DOWN", str);

 	sprintf(str,"%d",tux_right_keyleft_val->key);

-	setValueInConfigFile(keycontrolFile, "TUX_RIGHT_MOVE_LEFT", str);

+	setValueInConfigFile(configFile, "TUX_RIGHT_MOVE_LEFT", str);

 	sprintf(str,"%d",tux_right_keyright_val->key);

-	setValueInConfigFile(keycontrolFile, "TUX_RIGHT_MOVE_RIGHT", str);

+	setValueInConfigFile(configFile, "TUX_RIGHT_MOVE_RIGHT", str);

 	sprintf(str,"%d",tux_right_keyfire_val->key);

-	setValueInConfigFile(keycontrolFile, "TUX_RIGHT_MOVE_SHOOT", str);

+	setValueInConfigFile(configFile, "TUX_RIGHT_SHOOT", str);

 	sprintf(str,"%d",tux_right_keyswitch_val->key);

-	setValueInConfigFile(keycontrolFile, "TUX_RIGHT_MOVE_SWITCH_WEAPON ", str);

+	setValueInConfigFile(configFile, "TUX_RIGHT_SWITCH_WEAPON", str);

 

-	saveTextFile(keycontrolFile);

+	saveTextFile(configFile);

 }

+

 void quitScreenSettingKeys()

 {

-	saveKeyTable();

+	saveKeyTable(keycontrolFile);

 	quitKeyTable();

+

 	// key names

 	destroyWidgetImage(image_backgorund);

 	destroyWidgetLabel(tux_right);

diff --git a/src/widget/widget_catchkey.c b/src/widget/widget_catchkey.c
index afdac23..099a4e9 100644
--- a/src/widget/widget_catchkey.c
+++ b/src/widget/widget_catchkey.c
@@ -6,7 +6,7 @@
 #include "font.h"
 #include "widget_catchkey.h"
 
-widget_catchkey_t* newWidgetCatchkey(int key, int x, int y)
+widget_catchkey_t* newWidgetCatchkey(int key, int x, int y, void *event)
 {
 	widget_catchkey_t *new;
 
@@ -15,6 +15,7 @@ widget_catchkey_t* newWidgetCatchkey(int key, int x, int y)
 	new->x = x;
 	new->y = y;
 	new->key = key;
+	new->fce_event = event;
 
 	return new;
 }
@@ -94,6 +95,7 @@ void eventWidgetCatchkey(widget_catchkey_t *p)
 		if( key != WIDGET_CATCHKEY_NOKEY )
 		{
 			p->key = key;
+			p->fce_event(p);
 		}
 	}
 }
diff --git a/src/widget/widget_catchkey.h b/src/widget/widget_catchkey.h
index 0b8b080..d5f9a36 100644
--- a/src/widget/widget_catchkey.h
+++ b/src/widget/widget_catchkey.h
@@ -5,8 +5,8 @@
 
 #include "main.h"
 
-#define WIDGET_CATCHKEY_WIDTH	64
-#define WIDGET_CATCHKEY_HEIGHT	32
+#define WIDGET_CATCHKEY_WIDTH	110
+#define WIDGET_CATCHKEY_HEIGHT	12
 
 #define WIDGET_CATCHKEY_NOKEY	-1
 
@@ -16,9 +16,10 @@ typedef struct widget_catchkey_struct
 	int w, h;
 	int key;
 	bool_t active;
+	void (*fce_event)(void *p);
 } widget_catchkey_t;
 
-extern widget_catchkey_t* newWidgetCatchkey(int key, int x, int y);
+extern widget_catchkey_t* newWidgetCatchkey(int key, int x, int y, void *event);
 extern int getWidgetCatchKey(widget_catchkey_t *p);
 extern void setWidgetCatchKey(widget_catchkey_t *p, int key);
 extern void drawWidgetCatchkey(widget_catchkey_t *p);