src/tX_global.c

   1 /*
   2     terminatorX - realtime audio scratching software
   3     Copyright (C) 1999-2004  Alexander König
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19     File: tX_global.c
  20
  21     Description:  This file contains the routines for handling the
  22                   "globals" block. Intializing, reading setup from
  23                   disk and storing it.
  24
  25     Changes:
  26
  27     21 Jul 1999: introduced the lowpass globals.
  28         There were some changes in between...
  29         14 Jul 2002: switched to libxml instead of binary saving.
  30 */
  31
  32 #include <config.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include "tX_types.h"
  36 #include "tX_global.h"
  37 #include "string.h"
  38 #include <libxml/xmlmemory.h>
  39 #include <libxml/parser.h>
  40 #include <libxml/encoding.h>
  41
  42
  43 #define TX_XML_RC_VERSION "1.0"
  44
  45 tx_global globals;
  46 int _store_compress_xml=0;
  47
  48 #ifdef USE_ALSA_MIDI_IN
  49 extern void tX_midiin_store_connections(FILE *rc, char *indent);
  50 extern void tX_midiin_restore_connections(xmlNodePtr node);
  51 #endif
  52
  53 void get_rc_name(char *buffer)
  54 {
  55         strcpy(buffer,"");
  56         if (globals.alternate_rc) {
  57                 strcpy(buffer, globals.alternate_rc);
  58         } else {
  59                 if (getenv("HOME")) {
  60                         strcpy(buffer, getenv("HOME"));
  61                         if (buffer[strlen(buffer)-1]!='/')
  62                         strcat(buffer, "/");
  63                 }
  64                 strcat(buffer, ".terminatorXrc");
  65         }
  66 }
  67
  68 void set_global_defaults() {
  69         globals.startup_set = 0;
  70         globals.store_globals = 1;
  71         globals.no_gui = 0;
  72         globals.alternate_rc = 0;
  73
  74         strcpy(globals.xinput_device, "");
  75         globals.xinput_enable=0;
  76
  77         globals.update_idle=14;
  78         globals.update_delay=1;
  79
  80         strcpy(globals.oss_device, "/dev/dsp");
  81         globals.oss_buff_no=2;
  82         globals.oss_buff_size=9;
  83         globals.oss_samplerate=44100;
  84
  85         strcpy(globals.alsa_device_id, "hw:0,0");
  86         globals.alsa_buffer_time=80000;
  87         globals.alsa_period_time=20000;
  88         globals.alsa_samplerate=44100;
  89
  90         globals.sense_cycles=80;
  91
  92         globals.mouse_speed=0.8;
  93
  94         globals.width=800;
  95         globals.height=440;
  96
  97         globals.tooltips=1;
  98
  99         globals.use_stdout=0;
 100         globals.use_stdout_from_conf_file=0;
 101
 102         globals.show_nag=1;
 103         globals.prelis=1;
 104
 105         strcpy(globals.last_fn,"");
 106
 107         globals.pitch=1.0;
 108         globals.volume=1.0;
 109         globals.gui_wrap=3;
 110
 111         globals.flash_response=0.95;
 112
 113         globals.button_type=BUTTON_TYPE_BOTH;
 114
 115         globals.true_block_size=0;
 116
 117         strcpy(globals.tables_filename, "");
 118         strcpy(globals.record_filename, "tX_record.wav");
 119         strcpy(globals.file_editor, "");
 120
 121 #ifdef USE_OSS
 122         globals.audiodevice_type=OSS;
 123 #else
 124 #ifdef USE_ALSA
 125         globals.audiodevice_type=ALSA;
 126 #endif
 127 #endif
 128         globals.use_stdout_cmdline=0;
 129         strcpy(globals.current_path, "");
 130         strcpy(globals.lrdf_path, "/usr/share/ladspa/rdf:/usr/local/share/ladspa/rdf");
 131         globals.fullscreen_enabled=0;
 132         globals.confirm_events=0;
 133         globals.compress_set_files=0;
 134
 135         globals.vtt_inertia=10.0;
 136
 137         globals.alsa_free_hwstats=0;
 138         globals.filename_length=20;
 139         globals.restore_midi_connections=1;
 140
 141         strcpy(globals.wav_display_bg_focus, "#00004C");
 142         strcpy(globals.wav_display_bg_no_focus, "#000000");
 143
 144         strcpy(globals.wav_display_fg_focus, "#FFFF00");
 145         strcpy(globals.wav_display_fg_no_focus, "#00FF00");
 146
 147         strcpy(globals.wav_display_cursor, "#FF6666");
 148         strcpy(globals.wav_display_cursor_mute, "#FFFFFF");
 149
 150         strcpy(globals.vu_meter_bg, "#000000");
 151         strcpy(globals.vu_meter_loud, "#FF0000");
 152         strcpy(globals.vu_meter_normal, "#00FF00");
 153         globals.vu_meter_border_intensity=0.7;
 154         globals.quit_confirm=1;
 155         globals.use_realtime=1;
 156         globals.auto_assign_midi=0;
 157 }
 158
 159 int load_globals_xml() {
 160         char rc_name[PATH_MAX]="";
 161         char device_type[16]="oss";
 162         xmlDocPtr doc;
 163         xmlNodePtr cur;
 164         int elementFound;
 165         double dvalue;
 166         char tmp_xml_buffer[4096];
 167
 168         get_rc_name(rc_name);
 169
 170         doc = xmlParseFile(rc_name);
 171
 172         if (doc == NULL ) {
 173                 fprintf(stderr, "tX: err: Error parsing terminatorXrc.\n");
 174                 return 1;
 175         }
 176
 177         cur = xmlDocGetRootElement(doc);
 178
 179         if (cur == NULL) {
 180                 fprintf(stderr,"tX: err: terminatorXrc contains no elements.\n");
 181                 xmlFreeDoc(doc);
 182                 return 2;
 183         }
 184
 185         if (xmlStrcmp(cur->name, (const xmlChar *) "terminatorXrc")) {
 186                 fprintf(stderr,"tX: err: This terminatorXrc is not a terminatorXrc.");
 187                 xmlFreeDoc(doc);
 188                 return 3;
 189         }
 190
 191         for (cur=cur->xmlChildrenNode; cur != NULL; cur = cur->next) {
 192                 if (cur->type == XML_ELEMENT_NODE) {
 193                         elementFound=0;
 194
 195                         restore_int("store_globals", globals.store_globals);
 196
 197                         restore_string("audio_driver", device_type);
 198
 199                         restore_string("oss_device", globals.oss_device);
 200                         restore_int("oss_buff_no", globals.oss_buff_no);
 201                         restore_int("oss_buff_size", globals.oss_buff_size);
 202                         restore_int("oss_samplerate", globals.oss_samplerate);
 203
 204                         restore_string("alsa_device_id", globals.alsa_device_id);
 205                         restore_int("alsa_buffer_time", globals.alsa_buffer_time);
 206                         restore_int("alsa_period_time", globals.alsa_period_time);
 207                         restore_int("alsa_samplerate", globals.alsa_samplerate);
 208                         restore_int("alsa_free_hwstats", globals.alsa_free_hwstats);
 209
 210                         restore_string("xinput_device", globals.xinput_device);
 211                         restore_int("xinput_enable", globals.xinput_enable);
 212                         restore_int("update_idle", globals.update_idle);
 213                         restore_int("update_delay", globals.update_delay);
 214                         restore_int("sense_cycles", globals.sense_cycles);
 215                         restore_float("mouse_speed", globals.mouse_speed);
 216                         restore_int("width", globals.width);
 217                         restore_int("height", globals.height);
 218                         restore_int("filename_length", globals.filename_length);
 219                         restore_int("tooltips", globals.tooltips);
 220                         restore_int("use_stdout", globals.use_stdout);
 221                         restore_int("show_nag", globals.show_nag);
 222                         restore_int("prelis", globals.prelis);
 223                         restore_string("last_fn", globals.last_fn);
 224                         restore_float("pitch", globals.pitch);
 225                         restore_float("volume", globals.volume);
 226                         restore_float("flash_response", globals.flash_response);
 227                         restore_int("button_type", globals.button_type);
 228                         restore_string("tables_filename", globals.tables_filename);
 229                         restore_string("record_filename", globals.record_filename);
 230                         restore_string("file_editor", globals.file_editor);
 231                         restore_string("lrdf_path", globals.lrdf_path);
 232                         restore_string("last_path", globals.current_path);
 233
 234                         restore_int("compress_set_files", globals.compress_set_files);
 235                         restore_int("fullscreen_enabled", globals.fullscreen_enabled);
 236                         restore_int("confirm_events", globals.confirm_events);
 237                         restore_float("vtt_inertia", globals.vtt_inertia);
 238                         restore_int("restore_midi_connections", globals.restore_midi_connections);
 239
 240                         restore_string("wav_display_bg_focus", globals.wav_display_bg_focus);
 241                         restore_string("wav_display_bg_no_focus", globals.wav_display_bg_no_focus);
 242                         restore_string("wav_display_fg_focus", globals.wav_display_fg_focus);
 243                         restore_string("wav_display_fg_no_focus", globals.wav_display_fg_no_focus);
 244                         restore_string("wav_display_cursor", globals.wav_display_cursor);
 245                         restore_string("wav_display_cursor_mute", globals.wav_display_cursor_mute);
 246
 247                         restore_string("vu_meter_bg", globals.vu_meter_bg);
 248                         restore_string("vu_meter_normal", globals.vu_meter_normal);
 249                         restore_string("vu_meter_loud", globals.vu_meter_loud);
 250
 251                         restore_float("vu_meter_border_intensity", globals.vu_meter_border_intensity);
 252
 253                         restore_int("quit_confirm", globals.quit_confirm);
 254                         restore_int("use_realtime", globals.use_realtime);
 255                         restore_int("auto_assign_midi", globals.auto_assign_midi);
 256
 257 #ifdef USE_ALSA_MIDI_IN
 258                         if (!elementFound && (xmlStrcmp(cur->name, (xmlChar *) "midi_connections")==0)) {
 259                                 if (globals.restore_midi_connections) {
 260                                         tX_midiin_restore_connections(cur);
 261                                 }
 262                                 elementFound=1;
 263                         }
 264 #endif
 265
 266                         if (!elementFound) {
 267                                 fprintf(stderr, "tX: Unhandled XML element: \"%s\"\n", cur->name);
 268                         }
 269                 }
 270         }
 271
 272         xmlFreeDoc(doc);
 273
 274         if (strcmp(device_type, "alsa")==0) globals.audiodevice_type=ALSA;
 275         else if (strcmp(device_type, "jack")==0) globals.audiodevice_type=JACK;
 276         else globals.audiodevice_type=OSS;
 277
 278         return 0;
 279 }
 280
 281 void store_globals() {
 282         char rc_name[PATH_MAX+256]="";
 283         char device_type[16];
 284         char indent[32]="\t";
 285         FILE *rc=NULL;
 286         gzFile rz=NULL;
 287         char tmp_xml_buffer[4096];
 288         _store_compress_xml=0;
 289
 290         get_rc_name(rc_name);
 291
 292         rc=fopen(rc_name, "w");
 293
 294         switch (globals.audiodevice_type) {
 295                 case JACK:
 296                         strcpy(device_type, "jack");
 297                         break;
 298                 case ALSA:
 299                         strcpy(device_type, "alsa");
 300                         break;
 301                 case OSS:
 302                 default:
 303                         strcpy(device_type, "oss");
 304         }
 305
 306         if (rc) {
 307                 fprintf(rc, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n\n");
 308                 fprintf(rc, "<!-- Warning: this file will be rewritten by terminatorX on exit!\n     Don\'t waste your time adding comments - they will be erased -->\n\n" );
 309                 fprintf(rc, "<terminatorXrc version=\"%s\">\n", TX_XML_RC_VERSION);
 310
 311                 store_int("store_globals", globals.store_globals);
 312
 313                 store_string("audio_driver", device_type);
 314
 315                 store_string("oss_device", globals.oss_device);
 316                 store_int("oss_buff_no", globals.oss_buff_no);
 317                 store_int("oss_buff_size", globals.oss_buff_size);
 318                 store_int("oss_samplerate", globals.oss_samplerate);
 319
 320                 store_string("alsa_device_id", globals.alsa_device_id);
 321                 store_int("alsa_buffer_time", globals.alsa_buffer_time);
 322                 store_int("alsa_period_time", globals.alsa_period_time);
 323                 store_int("alsa_samplerate", globals.alsa_samplerate);
 324                 store_int("alsa_free_hwstats", globals.alsa_free_hwstats);
 325
 326                 store_string("xinput_device", globals.xinput_device);
 327                 store_int("xinput_enable", globals.xinput_enable);
 328                 store_int("update_idle", globals.update_idle);
 329                 store_int("update_delay", globals.update_delay);
 330                 store_int("sense_cycles", globals.sense_cycles);
 331                 store_float("mouse_speed", globals.mouse_speed);
 332                 store_int("width", globals.width);
 333                 store_int("height", globals.height);
 334                 store_int("filename_length", globals.filename_length);
 335                 store_int("tooltips", globals.tooltips);
 336                 store_int("use_stdout", globals.use_stdout);
 337                 // globals.use_stdout_from_conf_file=0; What the heck is this?
 338                 store_int("show_nag", globals.show_nag);
 339                 store_int("prelis", globals.prelis);
 340                 store_string("last_fn", globals.last_fn);
 341                 store_float("pitch", globals.pitch);
 342                 store_float("volume", globals.volume);
 343                 store_float("flash_response", globals.flash_response);
 344                 store_int("button_type", globals.button_type);
 345                 store_string("tables_filename", globals.tables_filename);
 346                 store_string("record_filename", globals.record_filename);
 347                 store_string("file_editor", globals.file_editor);
 348                 store_string("lrdf_path", globals.lrdf_path);
 349                 store_int("compress_set_files", globals.compress_set_files);
 350                 store_int("fullscreen_enabled", globals.fullscreen_enabled);
 351                 store_int("confirm_events", globals.confirm_events);
 352                 store_float("vtt_inertia", globals.vtt_inertia);
 353
 354                 store_string("last_path", globals.current_path);
 355                 store_int("restore_midi_connections", globals.restore_midi_connections);
 356
 357                 store_string("wav_display_bg_focus", globals.wav_display_bg_focus);
 358                 store_string("wav_display_bg_no_focus", globals.wav_display_bg_no_focus);
 359                 store_string("wav_display_fg_focus", globals.wav_display_fg_focus);
 360                 store_string("wav_display_fg_no_focus", globals.wav_display_fg_no_focus);
 361                 store_string("wav_display_cursor", globals.wav_display_cursor);
 362                 store_string("wav_display_cursor_mute", globals.wav_display_cursor_mute);
 363
 364                 store_string("vu_meter_bg", globals.vu_meter_bg);
 365                 store_string("vu_meter_normal", globals.vu_meter_normal);
 366                 store_string("vu_meter_loud", globals.vu_meter_loud);
 367
 368                 store_float("vu_meter_border_intensity", globals.vu_meter_border_intensity);
 369
 370                 store_int("quit_confirm", globals.quit_confirm);
 371                 store_int("use_realtime", globals.use_realtime);
 372                 store_int("auto_assign_midi", globals.auto_assign_midi);
 373
 374 #ifdef USE_ALSA_MIDI_IN
 375                 tX_midiin_store_connections(rc, indent);
 376 #endif
 377
 378                 fprintf(rc,"</terminatorXrc>\n");
 379         }
 380 }
 381
 382 #ifdef ENABLE_TX_LEGACY
 383 extern void load_globals_old();
 384 #endif
 385
 386 void load_globals() {
 387         set_global_defaults();
 388
 389         if (load_globals_xml()!=0) {
 390                 fprintf(stderr, "tX: Failed loading terminatorXrc - trying to load old binary rc.\n");
 391 #ifdef ENABLE_TX_LEGACY
 392                 load_globals_old();
 393 #endif
 394         }
 395 }
 396
 397 char *encode_xml(char *dest, const char *src) {
 398         int i, t, max;
 399         char tmp[4096];
 400         int outlen=4096;
 401         int inlen;
 402         int res;
 403
 404         tmp[0]=0;
 405         t=0;
 406         max=strlen(src);
 407
 408         for (i=0; i<max; i++) {
 409                 switch (src[i]) {
 410                         case '<': tmp[t]=0; strcat(tmp, "&lt;"); t+=4; break;
 411                         case '>': tmp[t]=0; strcat(tmp, "&gt;"); t+=4; break;
 412                         case '&': tmp[t]=0; strcat(tmp, "&amp;"); t+=5; break;
 413                         case '"': tmp[t]=0; strcat(tmp, "&quot;"); t+=6; break;
 414                         case '\'': strcat(tmp, "&apos;"); t+=7; break;
 415                         default: tmp[t]=src[i]; t++;
 416                 }
 417         }
 418         tmp[t]=0;
 419
 420         inlen=t;
 421         res=isolat1ToUTF8((unsigned char *) dest, &outlen, (unsigned char *) tmp, &inlen);
 422         dest[outlen]=0;
 423         if (res<0) {
 424                 tX_error("failed to encode string (%s) to UTF-8.", src);
 425         }
 426
 427         return dest;
 428 }
 429
 430 char *decode_xml(char *dest, const char *src) {
 431         int inlen=strlen(src);
 432         int outlen=4096;
 433
 434         int res=UTF8Toisolat1(dest, &outlen, src, &inlen);
 435         dest[outlen]=0;
 436
 437         if (res<0) {
 438                 tX_error("failed to decode UTF-8 string (%s).", src);
 439         }
 440
 441         return dest;
 442 }