version 0.2.0 v0.2.0
authorMats Johannesson <devel@bredband.net>
Thu, 26 Jun 2008 18:13:37 +0000 (14:13 -0400)
committerAristeu Rozanski <arozansk@redhat.com>
Thu, 26 Jun 2008 18:13:37 +0000 (14:13 -0400)
(NOTE: A version of this archive was pulled from the website after a
few hours of exposure on April 28, based on the suspicion that it
contained a corrupt file due to some file system issues on my machine.
Both fears were unfounded. I've spent this interim on further
restructuring of the text files outside of the code directories)

* New configuration file format. Incompatible with the old one, hence
the version bump from 0.1 to 0.2

Move/rename the old file and run the program to get a new. Then edit...

The old format was basically just a transcript of how a C structure
is initialized. It had nothing in common with how a configuration
file in *nix should be construed.

Rules for the new configuration file is: Blank lines and everything
after a "#" is discarded. Full program records begin and end with
a double percentage sign "%%". A program field begins after a colon ":".
The program names must be within two double quotes "". Like so:

"A ProgramName" <-- OK
" A ProgramName" or "A ProgramName " <-- NOT-OK

This is in accordance with the old rule about how to deal with spaces
in that field.

I can only vouch for parsing sanity if each line in the file is kept
below 160 bytes in length (see the BUGS file). That's the equiv of
two old style terminal lines. If you want more, change the MAXBUFFER
value in globals.h

* Another command line option: "-v". Will turn on the be_verbose flag
which prints info to the screen from plenty of program execution points.
An aid for debugging, or just checking out the runtime state.

* Got rid of the ugly switch routines in event_loop.c and config_read.c.
I've done extensive benchmarking and see no difference in code speed.
Advantage, apart from code simplicity, is that the compiled program
size was reduced by ca 4000 bytes - before the 0.2.0 additions.

20 files changed:
BUGS [new file with mode: 0644]
ChangeLog
ChangeLog.1 [moved from ChangeLog.old with 100% similarity]
Makefile
NEWS [new file with mode: 0644]
README
TODO [new file with mode: 0644]
USAGE
src-client/Makefile
src-server/config_read.c
src-server/config_write.c
src-server/event_loop.c
src-server/get_device.c
src-server/globals.c
src-server/globals.h
src-server/main_setup.c
src-server/on_error.c
src-server/on_signal.c
src-server/pen_mode.c
src-server/reg_events.c

diff --git a/BUGS b/BUGS
new file mode 100644 (file)
index 0000000..10710ca
--- /dev/null
+++ b/BUGS
@@ -0,0 +1,21 @@
+
+_Known bugs marked with FIXME in the code_
+
+! Parsing of the configuration file still leaves some corner cases
+to chance. The behaviour when reading in the next line/part, after
+having cut a line longer than MAXBUFFER, is totally unpredictable.
+
+! The exit_on_error function drops the EXIT_KO when callig
+clean_up_exit. It becomes a normal EXIT_OK signal for any controlling
+parent.
+
+_Possible bugs, unmarked_
+
+! I've tried to break the parsing of the configuration file with
+different scenarios, but am limited by my imagination of how
+broken a file can be...
+
+_Known bugs, unmarked_
+
+! Should ignore a pen mode 999 definition in the "Plus" button fields.
+
index c242d0c..9708b1c 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,4 +1,47 @@
 
+_Version 0.2.0 29 April 2005_
+
+(NOTE: A version of this archive was pulled from the website after a
+few hours of exposure on April 28, based on the suspicion that it
+contained a corrupt file due to some file system issues on my machine.
+Both fears were unfounded. I've spent this interim on further
+restructuring of the text files outside of the code directories)
+
+* New configuration file format. Incompatible with the old one, hence
+the version bump from 0.1 to 0.2
+
+Move/rename the old file and run the program to get a new. Then edit...
+
+The old format was basically just a transcript of how a C structure
+is initialized. It had nothing in common with how a configuration
+file in *nix should be construed.
+
+Rules for the new configuration file is: Blank lines and everything
+after a "#" is discarded. Full program records begin and end with
+a double percentage sign "%%". A program field begins after a colon ":".
+The program names must be within two double quotes "". Like so:
+
+"A ProgramName" <-- OK
+" A ProgramName" or "A ProgramName " <-- NOT-OK
+
+This is in accordance with the old rule about how to deal with spaces
+in that field.
+
+I can only vouch for parsing sanity if each line in the file is kept
+below 160 bytes in length (see the BUGS file). That's the equiv of
+two old style terminal lines. If you want more, change the MAXBUFFER
+value in globals.h
+
+* Another command line option: "-v". Will turn on the be_verbose flag
+which prints info to the screen from plenty of program execution points.
+An aid for debugging, or just checking out the runtime state.
+
+* Got rid of the ugly switch routines in event_loop.c and config_read.c.
+I've done extensive benchmarking and see no difference in code speed.
+Advantage, apart from code simplicity, is that the compiled program
+size was reduced by ca 4000 bytes - before the 0.2.0 additions.
+
+
 _Version 0.1.4 24 April 2005_
 
 * Memory bugfix. Running the program under Valgrind to catch memory
similarity index 100%
rename from ChangeLog.old
rename to ChangeLog.1
index da918e1..4d3642a 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -4,7 +4,7 @@ all:
        mv src-server/expresskeys .
 
 #      $(MAKE) -C src-client
-#      mv src-client/cekeys .
+#      mv src-client/expresskeys-conf .
 clean:
-       rm -f expresskeys cekeys src-server/*.o src-client/*.o
+       rm -f expresskeys expresskeys-conf src-server/*.o src-client/*.o
 
diff --git a/NEWS b/NEWS
new file mode 100644 (file)
index 0000000..3e6fed3
--- /dev/null
+++ b/NEWS
@@ -0,0 +1,9 @@
+
+_Changes since last version. Executive edition_
+
+- New configuration file format.
+
+- Another command line option: "-v" (verbose mode).
+
+- Some code simplifications.
+
diff --git a/README b/README
index c074810..aa8ccc2 100644 (file)
--- a/README
+++ b/README
@@ -7,8 +7,14 @@ http://web.telia.com/~u46133770/wacom/index.html
 The USAGE file lists all the important and current key points for
 program configuration and execution.
 
+NEWS gives a quick view of changes. Expanded in ChangeLog.
+
 The INSTALL file keeps compilation information.
 
+BUGS lists the known cases.
+
+TODO is a wish-list, not a promise.
+
 AUTHORS and Copyright speak of who it was that wrote the code. The
 latter also gives explicit permission for the code and program usage.
 
diff --git a/TODO b/TODO
new file mode 100644 (file)
index 0000000..41cb4ac
--- /dev/null
+++ b/TODO
@@ -0,0 +1,14 @@
+
+_Wish-list_
+
++ Graphical client for editing the configuration file, signalling
+the server to re-read it when done. Should optimally fill in the
+keycodes when user pushes a key (maybe just show the key) and fill
+in the class name as well when user clicks on a window.
+
++ Autotool the build and install process?
+
++ Replace ASCII with something more international, like UTF-8.
+
++ Make the code 64-bit clean.
+
diff --git a/USAGE b/USAGE
index b3bfee2..837582f 100644 (file)
--- a/USAGE
+++ b/USAGE
@@ -28,11 +28,12 @@ USAGE of expresskeys:
 
 * Command line can be:
 
-expresskeys <pad-device-name> [<pen-device-name>] [-d]
+expresskeys <pad-device-name> [<pen-device-name>] [-d] [-v]
 
 Where the pad name is mandatory. Specify a pen name
 if you want the program to handle pen mode switches.
 Use -d to make the program a daemon (run in the background).
+Use -v to print info to the screen at many execution points.
 
 Example: expresskeys pad stylus -d
 
@@ -53,6 +54,11 @@ recreated whenever a configuration file is missing on program start.
 * A file with the program PID number is written if run with -d in:
 ~/.expresskeys/expresskeys.pid
 
+The pid-file is deleted on normal program exit like "kill <pid>",
+"killall expresskeys", "kill -TERM <pid>" etc. A brutal "kill -9 <pid>"
+or a program crash will leave the pid-file undeleted. This is also
+the case if the program is terminated by X close-down on some systems.
+
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
 * The configuration file is re-read upon receipt of the signal SIGUSR1.
@@ -76,15 +82,13 @@ It's the last string we would use, the "OpenOffice.org 1.1.4". We always
 use the last part, and the spelling is case sensitive. Putting
 "openoffice.org 1.1.4" in the configuration file would not match up.
 
-Also, since spaces are accepted as part of a class name, make sure there are
-no space _before or after_ the name, prior to the terminating field comma:
+Also, since spaces are accepted as part of a class name, make sure there
+are no space _before or after_ the name, within the double quotes:
 
-{"A ProgramName", or {A ProgramName,    <-- OK
-{"A ProgramName" , or { A ProgramName,  <-- NOT-OK
+"A ProgramName" <-- OK
+" A ProgramName" or "A ProgramName " <-- NOT-OK
 
 The extra space/s would become part of the class name. Not what you want.
-If you absolutely must put some space before the comma, use TAB instead.
-Those are discarded while parsing the string.
 
 The very first entry (at the top) in the configuration file is named
 "default" and holds a key definition for all programs not specified
@@ -97,23 +101,24 @@ and programs lacking a class name in their WM_CLASS.
 
 The "default" entry holds keycodes to make the pad buttons behave just
 as Wacom list them in the Quick Start Guide: Shift, Alt, Ctrl and Space
-mirrored on both sides. Touch Strip support is turned off by default.
-Use the number 1 in the handle_touch field to turn it on. You then get
+mirrored on both sides. Touch Strip support is turned off by default. Use
+the number 1 in the "Handle Touch Strips" field to turn it on. You then get
 Arrow-key Up/Down on the left strip and Arrow-key Right/Left on the right.
-Change direction of the movement by switching the _up and _down values.
+Change direction of the movement by switching the "Up" and "Down" values.
+
+Both pad buttons and touch strips can send two keys at a time if so
+configured through usage of the "Plus" keycode fields.
 
 If you want a button to do pen mode toggling between Absolute and Relative,
 use the value 999 in the corresponding keycode field. To be able to switch
-mode anywhere, each program block must contain one 999 definition. And,
+mode anywhere each program block must contain one 999 definition. And,
 of course, a pen name must be used on the command line when starting the
-program.
-
-Both pad buttons and touch strips can send two keys at a time if so
-configured through usage of the _plus keycode fields.
+program. OBS: The pen mode toggle can only be assigned to a "real" button,
+not the "Plus" version :OBS.
 
-Please don't alter or remove the commas (,) after the class name or keycodes.
-They must be there to separate the fields, just like the { and } are used to
-separate and define the program blocks.
+Please don't alter or remove the colons ":" before the class name or
+keycodes. They must be there to separate the fields, just like the "%%" is
+used to separate and define the program blocks.
 
 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
index 51e7234..6de8f90 100644 (file)
@@ -4,9 +4,9 @@ CFLAGS = -O2 -Wall
 
 INCLUDES = -I/usr/X11R6/lib
 LDFLAGS = -L/usr/X11R6/lib
-LIBS = -lX11 -lXi -lXext -lXtst
+LIBS = -lX11 -lXext -lXi -lXtst
 
-TARGET = cekeys
+TARGET = expresskeys-conf
 
 SRCS = main_dummy.c
 
index 1054b8f..310fb82 100644 (file)
@@ -1,32 +1,31 @@
 /*
- * config_read.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
- *
- * Copyright (C) 2005 - Mats Johannesson
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
- *
- */
+ config_read.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
+ Copyright (C) 2005 - Mats Johannesson
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+*/
 
 #include "globals.h"
 
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-/* Function reads a configuration file containing program names and */
-/* definitions of which keys that should be mapped to pad buttons and */
-/* touch strips. It takes a file pointer and a pointer to a global */
-/* structure as input. Returns nothing unless an error occured.*/
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Function reads a configuration file containing program names and
+ definitions of which keys that should be mapped to pad buttons and
+ touch strips. It takes a file pointer and a pointer to a global
+ structure as input. Returns nothing unless an error occured.
+ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 
 int read_file_config(int *ip, FILE *fp)
 {
@@ -34,17 +33,20 @@ int read_file_config(int *ip, FILE *fp)
        struct program *p;
        p = (void *)*ip;
 
-       int i = 0;
-       int j = 0;
-       char c;
-       
+       int i;
        int num_record = 0;
        int num_field = 0;
+       
+       int *field_index = 0;
 
        char buffer [MAXBUFFER];
+       char line_buffer [MAXBUFFER];
+       const char ignore[] = " \t\n";
+       const char *delimiter_first, *delimiter_last;
+       char *token;
 
-/* Previously allocated memory for the program names must be released */
-/* on subsequent reads of the config file. At program start the flag is 0 */
+/* Previously allocated memory for the program names must be released
+   on subsequent reads of the config file. At program start the flag is 0 */
 
        if (reread_config) {
                for (i = 0; i < num_list; i++, p++) {
@@ -53,141 +55,123 @@ int read_file_config(int *ip, FILE *fp)
                p = (void *)*ip;
        }
        reread_config = 1;
+       num_list = 0;
+
+/* Begin by making sure that the Config File Version number is present before
+   a record begins. We exit if it's lacking or the number doesn't match up */
+
+/* FIXME Unpredictable behaviour on lines longer than MAXBUFFER! */
+
+       while ((fgets(line_buffer, MAXBUFFER, fp)) != NULL) {
+               if ((delimiter_first = (strchr(line_buffer, '#'))) != NULL) {
+                       strncpy(buffer, line_buffer, ((delimiter_first) - (line_buffer)));
+                       strncpy(buffer + ((delimiter_first) - (line_buffer)), "\0", 1);
+                       strcpy(line_buffer, buffer);
+               }
+               if ((delimiter_first = (strchr(line_buffer, '%'))) != NULL &&
+               (delimiter_last = (strrchr(line_buffer, '%'))) != NULL &&
+               (delimiter_last != delimiter_first)) {
+                       return 3;
+               }
+               if ((delimiter_first = (strchr(line_buffer, ':'))) != NULL) {
+                       strcpy(buffer, line_buffer);
+                       token = strtok(buffer, ":");
+                       token = strtok(NULL, ignore);
+                       strcpy(buffer, token);
+                       if ((atoi(buffer)) != CONFIG_VERSION) {
+                               return 3;
+                       }
+                       break;
+               }
+       }
+
+/* Read the config file in one go from top to bottom. Parse out the info
+   between record start "%%" and record end "%%". Recognize field beginnings
+   by a colon ":". Each full record is written to a global memory structure,
+   while partial records are discarded and excessive fields are truncated.
+   No sanity check on program names or keycode functionality is performed
+   A global counter variable of full record instances is updated before the
+   function exits to reflect the new state. */
 
-/* Read the config file in one go from top to bottom. Parse out the info */
-/* between record start "{" and record end "}". Recognize field ends by a */
-/* comma ",".Each full record is written to a global memory structure, */
-/* while partial records are discarded and excessive fields are truncated. */
-/* No sanity check on program names or keycode functionality is performed */
-/* A global counter variable of full record instances is updated before */
-/* the function exits to reflect the new state. */
+/* FIXME Unpredictable behaviour on lines longer than MAXBUFFER! */
 
-       while ((c = fgetc(fp)) != EOF) {
+       while ((fgets(line_buffer, MAXBUFFER, fp)) != NULL) {
                if (num_record < MAXRECORDS) {
-                       if (c == '{') {
-                               while ((c = fgetc(fp)) != EOF && (c != ',')) {
-                                               if ((j < MAXBUFFER - 1) && (c != '"') && (isprint(c))) {
-                                                       buffer [j] = c;
-                                                       j++;
+                       if ((delimiter_first = (strchr(line_buffer, '#'))) != NULL) {
+                               strncpy(buffer, line_buffer, ((delimiter_first) - (line_buffer)));
+                               strncpy(buffer + ((delimiter_first) - (line_buffer)), "\0", 1);
+                               strcpy(line_buffer, buffer);
+                       }
+                       if ((delimiter_first = (strchr(line_buffer, '%'))) == NULL &&
+                       (delimiter_last = (strrchr(line_buffer, '%'))) == NULL &&
+                       (delimiter_last == delimiter_first)) {
+                               if ((delimiter_first = (strchr(line_buffer, ':'))) != NULL) {
+                                       if ((delimiter_first = (strchr(line_buffer, '"'))) != NULL) {
+                                               strcpy(buffer, line_buffer);
+                                               token = strtok(buffer, "\t\n");
+                                               while ((delimiter_first = (strchr(token, '"'))) == NULL) {
+                                                       token = strtok(NULL, "\t\n");
                                                }
-                               }
-                               buffer [j] = '\0';
-                               i = 0;
-                               j = 0;
-                               if ((p->class_name = (char *)malloc(strlen(buffer)+1)) == NULL) {
-                                       return 2;
-                               }
-                               sprintf(p->class_name, "%s", buffer);
-                               while ((c = fgetc(fp)) != EOF && (c != '}')) {
-                                       if (num_field < MAXFIELDS) {
-                                               if ((c != ',') && (isdigit(c))) {
-                                                       if (i < MAXDIGITS) {
-                                                               buffer [i] = c;
-                                                               i++;
+                                               if (((delimiter_last = (strrchr(token, '"'))) != NULL) &&
+                                               (delimiter_last != delimiter_first)) {
+                                                       strncpy(buffer, delimiter_first+1, ((delimiter_last) - (delimiter_first + 1)));
+                                                       strncpy(buffer + ((delimiter_last) - (delimiter_first + 1)), "\0", 1);
+                                                       if ((p->class_name = (char *)malloc(strlen(buffer)+1)) == NULL) {
+                                                               return 2;
                                                        }
-                                               }
-                                               if (c == ',') {
-                                                       buffer [i] = '\0';
-                                                       i=0;
-
-                                                       switch (num_field) {
-                                                               case 0:
-                                                               p->handle_touch = atoi(buffer);
-                                                               break;
-                                                               case 1:
-                                                               p->l_touch_up = atoi(buffer);
-                                                               break;
-                                                               case 2:
-                                                               p->l_touch_up_plus = atoi(buffer);
-                                                               break;
-                                                               case 3:
-                                                               p->l_touch_down = atoi(buffer);
-                                                               break;
-                                                               case 4:
-                                                               p->l_touch_down_plus = atoi(buffer);
-                                                               break;
-                                                               case 5:
-                                                               p->r_touch_up = atoi(buffer);
-                                                               break;
-                                                               case 6:
-                                                               p->r_touch_up_plus = atoi(buffer);
-                                                               break;
-                                                               case 7:
-                                                               p->r_touch_down = atoi(buffer);
-                                                               break;
-                                                               case 8:
-                                                               p->r_touch_down_plus = atoi(buffer);
-                                                               break;
-                                                               case 9:
-                                                               p->key_9 = atoi(buffer);
-                                                               break;
-                                                               case 10:
-                                                               p->key_9_plus = atoi(buffer);
-                                                               break;
-                                                               case 11:
-                                                               p->key_10 = atoi(buffer);
-                                                               break;
-                                                               case 12:
-                                                               p->key_10_plus = atoi(buffer);
-                                                               break;
-                                                               case 13:
-                                                               p->key_11 = atoi(buffer);
-                                                               break;
-                                                               case 14:
-                                                               p->key_11_plus = atoi(buffer);
-                                                               break;
-                                                               case 15:
-                                                               p->key_12 = atoi(buffer);
-                                                               break;
-                                                               case 16:
-                                                               p->key_12_plus = atoi(buffer);
-                                                               break;
-                                                               case 17:
-                                                               p->key_13 = atoi(buffer);
-                                                               break;
-                                                               case 18:
-                                                               p->key_13_plus = atoi(buffer);
-                                                               break;
-                                                               case 19:
-                                                               p->key_14 = atoi(buffer);
-                                                               break;
-                                                               case 20:
-                                                               p->key_14_plus = atoi(buffer);
-                                                               break;
-                                                               case 21:
-                                                               p->key_15 = atoi(buffer);
-                                                               break;
-                                                               case 22:
-                                                               p->key_15_plus = atoi(buffer);
-                                                               break;
-                                                               case 23:
-                                                               p->key_16 = atoi(buffer);
-                                                               break;
-                                                               case 24:
-                                                               p->key_16_plus = atoi(buffer);
-                                                               break;
-                                                               default:
-                                                               break;
+                                                       sprintf(p->class_name, "%s", buffer);
+                                                       if (be_verbose) {
+                                                               fprintf(stderr, "PGR RECNAME = %s\n", buffer);
+                                                       }
+                                                       field_index = &p->handle_touch;
+
+/* FIXME Unpredictable behaviour on lines longer than MAXBUFFER! */
+
+                                                       while ((fgets(line_buffer, MAXBUFFER, fp)) != NULL) {
+                                                               if ((delimiter_first = (strchr(line_buffer, '%'))) != NULL &&
+                                                               (delimiter_last = (strrchr(line_buffer, '%'))) != NULL &&
+                                                               (delimiter_last != delimiter_first)) {
+                                                                       break;
+                                                               }
+                                                               if (num_field < MAXFIELDS) {
+                                                                       if ((delimiter_first = (strchr(line_buffer, '#'))) != NULL) {
+                                                                               strncpy(buffer, line_buffer, ((delimiter_first) - (line_buffer)));
+                                                                               strncpy(buffer + ((delimiter_first) - (line_buffer)), "\0", 1);
+                                                                               strcpy(line_buffer, buffer);
+                                                                       }
+                                                                       if ((delimiter_first = (strchr(line_buffer, ':'))) != NULL) {
+                                                                               strcpy(buffer, line_buffer);
+                                                                               token = strtok(buffer, ":");
+                                                                               token = strtok(NULL, ignore);
+                                                                               strcpy(buffer, token);
+                                                                               *field_index = atoi(buffer);
+                                                                               field_index++;
+                                                                               num_field++;
+                                                                       }
+                                                               }
                                                        }
-                                                       num_field++;
+                                                       if (num_field == MAXFIELDS) {
+                                                               num_record++;
+                                                               p++;
+                                                       } else {
+                                                               free(p->class_name);
+                                                       }
+                                                       num_field = 0;
                                                }
                                        }
                                }
-                               if (num_field == MAXFIELDS) {
-                                       num_record++;
-                                       p++;
-                               } else {
-                                       free(p->class_name);
-                               }
-                               num_field = 0;
                        }
                }
        }
        if (!num_record) {
-               num_list = 0;
                return 1;
        }
        num_list = num_record;
+
+       if (be_verbose) {
+               fprintf(stderr, "PGR RECORDS = %d\n", num_list);
+       }
+
        return 0;
 }
 
index 55a3020..888050d 100644 (file)
@@ -1,33 +1,76 @@
 /*
- * config_write.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
- *
- * Copyright (C) 2005 - Mats Johannesson
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
- *
- */
+ config_write.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
+ Copyright (C) 2005 - Mats Johannesson
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+*/
 
 #include "globals.h"
 
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-/* Function writes out a short configuration file if none exists. It takes */
-/* the info from a global memory structure whose only purpose is this initial */
-/* write moment. The file should then be read back immediately to populate a */
-/* memory structure that other functions rely on for their proper operation. */
-/* Returns nothing useful. Write errors are checked in the calling function. */
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Function writes a header in a new file, including config file version
+ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+
+int write_file_config_header(FILE *fp)
+{
+
+       fprintf(fp, "\nVersion: %d              # Config File Version. Please don't remove.\n\n", CONFIG_VERSION);
+       fprintf(fp, "# Blank lines and everything following a comment \"#\" sign are ignored.\n\n");
+       fprintf(fp, "# Some ASCII art showing the \"default\" program record:\n");
+       fprintf(fp, "#\n");
+       fprintf(fp, "# Left ExpressKey Pad\n");
+       fprintf(fp, "# ------------\n");
+       fprintf(fp, "# |  |   |   |             Wacom Intuos3 defaults are:\n");
+       fprintf(fp, "# |  | 9 | T |\n");
+       fprintf(fp, "# |11|---| O |             Button 9  = (left) Shift        = keycode 50\n");
+       fprintf(fp, "# |  |10 | U |             Button 10 = (left) Alt          = keycode 64\n");
+       fprintf(fp, "# |------| C |             Button 11 = (left) Control      = keycode 37\n");
+       fprintf(fp, "# |  12  | H |             Button 12 = Space               = keycode 65\n");
+       fprintf(fp, "# ------------\n");
+       fprintf(fp, "#\n");
+       fprintf(fp, "# Right ExpressKey Pad\n");
+       fprintf(fp, "# ------------\n");
+       fprintf(fp, "# |   |   |  |             Wacom Intuos3 defaults are:\n");
+       fprintf(fp, "# | T |13 |  |\n");
+       fprintf(fp, "# | O |---|15|             Button 13 = (left) Shift        = keycode 50\n");
+       fprintf(fp, "# | U |14 |  |             Button 14 = (left) Alt          = keycode 64\n");
+       fprintf(fp, "# | C |------|             Button 15 = (left) Control      = keycode 37\n");
+       fprintf(fp, "# | H |  16  |             Button 16 = Space               = keycode 65\n");
+       fprintf(fp, "# ------------\n");
+       fprintf(fp, "#\n");
+       fprintf(fp, "# The \"default\" program record must be the very first record, at the top.\n");
+       fprintf(fp, "# Use the value 999 as a keycode to enable pen mode toggling. To be able\n");
+       fprintf(fp, "# to switch mode anywhere each program block must then contain one 999\n");
+       fprintf(fp, "# definition.\n\n");
+       fprintf(fp, "# Each program record is enclosed between two sets of double percentage signs.\n");
+       fprintf(fp, "# Each program field begins after a colon \":\". Whitespace (tabs and spaces)\n");
+       fprintf(fp, "# are ignored in the keycode fields, but spaces are recorded when in a\n");
+       fprintf(fp, "# Program Name field (between the double quotes).\n\n\n");
+
+       return 0;
+
+}
+
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Function writes out a short configuration file if none exists. It takes
+ the info from a global memory structure whose only purpose is this initial
+ write moment. The file should then be read back immediately to populate a
+ memory structure that other functions rely on for their proper operation.
+ Returns nothing useful. Write errors are checked in the calling function.
+ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 
 int write_file_config(int *ip, FILE *fp)
 {
@@ -35,25 +78,34 @@ int write_file_config(int *ip, FILE *fp)
        struct program *p;
        p = (void *)*ip;
 
-       fprintf(fp, "------------------------------The field order is:-------------------------\n");
-       fprintf(fp, "Programname        handle_touch \n");
-       fprintf(fp, "l_touch_up l_touch_up_plus l_touch_down    l_touch_down_plus\n");
-       fprintf(fp, "r_touch_up r_touch_up_plus r_touch_down    r_touch_down_plus\n");
-       fprintf(fp, "key_9              key_9_plus      key_10          key_10_plus\n");
-       fprintf(fp, "key_11             key_11_plus     key_12          key_12_plus\n");
-       fprintf(fp, "key_13             key_13_plus     key_14          key_14_plus\n");
-       fprintf(fp, "key_15             key_15_plus     key_16          key_16_plus\n");
-       fprintf(fp, "--------------------------------------------------------------------------\n");
-       fprintf(fp, "Please don't put any comment inside the definition below this text block.\n");
-       fprintf(fp, "And please don't alter or remove the commas (,) after each field entry.\n");
-       fprintf(fp, "\n");
-       fprintf(fp, "{\"%s\",   %d,\n", p->class_name, p->handle_touch);
-       fprintf(fp, "%d,                %d,             %d,             %d,\n", p->l_touch_up, p->l_touch_up_plus, p->l_touch_down, p->l_touch_down_plus);
-       fprintf(fp, "%d,                %d,             %d,             %d,\n", p->r_touch_up, p->r_touch_up_plus, p->r_touch_down, p->r_touch_down_plus);
-       fprintf(fp, "%d,                %d,             %d,             %d,\n", p->key_9, p->key_9_plus, p->key_10, p->key_10_plus);
-       fprintf(fp, "%d,                %d,             %d,             %d,\n", p->key_11, p->key_11_plus, p->key_12, p->key_12_plus);
-       fprintf(fp, "%d,                %d,             %d,             %d,\n", p->key_13, p->key_13_plus, p->key_14, p->key_14_plus);
-       fprintf(fp, "%d,                %d,             %d,             %d,     }\n\n", p->key_15, p->key_15_plus, p->key_16, p->key_16_plus);
+       fprintf(fp, "%s                         # <--- Begin New Program Record\n\n", "%%");
+       fprintf(fp, "00 Program Name: \"%s\"    # Name must be within double quotes \"\"\n", p->class_name);
+       fprintf(fp, "01 Handle Touch Strips: %d # Main switch. Use 1 to enable the Touch Strips\n\n", p->handle_touch);
+       fprintf(fp, "02 Left Pad - Touch Up:            %d      # Left Touch Up\n", p->l_touch_up);
+       fprintf(fp, "03 Left Pad - Touch Up Plus:       %d      # Extra key\n\n", p->l_touch_up_plus);
+       fprintf(fp, "04 Left Pad - Touch Down:  %d      # Left Touch Down\n", p->l_touch_down);
+       fprintf(fp, "05 Left Pad - Touch Down Plus:     %d      # Extra key\n\n", p->l_touch_down_plus);
+       fprintf(fp, "06 Right Pad - Touch Up:   %d      # Right Touch Up\n", p->r_touch_up);
+       fprintf(fp, "07 Right Pad - Touch Up Plus:      %d      # Extra key\n\n", p->r_touch_up_plus);
+       fprintf(fp, "08 Right Pad - Touch Down: %d      # Right Touch Down\n", p->r_touch_down);
+       fprintf(fp, "09 Right Pad - Touch Down Plus:    %d      # Extra key\n\n", p->r_touch_down_plus);
+       fprintf(fp, "10 Left Pad - Button 9:            %d      # Button 9\n", p->key_9);
+       fprintf(fp, "11 Left Pad - Button 9 Plus:       %d      # Extra key\n\n", p->key_9_plus);
+       fprintf(fp, "12 Left Pad - Button 10:   %d      # Button 10\n", p->key_10);
+       fprintf(fp, "13 Left Pad - Button 10 Plus:      %d      # Extra key\n\n", p->key_10_plus);
+       fprintf(fp, "14 Left Pad - Button 11:   %d      # Button 11\n", p->key_11);
+       fprintf(fp, "15 Left Pad - Button 11 Plus:      %d      # Extra key\n\n", p->key_11_plus);
+       fprintf(fp, "16 Left Pad - Button 12:   %d      # Button 12\n", p->key_12);
+       fprintf(fp, "17 Left Pad - Button 12 Plus:      %d      # Extra key\n\n", p->key_12_plus);
+       fprintf(fp, "18 Right Pad - Button 13:  %d      # Button 13\n", p->key_13);
+       fprintf(fp, "19 Right Pad - Button 13 Plus:     %d      # Extra key\n\n", p->key_13_plus);
+       fprintf(fp, "20 Right Pad - Button 14:  %d      # Button 14\n", p->key_14);
+       fprintf(fp, "21 Right Pad - Button 14 Plus:     %d      # Extra key\n\n", p->key_14_plus);
+       fprintf(fp, "22 Right Pad - Button 15:  %d      # Button 15\n", p->key_15);
+       fprintf(fp, "23 Right Pad - Button 15 Plus:     %d      # Extra key\n\n", p->key_15_plus);
+       fprintf(fp, "24 Right Pad - Button 16:  %d      # Button 16\n", p->key_16);
+       fprintf(fp, "25 Right Pad - Button 16 Plus:     %d      # Extra key\n\n", p->key_16_plus);
+       fprintf(fp, "%s                         # <--- End Program Record\n\n", "%%");
 
        return 0;
 }
index 97a5f9c..40520a3 100644 (file)
@@ -1,32 +1,31 @@
 /*
- * event_loop.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
- *
- * Copyright (C) 2005 - Mats Johannesson
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
- *
- */
+ event_loop.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
+ Copyright (C) 2005 - Mats Johannesson
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+*/
 
 #include "globals.h"
 
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-/* Function waits perpetually for the X server to deliver information */
-/* about events from the input device. Receipt of an event that we've */
-/* registered for (button press/release and motion) triggers a good deal */
-/* of activity in a setup phase, after which we send the fake key press */
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Function waits perpetually for the X server to deliver information
+ about events from the input device. Receipt of an event that we've
+ registered for (button press/release and motion) triggers a good deal
+ of activity in a setup phase, after which we send the fake key press
+ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 
 int use_events(Display *display)
 {
@@ -50,6 +49,9 @@ int use_events(Display *display)
        int rotation;              /* recorded. Bottom is 4097. Top is 2 */
        int throttle;
 
+       int i = 0;
+       int *button_index = 0;
+
        XDeviceMotionEvent *motion;
        XDeviceButtonEvent *button;
 
@@ -64,16 +66,16 @@ int use_events(Display *display)
                focus_window = None;
                in_list = 0;
 
-/* Locate which window that currently has the focus and get its list of */
-/* related windows. Then pull its ClassHint into our allocated structure */
+/* Locate which window that currently has the focus and get its list of
+   related windows. Then pull its ClassHint into our allocated structure */
 
                XGetInputFocus(display, &focus_window, &focus_state);
                XQueryTree(display, focus_window, &root, &parent, &children, &num_children);
                XGetClassHint(display, focus_window, class_hint);
 
-/* If the class hint (aka WM_CLASS) contains no class string we free the */
-/* allocated memory for each structure member and get the ClassHint of the */
-/* window parent, if it has one. Observe that we must skip the root window */
+/* If the class hint (aka WM_CLASS) contains no class string we free the
+   allocated memory for each structure member and get the ClassHint of the
+   window parent, if it has one. Observe that we must skip the root window */
 
                if ((!class_hint->res_class) && (parent) && (focus_window != root)) {
                        XFree(class_hint->res_class);
@@ -81,11 +83,11 @@ int use_events(Display *display)
                        XGetClassHint(display, parent, class_hint);
                }
 
-/* If the root window had the focus, or if the active window or its parent */
-/* had no class string at all, we use the top ("default") program definition */
-/* from the read in configuration file when evaluating the event. Otherwise */
-/* we start scanning for a match between the class strings in our list and */
-/* the found window class. Set a flag if a match is encountered */
+/* If the root window had the focus, or if the active window or its parent
+   had no class string at all, we use the top ("default") program definition
+   from the read in configuration file when evaluating the event. Otherwise
+   we start scanning for a match between the class strings in our list and
+   the found window class. Set a flag if a match is encountered */
 
                if ((focus_window == root) || (class_hint->res_class == NULL)) {
                        p = external_list;
@@ -103,16 +105,20 @@ int use_events(Display *display)
                        p = external_list;
                }
 
-/* The allocated memory for the ClassHint structure, and each of its */
-/* members, must be freed here. Also, the call to XQueryTree to get a */
-/* list of related windows might have allocated memory for child entries. */
-/* It must be released as well */
+/* The allocated memory for the ClassHint structure, and each of its
+   members, must be freed here. Also, the call to XQueryTree to get a
+   list of related windows might have allocated memory for child entries.
+   It must be released as well */
                
                XFree(class_hint->res_class);
                XFree(class_hint->res_name);
                XFree(class_hint);
                if (children) XFree((char *)children);
 
+               if (be_verbose) {
+                       fprintf(stderr, "PGR RUNNAME = %s\n", p->class_name);
+               }
+
 /* Finally start to look at the actual event. Touch Strips come first */
 
                if (Event.type == motion_type) {
@@ -124,18 +130,18 @@ int use_events(Display *display)
                                rotation = motion->axis_data[3];
                                throttle = motion->axis_data[4];
 
-/* As can be analyzed with Frederic Lepied's excellent xinput-1.2 program */
-/* the touch strip data comes in on axis 3 and 4 (left and right strips). */
-/* The pad device never uses x-axis [0], y-axis [1] or wheel [5]. The value */
-/* is always 0 there. The pressure [2], rotation [3] and throttle [4] all */
-/* rest with a value of 1. Touch strips send data about the finger position */
-/* in 13 steps. Furthest down is 4097 while the top is 2. Template: */
-/* 4097, 2049, 1025, 513, 257, 129, 65, 33, 17, 9, 5, 3, 2. We don't care */
-/* about those numbers per se (for now at least ;-), but just stick them */
-/* in history buffers. The present value is then compared to an old and */
-/* an even older one to determine direction of the finger movement. Observe */
-/* that when we finally send a fake keypress, it has two parts - true and */
-/* false. It corresponds with a key press and a key release. Order is key ;-) */
+/* As can be analyzed with Frederic Lepied's excellent xinput-1.2 program
+   the touch strip data comes in on axis 3 and 4 (left and right strips).
+   The pad device never uses x-axis [0], y-axis [1] or wheel [5]. The value
+   is always 0 there. The pressure [2], rotation [3] and throttle [4] all
+   rest with a value of 1. Touch strips send data about the finger position
+   in 13 steps. Furthest down is 4097 while the top is 2. Template:
+   4097, 2049, 1025, 513, 257, 129, 65, 33, 17, 9, 5, 3, 2. We don't care
+   about those numbers per se (for now at least ;-), but just stick them
+   in history buffers. The present value is then compared to an old and
+   an even older one to determine direction of the finger movement. Observe
+   that when we finally send a fake keypress, it has two parts - true and
+   false. It corresponds with a key press and a key release. Order is key ;-) */
 
 /* Left Touch Strip */
 
@@ -143,18 +149,30 @@ int use_events(Display *display)
                                        if ((rotation < old_rotation) && (old_rotation <= elder_rotation)) {
                                                if (p->l_touch_up) {
                                                        XTestFakeKeyEvent(display, p->l_touch_up, True, CurrentTime);
+                                                       if (be_verbose) {
+                                                               fprintf(stderr, "KEY LTCHUP = %d\n", p->l_touch_up);
+                                                       }
                                                        if (p->l_touch_up_plus) {
                                                                XTestFakeKeyEvent(display, p->l_touch_up_plus, True, CurrentTime);
                                                                XTestFakeKeyEvent(display, p->l_touch_up_plus, False, CurrentTime);
+                                                               if (be_verbose) {
+                                                                       fprintf(stderr, "KEY LTCHUP+ = %d\n", p->l_touch_up_plus);
+                                                               }
                                                        }
                                                        XTestFakeKeyEvent(display, p->l_touch_up, False, CurrentTime);
                                                }
                                        } else if ((rotation > old_rotation) && (old_rotation >= elder_rotation)) {
                                                if (p->l_touch_down) {
                                                        XTestFakeKeyEvent(display, p->l_touch_down, True, CurrentTime);
+                                                       if (be_verbose) {
+                                                               fprintf(stderr, "KEY LTCHDN = %d\n", p->l_touch_down);
+                                                       }
                                                        if (p->l_touch_down_plus) {
                                                                XTestFakeKeyEvent(display, p->l_touch_down_plus, True, CurrentTime);
                                                                XTestFakeKeyEvent(display, p->l_touch_down_plus, False, CurrentTime);
+                                                               if (be_verbose) {
+                                                                       fprintf(stderr, "KEY LTCHDN+ = %d\n", p->l_touch_down_plus);
+                                                               }
                                                        }
                                                        XTestFakeKeyEvent(display, p->l_touch_down, False, CurrentTime);
                                                }
@@ -169,18 +187,30 @@ int use_events(Display *display)
                                        if ((throttle < old_throttle) && (old_throttle <= elder_throttle)) {
                                                if (p->r_touch_up) {
                                                        XTestFakeKeyEvent(display, p->r_touch_up, True, CurrentTime);
+                                                       if (be_verbose) {
+                                                               fprintf(stderr, "KEY RTCHUP = %d\n", p->r_touch_up);
+                                                       }
                                                        if (p->r_touch_up_plus) {
                                                                XTestFakeKeyEvent(display, p->r_touch_up_plus, True, CurrentTime);
                                                                XTestFakeKeyEvent(display, p->r_touch_up_plus, False, CurrentTime);
+                                                               if (be_verbose) {
+                                                                       fprintf(stderr, "KEY RTCHUP+ = %d\n", p->r_touch_up_plus);
+                                                               }
                                                        }
                                                        XTestFakeKeyEvent(display, p->r_touch_up, False, CurrentTime);
                                                }
                                        } else if ((throttle > old_throttle) && (old_throttle >= elder_throttle)) {
                                                if (p->r_touch_down) {
                                                        XTestFakeKeyEvent(display, p->r_touch_down, True, CurrentTime);
+                                                       if (be_verbose) {
+                                                               fprintf(stderr, "KEY RTCHDN = %d\n", p->r_touch_down);
+                                                       }
                                                        if (p->r_touch_down_plus) {
                                                                XTestFakeKeyEvent(display, p->r_touch_down_plus, True, CurrentTime);
                                                                XTestFakeKeyEvent(display, p->r_touch_down_plus, False, CurrentTime);
+                                                               if (be_verbose) {
+                                                                       fprintf(stderr, "KEY RTCHDN+ = %d\n", p->r_touch_down_plus);
+                                                               }
                                                        }
                                                        XTestFakeKeyEvent(display, p->r_touch_down, False, CurrentTime);
                                                }
@@ -191,13 +221,12 @@ int use_events(Display *display)
                        }
                }
 
-/* Now see if the event concerned the pad buttons. Not much to talk about. */
-/* We follow the configuration definitions, and handle a pen if requested */
-/* to do so. The switch routine is ugly and easy to get wrong, but it */
-/* works! Ah yes, the xinput-1.2 program reveals Wacom to have numbered the */
-/* buttons 9, 10, 11, 12 on the left side and 13, 14, 15, 16 on the right. */
-/* Template: */
-/*
+/* Now see if the event concerned the pad buttons. Not much to talk about.
+   We follow the configuration definitions, and handle a pen if requested
+   to do so. Ah yes, the xinput-1.2 program reveals Wacom to have numbered
+   the buttons 9, 10, 11, 12 on the left side and 13, 14, 15, 16 on the
+   right. Template:
+
 Left ExpressKey Pad
 ------------ 
 |  |   |   |           Wacom Intuos3 defaults are:
@@ -225,242 +254,69 @@ Right ExpressKey Pad
 
                        button = (XDeviceButtonEvent *) &Event;
 
-                       switch (button->button) {
+                       button_index = &p->key_9;
 
-                               case 9:
-                               if (p->key_9 == TOGGLE_PEN)
-                                       if (handle_pen)
-                                               toggle_pen_mode(display, pen_name);
-                                       else
-                                       break;
-                               else
-                               if (p->key_9)
-                                       XTestFakeKeyEvent(display, p->key_9, True, CurrentTime );
-                                       if (p->key_9_plus)
-                                               XTestFakeKeyEvent(display, p->key_9_plus, True, CurrentTime );
-                                       else
-                                       break;
-                               break;
-
-                               case 10:
-                               if (p->key_10 == TOGGLE_PEN)
-                                       if (handle_pen)
-                                               toggle_pen_mode(display, pen_name);
-                                       else
-                                       break;
-                               else
-                               if (p->key_10)
-                                       XTestFakeKeyEvent(display, p->key_10, True, CurrentTime );
-                                       if (p->key_10_plus)
-                                               XTestFakeKeyEvent(display, p->key_10_plus, True, CurrentTime );
-                                       else
-                                       break;
-                               break;
-
-                               case 11:
-                               if (p->key_11 == TOGGLE_PEN)
-                                       if (handle_pen)
-                                               toggle_pen_mode(display, pen_name);
-                                       else
-                                       break;
-                               else
-                               if (p->key_11)
-                                       XTestFakeKeyEvent(display, p->key_11, True, CurrentTime );
-                                       if (p->key_11_plus)
-                                               XTestFakeKeyEvent(display, p->key_11_plus, True, CurrentTime );
-                                       else
-                                       break;
-                               break;
-
-                               case 12:
-                               if (p->key_12 == TOGGLE_PEN)
-                                       if (handle_pen)
-                                               toggle_pen_mode(display, pen_name);
-                                       else
-                                       break;
-                               else
-                               if (p->key_12)
-                                       XTestFakeKeyEvent(display, p->key_12, True, CurrentTime );
-                                       if (p->key_12_plus)
-                                               XTestFakeKeyEvent(display, p->key_12_plus, True, CurrentTime );
-                                       else
-                                       break;
-                               break;
-
-                               case 13:
-                               if (p->key_13 == TOGGLE_PEN)
-                                       if (handle_pen)
-                                               toggle_pen_mode(display, pen_name);
-                                       else
-                                       break;
-                               else
-                               if (p->key_13)
-                                       XTestFakeKeyEvent(display, p->key_13, True, CurrentTime );
-                                       if (p->key_13_plus)
-                                               XTestFakeKeyEvent(display, p->key_13_plus, True, CurrentTime );
-                                       else
-                                       break;
-                               break;
-
-                               case 14:
-                               if (p->key_14 == TOGGLE_PEN)
-                                       if (handle_pen)
-                                               toggle_pen_mode(display, pen_name);
-                                       else
-                                       break;
-                               else
-                               if (p->key_14)
-                                       XTestFakeKeyEvent(display, p->key_14, True, CurrentTime );
-                                       if (p->key_14_plus)
-                                               XTestFakeKeyEvent(display, p->key_14_plus, True, CurrentTime );
-                                       else
-                                       break;
-                               break;
-
-                               case 15:
-                               if (p->key_15 == TOGGLE_PEN)
-                                       if (handle_pen)
-                                               toggle_pen_mode(display, pen_name);
-                                       else
-                                       break;
-                               else
-                               if (p->key_15)
-                                       XTestFakeKeyEvent(display, p->key_15, True, CurrentTime );
-                                       if (p->key_15_plus)
-                                               XTestFakeKeyEvent(display, p->key_15_plus, True, CurrentTime );
-                                       else
-                                       break;
-                               break;
-
-                               case 16:
-                               if (p->key_16 == TOGGLE_PEN)
-                                       if (handle_pen)
-                                               toggle_pen_mode(display, pen_name);
-                                       else
-                                       break;
-                               else
-                               if (p->key_16)
-                                       XTestFakeKeyEvent(display, p->key_16, True, CurrentTime );
-                                       if (p->key_16_plus)
-                                               XTestFakeKeyEvent(display, p->key_16_plus, True, CurrentTime );
-                                       else
-                                       break;
-                               break;                  
+                       for (i = 9; i < button->button; i++) {
+                               button_index++;
+                               button_index++;
+                       }
 
-                               default:
-                               break;
+                       if (*button_index == TOGGLE_PEN) {
+                               if (handle_pen) {
+                                       toggle_pen_mode(display, pen_name);
+                                       if (be_verbose) {
+                                               fprintf(stderr, "BTN %d = %d\n", button->button, *button_index);
+                                       }
+                               }
+                       } else {
+                               if (*button_index) {
+                                       XTestFakeKeyEvent(display, *button_index, True, CurrentTime );
+                                       if (be_verbose) {
+                                               fprintf(stderr, "BTN %d = %d\n", button->button, *button_index);
+                                       }
+                               }
+                               button_index++;
+                               if (*button_index) {
+                                       XTestFakeKeyEvent(display, *button_index, True, CurrentTime );
+                                       if (be_verbose) {
+                                               fprintf(stderr, "BTN+ %d = %d\n", button->button, *button_index);
+                                       }
+                               }
                        }
                }
 
 /* Pad Button Release */
 
-/* There is just an exit point below */
-/* this switch routine by the way */
-
                if (Event.type == button_release_type) {
 
                        button = (XDeviceButtonEvent *) &Event;
 
-                       switch (button->button) {
-
-                               case 9:
-                               if (p->key_9 == TOGGLE_PEN)
-                                       break;
-                               else
-                               if (p->key_9_plus)
-                                       XTestFakeKeyEvent(display, p->key_9_plus, False, CurrentTime );
-                                       if (p->key_9)
-                                               XTestFakeKeyEvent(display, p->key_9, False, CurrentTime );
-                                       else
-                                       break;
-                               break;
-
-                               case 10:
-                               if (p->key_10 == TOGGLE_PEN)            
-                                       break;
-                               else
-                               if (p->key_10_plus)
-                                       XTestFakeKeyEvent(display, p->key_10_plus, False, CurrentTime );
-                                       if (p->key_10)
-                                               XTestFakeKeyEvent(display, p->key_10, False, CurrentTime );
-                                       else
-                                       break;
-                               break;
-
-                               case 11:
-                               if (p->key_11 == TOGGLE_PEN)
-                                       break;
-                               else
-                               if (p->key_11_plus)
-                                       XTestFakeKeyEvent(display, p->key_11_plus, False, CurrentTime );
-                                       if (p->key_11)
-                                               XTestFakeKeyEvent(display, p->key_11, False, CurrentTime );
-                                       else
-                                       break;
-                               break;
-
-                               case 12:
-                               if (p->key_12 == TOGGLE_PEN)
-                                       break;
-                               else
-                               if (p->key_12_plus)
-                                       XTestFakeKeyEvent(display, p->key_12_plus, False, CurrentTime );
-                                       if (p->key_12)
-                                               XTestFakeKeyEvent(display, p->key_12, False, CurrentTime );
-                                       else
-                                       break;
-                               break;
+                       button_index = &p->key_9;
 
-                               case 13:
-                               if (p->key_13 == TOGGLE_PEN)
-                                       break;
-                               else
-                               if (p->key_13_plus)             
-                                       XTestFakeKeyEvent(display, p->key_13_plus, False, CurrentTime );
-                                       if (p->key_13)
-                                               XTestFakeKeyEvent(display, p->key_13, False, CurrentTime );
-                                       else
-                                       break;
-                               break;
-
-                               case 14:
-                               if (p->key_14 == TOGGLE_PEN)
-                                       break;
-                               else
-                               if (p->key_14_plus)
-                                       XTestFakeKeyEvent(display, p->key_14_plus, False, CurrentTime );
-                                       if (p->key_14)
-                                               XTestFakeKeyEvent(display, p->key_14, False, CurrentTime );
-                                       else
-                                       break;
-                               break;
-
-                               case 15:
-                               if (p->key_15 == TOGGLE_PEN)
-                                       break;
-                               else
-                               if (p->key_15_plus)
-                                       XTestFakeKeyEvent(display, p->key_15_plus, False, CurrentTime );
-                                       if (p->key_15)
-                                               XTestFakeKeyEvent(display, p->key_15, False, CurrentTime );
-                                       else
-                                       break;
-                               break;
-
-                               case 16:
-                               if (p->key_16 == TOGGLE_PEN)
-                                       break;
-                               else
-                               if (p->key_16_plus)
-                                       XTestFakeKeyEvent(display, p->key_16_plus, False, CurrentTime );
-                                       if (p->key_16)
-                                               XTestFakeKeyEvent(display, p->key_16, False, CurrentTime );
-                                       else
-                                       break;
-                               break;
+                       for (i = 9; i < button->button; i++) {
+                               button_index++;
+                               button_index++;
+                       }
 
-                               default:
-                               break;
+                       if (*button_index == TOGGLE_PEN) {
+                               if (be_verbose) {
+                                       fprintf(stderr, "BTN %d = %d\n", button->button, *button_index);
+                               }
+                       } else {
+                               button_index++;
+                               if (*button_index) {
+                                       XTestFakeKeyEvent(display, *button_index, False, CurrentTime );
+                                       if (be_verbose) {
+                                               fprintf(stderr, "BTN+ %d = %d\n", button->button, *button_index);
+                                       }
+                               }
+                               button_index--;
+                               if (*button_index) {
+                                       XTestFakeKeyEvent(display, *button_index, False, CurrentTime );
+                                       if (be_verbose) {
+                                               fprintf(stderr, "BTN %d = %d\n", button->button, *button_index);
+                                       }
+                               }
                        }
                }
        }
index 9d65f35..342297a 100644 (file)
@@ -1,34 +1,33 @@
 /*
- * get_device.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
- *
- * Copyright (C) 2005 - Mats Johannesson
- *
- * Based on xinput.c 1996 by Frederic Lepied (xinput-1.2)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
- *
- */
+ get_device.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
+ Copyright (C) 2005 - Mats Johannesson
+ Based on xinput.c 1996 by Frederic Lepied (xinput-1.2)
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+*/
 
 #include "globals.h"
 
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-/* Function queries the X server for input devices. It only cares about non */
-/* core ones, and compares them with what was specified on the command line. */
-/* The "info" is a XDeviceInfo construct whos address is transferred to a */
-/* permanent global copy for freeing at program exit */
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Function queries the X server for input devices. It only cares about non
+ core ones, and compares them with what was specified on the command line.
+ The "info" is a XDeviceInfo construct whos address is transferred to a
+ permanent global copy for freeing at program exit
+ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 
 int get_device_info(Display *display, XDeviceInfo *info, char *name)
 {
index 87aeef0..eecd80a 100644 (file)
@@ -1,23 +1,22 @@
 /*
- * globals.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
- *
- * Copyright (C) 2005 - Mats Johannesson
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
- *
- */
+ globals.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
+ Copyright (C) 2005 - Mats Johannesson
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+*/
 
 #include "globals.h"
 
@@ -42,6 +41,7 @@ char *error_file = "/error.log";      /* files should be called */
 
 int screen;
 int go_daemon = 0;     /* Do not become a daemon without a command */
+int be_verbose = 0; /* Run silently per default */
 int reread_config = 0; /* No memory should be freed on the first read */
 int handle_pen = 0;    /* Pen should not be handled per default */
 int pen_mode = 1;      /* Assume pen is in Absolute mode initially */
@@ -51,8 +51,8 @@ int motion_type = NON_VALID;
 int button_press_type = NON_VALID;
 int button_release_type = NON_VALID;
 
-/* Allocate space for a list of program definitions (config file based) */
-/* Also initialize a small list that is written out if no config file exists */
+/* Allocate space for a list of program definitions (config file based)
+   Also initialize a small list that is written out if no config file exists */
 
 struct program external_list [MAXRECORDS];
 struct program internal_list[] = {
index 9d4b356..80fc44a 100644 (file)
@@ -1,23 +1,22 @@
 /*
- * globals.h -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
- *
- * Copyright (C) 2005 - Mats Johannesson
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
- *
- */
+ globals.h -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
+ Copyright (C) 2005 - Mats Johannesson
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+*/
 
 /* Standard Program includes */
 #include <stdio.h>
@@ -50,9 +49,8 @@
 #define TOGGLE_PEN 999 /* String signaling the key's use as a mode toggle */
 #define MAXRECORDS 64  /* Max program definitions to handle (enough? ;-) */
 #define MAXFIELDS 25   /* Max entries (minus program name) in each record */
-#define MAXDIGITS 3    /* Max number of digits in a key entry */
-#define MAXBUFFER 64   /* Scratch buffer. Also sets program name length limit*/
-#define CONFIG_VERSION 1 /* Config file version - for future format changes */
+#define MAXBUFFER 160  /* Scratch buffer. Two full terminal lines */
+#define CONFIG_VERSION 2 /* Config file version - for future format changes */
 
 /* Our global variables */
 extern char *our_prog_name;    /* This program's file name */
@@ -70,6 +68,7 @@ extern int screen;    /* Active screen. An X thing */
 extern int num_list;   /* Number of programs we currently handle */
 
 extern int go_daemon;  /* Flag to see if this program is in daemon mode */
+extern int be_verbose; /* Flag to see if we should be spitting out info */
 extern int reread_config; /* Flag for memory release if redoing the config */
 extern int handle_pen; /* Flag (main switch) to see if a pen is handled */
 extern int pen_mode;   /* Flag to keep track of the pen mode we are in */
@@ -89,6 +88,7 @@ extern XDevice *pad_device;   /* The actual pointer to the pad device */
 extern XDevice *pen_device;    /* The actual pointer to the pen device */
 
 /* Our global (internal) functions */
+extern int write_file_config_header(FILE *fp);
 extern int write_file_config(int *ip, FILE *fp);
 extern int read_file_config(int *ip, FILE *fp);
 extern int get_device_info(Display *display, XDeviceInfo *info, char *name);
@@ -100,8 +100,8 @@ extern void re_read_file_config(int signum);
 extern void clean_up_exit(int signum);
 
 /* Our global structures */
-/* The internal_list is initialized in globals.c */
-/* The external_list is initialized from file reads */
+/* The internal_list is initialized in globals.c
+   The external_list is initialized from file reads */
 extern struct program {
        char *class_name;
        int handle_touch;
index 91b35ef..2abeace 100644 (file)
@@ -1,23 +1,22 @@
 /*
- * main_setup.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
- *
- * Copyright (C) 2005 - Mats Johannesson
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
- *
- */
+ main_setup.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
+ Copyright (C) 2005 - Mats Johannesson
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+*/
 
 #include "globals.h"
 
@@ -49,9 +48,9 @@ int main (int argc, char *argv[])
                exit_on_error(errorfp, "%s ERROR: Can not find your HOME directory!\n", our_prog_name, "");
        }
 
-/* Concatenate the home directory string with the string of our preferred*/
-/* configuration file directory. The address to the whole string is then */
-/* copied to a global pointer, so we won't have to perform this part again */
+/* Concatenate the home directory string with the string of our preferred
+   configuration file directory. The address to the whole string is then
+   copied to a global pointer, so we won't have to perform this part again */
 
        char *total_config_dir_block;
        len = strlen(user_homedir) + strlen(config_dir) + 1;
@@ -95,10 +94,9 @@ int main (int argc, char *argv[])
 
        char pid_buffer [MAXBUFFER];
 
-/* Try to open the the configuration directory for */
-/* reading, just as a test to see if it exists. A failure */
-/* here can mean many things, but we then try to create */
-/* it as a means to rule out a true lack of existence */
+/* Try to open the the configuration directory for reading, just as a
+   test to see if it exists. A failure here can mean many things, but we
+   then try to create it as a means to rule out a true lack of existence */
 
        if ((fp = fopen(total_config_dir, "r")) == NULL) {
                if ((mkdir(total_config_dir, 0777)) == NON_VALID) {
@@ -108,12 +106,12 @@ int main (int argc, char *argv[])
                fclose(fp);
        }
 
-/* If a pid file exists it is a sign of either A) program already runs, or */
-/* B) a crash/brutal kill not handled by our exit routine has occured */
-/* previously. We therefore read in such a PID and perform a "fake" kill */
-/* with it (signal number 0). If -1 (error) is returned we just carry on. */
-/* Otherwise our kill test detected a process with that PID and we exit, */
-/* based on the assumption that another instance is running */
+/* If a pid file exists it is a sign of either A) program already runs, or
+   B) a crash/brutal kill not handled by our exit routine has occured
+   previously. We therefore read in such a PID and perform a "fake" kill
+   with it (signal number 0). If -1 (error) is returned we just carry on.
+   Otherwise our kill test detected a process with that PID and we exit,
+   based on the assumption that another instance is running */
 
        if ((fp = fopen(total_pid_file, "r")) != NULL) {
                fgets(pid_buffer, MAXBUFFER, fp);
@@ -152,11 +150,12 @@ int main (int argc, char *argv[])
 
        if (argc < 2) {
                fprintf(stderr, "\n");
-               fprintf(stderr, "Usage: %s <pad-device-name> [<pen-device-name>] [-d]\n", our_prog_name);
+               fprintf(stderr, "Usage: %s <pad-device-name> [<pen-device-name>] [-d] [-v]\n", our_prog_name);
                fprintf(stderr, "\n");
                fprintf(stderr, "Where the pad name is mandatory. Specify a pen name\n");
                fprintf(stderr, "if you want the program to handle pen mode switches.\n");
                fprintf(stderr, "Use -d to make the program a daemon (run in the background).\n");
+               fprintf(stderr, "Use -v to print info to the screen at many execution points\n");
                fprintf(stderr, "\n");
                fprintf(stderr, "Example: %s pad stylus -d\n", our_prog_name);
                fprintf(stderr, "\n");
@@ -170,8 +169,8 @@ int main (int argc, char *argv[])
                exit_on_error(errorfp, "%s ERROR: Can not find pad device: %s\n", our_prog_name, argv[1]);
        }
 
-/* Set a flag if we should run as a daemon. Also register */
-/* and check a pen device, should such an action be requested */
+/* Set a flag if we should run as a daemon or/and in verbose mode. Also
+   register and check a pen device, should such an action be requested */
 
        if (argc > 2) {
                for (i = 2; i < argc; i++) {
@@ -181,7 +180,14 @@ int main (int argc, char *argv[])
                        }
                }
                for (i = 2; i < argc; i++) {
-                       if (strcmp(argv[i], "-d") != 0) {
+                       if (strcmp(argv[i], "-v") == 0) {
+                               be_verbose = 1;
+                               break;
+                       }
+               }
+               for (i = 2; i < argc; i++) {
+                       if ((strcmp(argv[i], "-d")) != 0 &&
+                       ((strcmp(argv[i], "-v")) != 0)) {
                                pen_name = argv[i];
                                handle_pen = 1;
                                pen_info = (void *) get_device_info(display, pen_info_block, argv[i]);
@@ -193,6 +199,18 @@ int main (int argc, char *argv[])
                }
        }
 
+       if (be_verbose) {
+               fprintf(stderr, "USR HOMEDIR = %s\n", user_homedir);
+               fprintf(stderr, "OUR CNF-DIR = %s\n", total_config_dir);
+               fprintf(stderr, "OUR CNFFILE = %s\n", total_config_file);
+               fprintf(stderr, "OUR PIDFILE = %s\n", total_pid_file);
+               fprintf(stderr, "OUR LOGFILE = %s\n", total_error_file);
+               fprintf(stderr, "OUR PADNAME = %s\n", argv[1]);
+               if (pen_name) {
+                       fprintf(stderr, "OUR PENNAME = %s\n", pen_name);
+               }
+       }
+
 /* Make sure we can open a requested pen */
 
        if (handle_pen) {
@@ -202,15 +220,15 @@ int main (int argc, char *argv[])
                }
        }
 
-/* If no configuration file exists, write out a short one from an internal */
-/* memory structure. Also tag it with a version number - for future use */
+/* If no configuration file exists, write out a short one from an internal
+   memory structure. Also tag it with a Config File Version number */
 
        if ((fp = fopen(total_config_file, "a+")) == NULL) {
                exit_on_error(errorfp, "%s ERROR: Can not open %s in read/write mode\n", our_prog_name, total_config_file);
        } else {
                rewind(fp);
                if (fgetc(fp) == EOF) {
-                       fprintf(fp, "Version: %d\n\n", CONFIG_VERSION);
+                       write_file_config_header(fp);
                        for (p = internal_list; p < internal_list + num_list; p++) {
                                write_file_config((void *)&p, fp);
                                if (ferror(fp)) {
@@ -240,16 +258,20 @@ int main (int argc, char *argv[])
                        case 2:
                        fclose(fp);
                        exit_on_error(errorfp, "%s ERROR: Memory allocation error while parsing %s\n", our_prog_name, total_config_file);
-                       
+
+                       case 3:
+                       fclose(fp);
+                       exit_on_error(errorfp, "%s ERROR: Config File Version %d not found\n", our_prog_name, (void *)CONFIG_VERSION);
+
                        default:
                        fclose(fp);
                        exit_on_error(errorfp, "%s ERROR: Unknown error while parsing %s\n", our_prog_name, total_config_file);
                }
        }
 
-/* Replace some of the normal signal handlers with our own functions. We */
-/* want SIGUSR1 and SIGUSR2 to read in the config file after a modification, */
-/* and all the normal program exits should first clean up a bit */
+/* Replace some of the normal signal handlers with our own functions. We
+   want SIGUSR1 and SIGUSR2 to read in the config file after a modification,
+   and all the normal program exits should first clean up a bit */
 
        if ((signal(SIGUSR1, re_read_file_config) == SIG_ERR)
                || (signal(SIGUSR2, re_read_file_config) == SIG_ERR)
@@ -259,10 +281,11 @@ int main (int argc, char *argv[])
                exit_on_error(errorfp, "%s ERROR: Failed to modify signal handling!\n", our_prog_name, "");
        }
 
-/* Ready to launch in the foreground or as a daemon after one last check. */
-/* In daemon mode we also take care of storing our PID in the config dir */
-/* Observe that with a (0, 0) standard input/output/error goes to /dev/null */
-/* I've found it better to use (0, 1) and see errors while writing the code */
+/* Ready to launch in the foreground or as a daemon after one last check.
+   In daemon mode we also take care of storing our PID in the config dir
+   Observe that with a (0, 0) standard input/output/error goes to /dev/null
+   I've found it better to use (0, 1) and see errors while writing the code
+   It also comes in handy when running in (-v) verbose mode */
 
        if (register_events(display, pad_info, argv[1])) {
                if (go_daemon) {
@@ -273,6 +296,9 @@ int main (int argc, char *argv[])
                                if ((fp = fopen(total_pid_file, "w")) == NULL) {
                                        exit_on_error(errorfp, "%s ERROR: Can not open %s in write mode\n", our_prog_name, total_pid_file);
                                } else {
+                                       if (be_verbose) {
+                                               fprintf(stderr, "OUR RUN-PID = %s\n", pid_buffer);
+                                       }
                                        fprintf(fp, "%s", pid_buffer);
                                        if (ferror(fp)) {
                                                exit_on_error(errorfp, "%s ERROR: Write error in %s\n", our_prog_name, total_pid_file);
index 163f19a..4aee05f 100644 (file)
@@ -1,29 +1,28 @@
 /*
- * on_error.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
- *
- * Copyright (C) 2005 - Mats Johannesson
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
- *
- */
+ on_error.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
+ Copyright (C) 2005 - Mats Johannesson
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+*/
 
 #include "globals.h"
 
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-/* Function prints out the error strings from a caller and terminates */
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Function prints out the error strings from a caller and terminates
+ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 
 void exit_on_error(FILE *fp, char *string1, char *string2, char *string3)
 {
@@ -36,6 +35,8 @@ void exit_on_error(FILE *fp, char *string1, char *string2, char *string3)
        fprintf(stderr, string1, string2, string3);
        clean_up_exit(SIGTERM);
 
+/* FIXME Drops the state EXIT_KO when calling clean_up_exit, becomes EXIT_OK */
+
 }
 
 /* End Code */
index 3a3ac67..a5fb126 100644 (file)
@@ -1,30 +1,29 @@
 /*
- * on_signal.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
- *
- * Copyright (C) 2005 - Mats Johannesson
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
- *
- */
+ on_signal.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
+ Copyright (C) 2005 - Mats Johannesson
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+*/
 
 #include "globals.h"
 
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-/* Function acts as a signal handler replacement for SIGUSR1 and SIGUSR2 */
-/* On these signals we read a possibly changed configuration file again */
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Function acts as a signal handler replacement for SIGUSR1 and SIGUSR2
+ On these signals we read a possibly changed configuration file again
+ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 
 void re_read_file_config(int signum)
 {
@@ -59,7 +58,11 @@ void re_read_file_config(int signum)
                        case 2:
                        fclose(fp);
                        exit_on_error(errorfp, "%s ERROR: Reread - Memory allocation error while parsing %s\n", our_prog_name, total_config_file);
-                       
+
+                       case 3:
+                       fclose(fp);
+                       exit_on_error(errorfp, "%s ERROR: Reread - Config File Version %d not found\n", our_prog_name, (void *)CONFIG_VERSION);
+
                        default:
                        fclose(fp);
                        exit_on_error(errorfp, "%s ERROR: Reread - Unknown error while parsing %s\n", our_prog_name, total_config_file);
@@ -69,14 +72,14 @@ void re_read_file_config(int signum)
        fclose(errorfp);
 }
 
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-/* Function acts as a signal handler replacement for SIGINT, SIGHUP and */
-/* SIGTERM. All are normal exit signals. We want to trap them in order to */
-/* perform some house keeping pre-exit. Delete a PID file and free memory */
-/* Since it takes care of several signals, it could get invoked recursively */
-/* if some other signal comes in. We use this "volatile" variable to track */
-/* the case. At the end we restore the default signal handler and raise it */
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Function acts as a signal handler replacement for SIGINT, SIGHUP and
+ SIGTERM. All are normal exit signals. We want to trap them in order to
+ perform some house keeping pre-exit. Delete a PID file and free memory
+ Since it takes care of several signals, it could get invoked recursively
+ if some other signal comes in. We use this "volatile" variable to track
+ the case. At the end we restore the default signal handler and raise it
+ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 
 volatile sig_atomic_t clean_up_exit_in_progress = 0;
 void clean_up_exit(int signum)
index 52937e9..a048ea4 100644 (file)
@@ -1,33 +1,32 @@
 /*
- * pen_mode.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
- *
- * Copyright (C) 2005 - Mats Johannesson
- *
- * Based on setmode.c 1996 by Frederic Lepied (xinput-1.2)
- *
- * This code is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This code is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this code; if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
+ pen_mode.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
+ Copyright (C) 2005 - Mats Johannesson
+ Based on setmode.c 1996 by Frederic Lepied (xinput-1.2)
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+*/
 
 #include "globals.h"
 
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-/* Function opens the X input device (which stays open until program end) */
-/* and toggles mode between Absolute and Relative based on a flag status. */
-/* We make sure to only open the pen once by setting another flag. */
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Function opens the X input device (which stays open until program end)
+ and toggles mode between Absolute and Relative based on a flag status.
+ We make sure to only open the pen once by setting another flag.
+ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 
 int toggle_pen_mode(Display *display, char *name)
 {
@@ -37,6 +36,11 @@ int toggle_pen_mode(Display *display, char *name)
        } else {
                pen_mode = Absolute;
        }
+
+       if (be_verbose) {
+               fprintf(stderr, "PEN MODE = %d\n", pen_mode);
+       }
+
        if (!pen_open){
                pen_device = XOpenDevice(display, pen_info->id);
                pen_open = 1;
index ad5c4a4..b6a75d8 100644 (file)
@@ -1,35 +1,34 @@
 /*
- * reg_events.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
- *
- * Copyright (C) 2005 - Mats Johannesson
- *
- * Based on test.c 1996 by Frederic Lepied (xinput-1.2)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
- *
- */
+ reg_events.c -- Support ExpressKeys & Touch Strips on a Wacom Intuos3 tablet.
+ Copyright (C) 2005 - Mats Johannesson
+ Based on test.c 1996 by Frederic Lepied (xinput-1.2)
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+*/
 
 #include "globals.h"
 
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
-/* Function opens the X input device (which stays open until program end) */
-/* and starts to look for supported event types. The scope should be the */
-/* root window (ie everywhere) and we're only interested in motion events */
-/* (touch strip action) and button press/release. Having found the info */
-/* we ask the X server to keep us continuously notified about these events */
-/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ Function opens the X input device (which stays open until program end)
+ and starts to look for supported event types. The scope should be the
+ root window (ie everywhere) and we're only interested in motion events
+ (touch strip action) and button press/release. Having found the info
+ we ask the X server to keep us continuously notified about these events
+ +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
 
 int register_events(Display *display, XDeviceInfo *pad_info, char *name)
 {