/[winpt]/trunk/Src/wptRegistry.cpp
ViewVC logotype

Diff of /trunk/Src/wptRegistry.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 179 by twoaday, Fri Feb 24 13:12:26 2006 UTC revision 222 by twoaday, Thu Jun 1 08:30:46 2006 UTC
# Line 1  Line 1 
1  /* wptRegistry.cpp - W32 Registry access  /* wptRegistry.cpp - Windows Registry access
2   *      Copyright (C) 2000-2005 Timo Schulz   *      Copyright (C) 2000-2006 Timo Schulz
3   *   *
4   * This file is part of WinPT.   * This file is part of WinPT.
5   *   *
# Line 33  Line 33 
33  #include "wptTypes.h"  #include "wptTypes.h"
34  #include "wptNLS.h"  #include "wptNLS.h"
35  #include "wptVersion.h"  #include "wptVersion.h"
36    #include "wptHotkey.h"
37    
38  #define rc_ok(rc) ((rc) == ERROR_SUCCESS)  #define rc_ok(rc) ((rc) == ERROR_SUCCESS)
39    
# Line 45  struct gpg_filetype { Line 46  struct gpg_filetype {
46      int nicon;      int nicon;
47  };  };
48    
 struct reg_hotkey_s reg_hotkeys[] = {  
     {"ClipEncrypt", "", 0},  
     {"ClipDecrypt", "", 0},  
     {"ClipSign",    "", 0},  
     {"ClipSignEnc", "", 0},  
     {"CwsEncrypt",  "", 0},  
     {"CwsDecrypt",  "", 0},  
     {"CwsSign",     "", 0},  
     {"CwsSignEnc",  "", 0},  
     {NULL, "", 0}  
 };  
   
49  /* Global WinPT registry prefereneces. */  /* Global WinPT registry prefereneces. */
50  winpt_reg_prefs_s reg_prefs;  winpt_reg_prefs_s reg_prefs;
51    
# Line 289  leave: Line 278  leave:
278      if( reg )      if( reg )
279          RegCloseKey( reg );          RegCloseKey( reg );
280      return rc;      return rc;
281  } /* create_file_type */  }
282    
283    
284  /* Expand a string with %foo% entries so that %foo% will  /* Expand a string with %foo% entries so that %foo% will
# Line 374  set_reg_entry (HKEY root_key, const char Line 363  set_reg_entry (HKEY root_key, const char
363          rc = WPTERR_REGISTRY;            rc = WPTERR_REGISTRY;  
364      RegCloseKey( reg_key );      RegCloseKey( reg_key );
365      return rc;      return rc;
366  } /* set_reg_entry */  }
367    
368    
369  int  int
# Line 402  set_reg_key( HKEY root_key, const char * Line 391  set_reg_key( HKEY root_key, const char *
391  leave:  leave:
392      RegCloseKey( reg_key );      RegCloseKey( reg_key );
393      return rc;      return rc;
394  } /* set_reg_key */  }
395    
396    
397  int  int
# Line 466  get_reg_entry_mo (void) Line 455  get_reg_entry_mo (void)
455          return p;          return p;
456    
457      lang = get_gettext_langid ();      lang = get_gettext_langid ();
458      if (!lang)          if (!lang)
459          return NULL;              return NULL;
460      pp = new char[strlen ("share\\xxxxx\\locale\\LC_MESSAGES")+8];      pp = new char[strlen ("share\\xxxxx\\locale\\LC_MESSAGES")+8];
461      if (!pp)          if (!pp)    
462          BUG (NULL);          BUG (NULL);
# Line 483  static const char *cfg [] = { Line 472  static const char *cfg [] = {
472      NULL,            NULL,      
473      "CacheTime",      "CacheTime",
474      "WordWrap",      "WordWrap",
475      "FastMode",      "DefaultExt",
476      "Viewer",      "Viewer",
477      "WipeMode",      "WipeMode",
478      "AlwaysTrust",      "AlwaysTrust",
# Line 493  static const char *cfg [] = { Line 482  static const char *cfg [] = {
482      "NoCompressMultiMedia",          "NoCompressMultiMedia",    
483      "Expert",      "Expert",
484      "FMProgressBar",      "FMProgressBar",
485        "BackupSecring"
486  };  };
487    
488    
# Line 511  set_reg_winpt_single (int id, int val) Line 501  set_reg_winpt_single (int id, int val)
501  int  int
502  get_reg_winpt_single (int id)  get_reg_winpt_single (int id)
503  {  {
504      char * buf = NULL;      char *buf;
505      int val = 0;      int val = 0;
506    
507      buf = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[id]);      buf = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[id]);
# Line 543  set_reg_winpt_prefs (winpt_reg_prefs_s * Line 533  set_reg_winpt_prefs (winpt_reg_prefs_s *
533          case CFG_WIPEMODE:          case CFG_WIPEMODE:
534              sprintf (buf, "%d", opt->wipe_mode);              sprintf (buf, "%d", opt->wipe_mode);
535              break;              break;
536          case CFG_FASTMODE:          case CFG_FILEEXT:
537              sprintf (buf, "%d", opt->use_tmpfiles);              sprintf (buf, "%d", opt->default_ext);
538              break;              break;
539          case CFG_NOZIP_MMEDIA:          case CFG_NOZIP_MMEDIA:
540              sprintf (buf, "%d", opt->no_zip_mmedia);              sprintf (buf, "%d", opt->no_zip_mmedia);
# Line 571  set_reg_winpt_prefs (winpt_reg_prefs_s * Line 561  set_reg_winpt_prefs (winpt_reg_prefs_s *
561          case CFG_FM_PROGRESS:          case CFG_FM_PROGRESS:
562              sprintf (buf, "%d", opt->fm.progress);              sprintf (buf, "%d", opt->fm.progress);
563              break;              break;
564    
565            case CFG_BACKUP_INC_SKR:
566                sprintf (buf, "%d", opt->backup.include_secr);
567                break;
568          }          }
569          rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[i], buf);          rc = set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, cfg[i], buf);
570          if (rc)          if (rc)
# Line 584  set_reg_winpt_prefs (winpt_reg_prefs_s * Line 578  set_reg_winpt_prefs (winpt_reg_prefs_s *
578              goto leave;              goto leave;
579      }      }
580    
581      for (i=0; reg_hotkeys[i].reg_entry; i++) {      for (i=0; wpt_hotkeys[i].name; i++) {
582          strcpy (buf, " ");          if (wpt_hotkeys[i].enabled) {
583          if (reg_hotkeys[i].enabled)              buf[0] = wpt_hotkeys[i].key;
584              strcpy (buf, reg_hotkeys[i].key);              buf[1] = 0;
585            }
586            else
587                strcpy (buf, " ");
588          rc = set_reg_key (HKEY_CURRENT_USER, WINPT_REG,          rc = set_reg_key (HKEY_CURRENT_USER, WINPT_REG,
589                            reg_hotkeys[i].reg_entry, buf);                            wpt_hotkeys[i].name, buf);
590          if (rc)          if (rc)
591              break;              break;
592      }      }
# Line 607  int Line 604  int
604  set_reg_winpt_flag (const char * name, int val)  set_reg_winpt_flag (const char * name, int val)
605  {  {
606      return set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, name, val? "1" : "0");      return set_reg_entry (HKEY_CURRENT_USER, WINPT_REG, name, val? "1" : "0");
607  } /* set_reg_winpt_flag */  }
608    
609    
610  int  int
# Line 623  get_reg_winpt_flag (const char * name) Line 620  get_reg_winpt_flag (const char * name)
620          flag = -1;          flag = -1;
621      free_if_alloc (buf);      free_if_alloc (buf);
622      return flag;      return flag;
623  } /* get_reg_winpt_flag */  }
624    
625    
626  /* Retrieve the winpt preferences from the registry. */  /* Retrieve the winpt preferences from the registry. */
# Line 642  get_reg_winpt_prefs (winpt_reg_prefs_s * Line 639  get_reg_winpt_prefs (winpt_reg_prefs_s *
639          switch (i) {          switch (i) {
640          case CFG_CACHETIME:          case CFG_CACHETIME:
641              opt->cache_time = atol (val);              opt->cache_time = atol (val);
             /* We do NOT support passphrase caching for more than an hour.  
              * Perhaps we should allow it, but for now we silently drop this.  
              */  
             if (opt->cache_time > 3600)  
                 opt->cache_time = 3600;  
642              break;              break;
643          case CFG_WORDWRAP:          case CFG_WORDWRAP:
644              opt->word_wrap = atol (val);              opt->word_wrap = atol (val);
645              break;              break;
646          case CFG_FASTMODE:          case CFG_FILEEXT:
647              opt->use_tmpfiles = atol (val);              opt->default_ext = atol (val);
648              break;              break;
649          case CFG_NOZIP_MMEDIA:          case CFG_NOZIP_MMEDIA:
650              opt->no_zip_mmedia = atol (val);              opt->no_zip_mmedia = atol (val);
# Line 678  get_reg_winpt_prefs (winpt_reg_prefs_s * Line 670  get_reg_winpt_prefs (winpt_reg_prefs_s *
670          case CFG_EXPERT:          case CFG_EXPERT:
671              opt->expert = atol (val);              opt->expert = atol (val);
672              break;              break;
   
673          case CFG_FM_PROGRESS:          case CFG_FM_PROGRESS:
674              opt->fm.progress = atol (val);              opt->fm.progress = atol (val);
675              break;              break;
676    
677            case CFG_BACKUP_INC_SKR:
678                opt->backup.include_secr = atol (val);
679                break;
680          }          }
681          free_if_alloc (val);          free_if_alloc (val);
682      }          }    
# Line 691  get_reg_winpt_prefs (winpt_reg_prefs_s * Line 686  get_reg_winpt_prefs (winpt_reg_prefs_s *
686          opt->backup.path = m_strdup (val);          opt->backup.path = m_strdup (val);
687      free_if_alloc (val);      free_if_alloc (val);
688            
689      for (i=0; reg_hotkeys[i].reg_entry; i++) {      for (i=0; wpt_hotkeys[i].name; i++) {
690          val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, reg_hotkeys[i].reg_entry);          wpt_hotkeys[i].enabled = 0;
691            val = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG, wpt_hotkeys[i].name);
692          if (val && val[0] != ' ') {          if (val && val[0] != ' ') {
693              reg_hotkeys[i].key[0] = *val;              wpt_hotkeys[i].key = *val;
694              reg_hotkeys[i].enabled = 1;              wpt_hotkeys[i].enabled = 1;
695          }          }
         else  
             reg_hotkeys[i].enabled = 0;  
696          free_if_alloc (val);          free_if_alloc (val);
697      }      }
698      return 0;      return 0;
699  } /* get_reg_winpt_prefs */  }
700    
701    
702  char*  char*
703  get_reg_entry_keyserver (const char *name)  get_reg_entry_keyserver (const char *name)
704  {  {
705      char * p = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name);      char *p = get_reg_entry (HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name);
706      if (p && !strcmp (p, "")) {      if (p && (!strcmp (p, "") || strlen (p) == 0)) {
707          free_if_alloc (p);          free_if_alloc (p);
708          return NULL;          return NULL;
709      }      }
# Line 717  get_reg_entry_keyserver (const char *nam Line 711  get_reg_entry_keyserver (const char *nam
711  }  }
712    
713    
714    int
715    set_reg_entry_keyserver (const char * name, const char * val)
716    {
717        return set_reg_entry( HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name, val );
718    }
719    
720    static int
721    get_reg_entry_keyserver_int (const char *key)
722    {
723        char *p;
724        int val = 0;
725    
726        p = get_reg_entry_keyserver (key);
727        if (p && *p)
728            val = atoi (p);
729        free_if_alloc (p);
730        return val;
731    }
732    
733    
734  void  void
735  get_reg_proxy_prefs (char ** host, int * port, char ** user, char ** pass)  get_reg_proxy_prefs (keyserver_proxy_t prox)
736  {  {
737      if (host)      if (!prox)
738          *host = get_reg_entry_keyserver ("Host");          return;
739      if (user)      
740          *user = get_reg_entry_keyserver ("User");      free_if_alloc (prox->host);
741      if (pass)      prox->host = get_reg_entry_keyserver ("Host");
742          *pass = get_reg_entry_keyserver ("Pass");      free_if_alloc (prox->user);
743      if (port) {      prox->user = get_reg_entry_keyserver ("User");
744          char * p = get_reg_entry_keyserver ("Port");      free_if_alloc (prox->pass);
745          if (p) {      prox->pass = get_reg_entry_keyserver ("Pass");
746              *port = atol (p);      prox->port = get_reg_entry_keyserver_int ("Port");
747              free_if_alloc (p);  }
         }  
     }  
 } /* get_reg_proxy_prefs */  
748    
749    
750  int  static int
751  set_reg_entry_keyserver( const char * name, const char * val )  set_reg_entry_keyserver_int (const char *key, int val)
752  {  {
753      return set_reg_entry( HKEY_CURRENT_USER, WINPT_REG"\\Keyserver", name, val );      char buf[32];
754  } /* set_reg_entry_keyserver */  
755        sprintf (buf, "%d", val);
756        return set_reg_entry_keyserver (key, buf);
757    }
758    
759    
760  int  int
761  set_reg_proxy_prefs( const char * host, int port, const char * user, const char * pass )  set_reg_proxy_prefs (keyserver_proxy_t prox)
762  {  {    
763      int rc;      int rc;
764            
765      rc = set_reg_entry_keyserver( "Host", host? host : "" );      rc = set_reg_entry_keyserver_int ("Proto", prox->proto);
766      if( !rc ) {      if (!rc)
767          char buf[32];          rc = set_reg_entry_keyserver ("Host", prox->host? prox->host : "");
768          sprintf( buf, "%d", port );      if (!rc)
769          rc = set_reg_entry_keyserver( "Port", buf );          rc = set_reg_entry_keyserver_int ("Port", prox->port);
770      }      if (!rc)
771      if( !rc )          rc = set_reg_entry_keyserver ("User", prox->user? prox->user : "");
772          rc = set_reg_entry_keyserver( "User", user? user : "" );      if (!rc)
773      if( !rc )          rc = set_reg_entry_keyserver ("Pass", prox->pass? prox->pass : "");
         rc = set_reg_entry_keyserver( "Pass", pass? pass : "" );  
774      return rc;      return rc;
775  } /* set_reg_proxy_prefs */  }
Legend:
Removed from v.179  
changed lines
  Added in v.222
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26