Changeset 13683


Ignore:
Timestamp:
Dec 22, 2012, 8:35:19 PM (8 years ago)
Author:
jordan
Message:

(trunk, libT) first drop of the tr_quark patch.

Location:
trunk
Files:
3 added
56 edited

Legend:

Unmodified
Added
Removed
  • trunk/cli/cli.c

    r13667 r13683  
    266266    }
    267267
    268   if (tr_variantDictFindStr (&settings, TR_PREFS_KEY_DOWNLOAD_DIR, &str, NULL))
     268  if (tr_variantDictFindStr (&settings, TR_KEY_download_dir, &str, NULL))
    269269    {
    270270      str = tr_realpath (str, buf);
     
    272272      if (str != NULL)
    273273        {
    274           tr_variantDictAddStr (&settings, TR_PREFS_KEY_DOWNLOAD_DIR, str);
     274          tr_variantDictAddStr (&settings, TR_KEY_download_dir, str);
    275275        }
    276276      else
     
    400400        {
    401401          case 'b':
    402             tr_variantDictAddBool (d, TR_PREFS_KEY_BLOCKLIST_ENABLED, true);
    403             break;
    404 
    405           case 'B': tr_variantDictAddBool (d, TR_PREFS_KEY_BLOCKLIST_ENABLED, false);
     402            tr_variantDictAddBool (d, TR_KEY_blocklist_enabled, true);
     403            break;
     404
     405          case 'B': tr_variantDictAddBool (d, TR_KEY_blocklist_enabled, false);
    406406            break;
    407407
    408408          case 'd':
    409             tr_variantDictAddInt (d, TR_PREFS_KEY_DSPEED_KBps, atoi (optarg));
    410             tr_variantDictAddBool (d, TR_PREFS_KEY_DSPEED_ENABLED, true);
    411             break;
    412 
    413           case 'D': tr_variantDictAddBool (d, TR_PREFS_KEY_DSPEED_ENABLED, false);
     409            tr_variantDictAddInt (d, TR_KEY_speed_limit_down, atoi (optarg));
     410            tr_variantDictAddBool (d, TR_KEY_speed_limit_down_enabled, true);
     411            break;
     412
     413          case 'D': tr_variantDictAddBool (d, TR_KEY_speed_limit_down_enabled, false);
    414414            break;
    415415
    416416          case 'f':
    417             tr_variantDictAddStr (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, optarg);
    418             tr_variantDictAddBool (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, true);
     417            tr_variantDictAddStr (d, TR_KEY_script_torrent_done_filename, optarg);
     418            tr_variantDictAddBool (d, TR_KEY_script_torrent_done_enabled, true);
    419419            break;
    420420
     
    423423
    424424          case 'm':
    425             tr_variantDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING, true);
     425            tr_variantDictAddBool (d, TR_KEY_port_forwarding_enabled, true);
    426426            break;
    427427
    428428          case 'M':
    429             tr_variantDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING, false);
     429            tr_variantDictAddBool (d, TR_KEY_port_forwarding_enabled, false);
    430430            break;
    431431
    432432          case 'p':
    433             tr_variantDictAddInt (d, TR_PREFS_KEY_PEER_PORT, atoi (optarg));
     433            tr_variantDictAddInt (d, TR_KEY_peer_port, atoi (optarg));
    434434            break;
    435435
    436436          case 't':
    437             tr_variantDictAddInt (d, TR_PREFS_KEY_PEER_SOCKET_TOS, atoi (optarg));
     437            tr_variantDictAddInt (d, TR_KEY_peer_socket_tos, atoi (optarg));
    438438            break;
    439439
    440440          case 'u':
    441             tr_variantDictAddInt (d, TR_PREFS_KEY_USPEED_KBps, atoi (optarg));
    442             tr_variantDictAddBool (d, TR_PREFS_KEY_USPEED_ENABLED, true);
     441            tr_variantDictAddInt (d, TR_KEY_speed_limit_up, atoi (optarg));
     442            tr_variantDictAddBool (d, TR_KEY_speed_limit_up_enabled, true);
    443443            break;
    444444
    445445          case 'U':
    446             tr_variantDictAddBool (d, TR_PREFS_KEY_USPEED_ENABLED, false);
     446            tr_variantDictAddBool (d, TR_KEY_speed_limit_up_enabled, false);
    447447            break;
    448448
     
    456456
    457457          case 'w':
    458             tr_variantDictAddStr (d, TR_PREFS_KEY_DOWNLOAD_DIR, optarg);
     458            tr_variantDictAddStr (d, TR_KEY_download_dir, optarg);
    459459            break;
    460460
    461461          case 910:
    462             tr_variantDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_REQUIRED);
     462            tr_variantDictAddInt (d, TR_KEY_encryption, TR_ENCRYPTION_REQUIRED);
    463463            break;
    464464
    465465          case 911:
    466             tr_variantDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED);
     466            tr_variantDictAddInt (d, TR_KEY_encryption, TR_ENCRYPTION_PREFERRED);
    467467            break;
    468468
    469469          case 912:
    470             tr_variantDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_CLEAR_PREFERRED);
     470            tr_variantDictAddInt (d, TR_KEY_encryption, TR_CLEAR_PREFERRED);
    471471            break;
    472472
  • trunk/daemon/daemon.c

    r13667 r13683  
    3434#define MY_NAME "transmission-daemon"
    3535
    36 #define PREF_KEY_DIR_WATCH          "watch-dir"
    37 #define PREF_KEY_DIR_WATCH_ENABLED  "watch-dir-enabled"
    38 #define PREF_KEY_PIDFILE            "pidfile"
    39 
    4036#define MEM_K 1024
    4137#define MEM_K_STR "KiB"
     
    6662static FILE *logfile = NULL;
    6763static tr_session * mySession = NULL;
     64static tr_quark key_pidfile = 0;
    6865
    6966/***
     
    167164                tr_inf ("Reloading settings from \"%s\"", configDir);
    168165                tr_variantInitDict (&settings, 0);
    169                 tr_variantDictAddBool (&settings, TR_PREFS_KEY_RPC_ENABLED, true);
     166                tr_variantDictAddBool (&settings, TR_KEY_rpc_enabled, true);
    170167                tr_sessionLoadSettings (&settings, configDir, MY_NAME);
    171168                tr_sessionSet (mySession, &settings);
     
    370367    tr_session * session = NULL;
    371368
     369    key_pidfile = tr_quark_new ("pidfile",  7);
     370
    372371    signal (SIGINT, gotsig);
    373372    signal (SIGTERM, gotsig);
     
    378377    /* load settings from defaults + config file */
    379378    tr_variantInitDict (&settings, 0);
    380     tr_variantDictAddBool (&settings, TR_PREFS_KEY_RPC_ENABLED, true);
     379    tr_variantDictAddBool (&settings, TR_KEY_rpc_enabled, true);
    381380    configDir = getConfigDir (argc, (const char**)argv);
    382381    loaded = tr_sessionLoadSettings (&settings, configDir, MY_NAME);
     
    386385    while ((c = tr_getopt (getUsage (), argc, (const char**)argv, options, &optarg))) {
    387386        switch (c) {
    388             case 'a': tr_variantDictAddStr (&settings, TR_PREFS_KEY_RPC_WHITELIST, optarg);
    389                       tr_variantDictAddBool (&settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, true);
    390                       break;
    391             case 'b': tr_variantDictAddBool (&settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, true);
    392                       break;
    393             case 'B': tr_variantDictAddBool (&settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, false);
    394                       break;
    395             case 'c': tr_variantDictAddStr (&settings, PREF_KEY_DIR_WATCH, optarg);
    396                       tr_variantDictAddBool (&settings, PREF_KEY_DIR_WATCH_ENABLED, true);
    397                       break;
    398             case 'C': tr_variantDictAddBool (&settings, PREF_KEY_DIR_WATCH_ENABLED, false);
    399                       break;
    400             case 941: tr_variantDictAddStr (&settings, TR_PREFS_KEY_INCOMPLETE_DIR, optarg);
    401                       tr_variantDictAddBool (&settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, true);
    402                       break;
    403             case 942: tr_variantDictAddBool (&settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, false);
     387            case 'a': tr_variantDictAddStr  (&settings, TR_KEY_rpc_whitelist, optarg);
     388                      tr_variantDictAddBool (&settings, TR_KEY_rpc_whitelist_enabled, true);
     389                      break;
     390            case 'b': tr_variantDictAddBool (&settings, TR_KEY_blocklist_enabled, true);
     391                      break;
     392            case 'B': tr_variantDictAddBool (&settings, TR_KEY_blocklist_enabled, false);
     393                      break;
     394            case 'c': tr_variantDictAddStr  (&settings, TR_KEY_watch_dir, optarg);
     395                      tr_variantDictAddBool (&settings, TR_KEY_watch_dir_enabled, true);
     396                      break;
     397            case 'C': tr_variantDictAddBool (&settings, TR_KEY_watch_dir_enabled, false);
     398                      break;
     399            case 941: tr_variantDictAddStr  (&settings, TR_KEY_incomplete_dir, optarg);
     400                      tr_variantDictAddBool (&settings, TR_KEY_incomplete_dir_enabled, true);
     401                      break;
     402            case 942: tr_variantDictAddBool (&settings, TR_KEY_incomplete_dir_enabled, false);
    404403                      break;
    405404            case 'd': dumpSettings = true;
     
    418417                      fprintf (stderr, "%s %s\n", MY_NAME, LONG_VERSION_STRING);
    419418                      exit (0);
    420             case 'o': tr_variantDictAddBool (&settings, TR_PREFS_KEY_DHT_ENABLED, true);
    421                       break;
    422             case 'O': tr_variantDictAddBool (&settings, TR_PREFS_KEY_DHT_ENABLED, false);
    423                       break;
    424             case 'p': tr_variantDictAddInt (&settings, TR_PREFS_KEY_RPC_PORT, atoi (optarg));
    425                       break;
    426             case 't': tr_variantDictAddBool (&settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, true);
    427                       break;
    428             case 'T': tr_variantDictAddBool (&settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, false);
    429                       break;
    430             case 'u': tr_variantDictAddStr (&settings, TR_PREFS_KEY_RPC_USERNAME, optarg);
    431                       break;
    432             case 'v': tr_variantDictAddStr (&settings, TR_PREFS_KEY_RPC_PASSWORD, optarg);
    433                       break;
    434             case 'w': tr_variantDictAddStr (&settings, TR_PREFS_KEY_DOWNLOAD_DIR, optarg);
    435                       break;
    436             case 'P': tr_variantDictAddInt (&settings, TR_PREFS_KEY_PEER_PORT, atoi (optarg));
    437                       break;
    438             case 'm': tr_variantDictAddBool (&settings, TR_PREFS_KEY_PORT_FORWARDING, true);
    439                       break;
    440             case 'M': tr_variantDictAddBool (&settings, TR_PREFS_KEY_PORT_FORWARDING, false);
    441                       break;
    442             case 'L': tr_variantDictAddInt (&settings, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi (optarg));
    443                       break;
    444             case 'l': tr_variantDictAddInt (&settings, TR_PREFS_KEY_PEER_LIMIT_TORRENT, atoi (optarg));
     419            case 'o': tr_variantDictAddBool (&settings, TR_KEY_dht_enabled, true);
     420                      break;
     421            case 'O': tr_variantDictAddBool (&settings, TR_KEY_dht_enabled, false);
     422                      break;
     423            case 'p': tr_variantDictAddInt (&settings, TR_KEY_rpc_port, atoi (optarg));
     424                      break;
     425            case 't': tr_variantDictAddBool (&settings, TR_KEY_rpc_authentication_required, true);
     426                      break;
     427            case 'T': tr_variantDictAddBool (&settings, TR_KEY_rpc_authentication_required, false);
     428                      break;
     429            case 'u': tr_variantDictAddStr (&settings, TR_KEY_rpc_username, optarg);
     430                      break;
     431            case 'v': tr_variantDictAddStr (&settings, TR_KEY_rpc_password, optarg);
     432                      break;
     433            case 'w': tr_variantDictAddStr (&settings, TR_KEY_download_dir, optarg);
     434                      break;
     435            case 'P': tr_variantDictAddInt (&settings, TR_KEY_peer_port, atoi (optarg));
     436                      break;
     437            case 'm': tr_variantDictAddBool (&settings, TR_KEY_port_forwarding_enabled, true);
     438                      break;
     439            case 'M': tr_variantDictAddBool (&settings, TR_KEY_port_forwarding_enabled, false);
     440                      break;
     441            case 'L': tr_variantDictAddInt (&settings, TR_KEY_peer_limit_global, atoi (optarg));
     442                      break;
     443            case 'l': tr_variantDictAddInt (&settings, TR_KEY_peer_limit_per_torrent, atoi (optarg));
    445444                      break;
    446445            case 800: paused = true;
    447446                      break;
    448             case 910: tr_variantDictAddInt (&settings, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_REQUIRED);
    449                       break;
    450             case 911: tr_variantDictAddInt (&settings, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED);
    451                       break;
    452             case 912: tr_variantDictAddInt (&settings, TR_PREFS_KEY_ENCRYPTION, TR_CLEAR_PREFERRED);
    453                       break;
    454             case 'i': tr_variantDictAddStr (&settings, TR_PREFS_KEY_BIND_ADDRESS_IPV4, optarg);
    455                       break;
    456             case 'I': tr_variantDictAddStr (&settings, TR_PREFS_KEY_BIND_ADDRESS_IPV6, optarg);
    457                       break;
    458             case 'r': tr_variantDictAddStr (&settings, TR_PREFS_KEY_RPC_BIND_ADDRESS, optarg);
    459                       break;
    460             case 953: tr_variantDictAddReal (&settings, TR_PREFS_KEY_RATIO, atof (optarg));
    461                       tr_variantDictAddBool (&settings, TR_PREFS_KEY_RATIO_ENABLED, true);
    462                       break;
    463             case 954: tr_variantDictAddBool (&settings, TR_PREFS_KEY_RATIO_ENABLED, false);
    464                       break;
    465             case 'x': tr_variantDictAddStr (&settings, PREF_KEY_PIDFILE, optarg);
    466                       break;
    467             case 'y': tr_variantDictAddBool (&settings, TR_PREFS_KEY_LPD_ENABLED, true);
    468                       break;
    469             case 'Y': tr_variantDictAddBool (&settings, TR_PREFS_KEY_LPD_ENABLED, false);
    470                       break;
    471             case 810: tr_variantDictAddInt (&settings,  TR_PREFS_KEY_MSGLEVEL, TR_MSG_ERR);
    472                       break;
    473             case 811: tr_variantDictAddInt (&settings,  TR_PREFS_KEY_MSGLEVEL, TR_MSG_INF);
    474                       break;
    475             case 812: tr_variantDictAddInt (&settings,  TR_PREFS_KEY_MSGLEVEL, TR_MSG_DBG);
    476                       break;
    477             case 830: tr_variantDictAddBool (&settings, TR_PREFS_KEY_UTP_ENABLED, true);
    478                       break;
    479             case 831: tr_variantDictAddBool (&settings, TR_PREFS_KEY_UTP_ENABLED, false);
     447            case 910: tr_variantDictAddInt (&settings, TR_KEY_encryption, TR_ENCRYPTION_REQUIRED);
     448                      break;
     449            case 911: tr_variantDictAddInt (&settings, TR_KEY_encryption, TR_ENCRYPTION_PREFERRED);
     450                      break;
     451            case 912: tr_variantDictAddInt (&settings, TR_KEY_encryption, TR_CLEAR_PREFERRED);
     452                      break;
     453            case 'i': tr_variantDictAddStr (&settings, TR_KEY_bind_address_ipv4, optarg);
     454                      break;
     455            case 'I': tr_variantDictAddStr (&settings, TR_KEY_bind_address_ipv6, optarg);
     456                      break;
     457            case 'r': tr_variantDictAddStr (&settings, TR_KEY_rpc_bind_address, optarg);
     458                      break;
     459            case 953: tr_variantDictAddReal (&settings, TR_KEY_ratio_limit, atof (optarg));
     460                      tr_variantDictAddBool (&settings, TR_KEY_ratio_limit_enabled, true);
     461                      break;
     462            case 954: tr_variantDictAddBool (&settings, TR_KEY_ratio_limit_enabled, false);
     463                      break;
     464            case 'x': tr_variantDictAddStr (&settings, key_pidfile, optarg);
     465                      break;
     466            case 'y': tr_variantDictAddBool (&settings, TR_KEY_lpd_enabled, true);
     467                      break;
     468            case 'Y': tr_variantDictAddBool (&settings, TR_KEY_lpd_enabled, false);
     469                      break;
     470            case 810: tr_variantDictAddInt (&settings,  TR_KEY_message_level, TR_MSG_ERR);
     471                      break;
     472            case 811: tr_variantDictAddInt (&settings,  TR_KEY_message_level, TR_MSG_INF);
     473                      break;
     474            case 812: tr_variantDictAddInt (&settings,  TR_KEY_message_level, TR_MSG_DBG);
     475                      break;
     476            case 830: tr_variantDictAddBool (&settings, TR_KEY_utp_enabled, true);
     477                      break;
     478            case 831: tr_variantDictAddBool (&settings, TR_KEY_utp_enabled, false);
    480479                      break;
    481480            default:  showUsage ();
     
    519518
    520519    pid_filename = NULL;
    521     tr_variantDictFindStr (&settings, PREF_KEY_PIDFILE, &pid_filename, NULL);
     520    tr_variantDictFindStr (&settings, key_pidfile, &pid_filename, NULL);
    522521    if (pid_filename && *pid_filename)
    523522    {
     
    534533    }
    535534
    536     if (tr_variantDictFindBool (&settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &boolVal) && boolVal)
     535    if (tr_variantDictFindBool (&settings, TR_KEY_rpc_authentication_required, &boolVal) && boolVal)
    537536        tr_ninf (MY_NAME, "requiring authentication");
    538537
     
    547546        const char * dir;
    548547
    549         if (tr_variantDictFindBool (&settings, PREF_KEY_DIR_WATCH_ENABLED, &boolVal)
     548        if (tr_variantDictFindBool (&settings, TR_KEY_watch_dir_enabled, &boolVal)
    550549            && boolVal
    551             && tr_variantDictFindStr (&settings, PREF_KEY_DIR_WATCH, &dir, NULL)
     550            && tr_variantDictFindStr (&settings, TR_KEY_watch_dir, &dir, NULL)
    552551            && dir
    553552            && *dir)
  • trunk/daemon/remote.c

    r13672 r13683  
    4242#define DEFAULT_URL TR_DEFAULT_RPC_URL_STR "rpc/"
    4343
    44 #define ARGUMENTS "arguments"
     44#define ARGUMENTS TR_KEY_arguments
    4545
    4646#define MEM_K 1024
     
    324324numarg (const char * arg)
    325325{
    326     char *     end = NULL;
    327     const long num = strtol (arg, &end, 10);
    328 
    329     if (*end)
    330     {
    331         fprintf (stderr, "Not a number: \"%s\"\n", arg);
    332         showUsage ();
    333         exit (EXIT_FAILURE);
    334     }
    335     return num;
     326  char * end = NULL;
     327  const long num = strtol (arg, &end, 10);
     328
     329  if (*end)
     330    {
     331      fprintf (stderr, "Not a number: \"%s\"\n", arg);
     332      showUsage ();
     333      exit (EXIT_FAILURE);
     334    }
     335
     336  return num;
    336337}
    337338
    338339enum
    339340{
    340     MODE_TORRENT_START         = (1<<0),
    341     MODE_TORRENT_STOP          = (1<<1),
    342     MODE_TORRENT_VERIFY        = (1<<2),
    343     MODE_TORRENT_REANNOUNCE    = (1<<3),
    344     MODE_TORRENT_SET           = (1<<4),
    345     MODE_TORRENT_GET           = (1<<5),
    346     MODE_TORRENT_ADD           = (1<<6),
    347     MODE_TORRENT_REMOVE        = (1<<7),
    348     MODE_TORRENT_SET_LOCATION  = (1<<8),
    349     MODE_SESSION_SET           = (1<<9),
    350     MODE_SESSION_GET           = (1<<10),
    351     MODE_SESSION_STATS         = (1<<11),
    352     MODE_SESSION_CLOSE         = (1<<12),
    353     MODE_BLOCKLIST_UPDATE      = (1<<13),
    354     MODE_PORT_TEST             = (1<<14)
     341  MODE_TORRENT_START         = (1<<0),
     342  MODE_TORRENT_STOP          = (1<<1),
     343  MODE_TORRENT_VERIFY        = (1<<2),
     344  MODE_TORRENT_REANNOUNCE    = (1<<3),
     345  MODE_TORRENT_SET           = (1<<4),
     346  MODE_TORRENT_GET           = (1<<5),
     347  MODE_TORRENT_ADD           = (1<<6),
     348  MODE_TORRENT_REMOVE        = (1<<7),
     349  MODE_TORRENT_SET_LOCATION  = (1<<8),
     350  MODE_SESSION_SET           = (1<<9),
     351  MODE_SESSION_GET           = (1<<10),
     352  MODE_SESSION_STATS         = (1<<11),
     353  MODE_SESSION_CLOSE         = (1<<12),
     354  MODE_BLOCKLIST_UPDATE      = (1<<13),
     355  MODE_PORT_TEST             = (1<<14)
    355356};
    356357
     
    358359getOptMode (int val)
    359360{
    360     switch (val)
    361     {
    362         case TR_OPT_ERR:
    363         case TR_OPT_UNK:
    364         case 'a': /* add torrent */
    365         case 'b': /* debug */
    366         case 'n': /* auth */
    367         case 810: /* authenv */
    368         case 'N': /* netrc */
    369         case 820: /* UseSSL */
    370         case 't': /* set current torrent */
    371         case 'V': /* show version number */
    372             return 0;
    373 
    374         case 'c': /* incomplete-dir */
    375         case 'C': /* no-incomplete-dir */
    376         case 'e': /* cache */
    377         case 'm': /* portmap */
    378         case 'M': /* "no-portmap */
    379         case 'o': /* dht */
    380         case 'O': /* no-dht */
    381         case 'p': /* incoming peer port */
    382         case 'P': /* random incoming peer port */
    383         case 'x': /* pex */
    384         case 'X': /* no-pex */
    385         case 'y': /* lpd */
    386         case 'Y': /* no-lpd */
    387         case 800: /* torrent-done-script */
    388         case 801: /* no-torrent-done-script */
    389         case 830: /* utp */
    390         case 831: /* no-utp */
    391         case 970: /* alt-speed */
    392         case 971: /* no-alt-speed */
    393         case 972: /* alt-speed-downlimit */
    394         case 973: /* alt-speed-uplimit */
    395         case 974: /* alt-speed-scheduler */
    396         case 975: /* no-alt-speed-scheduler */
    397         case 976: /* alt-speed-time-begin */
    398         case 977: /* alt-speed-time-end */
    399         case 978: /* alt-speed-days */
    400         case 910: /* encryption-required */
    401         case 911: /* encryption-preferred */
    402         case 912: /* encryption-tolerated */
    403         case 953: /* global-seedratio */
    404         case 954: /* no-global-seedratio */
    405         case 990: /* start-paused */
    406         case 991: /* no-start-paused */
    407         case 992: /* trash-torrent */
    408         case 993: /* no-trash-torrent */
    409             return MODE_SESSION_SET;
    410 
    411         case 712: /* tracker-remove */
    412         case 950: /* seedratio */
    413         case 951: /* seedratio-default */
    414         case 952: /* no-seedratio */
    415         case 984: /* honor-session */
    416         case 985: /* no-honor-session */
    417             return MODE_TORRENT_SET;
    418 
    419         case 920: /* session-info */
    420             return MODE_SESSION_GET;
    421 
    422         case 'g': /* get */
    423         case 'G': /* no-get */
    424         case 700: /* torrent priority-high */
    425         case 701: /* torrent priority-normal */
    426         case 702: /* torrent priority-low */
    427         case 710: /* tracker-add */
    428         case 900: /* file priority-high */
    429         case 901: /* file priority-normal */
    430         case 902: /* file priority-low */
    431             return MODE_TORRENT_SET | MODE_TORRENT_ADD;
    432 
    433         case 961: /* find */
    434             return MODE_TORRENT_SET_LOCATION | MODE_TORRENT_ADD;
    435 
    436         case 'i': /* info */
    437         case 'l': /* list all torrents */
    438         case 940: /* info-files */
    439         case 941: /* info-peer */
    440         case 942: /* info-pieces */
    441         case 943: /* info-tracker */
    442             return MODE_TORRENT_GET;
    443 
    444         case 'd': /* download speed limit */
    445         case 'D': /* no download speed limit */
    446         case 'u': /* upload speed limit */
    447         case 'U': /* no upload speed limit */
    448         case 930: /* peers */
    449             return MODE_SESSION_SET | MODE_TORRENT_SET;
    450 
    451         case 's': /* start */
    452             return MODE_TORRENT_START | MODE_TORRENT_ADD;
    453 
    454         case 'S': /* stop */
    455             return MODE_TORRENT_STOP | MODE_TORRENT_ADD;
    456 
    457         case 'w': /* download-dir */
    458             return MODE_SESSION_SET | MODE_TORRENT_ADD;
    459 
    460         case 850: /* session-close */
    461             return MODE_SESSION_CLOSE;
    462 
    463         case 963: /* blocklist-update */
    464             return MODE_BLOCKLIST_UPDATE;
    465 
    466         case 921: /* session-stats */
    467             return MODE_SESSION_STATS;
    468 
    469         case 'v': /* verify */
    470             return MODE_TORRENT_VERIFY;
    471 
    472         case 600: /* reannounce */
    473             return MODE_TORRENT_REANNOUNCE;
    474 
    475         case 962: /* port-test */
    476             return MODE_PORT_TEST;
    477 
    478         case 'r': /* remove */
    479         case 'R': /* remove and delete */
    480             return MODE_TORRENT_REMOVE;
    481 
    482         case 960: /* move */
    483             return MODE_TORRENT_SET_LOCATION;
    484 
    485         default:
    486             fprintf (stderr, "unrecognized argument %d\n", val);
    487             assert ("unrecognized argument" && 0);
    488             return 0;
     361  switch (val)
     362    {
     363      case TR_OPT_ERR:
     364      case TR_OPT_UNK:
     365      case 'a': /* add torrent */
     366      case 'b': /* debug */
     367      case 'n': /* auth */
     368      case 810: /* authenv */
     369      case 'N': /* netrc */
     370      case 820: /* UseSSL */
     371      case 't': /* set current torrent */
     372      case 'V': /* show version number */
     373        return 0;
     374
     375      case 'c': /* incomplete-dir */
     376      case 'C': /* no-incomplete-dir */
     377      case 'e': /* cache */
     378      case 'm': /* portmap */
     379      case 'M': /* "no-portmap */
     380      case 'o': /* dht */
     381      case 'O': /* no-dht */
     382      case 'p': /* incoming peer port */
     383      case 'P': /* random incoming peer port */
     384      case 'x': /* pex */
     385      case 'X': /* no-pex */
     386      case 'y': /* lpd */
     387      case 'Y': /* no-lpd */
     388      case 800: /* torrent-done-script */
     389      case 801: /* no-torrent-done-script */
     390      case 830: /* utp */
     391      case 831: /* no-utp */
     392      case 970: /* alt-speed */
     393      case 971: /* no-alt-speed */
     394      case 972: /* alt-speed-downlimit */
     395      case 973: /* alt-speed-uplimit */
     396      case 974: /* alt-speed-scheduler */
     397      case 975: /* no-alt-speed-scheduler */
     398      case 976: /* alt-speed-time-begin */
     399      case 977: /* alt-speed-time-end */
     400      case 978: /* alt-speed-days */
     401      case 910: /* encryption-required */
     402      case 911: /* encryption-preferred */
     403      case 912: /* encryption-tolerated */
     404      case 953: /* global-seedratio */
     405      case 954: /* no-global-seedratio */
     406      case 990: /* start-paused */
     407      case 991: /* no-start-paused */
     408      case 992: /* trash-torrent */
     409      case 993: /* no-trash-torrent */
     410        return MODE_SESSION_SET;
     411
     412      case 712: /* tracker-remove */
     413      case 950: /* seedratio */
     414      case 951: /* seedratio-default */
     415      case 952: /* no-seedratio */
     416      case 984: /* honor-session */
     417      case 985: /* no-honor-session */
     418        return MODE_TORRENT_SET;
     419
     420      case 920: /* session-info */
     421        return MODE_SESSION_GET;
     422
     423      case 'g': /* get */
     424      case 'G': /* no-get */
     425      case 700: /* torrent priority-high */
     426      case 701: /* torrent priority-normal */
     427      case 702: /* torrent priority-low */
     428      case 710: /* tracker-add */
     429      case 900: /* file priority-high */
     430      case 901: /* file priority-normal */
     431      case 902: /* file priority-low */
     432        return MODE_TORRENT_SET | MODE_TORRENT_ADD;
     433
     434      case 961: /* find */
     435        return MODE_TORRENT_SET_LOCATION | MODE_TORRENT_ADD;
     436
     437      case 'i': /* info */
     438      case 'l': /* list all torrents */
     439      case 940: /* info-files */
     440      case 941: /* info-peer */
     441      case 942: /* info-pieces */
     442      case 943: /* info-tracker */
     443        return MODE_TORRENT_GET;
     444
     445      case 'd': /* download speed limit */
     446      case 'D': /* no download speed limit */
     447      case 'u': /* upload speed limit */
     448      case 'U': /* no upload speed limit */
     449      case 930: /* peers */
     450        return MODE_SESSION_SET | MODE_TORRENT_SET;
     451
     452      case 's': /* start */
     453        return MODE_TORRENT_START | MODE_TORRENT_ADD;
     454
     455      case 'S': /* stop */
     456        return MODE_TORRENT_STOP | MODE_TORRENT_ADD;
     457
     458      case 'w': /* download-dir */
     459        return MODE_SESSION_SET | MODE_TORRENT_ADD;
     460
     461      case 850: /* session-close */
     462        return MODE_SESSION_CLOSE;
     463
     464      case 963: /* blocklist-update */
     465        return MODE_BLOCKLIST_UPDATE;
     466
     467      case 921: /* session-stats */
     468        return MODE_SESSION_STATS;
     469
     470      case 'v': /* verify */
     471        return MODE_TORRENT_VERIFY;
     472
     473      case 600: /* reannounce */
     474        return MODE_TORRENT_REANNOUNCE;
     475
     476      case 962: /* port-test */
     477        return MODE_PORT_TEST;
     478
     479      case 'r': /* remove */
     480      case 'R': /* remove and delete */
     481        return MODE_TORRENT_REMOVE;
     482
     483      case 960: /* move */
     484        return MODE_TORRENT_SET_LOCATION;
     485
     486      default:
     487        fprintf (stderr, "unrecognized argument %d\n", val);
     488        assert ("unrecognized argument" && 0);
     489        return 0;
    489490    }
    490491}
     
    499500tr_getcwd (void)
    500501{
    501     char * result;
    502     char buf[2048];
     502  char * result;
     503  char buf[2048];
     504
    503505#ifdef WIN32
    504     result = _getcwd (buf, sizeof (buf));
     506  result = _getcwd (buf, sizeof (buf));
    505507#else
    506     result = getcwd (buf, sizeof (buf));
     508  result = getcwd (buf, sizeof (buf));
    507509#endif
    508     if (result == NULL)
    509     {
    510         fprintf (stderr, "getcwd error: \"%s\"", tr_strerror (errno));
    511         *buf = '\0';
    512     }
    513     return tr_strdup (buf);
     510
     511  if (result == NULL)
     512    {
     513      fprintf (stderr, "getcwd error: \"%s\"", tr_strerror (errno));
     514      *buf = '\0';
     515    }
     516
     517  return tr_strdup (buf);
    514518}
    515519
     
    517521absolutify (const char * path)
    518522{
    519     char * buf;
    520 
    521     if (*path == '/')
    522         buf = tr_strdup (path);
    523     else {
    524         char * cwd = tr_getcwd ();
    525         buf = tr_buildPath (cwd, path, NULL);
    526         tr_free (cwd);
    527     }
    528 
    529     return buf;
     523  char * buf;
     524
     525  if (*path == '/')
     526    {
     527      buf = tr_strdup (path);
     528    }
     529  else
     530    {
     531      char * cwd = tr_getcwd ();
     532      buf = tr_buildPath (cwd, path, NULL);
     533      tr_free (cwd);
     534    }
     535
     536  return buf;
    530537}
    531538
     
    564571                isNum = false;
    565572        if (isNum || isList)
    566             tr_rpc_parse_list_str (tr_variantDictAdd (args, "ids", 3), id, strlen (id));
     573            tr_rpc_parse_list_str (tr_variantDictAdd (args, TR_KEY_ids), id, strlen (id));
    567574        else
    568             tr_variantDictAddStr (args, "ids", id); /* it's a torrent sha hash */
     575            tr_variantDictAddStr (args, TR_KEY_ids, id); /* it's a torrent sha hash */
    569576    }
    570577}
    571578
    572579static void
    573 addTime (tr_variant * args, const char * key, const char * arg)
     580addTime (tr_variant * args, const tr_quark key, const char * arg)
    574581{
    575582    int time;
     
    597604
    598605static void
    599 addDays (tr_variant * args, const char * key, const char * arg)
    600 {
    601     int days = 0;
    602 
    603     if (arg)
    604     {
    605         int i;
    606         int valueCount;
    607         int * values = tr_parseNumberRange (arg, -1, &valueCount);
    608         for (i=0; i<valueCount; ++i)
    609         {
    610             if (values[i] < 0 || values[i] > 7) continue;
    611             if (values[i] == 7) values[i] = 0;
    612 
    613             days |= 1 << values[i];
    614         }
    615         tr_free (values);
    616     }
    617 
    618     if (days)
    619         tr_variantDictAddInt (args, key, days);
    620     else
    621         fprintf (stderr, "Please specify the days of the week in '1-3,4,7' format.\n");
     606addDays (tr_variant * args, const tr_quark key, const char * arg)
     607{
     608  int days = 0;
     609
     610  if (arg)
     611    {
     612      int i;
     613      int valueCount;
     614      int * values;
     615
     616      values = tr_parseNumberRange (arg, -1, &valueCount);
     617      for (i=0; i<valueCount; ++i)
     618        {
     619          if (values[i] < 0 || values[i] > 7)
     620            continue;
     621
     622          if (values[i] == 7)
     623            values[i] = 0;
     624
     625          days |= 1 << values[i];
     626        }
     627
     628      tr_free (values);
     629    }
     630
     631  if (days)
     632    tr_variantDictAddInt (args, key, days);
     633  else
     634    fprintf (stderr, "Please specify the days of the week in '1-3,4,7' format.\n");
    622635}
    623636
    624637static void
    625 addFiles (tr_variant *    args,
    626           const char * key,
    627           const char * arg)
    628 {
    629     tr_variant * files = tr_variantDictAddList (args, key, 100);
    630 
    631     if (!*arg)
    632     {
    633         fprintf (stderr, "No files specified!\n");
    634         arg = "-1"; /* no file will have this index, so should be a no-op */
    635     }
    636     if (strcmp (arg, "all"))
    637     {
    638         int i;
    639         int valueCount;
    640         int * values = tr_parseNumberRange (arg, -1, &valueCount);
    641         for (i=0; i<valueCount; ++i)
    642             tr_variantListAddInt (files, values[i]);
    643         tr_free (values);
     638addFiles (tr_variant      * args,
     639          const tr_quark    key,
     640          const char      * arg)
     641{
     642  tr_variant * files = tr_variantDictAddList (args, key, 100);
     643
     644  if (!*arg)
     645    {
     646      fprintf (stderr, "No files specified!\n");
     647      arg = "-1"; /* no file will have this index, so should be a no-op */
     648    }
     649
     650  if (strcmp (arg, "all"))
     651    {
     652      int i;
     653      int valueCount;
     654      int * values = tr_parseNumberRange (arg, -1, &valueCount);
     655
     656      for (i=0; i<valueCount; ++i)
     657        tr_variantListAddInt (files, values[i]);
     658
     659      tr_free (values);
    644660    }
    645661}
     
    647663#define TR_N_ELEMENTS(ary) (sizeof (ary) / sizeof (*ary))
    648664
    649 static const char * files_keys[] = {
    650     "files",
    651     "name",
    652     "priorities",
    653     "wanted"
     665static const tr_quark files_keys[] = {
     666    TR_KEY_files,
     667    TR_KEY_name,
     668    TR_KEY_priorities,
     669    TR_KEY_wanted
    654670};
    655671
    656 static const char * details_keys[] = {
    657     "activityDate",
    658     "addedDate",
    659     "bandwidthPriority",
    660     "comment",
    661     "corruptEver",
    662     "creator",
    663     "dateCreated",
    664     "desiredAvailable",
    665     "doneDate",
    666     "downloadDir",
    667     "downloadedEver",
    668     "downloadLimit",
    669     "downloadLimited",
    670     "error",
    671     "errorString",
    672     "eta",
    673     "hashString",
    674     "haveUnchecked",
    675     "haveValid",
    676     "honorsSessionLimits",
    677     "id",
    678     "isFinished",
    679     "isPrivate",
    680     "leftUntilDone",
    681     "magnetLink",
    682     "name",
    683     "peersConnected",
    684     "peersGettingFromUs",
    685     "peersSendingToUs",
    686     "peer-limit",
    687     "pieceCount",
    688     "pieceSize",
    689     "rateDownload",
    690     "rateUpload",
    691     "recheckProgress",
    692     "secondsDownloading",
    693     "secondsSeeding",
    694     "seedRatioMode",
    695     "seedRatioLimit",
    696     "sizeWhenDone",
    697     "startDate",
    698     "status",
    699     "totalSize",
    700     "uploadedEver",
    701     "uploadLimit",
    702     "uploadLimited",
    703     "webseeds",
    704     "webseedsSendingToUs"
     672static const tr_quark details_keys[] = {
     673    TR_KEY_activityDate,
     674    TR_KEY_addedDate,
     675    TR_KEY_bandwidthPriority,
     676    TR_KEY_comment,
     677    TR_KEY_corruptEver,
     678    TR_KEY_creator,
     679    TR_KEY_dateCreated,
     680    TR_KEY_desiredAvailable,
     681    TR_KEY_doneDate,
     682    TR_KEY_downloadDir,
     683    TR_KEY_downloadedEver,
     684    TR_KEY_downloadLimit,
     685    TR_KEY_downloadLimited,
     686    TR_KEY_error,
     687    TR_KEY_errorString,
     688    TR_KEY_eta,
     689    TR_KEY_hashString,
     690    TR_KEY_haveUnchecked,
     691    TR_KEY_haveValid,
     692    TR_KEY_honorsSessionLimits,
     693    TR_KEY_id,
     694    TR_KEY_isFinished,
     695    TR_KEY_isPrivate,
     696    TR_KEY_leftUntilDone,
     697    TR_KEY_magnetLink,
     698    TR_KEY_name,
     699    TR_KEY_peersConnected,
     700    TR_KEY_peersGettingFromUs,
     701    TR_KEY_peersSendingToUs,
     702    TR_KEY_peer_limit,
     703    TR_KEY_pieceCount,
     704    TR_KEY_pieceSize,
     705    TR_KEY_rateDownload,
     706    TR_KEY_rateUpload,
     707    TR_KEY_recheckProgress,
     708    TR_KEY_secondsDownloading,
     709    TR_KEY_secondsSeeding,
     710    TR_KEY_seedRatioMode,
     711    TR_KEY_seedRatioLimit,
     712    TR_KEY_sizeWhenDone,
     713    TR_KEY_startDate,
     714    TR_KEY_status,
     715    TR_KEY_totalSize,
     716    TR_KEY_uploadedEver,
     717    TR_KEY_uploadLimit,
     718    TR_KEY_uploadLimited,
     719    TR_KEY_webseeds,
     720    TR_KEY_webseedsSendingToUs
    705721};
    706722
    707 static const char * list_keys[] = {
    708     "error",
    709     "errorString",
    710     "eta",
    711     "id",
    712     "isFinished",
    713     "leftUntilDone",
    714     "name",
    715     "peersGettingFromUs",
    716     "peersSendingToUs",
    717     "rateDownload",
    718     "rateUpload",
    719     "sizeWhenDone",
    720     "status",
    721     "uploadRatio"
     723static const tr_quark list_keys[] = {
     724    TR_KEY_error,
     725    TR_KEY_errorString,
     726    TR_KEY_eta,
     727    TR_KEY_id,
     728    TR_KEY_isFinished,
     729    TR_KEY_leftUntilDone,
     730    TR_KEY_name,
     731    TR_KEY_peersGettingFromUs,
     732    TR_KEY_peersSendingToUs,
     733    TR_KEY_rateDownload,
     734    TR_KEY_rateUpload,
     735    TR_KEY_sizeWhenDone,
     736    TR_KEY_status,
     737    TR_KEY_uploadRatio
    722738};
    723739
     
    767783    bool boolVal;
    768784
    769     if (!tr_variantDictFindInt (t, "status", &status))
     785    if (!tr_variantDictFindInt (t, TR_KEY_status, &status))
    770786    {
    771787        *buf = '\0';
     
    779795
    780796        case TR_STATUS_STOPPED:
    781             if (tr_variantDictFindBool (t, "isFinished", &boolVal) && boolVal)
     797            if (tr_variantDictFindBool (t, TR_KEY_isFinished, &boolVal) && boolVal)
    782798                tr_strlcpy (buf, "Finished", buflen);
    783799            else
     
    791807                             : "Verifying";
    792808            double percent;
    793             if (tr_variantDictFindReal (t, "recheckProgress", &percent))
     809            if (tr_variantDictFindReal (t, TR_KEY_recheckProgress, &percent))
    794810                tr_snprintf (buf, buflen, "%s (%.0f%%)", str, floor (percent*100.0));
    795811            else
     
    803819            int64_t fromUs = 0;
    804820            int64_t toUs = 0;
    805             tr_variantDictFindInt (t, "peersGettingFromUs", &fromUs);
    806             tr_variantDictFindInt (t, "peersSendingToUs", &toUs);
     821            tr_variantDictFindInt (t, TR_KEY_peersGettingFromUs, &fromUs);
     822            tr_variantDictFindInt (t, TR_KEY_peersSendingToUs, &toUs);
    807823            if (fromUs && toUs)
    808824                tr_strlcpy (buf, "Up & Down", buflen);
     
    811827            else if (fromUs) {
    812828                int64_t leftUntilDone = 0;
    813                 tr_variantDictFindInt (t, "leftUntilDone", &leftUntilDone);
     829                tr_variantDictFindInt (t, TR_KEY_leftUntilDone, &leftUntilDone);
    814830                if (leftUntilDone > 0)
    815831                    tr_strlcpy (buf, "Uploading", buflen);
     
    838854    tr_variant *args, *torrents;
    839855
    840     if ((tr_variantDictFindDict (top, "arguments", &args))
    841       && (tr_variantDictFindList (args, "torrents", &torrents)))
     856    if ((tr_variantDictFindDict (top, TR_KEY_arguments, &args))
     857      && (tr_variantDictFindList (args, TR_KEY_torrents, &torrents)))
    842858    {
    843859        int ti, tCount;
     
    855871
    856872            printf ("NAME\n");
    857             if (tr_variantDictFindInt (t, "id", &i))
     873            if (tr_variantDictFindInt (t, TR_KEY_id, &i))
    858874                printf ("  Id: %" PRId64 "\n", i);
    859             if (tr_variantDictFindStr (t, "name", &str, NULL))
     875            if (tr_variantDictFindStr (t, TR_KEY_name, &str, NULL))
    860876                printf ("  Name: %s\n", str);
    861             if (tr_variantDictFindStr (t, "hashString", &str, NULL))
     877            if (tr_variantDictFindStr (t, TR_KEY_hashString, &str, NULL))
    862878                printf ("  Hash: %s\n", str);
    863             if (tr_variantDictFindStr (t, "magnetLink", &str, NULL))
     879            if (tr_variantDictFindStr (t, TR_KEY_magnetLink, &str, NULL))
    864880                printf ("  Magnet: %s\n", str);
    865881            printf ("\n");
     
    869885            printf ("  State: %s\n", buf);
    870886
    871             if (tr_variantDictFindStr (t, "downloadDir", &str, NULL))
     887            if (tr_variantDictFindStr (t, TR_KEY_downloadDir, &str, NULL))
    872888                printf ("  Location: %s\n", str);
    873889
    874             if (tr_variantDictFindInt (t, "sizeWhenDone", &i)
    875               && tr_variantDictFindInt (t, "leftUntilDone", &j))
     890            if (tr_variantDictFindInt (t, TR_KEY_sizeWhenDone, &i)
     891              && tr_variantDictFindInt (t, TR_KEY_leftUntilDone, &j))
    876892            {
    877893                strlpercent (buf, 100.0 * (i - j) / i, sizeof (buf));
     
    879895            }
    880896
    881             if (tr_variantDictFindInt (t, "eta", &i))
     897            if (tr_variantDictFindInt (t, TR_KEY_eta, &i))
    882898                printf ("  ETA: %s\n", tr_strltime (buf, i, sizeof (buf)));
    883             if (tr_variantDictFindInt (t, "rateDownload", &i))
     899            if (tr_variantDictFindInt (t, TR_KEY_rateDownload, &i))
    884900                printf ("  Download Speed: %s\n", tr_formatter_speed_KBps (buf, i/ (double)tr_speed_K, sizeof (buf)));
    885             if (tr_variantDictFindInt (t, "rateUpload", &i))
     901            if (tr_variantDictFindInt (t, TR_KEY_rateUpload, &i))
    886902                printf ("  Upload Speed: %s\n", tr_formatter_speed_KBps (buf, i/ (double)tr_speed_K, sizeof (buf)));
    887             if (tr_variantDictFindInt (t, "haveUnchecked", &i)
    888               && tr_variantDictFindInt (t, "haveValid", &j))
     903            if (tr_variantDictFindInt (t, TR_KEY_haveUnchecked, &i)
     904              && tr_variantDictFindInt (t, TR_KEY_haveValid, &j))
    889905            {
    890906                strlsize (buf, i + j, sizeof (buf));
     
    893909            }
    894910
    895             if (tr_variantDictFindInt (t, "sizeWhenDone", &i))
     911            if (tr_variantDictFindInt (t, TR_KEY_sizeWhenDone, &i))
    896912            {
    897913                if (i < 1)
    898914                    printf ("  Availability: None\n");
    899                 if (tr_variantDictFindInt (t, "desiredAvailable", &j)
    900                     && tr_variantDictFindInt (t, "leftUntilDone", &k))
     915                if (tr_variantDictFindInt (t, TR_KEY_desiredAvailable, &j)
     916                    && tr_variantDictFindInt (t, TR_KEY_leftUntilDone, &k))
    901917                {
    902918                    j += i - k;
     
    904920                    printf ("  Availability: %s%%\n", buf);
    905921                }
    906                 if (tr_variantDictFindInt (t, "totalSize", &j))
     922                if (tr_variantDictFindInt (t, TR_KEY_totalSize, &j))
    907923                {
    908924                    strlsize (buf2, i, sizeof (buf2));
     
    911927                }
    912928            }
    913             if (tr_variantDictFindInt (t, "downloadedEver", &i)
    914               && tr_variantDictFindInt (t, "uploadedEver", &j))
     929            if (tr_variantDictFindInt (t, TR_KEY_downloadedEver, &i)
     930              && tr_variantDictFindInt (t, TR_KEY_uploadedEver, &j))
    915931            {
    916932                strlsize (buf, i, sizeof (buf));
     
    921937                printf ("  Ratio: %s\n", buf);
    922938            }
    923             if (tr_variantDictFindInt (t, "corruptEver", &i))
     939            if (tr_variantDictFindInt (t, TR_KEY_corruptEver, &i))
    924940            {
    925941                strlsize (buf, i, sizeof (buf));
    926942                printf ("  Corrupt DL: %s\n", buf);
    927943            }
    928             if (tr_variantDictFindStr (t, "errorString", &str, NULL) && str && *str &&
    929                 tr_variantDictFindInt (t, "error", &i) && i)
     944            if (tr_variantDictFindStr (t, TR_KEY_errorString, &str, NULL) && str && *str &&
     945                tr_variantDictFindInt (t, TR_KEY_error, &i) && i)
    930946            {
    931947                switch (i) {
     
    936952                }
    937953            }
    938             if (tr_variantDictFindInt (t, "peersConnected", &i)
    939               && tr_variantDictFindInt (t, "peersGettingFromUs", &j)
    940               && tr_variantDictFindInt (t, "peersSendingToUs", &k))
     954            if (tr_variantDictFindInt (t, TR_KEY_peersConnected, &i)
     955              && tr_variantDictFindInt (t, TR_KEY_peersGettingFromUs, &j)
     956              && tr_variantDictFindInt (t, TR_KEY_peersSendingToUs, &k))
    941957            {
    942958                printf (
     
    950966            }
    951967
    952             if (tr_variantDictFindList (t, "webseeds", &l)
    953               && tr_variantDictFindInt (t, "webseedsSendingToUs", &i))
     968            if (tr_variantDictFindList (t, TR_KEY_webseeds, &l)
     969              && tr_variantDictFindInt (t, TR_KEY_webseedsSendingToUs, &i))
    954970            {
    955971                const int64_t n = tr_variantListSize (l);
     
    963979
    964980            printf ("HISTORY\n");
    965             if (tr_variantDictFindInt (t, "addedDate", &i) && i)
     981            if (tr_variantDictFindInt (t, TR_KEY_addedDate, &i) && i)
    966982            {
    967983                const time_t tt = i;
    968984                printf ("  Date added:       %s", ctime (&tt));
    969985            }
    970             if (tr_variantDictFindInt (t, "doneDate", &i) && i)
     986            if (tr_variantDictFindInt (t, TR_KEY_doneDate, &i) && i)
    971987            {
    972988                const time_t tt = i;
    973989                printf ("  Date finished:    %s", ctime (&tt));
    974990            }
    975             if (tr_variantDictFindInt (t, "startDate", &i) && i)
     991            if (tr_variantDictFindInt (t, TR_KEY_startDate, &i) && i)
    976992            {
    977993                const time_t tt = i;
    978994                printf ("  Date started:     %s", ctime (&tt));
    979995            }
    980             if (tr_variantDictFindInt (t, "activityDate", &i) && i)
     996            if (tr_variantDictFindInt (t, TR_KEY_activityDate, &i) && i)
    981997            {
    982998                const time_t tt = i;
    983999                printf ("  Latest activity:  %s", ctime (&tt));
    9841000            }
    985             if (tr_variantDictFindInt (t, "secondsDownloading", &i) && (i > 0))
     1001            if (tr_variantDictFindInt (t, TR_KEY_secondsDownloading, &i) && (i > 0))
    9861002                printf ("  Downloading Time: %s\n", tr_strltime (buf, i, sizeof (buf)));
    987             if (tr_variantDictFindInt (t, "secondsSeeding", &i) && (i > 0))
     1003            if (tr_variantDictFindInt (t, TR_KEY_secondsSeeding, &i) && (i > 0))
    9881004                printf ("  Seeding Time:     %s\n", tr_strltime (buf, i, sizeof (buf)));
    9891005            printf ("\n");
    9901006
    9911007            printf ("ORIGINS\n");
    992             if (tr_variantDictFindInt (t, "dateCreated", &i) && i)
     1008            if (tr_variantDictFindInt (t, TR_KEY_dateCreated, &i) && i)
    9931009            {
    9941010                const time_t tt = i;
    9951011                printf ("  Date created: %s", ctime (&tt));
    9961012            }
    997             if (tr_variantDictFindBool (t, "isPrivate", &boolVal))
     1013            if (tr_variantDictFindBool (t, TR_KEY_isPrivate, &boolVal))
    9981014                printf ("  Public torrent: %s\n", (boolVal ? "No" : "Yes"));
    999             if (tr_variantDictFindStr (t, "comment", &str, NULL) && str && *str)
     1015            if (tr_variantDictFindStr (t, TR_KEY_comment, &str, NULL) && str && *str)
    10001016                printf ("  Comment: %s\n", str);
    1001             if (tr_variantDictFindStr (t, "creator", &str, NULL) && str && *str)
     1017            if (tr_variantDictFindStr (t, TR_KEY_creator, &str, NULL) && str && *str)
    10021018                printf ("  Creator: %s\n", str);
    1003             if (tr_variantDictFindInt (t, "pieceCount", &i))
     1019            if (tr_variantDictFindInt (t, TR_KEY_pieceCount, &i))
    10041020                printf ("  Piece Count: %" PRId64 "\n", i);
    1005             if (tr_variantDictFindInt (t, "pieceSize", &i))
     1021            if (tr_variantDictFindInt (t, TR_KEY_pieceSize, &i))
    10061022                printf ("  Piece Size: %s\n", strlmem (buf, i, sizeof (buf)));
    10071023            printf ("\n");
    10081024
    10091025            printf ("LIMITS & BANDWIDTH\n");
    1010             if (tr_variantDictFindBool (t, "downloadLimited", &boolVal)
    1011                 && tr_variantDictFindInt (t, "downloadLimit", &i))
     1026            if (tr_variantDictFindBool (t, TR_KEY_downloadLimited, &boolVal)
     1027                && tr_variantDictFindInt (t, TR_KEY_downloadLimit, &i))
    10121028            {
    10131029                printf ("  Download Limit: ");
     
    10171033                    printf ("Unlimited\n");
    10181034            }
    1019             if (tr_variantDictFindBool (t, "uploadLimited", &boolVal)
    1020                 && tr_variantDictFindInt (t, "uploadLimit", &i))
     1035            if (tr_variantDictFindBool (t, TR_KEY_uploadLimited, &boolVal)
     1036                && tr_variantDictFindInt (t, TR_KEY_uploadLimit, &i))
    10211037            {
    10221038                printf ("  Upload Limit: ");
     
    10261042                    printf ("Unlimited\n");
    10271043            }
    1028             if (tr_variantDictFindInt (t, "seedRatioMode", &i))
     1044            if (tr_variantDictFindInt (t, TR_KEY_seedRatioMode, &i))
    10291045            {
    10301046                switch (i) {
     
    10331049                        break;
    10341050                    case TR_RATIOLIMIT_SINGLE:
    1035                         if (tr_variantDictFindReal (t, "seedRatioLimit", &d))
     1051                        if (tr_variantDictFindReal (t, TR_KEY_seedRatioLimit, &d))
    10361052                            printf ("  Ratio Limit: %.2f\n", d);
    10371053                        break;
     
    10421058                }
    10431059            }
    1044             if (tr_variantDictFindBool (t, "honorsSessionLimits", &boolVal))
     1060            if (tr_variantDictFindBool (t, TR_KEY_honorsSessionLimits, &boolVal))
    10451061                printf ("  Honors Session Limits: %s\n", (boolVal ? "Yes" : "No"));
    1046             if (tr_variantDictFindInt (t, "peer-limit", &i))
     1062            if (tr_variantDictFindInt (t, TR_KEY_peer_limit, &i))
    10471063                printf ("  Peer limit: %" PRId64 "\n", i);
    1048             if (tr_variantDictFindInt (t, "bandwidthPriority", &i))
     1064            if (tr_variantDictFindInt (t, TR_KEY_bandwidthPriority, &i))
    10491065                printf ("  Bandwidth Priority: %s\n",
    10501066                        bandwidthPriorityNames[ (i + 1) & 3]);
     
    10601076    tr_variant *args, *torrents;
    10611077
    1062     if ((tr_variantDictFindDict (top, "arguments", &args))
    1063       && (tr_variantDictFindList (args, "torrents", &torrents)))
     1078    if ((tr_variantDictFindDict (top, TR_KEY_arguments, &args))
     1079      && (tr_variantDictFindList (args, TR_KEY_torrents, &torrents)))
    10641080    {
    10651081        int i, in;
     
    10691085            tr_variant *    files, *priorities, *wanteds;
    10701086            const char * name;
    1071             if (tr_variantDictFindStr (d, "name", &name, NULL)
    1072               && tr_variantDictFindList (d, "files", &files)
    1073               && tr_variantDictFindList (d, "priorities", &priorities)
    1074               && tr_variantDictFindList (d, "wanted", &wanteds))
     1087            if (tr_variantDictFindStr (d, TR_KEY_name, &name, NULL)
     1088              && tr_variantDictFindList (d, TR_KEY_files, &files)
     1089              && tr_variantDictFindList (d, TR_KEY_priorities, &priorities)
     1090              && tr_variantDictFindList (d, TR_KEY_wanted, &wanteds))
    10751091            {
    10761092                int j = 0, jn = tr_variantListSize (files);
     
    10871103                    const char * filename;
    10881104                    tr_variant *    file = tr_variantListChild (files, j);
    1089                     if (tr_variantDictFindInt (file, "length", &length)
    1090                       && tr_variantDictFindStr (file, "name", &filename, NULL)
    1091                       && tr_variantDictFindInt (file, "bytesCompleted", &have)
    1092                       && tr_variantGetInt (tr_variantListChild (priorities,
    1093                                                           j), &priority)
    1094                       && tr_variantGetInt (tr_variantListChild (wanteds,
    1095                                                           j), &wanted))
     1105                    if (tr_variantDictFindInt (file, TR_KEY_length, &length)
     1106                      && tr_variantDictFindStr (file, TR_KEY_name, &filename, NULL)
     1107                      && tr_variantDictFindInt (file, TR_KEY_bytesCompleted, &have)
     1108                      && tr_variantGetInt (tr_variantListChild (priorities, j), &priority)
     1109                      && tr_variantGetInt (tr_variantListChild (wanteds, j), &wanted))
    10961110                    {
    10971111                        char         sizestr[64];
     
    11271141printPeersImpl (tr_variant * peers)
    11281142{
    1129     int i, n;
    1130     printf ("%-20s  %-12s  %-5s %-6s  %-6s  %s\n",
    1131             "Address", "Flags", "Done", "Down", "Up", "Client");
    1132     for (i = 0, n = tr_variantListSize (peers); i < n; ++i)
    1133     {
    1134         double progress;
    1135         const char * address, * client, * flagstr;
    1136         int64_t rateToClient, rateToPeer;
    1137         tr_variant * d = tr_variantListChild (peers, i);
    1138 
    1139         if (tr_variantDictFindStr (d, "address", &address, NULL)
    1140           && tr_variantDictFindStr (d, "clientName", &client, NULL)
    1141           && tr_variantDictFindReal (d, "progress", &progress)
    1142           && tr_variantDictFindStr (d, "flagStr", &flagstr, NULL)
    1143           && tr_variantDictFindInt (d, "rateToClient", &rateToClient)
    1144           && tr_variantDictFindInt (d, "rateToPeer", &rateToPeer))
    1145         {
    1146             printf ("%-20s  %-12s  %-5.1f %6.1f  %6.1f  %s\n",
    1147                     address, flagstr, (progress*100.0),
    1148                     rateToClient / (double)tr_speed_K,
    1149                     rateToPeer / (double)tr_speed_K,
    1150                     client);
     1143  int i, n;
     1144  printf ("%-20s  %-12s  %-5s %-6s  %-6s  %s\n",
     1145          "Address", "Flags", "Done", "Down", "Up", "Client");
     1146
     1147  for (i=0, n=tr_variantListSize(peers); i<n; ++i)
     1148    {
     1149      double progress;
     1150      const char * address, * client, * flagstr;
     1151      int64_t rateToClient, rateToPeer;
     1152      tr_variant * d = tr_variantListChild (peers, i);
     1153
     1154      if  (tr_variantDictFindStr  (d, TR_KEY_address, &address, NULL)
     1155        && tr_variantDictFindStr  (d, TR_KEY_clientName, &client, NULL)
     1156        && tr_variantDictFindReal (d, TR_KEY_progress, &progress)
     1157        && tr_variantDictFindStr  (d, TR_KEY_flagStr, &flagstr, NULL)
     1158        && tr_variantDictFindInt  (d, TR_KEY_rateToClient, &rateToClient)
     1159        && tr_variantDictFindInt  (d, TR_KEY_rateToPeer, &rateToPeer))
     1160        {
     1161          printf ("%-20s  %-12s  %-5.1f %6.1f  %6.1f  %s\n",
     1162                  address, flagstr, (progress*100.0),
     1163                  rateToClient / (double)tr_speed_K,
     1164                  rateToPeer / (double)tr_speed_K,
     1165                  client);
    11511166        }
    11521167    }
     
    11561171printPeers (tr_variant * top)
    11571172{
    1158     tr_variant *args, *torrents;
    1159 
    1160     if (tr_variantDictFindDict (top, "arguments", &args)
    1161       && tr_variantDictFindList (args, "torrents", &torrents))
    1162     {
    1163         int i, n;
    1164         for (i=0, n=tr_variantListSize (torrents); i<n; ++i)
    1165         {
    1166             tr_variant * peers;
    1167             tr_variant * torrent = tr_variantListChild (torrents, i);
    1168             if (tr_variantDictFindList (torrent, "peers", &peers)) {
    1169                 printPeersImpl (peers);
    1170                 if (i+1<n)
    1171                     printf ("\n");
     1173  tr_variant *args, *torrents;
     1174
     1175  if (tr_variantDictFindDict (top, TR_KEY_arguments, &args)
     1176      && tr_variantDictFindList (args, TR_KEY_torrents, &torrents))
     1177    {
     1178      int i, n;
     1179      for (i=0, n=tr_variantListSize (torrents); i<n; ++i)
     1180        {
     1181          tr_variant * peers;
     1182          tr_variant * torrent = tr_variantListChild (torrents, i);
     1183          if (tr_variantDictFindList (torrent, TR_KEY_peers, &peers))
     1184            {
     1185              printPeersImpl (peers);
     1186              if (i+1<n)
     1187                printf ("\n");
    11721188            }
    11731189        }
     
    11981214    tr_variant *args, *torrents;
    11991215
    1200     if (tr_variantDictFindDict (top, "arguments", &args)
    1201       && tr_variantDictFindList (args, "torrents", &torrents))
     1216    if (tr_variantDictFindDict (top, TR_KEY_arguments, &args)
     1217      && tr_variantDictFindList (args, TR_KEY_torrents, &torrents))
    12021218    {
    12031219        int i, n;
     
    12081224            size_t       rawlen;
    12091225            tr_variant * torrent = tr_variantListChild (torrents, i);
    1210             if (tr_variantDictFindRaw (torrent, "pieces", &raw, &rawlen) &&
    1211                 tr_variantDictFindInt (torrent, "pieceCount", &j)) {
     1226            if (tr_variantDictFindRaw (torrent, TR_KEY_pieces, &raw, &rawlen) &&
     1227                tr_variantDictFindInt (torrent, TR_KEY_pieceCount, &j)) {
    12121228                printPiecesImpl (raw, rawlen, j);
    12131229                if (i+1<n)
     
    12221238{
    12231239    tr_variant *args;
    1224     if ((tr_variantDictFindDict (top, "arguments", &args)))
     1240    if ((tr_variantDictFindDict (top, TR_KEY_arguments, &args)))
    12251241    {
    12261242        bool      boolVal;
    12271243
    1228         if (tr_variantDictFindBool (args, "port-is-open", &boolVal))
     1244        if (tr_variantDictFindBool (args, TR_KEY_port_is_open, &boolVal))
    12291245            printf ("Port is open: %s\n", (boolVal ? "Yes" : "No"));
    12301246    }
     
    12361252    tr_variant *args, *list;
    12371253
    1238     if ((tr_variantDictFindDict (top, "arguments", &args))
    1239       && (tr_variantDictFindList (args, "torrents", &list)))
     1254    if ((tr_variantDictFindDict (top, TR_KEY_arguments, &args))
     1255      && (tr_variantDictFindList (args, TR_KEY_torrents, &list)))
    12401256    {
    12411257        int i, n;
     
    12551271            const char * name;
    12561272            tr_variant *   d = tr_variantListChild (list, i);
    1257             if (tr_variantDictFindInt (d, "eta", &eta)
    1258               && tr_variantDictFindInt (d, "id", &id)
    1259               && tr_variantDictFindInt (d, "leftUntilDone", &leftUntilDone)
    1260               && tr_variantDictFindStr (d, "name", &name, NULL)
    1261               && tr_variantDictFindInt (d, "rateDownload", &down)
    1262               && tr_variantDictFindInt (d, "rateUpload", &up)
    1263               && tr_variantDictFindInt (d, "sizeWhenDone", &sizeWhenDone)
    1264               && tr_variantDictFindInt (d, "status", &status)
    1265               && tr_variantDictFindReal (d, "uploadRatio", &ratio))
     1273            if  (tr_variantDictFindInt  (d, TR_KEY_eta, &eta)
     1274              && tr_variantDictFindInt  (d, TR_KEY_id, &id)
     1275              && tr_variantDictFindInt  (d, TR_KEY_leftUntilDone, &leftUntilDone)
     1276              && tr_variantDictFindStr  (d, TR_KEY_name, &name, NULL)
     1277              && tr_variantDictFindInt  (d, TR_KEY_rateDownload, &down)
     1278              && tr_variantDictFindInt  (d, TR_KEY_rateUpload, &up)
     1279              && tr_variantDictFindInt  (d, TR_KEY_sizeWhenDone, &sizeWhenDone)
     1280              && tr_variantDictFindInt  (d, TR_KEY_status, &status)
     1281              && tr_variantDictFindReal (d, TR_KEY_uploadRatio, &ratio))
    12661282            {
    12671283                char etaStr[16];
     
    12831299                else
    12841300                    tr_snprintf (etaStr, sizeof (etaStr), "Done");
    1285                 if (tr_variantDictFindInt (d, "error", &error) && error)
     1301                if (tr_variantDictFindInt (d, TR_KEY_error, &error) && error)
    12861302                    errorMark = '*';
    12871303                else
     
    13461362        int64_t scrapeState;
    13471363
    1348         if (tr_variantDictFindInt (t, "downloadCount", &downloadCount) &&
    1349             tr_variantDictFindBool (t, "hasAnnounced", &hasAnnounced) &&
    1350             tr_variantDictFindBool (t, "hasScraped", &hasScraped) &&
    1351             tr_variantDictFindStr (t, "host", &host, NULL) &&
    1352             tr_variantDictFindInt (t, "id", &id) &&
    1353             tr_variantDictFindBool (t, "isBackup", &isBackup) &&
    1354             tr_variantDictFindInt (t, "announceState", &announceState) &&
    1355             tr_variantDictFindInt (t, "scrapeState", &scrapeState) &&
    1356             tr_variantDictFindInt (t, "lastAnnouncePeerCount", &lastAnnouncePeerCount) &&
    1357             tr_variantDictFindStr (t, "lastAnnounceResult", &lastAnnounceResult, NULL) &&
    1358             tr_variantDictFindInt (t, "lastAnnounceStartTime", &lastAnnounceStartTime) &&
    1359             tr_variantDictFindBool (t, "lastAnnounceSucceeded", &lastAnnounceSucceeded) &&
    1360             tr_variantDictFindInt (t, "lastAnnounceTime", &lastAnnounceTime) &&
    1361             tr_variantDictFindBool (t, "lastAnnounceTimedOut", &lastAnnounceTimedOut) &&
    1362             tr_variantDictFindStr (t, "lastScrapeResult", &lastScrapeResult, NULL) &&
    1363             tr_variantDictFindInt (t, "lastScrapeStartTime", &lastScrapeStartTime) &&
    1364             tr_variantDictFindBool (t, "lastScrapeSucceeded", &lastScrapeSucceeded) &&
    1365             tr_variantDictFindInt (t, "lastScrapeTime", &lastScrapeTime) &&
    1366             tr_variantDictFindBool (t, "lastScrapeTimedOut", &lastScrapeTimedOut) &&
    1367             tr_variantDictFindInt (t, "leecherCount", &leecherCount) &&
    1368             tr_variantDictFindInt (t, "nextAnnounceTime", &nextAnnounceTime) &&
    1369             tr_variantDictFindInt (t, "nextScrapeTime", &nextScrapeTime) &&
    1370             tr_variantDictFindInt (t, "seederCount", &seederCount) &&
    1371             tr_variantDictFindInt (t, "tier", &tier))
     1364        if (tr_variantDictFindInt  (t, TR_KEY_downloadCount, &downloadCount) &&
     1365            tr_variantDictFindBool (t, TR_KEY_hasAnnounced, &hasAnnounced) &&
     1366            tr_variantDictFindBool (t, TR_KEY_hasScraped, &hasScraped) &&
     1367            tr_variantDictFindStr  (t, TR_KEY_host, &host, NULL) &&
     1368            tr_variantDictFindInt  (t, TR_KEY_id, &id) &&
     1369            tr_variantDictFindBool (t, TR_KEY_isBackup, &isBackup) &&
     1370            tr_variantDictFindInt  (t, TR_KEY_announceState, &announceState) &&
     1371            tr_variantDictFindInt  (t, TR_KEY_scrapeState, &scrapeState) &&
     1372            tr_variantDictFindInt  (t, TR_KEY_lastAnnouncePeerCount, &lastAnnouncePeerCount) &&
     1373            tr_variantDictFindStr  (t, TR_KEY_lastAnnounceResult, &lastAnnounceResult, NULL) &&
     1374            tr_variantDictFindInt  (t, TR_KEY_lastAnnounceStartTime, &lastAnnounceStartTime) &&
     1375            tr_variantDictFindBool (t, TR_KEY_lastAnnounceSucceeded, &lastAnnounceSucceeded) &&
     1376            tr_variantDictFindInt  (t, TR_KEY_lastAnnounceTime, &lastAnnounceTime) &&
     1377            tr_variantDictFindBool (t, TR_KEY_lastAnnounceTimedOut, &lastAnnounceTimedOut) &&
     1378            tr_variantDictFindStr  (t, TR_KEY_lastScrapeResult, &lastScrapeResult, NULL) &&
     1379            tr_variantDictFindInt  (t, TR_KEY_lastScrapeStartTime, &lastScrapeStartTime) &&
     1380            tr_variantDictFindBool (t, TR_KEY_lastScrapeSucceeded, &lastScrapeSucceeded) &&
     1381            tr_variantDictFindInt  (t, TR_KEY_lastScrapeTime, &lastScrapeTime) &&
     1382            tr_variantDictFindBool (t, TR_KEY_lastScrapeTimedOut, &lastScrapeTimedOut) &&
     1383            tr_variantDictFindInt  (t, TR_KEY_leecherCount, &leecherCount) &&
     1384            tr_variantDictFindInt  (t, TR_KEY_nextAnnounceTime, &nextAnnounceTime) &&
     1385            tr_variantDictFindInt  (t, TR_KEY_nextScrapeTime, &nextScrapeTime) &&
     1386            tr_variantDictFindInt  (t, TR_KEY_seederCount, &seederCount) &&
     1387            tr_variantDictFindInt  (t, TR_KEY_tier, &tier))
    13721388        {
    13731389            const time_t now = time (NULL);
     
    14501466printTrackers (tr_variant * top)
    14511467{
    1452     tr_variant *args, *torrents;
    1453 
    1454     if (tr_variantDictFindDict (top, "arguments", &args)
    1455       && tr_variantDictFindList (args, "torrents", &torrents))
    1456     {
    1457         int i, n;
    1458         for (i=0, n=tr_variantListSize (torrents); i<n; ++i)
    1459         {
    1460             tr_variant * trackerStats;
    1461             tr_variant * torrent = tr_variantListChild (torrents, i);
    1462             if (tr_variantDictFindList (torrent, "trackerStats", &trackerStats)) {
    1463                 printTrackersImpl (trackerStats);
    1464                 if (i+1<n)
    1465                     printf ("\n");
     1468  tr_variant *args, *torrents;
     1469
     1470  if (tr_variantDictFindDict (top, TR_KEY_arguments, &args)
     1471      && tr_variantDictFindList (args, TR_KEY_torrents, &torrents))
     1472    {
     1473      int i, n;
     1474      for (i=0, n=tr_variantListSize (torrents); i<n; ++i)
     1475        {
     1476          tr_variant * trackerStats;
     1477          tr_variant * torrent = tr_variantListChild (torrents, i);
     1478
     1479          if (tr_variantDictFindList (torrent, TR_KEY_trackerStats, &trackerStats))
     1480            {
     1481              printTrackersImpl (trackerStats);
     1482
     1483              if (i+1<n)
     1484                printf ("\n");
    14661485            }
    14671486        }
     
    14721491printSession (tr_variant * top)
    14731492{
    1474     tr_variant *args;
    1475     if ((tr_variantDictFindDict (top, "arguments", &args)))
    1476     {
    1477         int64_t i;
    1478         char buf[64];
    1479         bool boolVal;
    1480         const char * str;
    1481 
    1482         printf ("VERSION\n");
    1483         if (tr_variantDictFindStr (args,  "version", &str, NULL))
    1484             printf ("  Daemon version: %s\n", str);
    1485         if (tr_variantDictFindInt (args, "rpc-version", &i))
    1486             printf ("  RPC version: %" PRId64 "\n", i);
    1487         if (tr_variantDictFindInt (args, "rpc-version-minimum", &i))
    1488             printf ("  RPC minimum version: %" PRId64 "\n", i);
    1489         printf ("\n");
    1490 
    1491         printf ("CONFIG\n");
    1492         if (tr_variantDictFindStr (args, "config-dir", &str, NULL))
    1493             printf ("  Configuration directory: %s\n", str);
    1494         if (tr_variantDictFindStr (args,  TR_PREFS_KEY_DOWNLOAD_DIR, &str, NULL))
    1495             printf ("  Download directory: %s\n", str);
    1496         if (tr_variantDictFindInt (args,  "download-dir-free-space", &i))
    1497             printf ("  Download directory free space: %s\n",  strlsize (buf, i, sizeof buf));
    1498         if (tr_variantDictFindInt (args, TR_PREFS_KEY_PEER_PORT, &i))
    1499             printf ("  Listenport: %" PRId64 "\n", i);
    1500         if (tr_variantDictFindBool (args, TR_PREFS_KEY_PORT_FORWARDING, &boolVal))
    1501             printf ("  Portforwarding enabled: %s\n", (boolVal ? "Yes" : "No"));
    1502         if (tr_variantDictFindBool (args, TR_PREFS_KEY_UTP_ENABLED, &boolVal))
    1503             printf ("  uTP enabled: %s\n", (boolVal ? "Yes" : "No"));
    1504         if (tr_variantDictFindBool (args, TR_PREFS_KEY_DHT_ENABLED, &boolVal))
    1505             printf ("  Distributed hash table enabled: %s\n", (boolVal ? "Yes" : "No"));
    1506         if (tr_variantDictFindBool (args, TR_PREFS_KEY_LPD_ENABLED, &boolVal))
    1507             printf ("  Local peer discovery enabled: %s\n", (boolVal ? "Yes" : "No"));
    1508         if (tr_variantDictFindBool (args, TR_PREFS_KEY_PEX_ENABLED, &boolVal))
    1509             printf ("  Peer exchange allowed: %s\n", (boolVal ? "Yes" : "No"));
    1510         if (tr_variantDictFindStr (args,  TR_PREFS_KEY_ENCRYPTION, &str, NULL))
    1511             printf ("  Encryption: %s\n", str);
    1512         if (tr_variantDictFindInt (args, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, &i))
    1513             printf ("  Maximum memory cache size: %s\n", tr_formatter_mem_MB (buf, i, sizeof (buf)));
    1514         printf ("\n");
     1493  tr_variant *args;
     1494  if ((tr_variantDictFindDict (top, TR_KEY_arguments, &args)))
     1495    {
     1496      int64_t i;
     1497      char buf[64];
     1498      bool boolVal;
     1499      const char * str;
     1500
     1501      printf ("VERSION\n");
     1502      if (tr_variantDictFindStr (args, TR_KEY_version, &str, NULL))
     1503        printf ("  Daemon version: %s\n", str);
     1504      if (tr_variantDictFindInt (args, TR_KEY_rpc_version, &i))
     1505        printf ("  RPC version: %" PRId64 "\n", i);
     1506      if (tr_variantDictFindInt (args, TR_KEY_rpc_version_minimum, &i))
     1507        printf ("  RPC minimum version: %" PRId64 "\n", i);
     1508      printf ("\n");
     1509
     1510      printf ("CONFIG\n");
     1511      if (tr_variantDictFindStr (args, TR_KEY_config_dir, &str, NULL))
     1512        printf ("  Configuration directory: %s\n", str);
     1513      if (tr_variantDictFindStr (args,  TR_KEY_download_dir, &str, NULL))
     1514        printf ("  Download directory: %s\n", str);
     1515      if (tr_variantDictFindInt (args,  TR_KEY_download_dir_free_space, &i))
     1516        printf ("  Download directory free space: %s\n",  strlsize (buf, i, sizeof buf));
     1517      if (tr_variantDictFindInt (args, TR_KEY_peer_port, &i))
     1518        printf ("  Listenport: %" PRId64 "\n", i);
     1519      if (tr_variantDictFindBool (args, TR_KEY_port_forwarding_enabled, &boolVal))
     1520        printf ("  Portforwarding enabled: %s\n", (boolVal ? "Yes" : "No"));
     1521      if (tr_variantDictFindBool (args, TR_KEY_utp_enabled, &boolVal))
     1522        printf ("  uTP enabled: %s\n", (boolVal ? "Yes" : "No"));
     1523      if (tr_variantDictFindBool (args, TR_KEY_dht_enabled, &boolVal))
     1524        printf ("  Distributed hash table enabled: %s\n", (boolVal ? "Yes" : "No"));
     1525      if (tr_variantDictFindBool (args, TR_KEY_lpd_enabled, &boolVal))
     1526        printf ("  Local peer discovery enabled: %s\n", (boolVal ? "Yes" : "No"));
     1527      if (tr_variantDictFindBool (args, TR_KEY_pex_enabled, &boolVal))
     1528        printf ("  Peer exchange allowed: %s\n", (boolVal ? "Yes" : "No"));
     1529      if (tr_variantDictFindStr (args,  TR_KEY_encryption, &str, NULL))
     1530        printf ("  Encryption: %s\n", str);
     1531      if (tr_variantDictFindInt (args, TR_KEY_cache_size_mb, &i))
     1532        printf ("  Maximum memory cache size: %s\n", tr_formatter_mem_MB (buf, i, sizeof (buf)));
     1533      printf ("\n");
    15151534
    15161535        {
     
    15191538            double seedRatioLimit;
    15201539
    1521             if (tr_variantDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, &altDown) &&
    1522                 tr_variantDictFindBool (args, TR_PREFS_KEY_ALT_SPEED_ENABLED, &altEnabled) &&
    1523                 tr_variantDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &altBegin) &&
    1524                 tr_variantDictFindBool (args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &altTimeEnabled) &&
    1525                 tr_variantDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_TIME_END, &altEnd) &&
    1526                 tr_variantDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, &altDay) &&
    1527                 tr_variantDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_UP_KBps, &altUp) &&
    1528                 tr_variantDictFindInt (args, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &peerLimit) &&
    1529                 tr_variantDictFindInt (args, TR_PREFS_KEY_DSPEED_KBps, &downLimit) &&
    1530                 tr_variantDictFindBool (args, TR_PREFS_KEY_DSPEED_ENABLED, &downEnabled) &&
    1531                 tr_variantDictFindInt (args, TR_PREFS_KEY_USPEED_KBps, &upLimit) &&
    1532                 tr_variantDictFindBool (args, TR_PREFS_KEY_USPEED_ENABLED, &upEnabled) &&
    1533                 tr_variantDictFindReal (args, "seedRatioLimit", &seedRatioLimit) &&
    1534                 tr_variantDictFindBool (args, "seedRatioLimited", &seedRatioLimited))
     1540            if (tr_variantDictFindInt  (args, TR_KEY_alt_speed_down, &altDown) &&
     1541                tr_variantDictFindBool (args, TR_KEY_alt_speed_enabled, &altEnabled) &&
     1542                tr_variantDictFindInt  (args, TR_KEY_alt_speed_time_begin, &altBegin) &&
     1543                tr_variantDictFindBool (args, TR_KEY_alt_speed_time_enabled, &altTimeEnabled) &&
     1544                tr_variantDictFindInt  (args, TR_KEY_alt_speed_time_end, &altEnd) &&
     1545                tr_variantDictFindInt  (args, TR_KEY_alt_speed_time_day, &altDay) &&
     1546                tr_variantDictFindInt  (args, TR_KEY_alt_speed_up, &altUp) &&
     1547                tr_variantDictFindInt  (args, TR_KEY_peer_limit_global, &peerLimit) &&
     1548                tr_variantDictFindInt  (args, TR_KEY_speed_limit_down, &downLimit) &&
     1549                tr_variantDictFindBool (args, TR_KEY_speed_limit_down_enabled, &downEnabled) &&
     1550                tr_variantDictFindInt  (args, TR_KEY_speed_limit_up, &upLimit) &&
     1551                tr_variantDictFindBool (args, TR_KEY_speed_limit_up_enabled, &upEnabled) &&
     1552                tr_variantDictFindReal (args, TR_KEY_seedRatioLimit, &seedRatioLimit) &&
     1553                tr_variantDictFindBool (args, TR_KEY_seedRatioLimited, &seedRatioLimited))
    15351554            {
    15361555                char buf[128];
     
    15911610
    15921611        printf ("MISC\n");
    1593         if (tr_variantDictFindBool (args, TR_PREFS_KEY_START, &boolVal))
     1612        if (tr_variantDictFindBool (args, TR_KEY_start_added_torrents, &boolVal))
    15941613            printf ("  Autostart added torrents: %s\n", (boolVal ? "Yes" : "No"));
    1595         if (tr_variantDictFindBool (args, TR_PREFS_KEY_TRASH_ORIGINAL, &boolVal))
     1614        if (tr_variantDictFindBool (args, TR_KEY_trash_original_torrent_files, &boolVal))
    15961615            printf ("  Delete automatically added torrents: %s\n", (boolVal ? "Yes" : "No"));
    15971616    }
     
    16011620printSessionStats (tr_variant * top)
    16021621{
    1603     tr_variant *args, *d;
    1604     if ((tr_variantDictFindDict (top, "arguments", &args)))
    1605     {
    1606         char buf[512];
    1607         int64_t up, down, secs, sessions;
    1608 
    1609         if (tr_variantDictFindDict (args, "current-stats", &d)
    1610             && tr_variantDictFindInt (d, "uploadedBytes", &up)
    1611             && tr_variantDictFindInt (d, "downloadedBytes", &down)
    1612             && tr_variantDictFindInt (d, "secondsActive", &secs))
    1613         {
    1614             printf ("\nCURRENT SESSION\n");
    1615             printf ("  Uploaded:   %s\n", strlsize (buf, up, sizeof (buf)));
    1616             printf ("  Downloaded: %s\n", strlsize (buf, down, sizeof (buf)));
    1617             printf ("  Ratio:      %s\n", strlratio (buf, up, down, sizeof (buf)));
    1618             printf ("  Duration:   %s\n", tr_strltime (buf, secs, sizeof (buf)));
    1619         }
    1620 
    1621         if (tr_variantDictFindDict (args, "cumulative-stats", &d)
    1622             && tr_variantDictFindInt (d, "sessionCount", &sessions)
    1623             && tr_variantDictFindInt (d, "uploadedBytes", &up)
    1624             && tr_variantDictFindInt (d, "downloadedBytes", &down)
    1625             && tr_variantDictFindInt (d, "secondsActive", &secs))
    1626         {
    1627             printf ("\nTOTAL\n");
    1628             printf ("  Started %lu times\n", (unsigned long)sessions);
    1629             printf ("  Uploaded:   %s\n", strlsize (buf, up, sizeof (buf)));
    1630             printf ("  Downloaded: %s\n", strlsize (buf, down, sizeof (buf)));
    1631             printf ("  Ratio:      %s\n", strlratio (buf, up, down, sizeof (buf)));
    1632             printf ("  Duration:   %s\n", tr_strltime (buf, secs, sizeof (buf)));
     1622  tr_variant *args, *d;
     1623  if ((tr_variantDictFindDict (top, TR_KEY_arguments, &args)))
     1624    {
     1625      char buf[512];
     1626      int64_t up, down, secs, sessions;
     1627
     1628      if (tr_variantDictFindDict (args, TR_KEY_current_stats, &d)
     1629          && tr_variantDictFindInt (d, TR_KEY_uploadedBytes, &up)
     1630          && tr_variantDictFindInt (d, TR_KEY_downloadedBytes, &down)
     1631          && tr_variantDictFindInt (d, TR_KEY_secondsActive, &secs))
     1632        {
     1633          printf ("\nCURRENT SESSION\n");
     1634          printf ("  Uploaded:   %s\n", strlsize (buf, up, sizeof (buf)));
     1635          printf ("  Downloaded: %s\n", strlsize (buf, down, sizeof (buf)));
     1636          printf ("  Ratio:      %s\n", strlratio (buf, up, down, sizeof (buf)));
     1637          printf ("  Duration:   %s\n", tr_strltime (buf, secs, sizeof (buf)));
     1638        }
     1639
     1640      if (tr_variantDictFindDict (args, TR_KEY_cumulative_stats, &d)
     1641            && tr_variantDictFindInt (d, TR_KEY_sessionCount, &sessions)
     1642            && tr_variantDictFindInt (d, TR_KEY_uploadedBytes, &up)
     1643            && tr_variantDictFindInt (d, TR_KEY_downloadedBytes, &down)
     1644            && tr_variantDictFindInt (d, TR_KEY_secondsActive, &secs))
     1645        {
     1646          printf ("\nTOTAL\n");
     1647          printf ("  Started %lu times\n", (unsigned long)sessions);
     1648          printf ("  Uploaded:   %s\n", strlsize (buf, up, sizeof (buf)));
     1649          printf ("  Downloaded: %s\n", strlsize (buf, down, sizeof (buf)));
     1650          printf ("  Ratio:      %s\n", strlratio (buf, up, down, sizeof (buf)));
     1651          printf ("  Duration:   %s\n", tr_strltime (buf, secs, sizeof (buf)));
    16331652        }
    16341653    }
     
    16581677        const char * str;
    16591678
    1660         if (tr_variantDictFindStr (&top, "result", &str, NULL))
     1679        if (tr_variantDictFindStr (&top, TR_KEY_result, &str, NULL))
    16611680        {
    16621681            if (strcmp (str, "success"))
     
    16671686            else
    16681687            {
    1669         tr_variantDictFindInt (&top, "tag", &tag);
     1688        tr_variantDictFindInt (&top, TR_KEY_tag, &tag);
    16701689
    16711690        switch (tag)
     
    17021721                tr_variant * b = &top;
    17031722                if (tr_variantDictFindDict (&top, ARGUMENTS, &b)
    1704                         && tr_variantDictFindDict (b, "torrent-added", &b)
    1705                         && tr_variantDictFindInt (b, "id", &i))
     1723                        && tr_variantDictFindDict (b, TR_KEY_torrent_added, &b)
     1724                        && tr_variantDictFindInt (b, TR_KEY_id, &i))
    17061725                    tr_snprintf (id, sizeof (id), "%"PRId64, i);
    17071726                /* fall-through to default: to give success or failure msg */
    17081727            }
    17091728            default:
    1710                 if (!tr_variantDictFindStr (&top, "result", &str, NULL))
     1729                if (!tr_variantDictFindStr (&top, TR_KEY_result, &str, NULL))
    17111730                    status |= EXIT_FAILURE;
    17121731                else {
     
    18251844        *sset = tr_new0 (tr_variant, 1);
    18261845        tr_variantInitDict (*sset, 3);
    1827         tr_variantDictAddStr (*sset, "method", "session-set");
     1846        tr_variantDictAddStr (*sset, TR_KEY_method, "session-set");
    18281847        args = tr_variantDictAddDict (*sset, ARGUMENTS, 0);
    18291848    }
     
    18421861        *tset = tr_new0 (tr_variant, 1);
    18431862        tr_variantInitDict (*tset, 3);
    1844         tr_variantDictAddStr (*tset, "method", "torrent-set");
     1863        tr_variantDictAddStr (*tset, TR_KEY_method, "torrent-set");
    18451864        args = tr_variantDictAddDict (*tset, ARGUMENTS, 1);
    18461865    }
     
    18751894                    tadd = tr_new0 (tr_variant, 1);
    18761895                    tr_variantInitDict (tadd, 3);
    1877                     tr_variantDictAddStr (tadd, "method", "torrent-add");
    1878                     tr_variantDictAddInt (tadd, "tag", TAG_TORRENT_ADD);
     1896                    tr_variantDictAddStr (tadd, TR_KEY_method, "torrent-add");
     1897                    tr_variantDictAddInt (tadd, TR_KEY_tag, TAG_TORRENT_ADD);
    18791898                    tr_variantDictAddDict (tadd, ARGUMENTS, 0);
    18801899                    break;
     
    19291948                        char * tmp = getEncodedMetainfo (optarg);
    19301949                        if (tmp)
    1931                             tr_variantDictAddStr (args, "metainfo", tmp);
     1950                            tr_variantDictAddStr (args, TR_KEY_metainfo, tmp);
    19321951                        else
    1933                             tr_variantDictAddStr (args, "filename", optarg);
     1952                            tr_variantDictAddStr (args, TR_KEY_filename, optarg);
    19341953                        tr_free (tmp);
    19351954                    } else {
     
    19471966            tr_variant * fields;
    19481967            tr_variantInitDict (top, 3);
    1949             tr_variantDictAddStr (top, "method", "torrent-get");
     1968            tr_variantDictAddStr (top, TR_KEY_method, "torrent-get");
    19501969            args = tr_variantDictAddDict (top, ARGUMENTS, 0);
    1951             fields = tr_variantDictAddList (args, "fields", 0);
     1970            fields = tr_variantDictAddList (args, TR_KEY_fields, 0);
    19521971
    19531972            if (tset != 0) { addIdArg (tr_variantDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
     
    19551974            switch (c)
    19561975            {
    1957                 case 'i': tr_variantDictAddInt (top, "tag", TAG_DETAILS);
     1976                case 'i': tr_variantDictAddInt (top, TR_KEY_tag, TAG_DETAILS);
    19581977                          n = TR_N_ELEMENTS (details_keys);
    1959                           for (i=0; i<n; ++i) tr_variantListAddStr (fields, details_keys[i]);
     1978                          for (i=0; i<n; ++i) tr_variantListAddQuark (fields, details_keys[i]);
    19601979                          addIdArg (args, id);
    19611980                          break;
    1962                 case 'l': tr_variantDictAddInt (top, "tag", TAG_LIST);
     1981                case 'l': tr_variantDictAddInt (top, TR_KEY_tag, TAG_LIST);
    19631982                          n = TR_N_ELEMENTS (list_keys);
    1964                           for (i=0; i<n; ++i) tr_variantListAddStr (fields, list_keys[i]);
    1965                           break;
    1966                 case 940: tr_variantDictAddInt (top, "tag", TAG_FILES);
     1983                          for (i=0; i<n; ++i) tr_variantListAddQuark (fields, list_keys[i]);
     1984                          break;
     1985                case 940: tr_variantDictAddInt (top, TR_KEY_tag, TAG_FILES);
    19671986                          n = TR_N_ELEMENTS (files_keys);
    1968                           for (i=0; i<n; ++i) tr_variantListAddStr (fields, files_keys[i]);
     1987                          for (i=0; i<n; ++i) tr_variantListAddQuark (fields, files_keys[i]);
    19691988                          addIdArg (args, id);
    19701989                          break;
    1971                 case 941: tr_variantDictAddInt (top, "tag", TAG_PEERS);
     1990                case 941: tr_variantDictAddInt (top, TR_KEY_tag, TAG_PEERS);
    19721991                          tr_variantListAddStr (fields, "peers");
    19731992                          addIdArg (args, id);
    19741993                          break;
    1975                 case 942: tr_variantDictAddInt (top, "tag", TAG_PIECES);
     1994                case 942: tr_variantDictAddInt (top, TR_KEY_tag, TAG_PIECES);
    19761995                          tr_variantListAddStr (fields, "pieces");
    19771996                          tr_variantListAddStr (fields, "pieceCount");
    19781997                          addIdArg (args, id);
    19791998                          break;
    1980                 case 943: tr_variantDictAddInt (top, "tag", TAG_TRACKERS);
     1999                case 943: tr_variantDictAddInt (top, TR_KEY_tag, TAG_TRACKERS);
    19812000                          tr_variantListAddStr (fields, "trackerStats");
    19822001                          addIdArg (args, id);
     
    19932012            switch (c)
    19942013            {
    1995                 case 800: tr_variantDictAddStr (args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, optarg);
    1996                           tr_variantDictAddBool (args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, true);
    1997                           break;
    1998                 case 801: tr_variantDictAddBool (args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, false);
    1999                           break;
    2000                 case 970: tr_variantDictAddBool (args, TR_PREFS_KEY_ALT_SPEED_ENABLED, true);
    2001                           break;
    2002                 case 971: tr_variantDictAddBool (args, TR_PREFS_KEY_ALT_SPEED_ENABLED, false);
    2003                           break;
    2004                 case 972: tr_variantDictAddInt (args, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, numarg (optarg));
    2005                           break;
    2006                 case 973: tr_variantDictAddInt (args, TR_PREFS_KEY_ALT_SPEED_UP_KBps, numarg (optarg));
    2007                           break;
    2008                 case 974: tr_variantDictAddBool (args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, true);
    2009                           break;
    2010                 case 975: tr_variantDictAddBool (args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, false);
    2011                           break;
    2012                 case 976: addTime (args, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, optarg);
    2013                           break;
    2014                 case 977: addTime (args, TR_PREFS_KEY_ALT_SPEED_TIME_END, optarg);
    2015                           break;
    2016                 case 978: addDays (args, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, optarg);
    2017                           break;
    2018                 case 'c': tr_variantDictAddStr (args, TR_PREFS_KEY_INCOMPLETE_DIR, optarg);
    2019                           tr_variantDictAddBool (args, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, true);
    2020                           break;
    2021                 case 'C': tr_variantDictAddBool (args, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, false);
    2022                           break;
    2023                 case 'e': tr_variantDictAddInt (args, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, atoi (optarg));
    2024                           break;
    2025                 case 910: tr_variantDictAddStr (args, TR_PREFS_KEY_ENCRYPTION, "required");
    2026                           break;
    2027                 case 911: tr_variantDictAddStr (args, TR_PREFS_KEY_ENCRYPTION, "preferred");
    2028                           break;
    2029                 case 912: tr_variantDictAddStr (args, TR_PREFS_KEY_ENCRYPTION, "tolerated");
    2030                           break;
    2031                 case 'm': tr_variantDictAddBool (args, TR_PREFS_KEY_PORT_FORWARDING, true);
    2032                           break;
    2033                 case 'M': tr_variantDictAddBool (args, TR_PREFS_KEY_PORT_FORWARDING, false);
    2034                           break;
    2035                 case 'o': tr_variantDictAddBool (args, TR_PREFS_KEY_DHT_ENABLED, true);
    2036                           break;
    2037                 case 'O': tr_variantDictAddBool (args, TR_PREFS_KEY_DHT_ENABLED, false);
    2038                           break;
    2039                 case 830: tr_variantDictAddBool (args, TR_PREFS_KEY_UTP_ENABLED, true);
    2040                           break;
    2041                 case 831: tr_variantDictAddBool (args, TR_PREFS_KEY_UTP_ENABLED, false);
    2042                           break;
    2043                 case 'p': tr_variantDictAddInt (args, TR_PREFS_KEY_PEER_PORT, numarg (optarg));
    2044                           break;
    2045                 case 'P': tr_variantDictAddBool (args, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, true);
    2046                           break;
    2047                 case 'x': tr_variantDictAddBool (args, TR_PREFS_KEY_PEX_ENABLED, true);
    2048                           break;
    2049                 case 'X': tr_variantDictAddBool (args, TR_PREFS_KEY_PEX_ENABLED, false);
    2050                           break;
    2051                 case 'y': tr_variantDictAddBool (args, TR_PREFS_KEY_LPD_ENABLED, true);
    2052                           break;
    2053                 case 'Y': tr_variantDictAddBool (args, TR_PREFS_KEY_LPD_ENABLED, false);
    2054                           break;
    2055                 case 953: tr_variantDictAddReal (args, "seedRatioLimit", atof (optarg));
    2056                           tr_variantDictAddBool (args, "seedRatioLimited", true);
    2057                           break;
    2058                 case 954: tr_variantDictAddBool (args, "seedRatioLimited", false);
    2059                           break;
    2060                 case 990: tr_variantDictAddBool (args, TR_PREFS_KEY_START, false);
    2061                           break;
    2062                 case 991: tr_variantDictAddBool (args, TR_PREFS_KEY_START, true);
    2063                           break;
    2064                 case 992: tr_variantDictAddBool (args, TR_PREFS_KEY_TRASH_ORIGINAL, true);
    2065                           break;
    2066                 case 993: tr_variantDictAddBool (args, TR_PREFS_KEY_TRASH_ORIGINAL, false);
     2014                case 800: tr_variantDictAddStr (args, TR_KEY_script_torrent_done_filename, optarg);
     2015                          tr_variantDictAddBool (args, TR_KEY_script_torrent_done_enabled, true);
     2016                          break;
     2017                case 801: tr_variantDictAddBool (args, TR_KEY_script_torrent_done_enabled, false);
     2018                          break;
     2019                case 970: tr_variantDictAddBool (args, TR_KEY_alt_speed_enabled, true);
     2020                          break;
     2021                case 971: tr_variantDictAddBool (args, TR_KEY_alt_speed_enabled, false);
     2022                          break;
     2023                case 972: tr_variantDictAddInt (args, TR_KEY_alt_speed_down, numarg (optarg));
     2024                          break;
     2025                case 973: tr_variantDictAddInt (args, TR_KEY_alt_speed_up, numarg (optarg));
     2026                          break;
     2027                case 974: tr_variantDictAddBool (args, TR_KEY_alt_speed_time_enabled, true);
     2028                          break;
     2029                case 975: tr_variantDictAddBool (args, TR_KEY_alt_speed_time_enabled, false);
     2030                          break;
     2031                case 976: addTime (args, TR_KEY_alt_speed_time_begin, optarg);
     2032                          break;
     2033                case 977: addTime (args, TR_KEY_alt_speed_time_end, optarg);
     2034                          break;
     2035                case 978: addDays (args, TR_KEY_alt_speed_time_day, optarg);
     2036                          break;
     2037                case 'c': tr_variantDictAddStr (args, TR_KEY_incomplete_dir, optarg);
     2038                          tr_variantDictAddBool (args, TR_KEY_incomplete_dir_enabled, true);
     2039                          break;
     2040                case 'C': tr_variantDictAddBool (args, TR_KEY_incomplete_dir_enabled, false);
     2041                          break;
     2042                case 'e': tr_variantDictAddInt (args, TR_KEY_cache_size_mb, atoi (optarg));
     2043                          break;
     2044                case 910: tr_variantDictAddStr (args, TR_KEY_encryption, "required");
     2045                          break;
     2046                case 911: tr_variantDictAddStr (args, TR_KEY_encryption, "preferred");
     2047                          break;
     2048                case 912: tr_variantDictAddStr (args, TR_KEY_encryption, "tolerated");
     2049                          break;
     2050                case 'm': tr_variantDictAddBool (args, TR_KEY_port_forwarding_enabled, true);
     2051                          break;
     2052                case 'M': tr_variantDictAddBool (args, TR_KEY_port_forwarding_enabled, false);
     2053                          break;
     2054                case 'o': tr_variantDictAddBool (args, TR_KEY_dht_enabled, true);
     2055                          break;
     2056                case 'O': tr_variantDictAddBool (args, TR_KEY_dht_enabled, false);
     2057                          break;
     2058                case 830: tr_variantDictAddBool (args, TR_KEY_utp_enabled, true);
     2059                          break;
     2060                case 831: tr_variantDictAddBool (args, TR_KEY_utp_enabled, false);
     2061                          break;
     2062                case 'p': tr_variantDictAddInt (args, TR_KEY_peer_port, numarg (optarg));
     2063                          break;
     2064                case 'P': tr_variantDictAddBool (args, TR_KEY_peer_port_random_on_start, true);
     2065                          break;
     2066                case 'x': tr_variantDictAddBool (args, TR_KEY_pex_enabled, true);
     2067                          break;
     2068                case 'X': tr_variantDictAddBool (args, TR_KEY_pex_enabled, false);
     2069                          break;
     2070                case 'y': tr_variantDictAddBool (args, TR_KEY_lpd_enabled, true);
     2071                          break;
     2072                case 'Y': tr_variantDictAddBool (args, TR_KEY_lpd_enabled, false);
     2073                          break;
     2074                case 953: tr_variantDictAddReal (args, TR_KEY_seedRatioLimit, atof (optarg));
     2075                          tr_variantDictAddBool (args, TR_KEY_seedRatioLimited, true);
     2076                          break;
     2077                case 954: tr_variantDictAddBool (args, TR_KEY_seedRatioLimited, false);
     2078                          break;
     2079                case 990: tr_variantDictAddBool (args, TR_KEY_start_added_torrents, false);
     2080                          break;
     2081                case 991: tr_variantDictAddBool (args, TR_KEY_start_added_torrents, true);
     2082                          break;
     2083                case 992: tr_variantDictAddBool (args, TR_KEY_trash_original_torrent_files, true);
     2084                          break;
     2085                case 993: tr_variantDictAddBool (args, TR_KEY_trash_original_torrent_files, false);
    20672086                          break;
    20682087                default:  assert ("unhandled value" && 0);
     
    20832102            {
    20842103                case 'd': if (targs) {
    2085                               tr_variantDictAddInt (targs, "downloadLimit", numarg (optarg));
    2086                               tr_variantDictAddBool (targs, "downloadLimited", true);
     2104                              tr_variantDictAddInt (targs, TR_KEY_downloadLimit, numarg (optarg));
     2105                              tr_variantDictAddBool (targs, TR_KEY_downloadLimited, true);
    20872106                          } else {
    2088                               tr_variantDictAddInt (sargs, TR_PREFS_KEY_DSPEED_KBps, numarg (optarg));
    2089                               tr_variantDictAddBool (sargs, TR_PREFS_KEY_DSPEED_ENABLED, true);
     2107                              tr_variantDictAddInt (sargs, TR_KEY_speed_limit_down, numarg (optarg));
     2108                              tr_variantDictAddBool (sargs, TR_KEY_speed_limit_down_enabled, true);
    20902109                          }
    20912110                          break;
    20922111                case 'D': if (targs)
    2093                               tr_variantDictAddBool (targs, "downloadLimited", false);
     2112                              tr_variantDictAddBool (targs, TR_KEY_downloadLimited, false);
    20942113                          else
    2095                               tr_variantDictAddBool (sargs, TR_PREFS_KEY_DSPEED_ENABLED, false);
     2114                              tr_variantDictAddBool (sargs, TR_KEY_speed_limit_down_enabled, false);
    20962115                          break;
    20972116                case 'u': if (targs) {
    2098                               tr_variantDictAddInt (targs, "uploadLimit", numarg (optarg));
    2099                               tr_variantDictAddBool (targs, "uploadLimited", true);
     2117                              tr_variantDictAddInt (targs, TR_KEY_uploadLimit, numarg (optarg));
     2118                              tr_variantDictAddBool (targs, TR_KEY_uploadLimited, true);
    21002119                          } else {
    2101                               tr_variantDictAddInt (sargs, TR_PREFS_KEY_USPEED_KBps, numarg (optarg));
    2102                               tr_variantDictAddBool (sargs, TR_PREFS_KEY_USPEED_ENABLED, true);
     2120                              tr_variantDictAddInt (sargs, TR_KEY_speed_limit_up, numarg (optarg));
     2121                              tr_variantDictAddBool (sargs, TR_KEY_speed_limit_up_enabled, true);
    21032122                          }
    21042123                          break;
    21052124                case 'U': if (targs)
    2106                               tr_variantDictAddBool (targs, "uploadLimited", false);
     2125                              tr_variantDictAddBool (targs, TR_KEY_uploadLimited, false);
    21072126                          else
    2108                               tr_variantDictAddBool (sargs, TR_PREFS_KEY_USPEED_ENABLED, false);
     2127                              tr_variantDictAddBool (sargs, TR_KEY_speed_limit_up_enabled, false);
    21092128                          break;
    21102129                case 930: if (targs)
    2111                               tr_variantDictAddInt (targs, "peer-limit", atoi (optarg));
     2130                              tr_variantDictAddInt (targs, TR_KEY_peer_limit, atoi (optarg));
    21122131                          else
    2113                               tr_variantDictAddInt (sargs, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi (optarg));
     2132                              tr_variantDictAddInt (sargs, TR_KEY_peer_limit_global, atoi (optarg));
    21142133                          break;
    21152134                default:  assert ("unhandled value" && 0);
     
    21232142            switch (c)
    21242143            {
    2125                 case 712: tr_variantListAddInt (tr_variantDictAddList (args, "trackerRemove", 1), atoi (optarg));
    2126                           break;
    2127                 case 950: tr_variantDictAddReal (args, "seedRatioLimit", atof (optarg));
    2128                           tr_variantDictAddInt (args, "seedRatioMode", TR_RATIOLIMIT_SINGLE);
    2129                           break;
    2130                 case 951: tr_variantDictAddInt (args, "seedRatioMode", TR_RATIOLIMIT_GLOBAL);
    2131                           break;
    2132                 case 952: tr_variantDictAddInt (args, "seedRatioMode", TR_RATIOLIMIT_UNLIMITED);
    2133                           break;
    2134                 case 984: tr_variantDictAddBool (args, "honorsSessionLimits", true);
    2135                           break;
    2136                 case 985: tr_variantDictAddBool (args, "honorsSessionLimits", false);
     2144                case 712: tr_variantListAddInt (tr_variantDictAddList (args, TR_KEY_trackerRemove, 1), atoi (optarg));
     2145                          break;
     2146                case 950: tr_variantDictAddReal (args, TR_KEY_seedRatioLimit, atof (optarg));
     2147                          tr_variantDictAddInt (args, TR_KEY_seedRatioMode, TR_RATIOLIMIT_SINGLE);
     2148                          break;
     2149                case 951: tr_variantDictAddInt (args, TR_KEY_seedRatioMode, TR_RATIOLIMIT_GLOBAL);
     2150                          break;
     2151                case 952: tr_variantDictAddInt (args, TR_KEY_seedRatioMode, TR_RATIOLIMIT_UNLIMITED);
     2152                          break;
     2153                case 984: tr_variantDictAddBool (args, TR_KEY_honorsSessionLimits, true);
     2154                          break;
     2155                case 985: tr_variantDictAddBool (args, TR_KEY_honorsSessionLimits, false);
    21372156                          break;
    21382157                default:  assert ("unhandled value" && 0);
     
    21512170            switch (c)
    21522171            {
    2153                 case 'g': addFiles (args, "files-wanted", optarg);
    2154                           break;
    2155                 case 'G': addFiles (args, "files-unwanted", optarg);
    2156                           break;
    2157                 case 900: addFiles (args, "priority-high", optarg);
    2158                           break;
    2159                 case 901: addFiles (args, "priority-normal", optarg);
    2160                           break;
    2161                 case 902: addFiles (args, "priority-low", optarg);
    2162                           break;
    2163                 case 700: tr_variantDictAddInt (args, "bandwidthPriority",  1);
    2164                           break;
    2165                 case 701: tr_variantDictAddInt (args, "bandwidthPriority",  0);
    2166                           break;
    2167                 case 702: tr_variantDictAddInt (args, "bandwidthPriority", -1);
    2168                           break;
    2169                 case 710: tr_variantListAddStr (tr_variantDictAddList (args, "trackerAdd", 1), optarg);
     2172                case 'g': addFiles (args, TR_KEY_files_wanted, optarg);
     2173                          break;
     2174                case 'G': addFiles (args, TR_KEY_files_unwanted, optarg);
     2175                          break;
     2176                case 900: addFiles (args, TR_KEY_priority_high, optarg);
     2177                          break;
     2178                case 901: addFiles (args, TR_KEY_priority_normal, optarg);
     2179                          break;
     2180                case 902: addFiles (args, TR_KEY_priority_low, optarg);
     2181                          break;
     2182                case 700: tr_variantDictAddInt (args, TR_KEY_bandwidthPriority,  1);
     2183                          break;
     2184                case 701: tr_variantDictAddInt (args, TR_KEY_bandwidthPriority,  0);
     2185                          break;
     2186                case 702: tr_variantDictAddInt (args, TR_KEY_bandwidthPriority, -1);
     2187                          break;
     2188                case 710: tr_variantListAddStr (tr_variantDictAddList (args, TR_KEY_trackerAdd, 1), optarg);
    21702189                          break;
    21712190                default:  assert ("unhandled value" && 0);
     
    21782197            {
    21792198                tr_variant * args = tr_variantDictFind (tadd, ARGUMENTS);
    2180                 tr_variantDictAddStr (args, "download-dir", optarg);
     2199                tr_variantDictAddStr (args, TR_KEY_download_dir, optarg);
    21812200            }
    21822201            else
     
    21852204                tr_variant * top = tr_new0 (tr_variant, 1);
    21862205                tr_variantInitDict (top, 2);
    2187                 tr_variantDictAddStr (top, "method", "torrent-set-location");
     2206                tr_variantDictAddStr (top, TR_KEY_method, "torrent-set-location");
    21882207                args = tr_variantDictAddDict (top, ARGUMENTS, 3);
    2189                 tr_variantDictAddStr (args, "location", optarg);
    2190                 tr_variantDictAddBool (args, "move", false);
     2208                tr_variantDictAddStr (args, TR_KEY_location, optarg);
     2209                tr_variantDictAddBool (args, TR_KEY_move, false);
    21912210                addIdArg (args, id);
    21922211                status |= flush (rpcurl, &top);
     
    22002219                tr_variant * top = tr_new0 (tr_variant, 1);
    22012220                tr_variantInitDict (top, 2);
    2202                 tr_variantDictAddStr (top, "method", "session-get");
    2203                 tr_variantDictAddInt (top, "tag", TAG_SESSION);
     2221                tr_variantDictAddStr (top, TR_KEY_method, "session-get");
     2222                tr_variantDictAddInt (top, TR_KEY_tag, TAG_SESSION);
    22042223                status |= flush (rpcurl, &top);
    22052224                break;
     
    22082227            {
    22092228                if (tadd)
    2210                     tr_variantDictAddBool (tr_variantDictFind (tadd, "arguments"), "paused", false);
     2229                    tr_variantDictAddBool (tr_variantDictFind (tadd, TR_KEY_arguments), TR_KEY_paused, false);
    22112230                else {
    22122231                    tr_variant * top = tr_new0 (tr_variant, 1);
    22132232                    tr_variantInitDict (top, 2);
    2214                     tr_variantDictAddStr (top, "method", "torrent-start");
     2233                    tr_variantDictAddStr (top, TR_KEY_method, "torrent-start");
    22152234                    addIdArg (tr_variantDictAddDict (top, ARGUMENTS, 1), id);
    22162235                    status |= flush (rpcurl, &top);
     
    22212240            {
    22222241                if (tadd)
    2223                     tr_variantDictAddBool (tr_variantDictFind (tadd, "arguments"), "paused", true);
     2242                    tr_variantDictAddBool (tr_variantDictFind (tadd, TR_KEY_arguments), TR_KEY_paused, true);
    22242243                else {
    22252244                    tr_variant * top = tr_new0 (tr_variant, 1);
    22262245                    tr_variantInitDict (top, 2);
    2227                     tr_variantDictAddStr (top, "method", "torrent-stop");
     2246                    tr_variantDictAddStr (top, TR_KEY_method, "torrent-stop");
    22282247                    addIdArg (tr_variantDictAddDict (top, ARGUMENTS, 1), id);
    22292248                    status |= flush (rpcurl, &top);
     
    22352254                char * path = absolutify (optarg);
    22362255                if (tadd)
    2237                     tr_variantDictAddStr (tr_variantDictFind (tadd, "arguments"), "download-dir", path);
     2256                    tr_variantDictAddStr (tr_variantDictFind (tadd, TR_KEY_arguments), TR_KEY_download_dir, path);
    22382257                else {
    22392258                    tr_variant * args = ensure_sset (&sset);
    2240                     tr_variantDictAddStr (args, "download-dir", path);
     2259                    tr_variantDictAddStr (args, TR_KEY_download_dir, path);
    22412260                }
    22422261                tr_free (path);
     
    22472266                tr_variant * top = tr_new0 (tr_variant, 1);
    22482267                tr_variantInitDict (top, 1);
    2249                 tr_variantDictAddStr (top, "method", "session-close");
     2268                tr_variantDictAddStr (top, TR_KEY_method, "session-close");
    22502269                status |= flush (rpcurl, &top);
    22512270                break;
     
    22552274                tr_variant * top = tr_new0 (tr_variant, 1);
    22562275                tr_variantInitDict (top, 1);
    2257                 tr_variantDictAddStr (top, "method", "blocklist-update");
     2276                tr_variantDictAddStr (top, TR_KEY_method, "blocklist-update");
    22582277                status |= flush (rpcurl, &top);
    22592278                break;
     
    22632282                tr_variant * top = tr_new0 (tr_variant, 1);
    22642283                tr_variantInitDict (top, 2);
    2265                 tr_variantDictAddStr (top, "method", "session-stats");
    2266                 tr_variantDictAddInt (top, "tag", TAG_STATS);
     2284                tr_variantDictAddStr (top, TR_KEY_method, "session-stats");
     2285                tr_variantDictAddInt (top, TR_KEY_tag, TAG_STATS);
    22672286                status |= flush (rpcurl, &top);
    22682287                break;
     
    22722291                tr_variant * top = tr_new0 (tr_variant, 1);
    22732292                tr_variantInitDict (top, 2);
    2274                 tr_variantDictAddStr (top, "method", "port-test");
    2275                 tr_variantDictAddInt (top, "tag", TAG_PORTTEST);
     2293                tr_variantDictAddStr (top, TR_KEY_method, "port-test");
     2294                tr_variantDictAddInt (top, TR_KEY_tag, TAG_PORTTEST);
    22762295                status |= flush (rpcurl, &top);
    22772296                break;
     
    22832302                top = tr_new0 (tr_variant, 1);
    22842303                tr_variantInitDict (top, 2);
    2285                 tr_variantDictAddStr (top, "method", "torrent-reannounce");
     2304                tr_variantDictAddStr (top, TR_KEY_method, "torrent-reannounce");
    22862305                addIdArg (tr_variantDictAddDict (top, ARGUMENTS, 1), id);
    22872306                status |= flush (rpcurl, &top);
     
    22942313                top = tr_new0 (tr_variant, 1);
    22952314                tr_variantInitDict (top, 2);
    2296                 tr_variantDictAddStr (top, "method", "torrent-verify");
     2315                tr_variantDictAddStr (top, TR_KEY_method, "torrent-verify");
    22972316                addIdArg (tr_variantDictAddDict (top, ARGUMENTS, 1), id);
    22982317                status |= flush (rpcurl, &top);
     
    23052324                tr_variant * top = tr_new0 (tr_variant, 1);
    23062325                tr_variantInitDict (top, 2);
    2307                 tr_variantDictAddStr (top, "method", "torrent-remove");
     2326                tr_variantDictAddStr (top, TR_KEY_method, "torrent-remove");
    23082327                args = tr_variantDictAddDict (top, ARGUMENTS, 2);
    2309                 tr_variantDictAddBool (args, "delete-local-data", c=='R');
     2328                tr_variantDictAddBool (args, TR_KEY_delete_local_data, c=='R');
    23102329                addIdArg (args, id);
    23112330                status |= flush (rpcurl, &top);
     
    23172336                tr_variant * top = tr_new0 (tr_variant, 1);
    23182337                tr_variantInitDict (top, 2);
    2319                 tr_variantDictAddStr (top, "method", "torrent-set-location");
     2338                tr_variantDictAddStr (top, TR_KEY_method, "torrent-set-location");
    23202339                args = tr_variantDictAddDict (top, ARGUMENTS, 3);
    2321                 tr_variantDictAddStr (args, "location", optarg);
    2322                 tr_variantDictAddBool (args, "move", true);
     2340                tr_variantDictAddStr (args, TR_KEY_location, optarg);
     2341                tr_variantDictAddBool (args, TR_KEY_move, true);
    23232342                addIdArg (args, id);
    23242343                status |= flush (rpcurl, &top);
  • trunk/gtk/actions.c

    r13625 r13683  
    5656static void
    5757sort_changed_cb (GtkAction            * action UNUSED,
    58                  GtkRadioAction *              current,
    59                  gpointer user_data            UNUSED)
    60 {
    61     const char * key = PREF_KEY_SORT_MODE;
    62     const int    i = gtk_radio_action_get_current_value (current);
    63     const char * val = sort_radio_entries[i].name;
     58                 GtkRadioAction       * current,
     59                 gpointer               user_data UNUSED)
     60{
     61  const tr_quark key = TR_KEY_sort_mode;
     62  const int i = gtk_radio_action_get_current_value (current);
     63  const char * val = sort_radio_entries[i].name;
    6464
    6565    gtr_core_set_pref (myCore, key, val);
     
    7979    const gboolean val = gtk_toggle_action_get_active (action);
    8080
    81     gtr_core_set_pref_bool (myCore, key, val);
     81    gtr_core_set_pref_bool (myCore, tr_quark_new(key,-1), val);
    8282}
    8383
     
    213213    gtk_action_group_set_translation_domain (action_group, NULL);
    214214
    215 
    216     match = gtr_pref_string_get (PREF_KEY_SORT_MODE);
     215    match = gtr_pref_string_get (TR_KEY_sort_mode);
    217216    for (i = 0, n = G_N_ELEMENTS (sort_radio_entries), active = -1;
    218217         active == -1 && i < n; ++i)
     
    234233    for (i = 0, n = G_N_ELEMENTS (pref_toggle_entries); i < n; ++i)
    235234        pref_toggle_entries[i].is_active =
    236             gtr_pref_flag_get (pref_toggle_entries[i].name);
     235            gtr_pref_flag_get (tr_quark_new (pref_toggle_entries[i].name, -1));
    237236
    238237    gtk_action_group_add_toggle_actions (action_group,
  • trunk/gtk/conf.c

    r13667 r13683  
    5858***/
    5959
    60 static void cf_check_older_configs (void);
    61 
    6260/**
    6361 * This is where we initialize the preferences file with the default values.
     
    7068  const char * special_dl_dir = g_get_user_special_dir (G_USER_DIRECTORY_DOWNLOAD);
    7169
    72   cf_check_older_configs ();
    73 
    7470  str = g_get_user_special_dir (G_USER_DIRECTORY_DOWNLOAD);
    7571  if (!str)
     
    7975
    8076  tr_variantDictReserve (d, 29);
    81 
    82   tr_variantDictAddStr (d, PREF_KEY_DIR_WATCH, str);
    83   tr_variantDictAddBool (d, PREF_KEY_DIR_WATCH_ENABLED, FALSE);
    84 
    85   tr_variantDictAddBool (d, PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT, FALSE);
    86   tr_variantDictAddBool (d, PREF_KEY_INHIBIT_HIBERNATION, FALSE);
    87   tr_variantDictAddBool (d, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, TRUE);
    88 
    89   tr_variantDictAddStr (d, PREF_KEY_OPEN_DIALOG_FOLDER, g_get_home_dir ());
    90 
    91   tr_variantDictAddBool (d, PREF_KEY_TOOLBAR, TRUE);
    92   tr_variantDictAddBool (d, PREF_KEY_FILTERBAR, TRUE);
    93   tr_variantDictAddBool (d, PREF_KEY_STATUSBAR, TRUE);
    94   tr_variantDictAddBool (d, PREF_KEY_TRASH_CAN_ENABLED, TRUE);
    95   tr_variantDictAddBool (d, PREF_KEY_SHOW_TRAY_ICON, FALSE);
    96   tr_variantDictAddBool (d, PREF_KEY_SHOW_MORE_TRACKER_INFO, FALSE);
    97   tr_variantDictAddBool (d, PREF_KEY_SHOW_MORE_PEER_INFO, FALSE);
    98   tr_variantDictAddBool (d, PREF_KEY_SHOW_BACKUP_TRACKERS, FALSE);
    99   tr_variantDictAddStr (d, PREF_KEY_STATUSBAR_STATS, "total-ratio");
    100 
    101   tr_variantDictAddBool (d, PREF_KEY_TORRENT_ADDED_NOTIFICATION_ENABLED, true);
    102   tr_variantDictAddBool (d, PREF_KEY_TORRENT_COMPLETE_NOTIFICATION_ENABLED, true);
    103   tr_variantDictAddStr (d, PREF_KEY_TORRENT_COMPLETE_SOUND_COMMAND, "canberra-gtk-play -i complete-download -d 'transmission torrent downloaded'");
    104   tr_variantDictAddBool (d, PREF_KEY_TORRENT_COMPLETE_SOUND_ENABLED, true);
    105 
    106   tr_variantDictAddBool (d, PREF_KEY_OPTIONS_PROMPT, TRUE);
    107 
    108   tr_variantDictAddBool (d, PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED, FALSE);
    109   tr_variantDictAddInt (d, PREF_KEY_MAIN_WINDOW_HEIGHT, 500);
    110   tr_variantDictAddInt (d, PREF_KEY_MAIN_WINDOW_WIDTH, 300);
    111   tr_variantDictAddInt (d, PREF_KEY_MAIN_WINDOW_X, 50);
    112   tr_variantDictAddInt (d, PREF_KEY_MAIN_WINDOW_Y, 50);
    113 
    114   tr_variantDictAddStr (d, TR_PREFS_KEY_DOWNLOAD_DIR, special_dl_dir ? special_dl_dir : str);
    115 
    116   tr_variantDictAddStr (d, PREF_KEY_SORT_MODE, "sort-by-name");
    117   tr_variantDictAddBool (d, PREF_KEY_SORT_REVERSED, FALSE);
    118   tr_variantDictAddBool (d, PREF_KEY_COMPACT_VIEW, FALSE);
    119 }
    120 
    121 static char*
    122 getPrefsFilename (void)
    123 {
    124   g_assert (gl_confdir != NULL);
    125   return g_build_filename (gl_confdir, "settings.json", NULL);
     77  tr_variantDictAddStr  (d, TR_KEY_watch_dir, str);
     78  tr_variantDictAddBool (d, TR_KEY_watch_dir_enabled, FALSE);
     79  tr_variantDictAddBool (d, TR_KEY_user_has_given_informed_consent, FALSE);
     80  tr_variantDictAddBool (d, TR_KEY_inhibit_desktop_hibernation, FALSE);
     81  tr_variantDictAddBool (d, TR_KEY_blocklist_updates_enabled, TRUE);
     82  tr_variantDictAddStr  (d, TR_KEY_open_dialog_dir, g_get_home_dir ());
     83  tr_variantDictAddBool (d, TR_KEY_show_toolbar, TRUE);
     84  tr_variantDictAddBool (d, TR_KEY_show_filterbar, TRUE);
     85  tr_variantDictAddBool (d, TR_KEY_show_statusbar, TRUE);
     86  tr_variantDictAddBool (d, TR_KEY_trash_can_enabled, TRUE);
     87  tr_variantDictAddBool (d, TR_KEY_show_notification_area_icon, FALSE);
     88  tr_variantDictAddBool (d, TR_KEY_show_tracker_scrapes, FALSE);
     89  tr_variantDictAddBool (d, TR_KEY_show_extra_peer_details, FALSE);
     90  tr_variantDictAddBool (d, TR_KEY_show_backup_trackers, FALSE);
     91  tr_variantDictAddStr  (d, TR_KEY_statusbar_stats, "total-ratio");
     92  tr_variantDictAddBool (d, TR_KEY_torrent_added_notification_enabled, true);
     93  tr_variantDictAddBool (d, TR_KEY_torrent_complete_notification_enabled, true);
     94  tr_variantDictAddStr  (d, TR_KEY_torrent_complete_sound_command, "canberra-gtk-play -i complete-download -d 'transmission torrent downloaded'");
     95  tr_variantDictAddBool (d, TR_KEY_torrent_complete_sound_enabled, true);
     96  tr_variantDictAddBool (d, TR_KEY_show_options_window, TRUE);
     97  tr_variantDictAddBool (d, TR_KEY_main_window_is_maximized, FALSE);
     98  tr_variantDictAddInt  (d, TR_KEY_main_window_height, 500);
     99  tr_variantDictAddInt  (d, TR_KEY_main_window_width, 300);
     100  tr_variantDictAddInt  (d, TR_KEY_main_window_x, 50);
     101  tr_variantDictAddInt  (d, TR_KEY_main_window_y, 50);
     102  tr_variantDictAddStr  (d, TR_KEY_download_dir, special_dl_dir ? special_dl_dir : str);
     103  tr_variantDictAddStr  (d, TR_KEY_sort_mode, "sort-by-name");
     104  tr_variantDictAddBool (d, TR_KEY_sort_reversed, FALSE);
     105  tr_variantDictAddBool (d, TR_KEY_compact_view, FALSE);
    126106}
    127107
     
    154134
    155135int64_t
    156 gtr_pref_int_get (const char * key)
     136gtr_pref_int_get (const tr_quark key)
    157137{
    158138  int64_t i = 0;
     
    164144
    165145void
    166 gtr_pref_int_set (const char * key, int64_t value)
     146gtr_pref_int_set (const tr_quark key, int64_t value)
    167147{
    168148  tr_variantDictAddInt (getPrefs (), key, value);
     
    170150
    171151double
    172 gtr_pref_double_get (const char * key)
     152gtr_pref_double_get (const tr_quark key)
    173153{
    174154  double d = 0.0;
     
    180160
    181161void
    182 gtr_pref_double_set (const char * key, double value)
     162gtr_pref_double_set (const tr_quark key, double value)
    183163{
    184164  tr_variantDictAddReal (getPrefs (), key, value);
     
    190170
    191171gboolean
    192 gtr_pref_flag_get (const char * key)
     172gtr_pref_flag_get (const tr_quark key)
    193173{
    194174  bool boolVal;
     
    200180
    201181void
    202 gtr_pref_flag_set (const char * key, gboolean value)
     182gtr_pref_flag_set (const tr_quark key, gboolean value)
    203183{
    204184  tr_variantDictAddBool (getPrefs (), key, value);
     
    210190
    211191const char*
    212 gtr_pref_string_get (const char * key)
     192gtr_pref_string_get (const tr_quark key)
    213193{
    214194  const char * str = NULL;
     
    220200
    221201void
    222 gtr_pref_string_set (const char * key, const char * value)
     202gtr_pref_string_set (const tr_quark key, const char * value)
    223203{
    224204  tr_variantDictAddStr (getPrefs (), key, value);
     
    235215}
    236216
    237 /***
    238 ****
    239 ***/
    240 
    241 static char*
    242 getCompat090PrefsFilename (void)
    243 {
    244   g_assert (gl_confdir != NULL);
    245 
    246   return g_build_filename (g_get_home_dir (), ".transmission", "gtk", "prefs.ini", NULL);
    247 }
    248 
    249 static char*
    250 getCompat121PrefsFilename (void)
    251 {
    252   return g_build_filename (g_get_user_config_dir (), "transmission", "gtk", "prefs.ini", NULL);
    253 }
    254 
    255 static void
    256 translate_keyfile_to_json (const char * old_file, const char * new_file)
    257 {
    258   tr_variant    dict;
    259   GKeyFile * keyfile;
    260   gchar **   keys;
    261   gsize      i;
    262   gsize      length;
    263 
    264   static struct pref_entry {
    265     const char*   oldkey;
    266     const char*   newkey;
    267   } renamed[] = {
    268     { "default-download-directory", "download-dir"             },
    269     { "encrypted-connections-only", "encryption"               },
    270     { "listening-port",             "peer-port"                },
    271     { "nat-traversal-enabled",      "port-forwarding-enabled"  },
    272     { "open-dialog-folder",         "open-dialog-dir"          },
    273     { "watch-folder",               "watch-dir"                },
    274     { "watch-folder-enabled",       "watch-dir-enabled"        }
    275   };
    276 
    277   keyfile = g_key_file_new ();
    278   g_key_file_load_from_file (keyfile, old_file, 0, NULL);
    279   length = 0;
    280   keys = g_key_file_get_keys (keyfile, "general", &length, NULL);
    281 
    282   tr_variantInitDict (&dict, length);
    283   for (i=0; i<length; i++)
    284     {
    285       guint j;
    286       const char * key = keys[i];
    287       gchar * val = g_key_file_get_value (keyfile, "general", key, NULL);
    288 
    289       for (j=0; j<G_N_ELEMENTS (renamed); j++)
    290         if (!strcmp (renamed[j].oldkey, key))
    291           key = renamed[j].newkey;
    292 
    293       if (!strcmp (val, "true") || !strcmp (val, "false"))
    294         {
    295           tr_variantDictAddInt (&dict, key, !strcmp (val, "true"));
    296         }
    297       else
    298         {
    299           char * end;
    300           long l;
    301 
    302           errno = 0;
    303 
    304           l = strtol (val, &end, 10);
    305           if (!errno && end && !*end)
    306             tr_variantDictAddInt (&dict, key, l);
    307           else
    308             tr_variantDictAddStr (&dict, key, val);
    309         }
    310 
    311       g_free (val);
    312     }
    313 
    314   g_key_file_free (keyfile);
    315   tr_variantToFile (&dict, TR_VARIANT_FMT_JSON, new_file);
    316   tr_variantFree (&dict);
    317 }
    318 
    319 static void
    320 cf_check_older_configs (void)
    321 {
    322   char * filename = getPrefsFilename ();
    323 
    324   if (!g_file_test (filename, G_FILE_TEST_IS_REGULAR))
    325     {
    326       char * key1 = getCompat121PrefsFilename ();
    327       char * key2 = getCompat090PrefsFilename ();
    328 
    329       if (g_file_test (key1, G_FILE_TEST_IS_REGULAR))
    330         {
    331           g_message (_("Importing \"%s\""), key1);
    332           translate_keyfile_to_json (key1, filename);
    333         }
    334       else if (g_file_test (key2, G_FILE_TEST_IS_REGULAR))
    335         {
    336           g_message (_("Importing \"%s\""), key2);
    337           translate_keyfile_to_json (key2, filename);
    338         }
    339 
    340       g_free (key2);
    341       g_free (key1);
    342     }
    343 
    344   g_free (filename);
    345 }
  • trunk/gtk/conf.h

    r13667 r13683  
    2828#include <inttypes.h>
    2929#include <libtransmission/transmission.h> /* tr_variant, tr_session */
     30#include <libtransmission/quark.h>
    3031
    31 void             gtr_pref_init            (const char * config_dir);
     32void                gtr_pref_init            (const char * config_dir);
    3233
    33 int64_t          gtr_pref_int_get         (const char * key);
    34 void             gtr_pref_int_set         (const char * key, int64_t value);
     34int64_t             gtr_pref_int_get         (const tr_quark key);
     35void                gtr_pref_int_set         (const tr_quark key, int64_t value);
    3536
    36 double           gtr_pref_double_get      (const char * key);
    37 void             gtr_pref_double_set      (const char * key, double value);
     37double              gtr_pref_double_get      (const tr_quark key);
     38void                gtr_pref_double_set      (const tr_quark key, double value);
    3839
    39 gboolean         gtr_pref_flag_get        (const char * key);
    40 void             gtr_pref_flag_set        (const char * key, gboolean value);
     40gboolean            gtr_pref_flag_get        (const tr_quark key);
     41void                gtr_pref_flag_set        (const tr_quark key, gboolean value);
    4142
    42 const char*      gtr_pref_string_get      (const char * key);
    43 void             gtr_pref_string_set      (const char * key, const char * value);
     43const char*         gtr_pref_string_get      (const tr_quark key);
     44void                gtr_pref_string_set      (const tr_quark key, const char * value);
    4445
    45 void             gtr_pref_save            (tr_session *);
     46void                gtr_pref_save            (tr_session *);
    4647struct tr_variant*  gtr_pref_get_all         (void);
    4748
  • trunk/gtk/details.c

    r13677 r13683  
    316316
    317317static void
    318 torrent_set_bool (struct DetailsImpl * di, const char * key, gboolean value)
     318torrent_set_bool (struct DetailsImpl * di, const tr_quark key, gboolean value)
    319319{
    320320    GSList *l;
     
    322322
    323323    tr_variantInitDict (&top, 2);
    324     tr_variantDictAddStr (&top, "method", "torrent-set");
    325     args = tr_variantDictAddDict (&top, "arguments", 2);
     324    tr_variantDictAddStr (&top, TR_KEY_method, "torrent-set");
     325    args = tr_variantDictAddDict (&top, TR_KEY_arguments, 2);
    326326    tr_variantDictAddBool (args, key, value);
    327     ids = tr_variantDictAddList (args, "ids", g_slist_length (di->ids));
     327    ids = tr_variantDictAddList (args, TR_KEY_ids, g_slist_length (di->ids));
    328328    for (l=di->ids; l; l=l->next)
    329329        tr_variantListAddInt (ids, GPOINTER_TO_INT (l->data));
     
    334334
    335335static void
    336 torrent_set_int (struct DetailsImpl * di, const char * key, int value)
     336torrent_set_int (struct DetailsImpl * di, const tr_quark key, int value)
    337337{
    338338    GSList *l;
     
    340340
    341341    tr_variantInitDict (&top, 2);
    342     tr_variantDictAddStr (&top, "method", "torrent-set");
    343     args = tr_variantDictAddDict (&top, "arguments", 2);
     342    tr_variantDictAddStr (&top, TR_KEY_method, "torrent-set");
     343    args = tr_variantDictAddDict (&top, TR_KEY_arguments, 2);
    344344    tr_variantDictAddInt (args, key, value);
    345     ids = tr_variantDictAddList (args, "ids", g_slist_length (di->ids));
     345    ids = tr_variantDictAddList (args, TR_KEY_ids, g_slist_length (di->ids));
    346346    for (l=di->ids; l; l=l->next)
    347347        tr_variantListAddInt (ids, GPOINTER_TO_INT (l->data));
     
    352352
    353353static void
    354 torrent_set_real (struct DetailsImpl * di, const char * key, double value)
     354torrent_set_real (struct DetailsImpl * di, const tr_quark key, double value)
    355355{
    356356    GSList *l;
     
    358358
    359359    tr_variantInitDict (&top, 2);
    360     tr_variantDictAddStr (&top, "method", "torrent-set");
    361     args = tr_variantDictAddDict (&top, "arguments", 2);
     360    tr_variantDictAddStr (&top, TR_KEY_method, "torrent-set");
     361    args = tr_variantDictAddDict (&top, TR_KEY_arguments, 2);
    362362    tr_variantDictAddReal (args, key, value);
    363     ids = tr_variantDictAddList (args, "ids", g_slist_length (di->ids));
     363    ids = tr_variantDictAddList (args, TR_KEY_ids, g_slist_length (di->ids));
    364364    for (l=di->ids; l; l=l->next)
    365365        tr_variantListAddInt (ids, GPOINTER_TO_INT (l->data));
     
    372372up_speed_toggled_cb (GtkToggleButton * tb, gpointer d)
    373373{
    374     torrent_set_bool (d, "uploadLimited", gtk_toggle_button_get_active (tb));
     374    torrent_set_bool (d, TR_KEY_uploadLimited, gtk_toggle_button_get_active (tb));
    375375}
    376376
     
    378378down_speed_toggled_cb (GtkToggleButton *tb, gpointer d)
    379379{
    380     torrent_set_bool (d, "downloadLimited", gtk_toggle_button_get_active (tb));
     380    torrent_set_bool (d, TR_KEY_downloadLimited, gtk_toggle_button_get_active (tb));
    381381}
    382382
     
    384384global_speed_toggled_cb (GtkToggleButton * tb, gpointer d)
    385385{
    386     torrent_set_bool (d, "honorsSessionLimits", gtk_toggle_button_get_active (tb));
     386    torrent_set_bool (d, TR_KEY_honorsSessionLimits, gtk_toggle_button_get_active (tb));
    387387}
    388388
     
    390390up_speed_spun_cb (GtkSpinButton * s, struct DetailsImpl * di)
    391391{
    392     torrent_set_int (di, "uploadLimit", gtk_spin_button_get_value_as_int (s));
     392    torrent_set_int (di, TR_KEY_uploadLimit, gtk_spin_button_get_value_as_int (s));
    393393}
    394394
     
    396396down_speed_spun_cb (GtkSpinButton * s, struct DetailsImpl * di)
    397397{
    398     torrent_set_int (di, "downloadLimit", gtk_spin_button_get_value_as_int (s));
     398    torrent_set_int (di, TR_KEY_downloadLimit, gtk_spin_button_get_value_as_int (s));
    399399}
    400400
     
    402402idle_spun_cb (GtkSpinButton * s, struct DetailsImpl * di)
    403403{
    404     torrent_set_int (di, "seedIdleLimit", gtk_spin_button_get_value_as_int (s));
     404    torrent_set_int (di, TR_KEY_seedIdleLimit, gtk_spin_button_get_value_as_int (s));
    405405}
    406406
     
    408408ratio_spun_cb (GtkSpinButton * s, struct DetailsImpl * di)
    409409{
    410     torrent_set_real (di, "seedRatioLimit", gtk_spin_button_get_value (s));
     410    torrent_set_real (di, TR_KEY_seedRatioLimit, gtk_spin_button_get_value (s));
    411411}
    412412
     
    414414max_peers_spun_cb (GtkSpinButton * s, struct DetailsImpl * di)
    415415{
    416     torrent_set_int (di, "peer-limit", gtk_spin_button_get_value (s));
     416    torrent_set_int (di, TR_KEY_peer_limit, gtk_spin_button_get_value (s));
    417417}
    418418
     
    421421{
    422422    const tr_priority_t priority = gtr_priority_combo_get_value (combo_box);
    423     torrent_set_int (di, "bandwidthPriority", priority);
     423    torrent_set_int (di, TR_KEY_bandwidthPriority, priority);
    424424}
    425425
     
    437437onComboEnumChanged (GtkComboBox * combo_box, struct DetailsImpl * di)
    438438{
    439     const char * key = g_object_get_qdata (G_OBJECT (combo_box), ARG_KEY);
     439    const tr_quark key = GPOINTER_TO_INT (g_object_get_qdata (G_OBJECT (combo_box), ARG_KEY));
    440440    torrent_set_int (di, key, gtr_combo_box_get_active_enum (combo_box));
    441441    refresh (di);
     
    450450        _("Stop seeding at ratio:"),    TR_RATIOLIMIT_SINGLE,
    451451        NULL);
    452     g_object_set_qdata (G_OBJECT (w), ARG_KEY, (gpointer)"seedRatioMode");
     452    g_object_set_qdata (G_OBJECT (w), ARG_KEY, GINT_TO_POINTER(TR_KEY_seedRatioMode));
    453453    return w;
    454454}
     
    462462        _("Stop seeding if idle for N minutes:"), TR_IDLELIMIT_SINGLE,
    463463        NULL);
    464     g_object_set_qdata (G_OBJECT (w), ARG_KEY, (gpointer)"seedIdleMode");
     464    g_object_set_qdata (G_OBJECT (w), ARG_KEY, GINT_TO_POINTER(TR_KEY_seedIdleMode));
    465465    return w;
    466466}
     
    15111511    int i;
    15121512    int n = 0;
    1513     const bool more = gtr_pref_flag_get (PREF_KEY_SHOW_MORE_PEER_INFO);
     1513    const bool more = gtr_pref_flag_get (TR_KEY_show_extra_peer_details);
    15141514    int view_columns[32];
    15151515    GtkTreeViewColumn * c;
     
    16431643onMorePeerInfoToggled (GtkToggleButton * button, struct DetailsImpl * di)
    16441644{
    1645     const char * key = PREF_KEY_SHOW_MORE_PEER_INFO;
     1645    const tr_quark key = TR_KEY_show_extra_peer_details;
    16461646    const gboolean value = gtk_toggle_button_get_active (button);
    16471647    gtr_core_set_pref_bool (di->core, key, value);
     
    17341734    w = gtk_check_button_new_with_mnemonic (_("Show _more details"));
    17351735    di->more_peer_details_check = w;
    1736     b = gtr_pref_flag_get (PREF_KEY_SHOW_MORE_PEER_INFO);
     1736    b = gtr_pref_flag_get (TR_KEY_show_extra_peer_details);
    17371737    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), b);
    17381738    g_signal_connect (w, "toggled", G_CALLBACK (onMorePeerInfoToggled), di);
     
    20762076onScrapeToggled (GtkToggleButton * button, struct DetailsImpl * di)
    20772077{
    2078     const char * key = PREF_KEY_SHOW_MORE_TRACKER_INFO;
    2079     const gboolean value = gtk_toggle_button_get_active (button);
    2080     gtr_core_set_pref_bool (di->core, key, value);
    2081     refresh (di);
     2078  const tr_quark key = TR_KEY_show_tracker_scrapes;
     2079  const gboolean value = gtk_toggle_button_get_active (button);
     2080  gtr_core_set_pref_bool (di->core, key, value);
     2081  refresh (di);
    20822082}
    20832083
     
    20852085onBackupToggled (GtkToggleButton * button, struct DetailsImpl * di)
    20862086{
    2087     const char * key = PREF_KEY_SHOW_BACKUP_TRACKERS;
    2088     const gboolean value = gtk_toggle_button_get_active (button);
    2089     gtr_core_set_pref_bool (di->core, key, value);
    2090     refresh (di);
     2087  const tr_quark key = TR_KEY_show_backup_trackers;
     2088  const gboolean value = gtk_toggle_button_get_active (button);
     2089  gtr_core_set_pref_bool (di->core, key, value);
     2090  refresh (di);
    20912091}
    20922092
     
    24412441    w = gtk_check_button_new_with_mnemonic (_("Show _more details"));
    24422442    di->scrape_check = w;
    2443     b = gtr_pref_flag_get (PREF_KEY_SHOW_MORE_TRACKER_INFO);
     2443    b = gtr_pref_flag_get (TR_KEY_show_tracker_scrapes);
    24442444    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), b);
    24452445    g_signal_connect (w, "toggled", G_CALLBACK (onScrapeToggled), di);
     
    24482448    w = gtk_check_button_new_with_mnemonic (_("Show _backup trackers"));
    24492449    di->all_check = w;
    2450     b = gtr_pref_flag_get (PREF_KEY_SHOW_BACKUP_TRACKERS);
     2450    b = gtr_pref_flag_get (TR_KEY_show_backup_trackers);
    24512451    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), b);
    24522452    g_signal_connect (w, "toggled", G_CALLBACK (onBackupToggled), di);
  • trunk/gtk/main.c

    r13667 r13683  
    317317                            && (gdk_window_get_state (gdk_window) & GDK_WINDOW_STATE_MAXIMIZED);
    318318
    319   gtr_pref_int_set (PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED, isMaximized);
     319  gtr_pref_int_set (TR_KEY_main_window_is_maximized, isMaximized);
    320320
    321321  if (!isMaximized)
     
    324324      gtk_window_get_position (GTK_WINDOW (gtk_window), &x, &y);
    325325      gtk_window_get_size (GTK_WINDOW (gtk_window), &w, &h);
    326       gtr_pref_int_set (PREF_KEY_MAIN_WINDOW_X, x);
    327       gtr_pref_int_set (PREF_KEY_MAIN_WINDOW_Y, y);
    328       gtr_pref_int_set (PREF_KEY_MAIN_WINDOW_WIDTH, w);
    329       gtr_pref_int_set (PREF_KEY_MAIN_WINDOW_HEIGHT, h);
     326      gtr_pref_int_set (TR_KEY_main_window_x, x);
     327      gtr_pref_int_set (TR_KEY_main_window_y, y);
     328      gtr_pref_int_set (TR_KEY_main_window_width, w);
     329      gtr_pref_int_set (TR_KEY_main_window_height, h);
    330330    }
    331331}
     
    406406        tr_variant * newval;
    407407        tr_variant * oldvals = gtr_pref_get_all ();
    408         const char * key;
     408        tr_quark key;
    409409        GSList * l;
    410410        GSList * changed_keys = NULL;
     
    429429
    430430            if (changed)
    431               changed_keys = g_slist_append (changed_keys, (gpointer)key);
     431              changed_keys = g_slist_append (changed_keys, GINT_TO_POINTER(key));
    432432          }
    433433        tr_sessionGetSettings (session, oldvals);
    434434
    435435        for (l=changed_keys; l!=NULL; l=l->next)
    436           gtr_core_pref_changed (cbdata->core, l->data);
     436          gtr_core_pref_changed (cbdata->core, GPOINTER_TO_INT(l->data));
    437437
    438438        g_slist_free (changed_keys);
     
    499499
    500500  /* ensure the directories are created */
    501   if ((str = gtr_pref_string_get (TR_PREFS_KEY_DOWNLOAD_DIR)))
     501  if ((str = gtr_pref_string_get (TR_KEY_download_dir)))
    502502    g_mkdir_with_parents (str, 0777);
    503   if ((str = gtr_pref_string_get (TR_PREFS_KEY_INCOMPLETE_DIR)))
     503  if ((str = gtr_pref_string_get (TR_KEY_incomplete_dir)))
    504504    g_mkdir_with_parents (str, 0777);
    505505
     
    507507  session = tr_sessionInit ("gtk", cbdata->config_dir, TRUE, gtr_pref_get_all ());
    508508
    509   gtr_pref_flag_set (TR_PREFS_KEY_ALT_SPEED_ENABLED, tr_sessionUsesAltSpeed (session));
    510   gtr_pref_int_set (TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort (session));
     509  gtr_pref_flag_set (TR_KEY_alt_speed_enabled, tr_sessionUsesAltSpeed (session));
     510  gtr_pref_int_set  (TR_KEY_peer_port, tr_sessionGetPeerPort (session));
    511511  cbdata->core = gtr_core_new (session);
    512512
     
    528528
    529529  /* check & see if it's time to update the blocklist */
    530   if (gtr_pref_flag_get (TR_PREFS_KEY_BLOCKLIST_ENABLED))
    531     {
    532       if (gtr_pref_flag_get (PREF_KEY_BLOCKLIST_UPDATES_ENABLED))
     530  if (gtr_pref_flag_get (TR_KEY_blocklist_enabled))
     531    {
     532      if (gtr_pref_flag_get (TR_KEY_blocklist_updates_enabled))
    533533        {
    534           const int64_t last_time = gtr_pref_int_get ("blocklist-date");
     534          const int64_t last_time = gtr_pref_int_get (TR_KEY_blocklist_date);
    535535          const int SECONDS_IN_A_WEEK = 7 * 24 * 60 * 60;
    536536          const time_t now = time (NULL);
     
    562562{
    563563  struct cbdata * cbdata = gdata;
    564   const gboolean do_start = gtr_pref_flag_get (TR_PREFS_KEY_START) && !cbdata->start_paused;
    565   const gboolean do_prompt = gtr_pref_flag_get (PREF_KEY_OPTIONS_PROMPT);
     564  const gboolean do_start = gtr_pref_flag_get (TR_KEY_start_added_torrents) && !cbdata->start_paused;
     565  const gboolean do_prompt = gtr_pref_flag_get (TR_KEY_show_options_window);
    566566  const gboolean do_notify = TRUE;
    567567
     
    680680static void on_core_error (TrCore *, guint, const char *, struct cbdata *);
    681681static void on_add_torrent (TrCore *, tr_ctor *, gpointer);
    682 static void on_prefs_changed (TrCore * core, const char * key, gpointer);
     682static void on_prefs_changed (TrCore * core, const tr_quark key, gpointer);
    683683static void main_window_setup (struct cbdata * cbdata, GtkWindow * wind);
    684684static gboolean update_model_loop (gpointer gdata);
     
    689689{
    690690  if (cbdata->is_iconified)
    691     gtr_pref_flag_set (PREF_KEY_SHOW_TRAY_ICON, TRUE);
     691    gtr_pref_flag_set (TR_KEY_show_notification_area_icon, TRUE);
    692692
    693693  gtr_actions_set_core (cbdata->core);
     
    707707
    708708  /* set up the icon */
    709   on_prefs_changed (cbdata->core, PREF_KEY_SHOW_TRAY_ICON, cbdata);
     709  on_prefs_changed (cbdata->core, TR_KEY_show_notification_area_icon, cbdata);
    710710
    711711  /* start model update timer */
     
    726726    }
    727727
    728   if (!gtr_pref_flag_get (PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT))
     728  if (!gtr_pref_flag_get (TR_KEY_user_has_given_informed_consent))
    729729    {
    730730      GtkWidget * w = gtk_message_dialog_new (GTK_WINDOW (wind),
     
    741741          case GTK_RESPONSE_ACCEPT:
    742742            /* only show it once */
    743             gtr_pref_flag_set (PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT, TRUE);
     743            gtr_pref_flag_set (TR_KEY_user_has_given_informed_consent, TRUE);
    744744            gtk_widget_destroy (w);
    745745            break;
     
    765765  if (!gtk_widget_get_visible (GTK_WIDGET (window)))
    766766    {
    767       gtk_window_resize (window, gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_WIDTH),
    768                                  gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_HEIGHT));
    769       gtk_window_move (window, gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_X),
    770                                gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_Y));
     767      gtk_window_resize (window, gtr_pref_int_get (TR_KEY_main_window_width),
     768                                 gtr_pref_int_get (TR_KEY_main_window_height));
     769      gtk_window_move (window, gtr_pref_int_get (TR_KEY_main_window_x),
     770                               gtr_pref_int_get (TR_KEY_main_window_y));
    771771      gtr_widget_set_visible (GTK_WIDGET (window), TRUE);
    772772    }
     
    970970   * this seems to be necessary because changing the main window's
    971971   * child seems to unset the size */
    972   gtk_window_resize (cbdata->wind, gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_WIDTH),
    973                                    gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_HEIGHT));
    974   gtk_window_move (cbdata->wind, gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_X),
    975                                  gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_Y));
     972  gtk_window_resize (cbdata->wind, gtr_pref_int_get (TR_KEY_main_window_width),
     973                                   gtr_pref_int_get (TR_KEY_main_window_height));
     974  gtk_window_move (cbdata->wind, gtr_pref_int_get (TR_KEY_main_window_x),
     975                                 gtr_pref_int_get (TR_KEY_main_window_y));
    976976
    977977  /* shut down libT */
     
    10781078
    10791079static void
    1080 on_prefs_changed (TrCore * core UNUSED, const char * key, gpointer data)
     1080on_prefs_changed (TrCore * core UNUSED, const tr_quark key, gpointer data)
    10811081{
    10821082  struct cbdata * cbdata = data;
    10831083  tr_session * tr = gtr_core_session (cbdata->core);
    10841084
    1085   if (!strcmp (key, TR_PREFS_KEY_ENCRYPTION))
    1086     {
    1087       tr_sessionSetEncryption (tr, gtr_pref_int_get (key));
    1088     }
    1089   else if (!strcmp (key, TR_PREFS_KEY_DOWNLOAD_DIR))
    1090     {
    1091       tr_sessionSetDownloadDir (tr, gtr_pref_string_get (key));
    1092     }
    1093   else if (!strcmp (key, TR_PREFS_KEY_MSGLEVEL))
    1094     {
    1095       tr_setMessageLevel (gtr_pref_int_get (key));
    1096     }
    1097   else if (!strcmp (key, TR_PREFS_KEY_PEER_PORT))
    1098     {
    1099       tr_sessionSetPeerPort (tr, gtr_pref_int_get (key));
    1100     }
    1101   else if (!strcmp (key, TR_PREFS_KEY_BLOCKLIST_ENABLED))
    1102     {
     1085  switch (key)
     1086    {
     1087      case TR_KEY_encryption:
     1088        tr_sessionSetEncryption (tr, gtr_pref_int_get (key));
     1089        break;
     1090
     1091      case TR_KEY_download_dir:
     1092        tr_sessionSetDownloadDir (tr, gtr_pref_string_get (key));
     1093        break;
     1094
     1095      case TR_KEY_message_level:
     1096        tr_setMessageLevel (gtr_pref_int_get (key));
     1097        break;
     1098
     1099      case TR_KEY_peer_port:
     1100        tr_sessionSetPeerPort (tr, gtr_pref_int_get (key));
     1101        break;
     1102
     1103      case TR_KEY_blocklist_enabled:
    11031104        tr_blocklistSetEnabled (tr, gtr_pref_flag_get (key));
    1104     }
    1105   else if (!strcmp (key, TR_PREFS_KEY_BLOCKLIST_URL))
    1106     {
     1105        break;
     1106
     1107      case TR_KEY_blocklist_url:
    11071108        tr_blocklistSetURL (tr, gtr_pref_string_get (key));
    1108     }
    1109   else if (!strcmp (key, PREF_KEY_SHOW_TRAY_ICON))
    1110     {
    1111       const int show = gtr_pref_flag_get (key);
    1112       if (show && !cbdata->icon)
    1113         cbdata->icon = gtr_icon_new (cbdata->core);
    1114       else if (!show && cbdata->icon)
    1115         g_clear_object (&cbdata->icon);
    1116     }
    1117   else if (!strcmp (key, TR_PREFS_KEY_DSPEED_ENABLED))
    1118     {
    1119       tr_sessionLimitSpeed (tr, TR_DOWN, gtr_pref_flag_get (key));
    1120     }
    1121   else if (!strcmp (key, TR_PREFS_KEY_DSPEED_KBps))
    1122     {
    1123       tr_sessionSetSpeedLimit_KBps (tr, TR_DOWN, gtr_pref_int_get (key));
    1124     }
    1125   else if (!strcmp (key, TR_PREFS_KEY_USPEED_ENABLED))
    1126     {
    1127       tr_sessionLimitSpeed (tr, TR_UP, gtr_pref_flag_get (key));
    1128     }
    1129   else if (!strcmp (key, TR_PREFS_KEY_USPEED_KBps))
    1130     {
    1131       tr_sessionSetSpeedLimit_KBps (tr, TR_UP, gtr_pref_int_get (key));
    1132     }
    1133   else if (!strcmp (key, TR_PREFS_KEY_RATIO_ENABLED))
    1134     {
    1135       tr_sessionSetRatioLimited (tr, gtr_pref_flag_get (key));
    1136     }
    1137   else if (!strcmp (key, TR_PREFS_KEY_RATIO))
    1138     {
    1139       tr_sessionSetRatioLimit (tr, gtr_pref_double_get (key));
    1140     }
    1141   else if (!strcmp (key, TR_PREFS_KEY_IDLE_LIMIT))
    1142     {
    1143       tr_sessionSetIdleLimit (tr, gtr_pref_int_get (key));
    1144     }
    1145   else if (!strcmp (key, TR_PREFS_KEY_IDLE_LIMIT_ENABLED))
    1146     {
    1147       tr_sessionSetIdleLimited (tr, gtr_pref_flag_get (key));
    1148     }
    1149   else if (!strcmp (key, TR_PREFS_KEY_PORT_FORWARDING))
    1150     {
    1151       tr_sessionSetPortForwardingEnabled (tr, gtr_pref_flag_get (key));
    1152     }
    1153   else if (!strcmp (key, TR_PREFS_KEY_PEX_ENABLED))
    1154     {
    1155       tr_sessionSetPexEnabled (tr, gtr_pref_flag_get (key));
    1156     }
    1157   else if (!strcmp (key, TR_PREFS_KEY_RENAME_PARTIAL_FILES))
    1158     {
    1159       tr_sessionSetIncompleteFileNamingEnabled (tr, gtr_pref_flag_get (key));
    1160     }
    1161   else if (!strcmp (key, TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE))
    1162     {
    1163       tr_sessionSetQueueSize (tr, TR_DOWN, gtr_pref_int_get (key));
    1164     }
    1165   else if (!strcmp (key, TR_PREFS_KEY_QUEUE_STALLED_MINUTES))
    1166     {
    1167       tr_sessionSetQueueStalledMinutes (tr, gtr_pref_int_get (key));
    1168     }
    1169   else if (!strcmp (key, TR_PREFS_KEY_DHT_ENABLED))
    1170     {
    1171       tr_sessionSetDHTEnabled (tr, gtr_pref_flag_get (key));
    1172     }
    1173   else if (!strcmp (key, TR_PREFS_KEY_UTP_ENABLED))
    1174     {
    1175       tr_sessionSetUTPEnabled (tr, gtr_pref_flag_get (key));
    1176     }
    1177   else if (!strcmp (key, TR_PREFS_KEY_LPD_ENABLED))
    1178     {
    1179       tr_sessionSetLPDEnabled (tr, gtr_pref_flag_get (key));
    1180     }
    1181   else if (!strcmp (key, TR_PREFS_KEY_RPC_PORT))
    1182     {
    1183       tr_sessionSetRPCPort (tr, gtr_pref_int_get (key));
    1184     }
    1185   else if (!strcmp (key, TR_PREFS_KEY_RPC_ENABLED))
    1186     {
    1187       tr_sessionSetRPCEnabled (tr, gtr_pref_flag_get (key));
    1188     }
    1189   else if (!strcmp (key, TR_PREFS_KEY_RPC_WHITELIST))
    1190     {
    1191       tr_sessionSetRPCWhitelist (tr, gtr_pref_string_get (key));
    1192     }
    1193   else if (!strcmp (key, TR_PREFS_KEY_RPC_WHITELIST_ENABLED))
    1194     {
    1195       tr_sessionSetRPCWhitelistEnabled (tr, gtr_pref_flag_get (key));
    1196     }
    1197   else if (!strcmp (key, TR_PREFS_KEY_RPC_USERNAME))
    1198     {
    1199       tr_sessionSetRPCUsername (tr, gtr_pref_string_get (key));
    1200     }
    1201   else if (!strcmp (key, TR_PREFS_KEY_RPC_PASSWORD))
    1202     {
    1203       tr_sessionSetRPCPassword (tr, gtr_pref_string_get (key));
    1204     }
    1205   else if (!strcmp (key, TR_PREFS_KEY_RPC_AUTH_REQUIRED))
    1206     {
    1207       tr_sessionSetRPCPasswordEnabled (tr, gtr_pref_flag_get (key));
    1208     }
    1209   else if (!strcmp (key, TR_PREFS_KEY_ALT_SPEED_UP_KBps))
    1210     {
    1211       tr_sessionSetAltSpeed_KBps (tr, TR_UP, gtr_pref_int_get (key));
    1212     }
    1213   else if (!strcmp (key, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps))
    1214     {
     1109        break;
     1110
     1111      case TR_KEY_show_notification_area_icon:
     1112        {
     1113          const bool show = gtr_pref_flag_get (key);
     1114          if (show && !cbdata->icon)
     1115            cbdata->icon = gtr_icon_new (cbdata->core);
     1116          else if (!show && cbdata->icon)
     1117            g_clear_object (&cbdata->icon);
     1118          break;
     1119        }
     1120
     1121      case TR_KEY_speed_limit_down_enabled:
     1122        tr_sessionLimitSpeed (tr, TR_DOWN, gtr_pref_flag_get (key));
     1123        break;
     1124
     1125      case TR_KEY_speed_limit_down:
     1126        tr_sessionSetSpeedLimit_KBps (tr, TR_DOWN, gtr_pref_int_get (key));
     1127        break;
     1128
     1129      case TR_KEY_speed_limit_up_enabled:
     1130        tr_sessionLimitSpeed (tr, TR_UP, gtr_pref_flag_get (key));
     1131        break;
     1132
     1133      case TR_KEY_speed_limit_up:
     1134        tr_sessionSetSpeedLimit_KBps (tr, TR_UP, gtr_pref_int_get (key));
     1135        break;
     1136
     1137      case TR_KEY_ratio_limit_enabled:
     1138        tr_sessionSetRatioLimited (tr, gtr_pref_flag_get (key));
     1139        break;
     1140
     1141      case TR_KEY_ratio_limit:
     1142        tr_sessionSetRatioLimit (tr, gtr_pref_double_get (key));
     1143        break;
     1144
     1145      case TR_KEY_idle_seeding_limit:
     1146        tr_sessionSetIdleLimit (tr, gtr_pref_int_get (key));
     1147        break;
     1148
     1149      case TR_KEY_idle_seeding_limit_enabled:
     1150        tr_sessionSetIdleLimited (tr, gtr_pref_flag_get (key));
     1151        break;
     1152
     1153      case TR_KEY_port_forwarding_enabled:
     1154        tr_sessionSetPortForwardingEnabled (tr, gtr_pref_flag_get (key));
     1155        break;
     1156
     1157      case TR_KEY_pex_enabled:
     1158        tr_sessionSetPexEnabled (tr, gtr_pref_flag_get (key));
     1159        break;
     1160
     1161      case TR_KEY_rename_partial_files:
     1162        tr_sessionSetIncompleteFileNamingEnabled (tr, gtr_pref_flag_get (key));
     1163        break;
     1164
     1165      case TR_KEY_download_queue_size:
     1166        tr_sessionSetQueueSize (tr, TR_DOWN, gtr_pref_int_get (key));
     1167        break;
     1168
     1169      case TR_KEY_queue_stalled_minutes:
     1170        tr_sessionSetQueueStalledMinutes (tr, gtr_pref_int_get (key));
     1171        break;
     1172
     1173      case TR_KEY_dht_enabled:
     1174        tr_sessionSetDHTEnabled (tr, gtr_pref_flag_get (key));
     1175        break;
     1176
     1177      case TR_KEY_utp_enabled:
     1178        tr_sessionSetUTPEnabled (tr, gtr_pref_flag_get (key));
     1179        break;
     1180
     1181      case TR_KEY_lpd_enabled:
     1182        tr_sessionSetLPDEnabled (tr, gtr_pref_flag_get (key));
     1183        break;
     1184
     1185      case TR_KEY_rpc_port:
     1186        tr_sessionSetRPCPort (tr, gtr_pref_int_get (key));
     1187        break;
     1188
     1189      case TR_KEY_rpc_enabled:
     1190        tr_sessionSetRPCEnabled (tr, gtr_pref_flag_get (key));
     1191        break;
     1192
     1193      case TR_KEY_rpc_whitelist:
     1194        tr_sessionSetRPCWhitelist (tr, gtr_pref_string_get (key));
     1195        break;
     1196
     1197      case TR_KEY_rpc_whitelist_enabled:
     1198        tr_sessionSetRPCWhitelistEnabled (tr, gtr_pref_flag_get (key));
     1199        break;
     1200
     1201      case TR_KEY_rpc_username:
     1202        tr_sessionSetRPCUsername (tr, gtr_pref_string_get (key));
     1203        break;
     1204
     1205      case TR_KEY_rpc_password:
     1206        tr_sessionSetRPCPassword (tr, gtr_pref_string_get (key));
     1207        break;
     1208
     1209      case TR_KEY_rpc_authentication_required:
     1210        tr_sessionSetRPCPasswordEnabled (tr, gtr_pref_flag_get (key));
     1211        break;
     1212
     1213      case TR_KEY_alt_speed_up:
     1214        tr_sessionSetAltSpeed_KBps (tr, TR_UP, gtr_pref_int_get (key));
     1215        break;
     1216
     1217      case TR_KEY_alt_speed_down:
    12151218        tr_sessionSetAltSpeed_KBps (tr, TR_DOWN, gtr_pref_int_get (key));
    1216     }
    1217   else if (!strcmp (key, TR_PREFS_KEY_ALT_SPEED_ENABLED))
    1218     {
    1219       const gboolean b = gtr_pref_flag_get (key);
    1220       tr_sessionUseAltSpeed (tr, b);
    1221       gtr_action_set_toggled (key, b);
    1222     }
    1223   else if (!strcmp (key, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN))
    1224     {
    1225       tr_sessionSetAltSpeedBegin (tr, gtr_pref_int_get (key));
    1226     }
    1227   else if (!strcmp (key, TR_PREFS_KEY_ALT_SPEED_TIME_END))
    1228     {
    1229       tr_sessionSetAltSpeedEnd (tr, gtr_pref_int_get (key));
    1230     }
    1231   else if (!strcmp (key, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED))
    1232     {
    1233       tr_sessionUseAltSpeedTime (tr, gtr_pref_flag_get (key));
    1234     }
    1235   else if (!strcmp (key, TR_PREFS_KEY_ALT_SPEED_TIME_DAY))
    1236     {
    1237       tr_sessionSetAltSpeedDay (tr, gtr_pref_int_get (key));
    1238     }
    1239   else if (!strcmp (key, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START))
    1240     {
    1241       tr_sessionSetPeerPortRandomOnStart (tr, gtr_pref_flag_get (key));
    1242     }
    1243   else if (!strcmp (key, TR_PREFS_KEY_INCOMPLETE_DIR))
    1244     {
    1245       tr_sessionSetIncompleteDir (tr, gtr_pref_string_get (key));
    1246     }
    1247   else if (!strcmp (key, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED))
    1248     {
    1249       tr_sessionSetIncompleteDirEnabled (tr, gtr_pref_flag_get (key));
    1250     }
    1251   else if (!strcmp (key, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED))
    1252     {
    1253       tr_sessionSetTorrentDoneScriptEnabled (tr, gtr_pref_flag_get (key));
    1254     }
    1255   else if (!strcmp (key, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME))
    1256     {
    1257       tr_sessionSetTorrentDoneScript (tr, gtr_pref_string_get (key));
    1258     }
    1259   else if (!strcmp (key, TR_PREFS_KEY_START))
    1260     {
    1261       tr_sessionSetPaused (tr, !gtr_pref_flag_get (key));
    1262     }
    1263   else if (!strcmp (key, TR_PREFS_KEY_TRASH_ORIGINAL))
    1264     {
    1265       tr_sessionSetDeleteSource (tr, gtr_pref_flag_get (key));
     1219        break;
     1220
     1221      case TR_KEY_alt_speed_enabled:
     1222        {
     1223          const bool b = gtr_pref_flag_get (key);
     1224          tr_sessionUseAltSpeed (tr, b);
     1225          gtr_action_set_toggled (tr_quark_get_string(key,NULL), b);
     1226          break;
     1227        }
     1228
     1229      case TR_KEY_alt_speed_time_begin:
     1230        tr_sessionSetAltSpeedBegin (tr, gtr_pref_int_get (key));
     1231        break;
     1232
     1233      case TR_KEY_alt_speed_time_end:
     1234        tr_sessionSetAltSpeedEnd (tr, gtr_pref_int_get (key));
     1235        break;
     1236
     1237      case TR_KEY_alt_speed_time_enabled:
     1238        tr_sessionUseAltSpeedTime (tr, gtr_pref_flag_get (key));
     1239        break;
     1240
     1241      case TR_KEY_alt_speed_time_day:
     1242        tr_sessionSetAltSpeedDay (tr, gtr_pref_int_get (key));
     1243        break;
     1244
     1245      case TR_KEY_peer_port_random_on_start:
     1246        tr_sessionSetPeerPortRandomOnStart (tr, gtr_pref_flag_get (key));
     1247        break;
     1248
     1249      case TR_KEY_incomplete_dir:
     1250        tr_sessionSetIncompleteDir (tr, gtr_pref_string_get (key));
     1251        break;
     1252
     1253      case TR_KEY_incomplete_dir_enabled:
     1254        tr_sessionSetIncompleteDirEnabled (tr, gtr_pref_flag_get (key));
     1255        break;
     1256
     1257      case TR_KEY_script_torrent_done_enabled:
     1258        tr_sessionSetTorrentDoneScriptEnabled (tr, gtr_pref_flag_get (key));
     1259        break;
     1260
     1261      case TR_KEY_script_torrent_done_filename:
     1262        tr_sessionSetTorrentDoneScript (tr, gtr_pref_string_get (key));
     1263        break;
     1264
     1265      case TR_KEY_start_added_torrents:
     1266        tr_sessionSetPaused (tr, !gtr_pref_flag_get (key));
     1267        break;
     1268
     1269      case TR_KEY_trash_original_torrent_files:
     1270        tr_sessionSetDeleteSource (tr, gtr_pref_flag_get (key));
     1271        break;
     1272
     1273      default:
     1274        break;
    12661275    }
    12671276}
     
    13561365
    13571366  tr_variantInitDict (&top, 2);
    1358   tr_variantDictAddStr (&top, "method", method);
    1359   args = tr_variantDictAddDict (&top, "arguments", 1);
    1360   ids = tr_variantDictAddList (args, "ids", 0);
     1367  tr_variantDictAddStr (&top, TR_KEY_method, method);
     1368  args = tr_variantDictAddDict (&top, TR_KEY_arguments, 1);
     1369  ids = tr_variantDictAddList (args, TR_KEY_ids, 0);
    13611370  gtk_tree_selection_selected_foreach (s, append_id_to_benc_list, ids);
    13621371
  • trunk/gtk/msgwin.c

    r13625 r13683  
    113113
    114114  tr_setMessageLevel (level);
    115   gtr_core_set_pref_int (data->core, TR_PREFS_KEY_MSGLEVEL, level);
     115  gtr_core_set_pref_int (data->core, TR_KEY_message_level, level);
    116116  data->maxLevel = level;
    117117  gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (data->filter));
     
    441441                                          _("Debug"),       TR_MSG_DBG,
    442442                                          NULL);
    443   gtr_combo_box_set_active_enum (GTK_COMBO_BOX (w), gtr_pref_int_get (TR_PREFS_KEY_MSGLEVEL));
     443  gtr_combo_box_set_active_enum (GTK_COMBO_BOX (w), gtr_pref_int_get (TR_KEY_message_level));
    444444  return w;
    445445}
     
    533533                                        COL_SEQUENCE,
    534534                                        GTK_SORT_ASCENDING);
    535   data->maxLevel = gtr_pref_int_get (TR_PREFS_KEY_MSGLEVEL);
     535  data->maxLevel = gtr_pref_int_get (TR_KEY_message_level);
    536536  gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (data->filter),
    537537                                          isRowVisible, data, NULL);
  • trunk/gtk/notify.c

    r13626 r13683  
    193193  TrNotification * n;
    194194  tr_torrent * tor;
    195   const char * cmd = gtr_pref_string_get (PREF_KEY_TORRENT_COMPLETE_SOUND_COMMAND);
    196 
    197   if (gtr_pref_flag_get (PREF_KEY_TORRENT_COMPLETE_SOUND_ENABLED))
     195  const char * cmd = gtr_pref_string_get (TR_KEY_torrent_complete_sound_command);
     196
     197  if (gtr_pref_flag_get (TR_KEY_torrent_complete_sound_enabled))
    198198    g_spawn_command_line_async (cmd, NULL);
    199199
    200   if (!gtr_pref_flag_get (PREF_KEY_TORRENT_COMPLETE_NOTIFICATION_ENABLED))
     200  if (!gtr_pref_flag_get (TR_KEY_torrent_complete_notification_enabled))
    201201      return;
    202202
     
    244244  g_return_if_fail (G_IS_DBUS_PROXY (proxy));
    245245
    246   if (!gtr_pref_flag_get (PREF_KEY_TORRENT_ADDED_NOTIFICATION_ENABLED))
     246  if (!gtr_pref_flag_get (TR_KEY_torrent_added_notification_enabled))
    247247    return;
    248248
  • trunk/gtk/open-dialog.c

    r13625 r13683  
    4343        const char * val;
    4444        g_snprintf (key, sizeof (key), "recent-download-dir-%d", i+1);
    45         if ((val = gtr_pref_string_get (key)))
     45        if ((val = gtr_pref_string_get (tr_quark_new(key,-1))))
    4646            list = g_slist_append (list, (void*)val);
    4747    }
     
    7575        char key[64];
    7676        g_snprintf (key, sizeof (key), "recent-download-dir-%d", i + 1);
    77         gtr_pref_string_set (key, l->data);
     77        gtr_pref_string_set (tr_quark_new(key,-1), l->data);
    7878    }
    7979    gtr_pref_save (gtr_core_session (core));
     
    397397    /* remember this folder the next time we use this dialog */
    398398    folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
    399     gtr_pref_string_set (PREF_KEY_OPEN_DIALOG_FOLDER, folder);
     399    gtr_pref_string_set (TR_KEY_open_dialog_dir, folder);
    400400    g_free (folder);
    401401
     
    405405        GtkWidget       * w = gtk_file_chooser_get_extra_widget (chooser);
    406406        GtkToggleButton * tb = GTK_TOGGLE_BUTTON (w);
    407         const gboolean    do_start = gtr_pref_flag_get (TR_PREFS_KEY_START);
     407        const gboolean    do_start = gtr_pref_flag_get (TR_KEY_start_added_torrents);
    408408        const gboolean    do_prompt = gtk_toggle_button_get_active (tb);
    409409        const gboolean    do_notify = FALSE;
     
    438438    g_signal_connect (w, "response", G_CALLBACK (onOpenDialogResponse), core);
    439439
    440     if ((folder = gtr_pref_string_get (PREF_KEY_OPEN_DIALOG_FOLDER)))
     440    if ((folder = gtr_pref_string_get (TR_KEY_open_dialog_dir)))
    441441        gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w), folder);
    442442
    443443    c = gtk_check_button_new_with_mnemonic (_("Show _options dialog"));
    444444    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (c),
    445                                  gtr_pref_flag_get (PREF_KEY_OPTIONS_PROMPT));
     445                                 gtr_pref_flag_get (TR_KEY_show_options_window));
    446446    gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (w), c);
    447447    gtk_widget_show (c);
  • trunk/gtk/relocate.c

    r13625 r13683  
    173173
    174174    if (previousLocation == NULL)
    175         previousLocation = g_strdup (gtr_pref_string_get (TR_PREFS_KEY_DOWNLOAD_DIR));
     175        previousLocation = g_strdup (gtr_pref_string_get (TR_KEY_download_dir));
    176176    w = gtk_file_chooser_button_new (_("Set Torrent Location"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
    177177    gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w), previousLocation);
  • trunk/gtk/tr-core.c

    r13667 r13683  
    179179                  G_STRUCT_OFFSET (TrCoreClass, prefs_changed),
    180180                  NULL, NULL,
    181                   g_cclosure_marshal_VOID__STRING,
     181                  g_cclosure_marshal_VOID__INT,
    182182                  G_TYPE_NONE,
    183183                  1, G_TYPE_STRING);
     
    252252
    253253void
    254 gtr_core_pref_changed (TrCore * core, const char * key)
     254gtr_core_pref_changed (TrCore * core, const tr_quark key)
    255255{
    256256  g_signal_emit (core, signals[PREFS_SIGNAL], 0, key);
     
    691691  if (unchanging != NULL)
    692692    {
    693       const gboolean do_start = gtr_pref_flag_get (TR_PREFS_KEY_START);
    694       const gboolean do_prompt = gtr_pref_flag_get (PREF_KEY_OPTIONS_PROMPT);
     693      const gboolean do_start = gtr_pref_flag_get (TR_KEY_start_added_torrents);
     694      const gboolean do_prompt = gtr_pref_flag_get (TR_KEY_show_options_window);
    695695
    696696      core->priv->adding_from_watch_dir = TRUE;
     
    757757core_watchdir_scan (TrCore * core)
    758758{
    759   const char * dirname = gtr_pref_string_get (PREF_KEY_DIR_WATCH);
     759  const char * dirname = gtr_pref_string_get (TR_KEY_watch_dir);
    760760  GDir * dir = g_dir_open (dirname, 0, NULL);
    761761
     
    779779core_watchdir_update (TrCore * core)
    780780{
    781   const gboolean is_enabled = gtr_pref_flag_get (PREF_KEY_DIR_WATCH_ENABLED);
    782   GFile * dir = g_file_new_for_path (gtr_pref_string_get (PREF_KEY_DIR_WATCH));
     781  const gboolean is_enabled = gtr_pref_flag_get (TR_KEY_watch_dir_enabled);
     782  GFile * dir = g_file_new_for_path (gtr_pref_string_get (TR_KEY_watch_dir));
    783783  struct TrCorePrivate * p = core->priv;
    784784
     
    815815
    816816static void
    817 on_pref_changed (TrCore * core, const char * key, gpointer data UNUSED)
    818 {
    819   if (!strcmp (key, PREF_KEY_SORT_MODE) ||
    820       !strcmp (key, PREF_KEY_SORT_REVERSED))
    821     {
    822       const char * mode = gtr_pref_string_get (PREF_KEY_SORT_MODE);
    823       gboolean is_reversed = gtr_pref_flag_get (PREF_KEY_SORT_REVERSED);
    824       core_set_sort_mode (core, mode, is_reversed);
    825     }
    826   else if (!strcmp (key, TR_PREFS_KEY_PEER_LIMIT_GLOBAL))
    827     {
    828       tr_sessionSetPeerLimit (gtr_core_session (core),
    829                               gtr_pref_int_get (key));
    830     }
    831   else if (!strcmp (key, TR_PREFS_KEY_PEER_LIMIT_TORRENT))
    832     {
    833       tr_sessionSetPeerLimitPerTorrent (gtr_core_session (core),
    834                                         gtr_pref_int_get (key));
    835     }
    836   else if (!strcmp (key, PREF_KEY_INHIBIT_HIBERNATION))
    837     {
    838       core_maybe_inhibit_hibernation (core);
    839     }
    840   else if (!strcmp (key, PREF_KEY_DIR_WATCH)
    841         || !strcmp (key, PREF_KEY_DIR_WATCH_ENABLED))
    842     {
    843       core_watchdir_update (core);
     817on_pref_changed (TrCore * core, const tr_quark key, gpointer data UNUSED)
     818{
     819  switch (key)
     820    {
     821      case TR_KEY_sort_mode:
     822      case TR_KEY_sort_reversed:
     823        {
     824          const char * mode = gtr_pref_string_get (TR_KEY_sort_mode);
     825          const gboolean is_reversed = gtr_pref_flag_get (TR_KEY_sort_reversed);
     826          core_set_sort_mode (core, mode, is_reversed);
     827          break;
     828        }
     829
     830      case TR_KEY_peer_limit_global:
     831        tr_sessionSetPeerLimit (gtr_core_session (core), gtr_pref_int_get (key));
     832        break;
     833
     834      case TR_KEY_peer_limit_per_torrent:
     835        tr_sessionSetPeerLimitPerTorrent (gtr_core_session (core), gtr_pref_int_get (key));
     836        break;
     837
     838      case TR_KEY_inhibit_desktop_hibernation:
     839        core_maybe_inhibit_hibernation (core);
     840        break;
     841
     842      case TR_KEY_watch_dir:
     843      case TR_KEY_watch_dir_enabled:
     844        core_watchdir_update (core);
     845        break;
     846
     847      default:
     848        break;
    844849    }
    845850}
     
    857862
    858863  /* init from prefs & listen to pref changes */
    859   on_pref_changed (core, PREF_KEY_SORT_MODE, NULL);
    860   on_pref_changed (core, PREF_KEY_SORT_REVERSED, NULL);
    861   on_pref_changed (core, PREF_KEY_DIR_WATCH_ENABLED, NULL);
    862   on_pref_changed (core, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, NULL);
    863   on_pref_changed (core, PREF_KEY_INHIBIT_HIBERNATION, NULL);
     864  on_pref_changed (core, TR_KEY_sort_mode, NULL);
     865  on_pref_changed (core, TR_KEY_sort_reversed, NULL);
     866  on_pref_changed (core, TR_KEY_watch_dir_enabled, NULL);
     867  on_pref_changed (core, TR_KEY_peer_limit_global, NULL);
     868  on_pref_changed (core, TR_KEY_inhibit_desktop_hibernation, NULL);
    864869  g_signal_connect (core, "prefs-changed", G_CALLBACK (on_pref_changed), NULL);
    865870
     
    11351140{
    11361141  if (tr_ctorGetPaused (ctor, TR_FORCE, NULL))
    1137     tr_ctorSetPaused (ctor, TR_FORCE, !gtr_pref_flag_get (TR_PREFS_KEY_START));
     1142    tr_ctorSetPaused (ctor, TR_FORCE, !gtr_pref_flag_get (TR_KEY_start_added_torrents));
    11381143
    11391144  if (tr_ctorGetDeleteSource (ctor, NULL))
    1140     tr_ctorSetDeleteSource (ctor, gtr_pref_flag_get (TR_PREFS_KEY_TRASH_ORIGINAL));
     1145    tr_ctorSetDeleteSource (ctor, gtr_pref_flag_get (TR_KEY_trash_original_torrent_files));
    11411146
    11421147  if (tr_ctorGetPeerLimit (ctor, TR_FORCE, NULL))
    1143     tr_ctorSetPeerLimit (ctor, TR_FORCE, gtr_pref_int_get (TR_PREFS_KEY_PEER_LIMIT_TORRENT));
     1148    tr_ctorSetPeerLimit (ctor, TR_FORCE, gtr_pref_int_get (TR_KEY_peer_limit_per_torrent));
    11441149
    11451150  if (tr_ctorGetDownloadDir (ctor, TR_FORCE, NULL))
    1146     tr_ctorSetDownloadDir (ctor, TR_FORCE, gtr_pref_string_get (TR_PREFS_KEY_DOWNLOAD_DIR));
     1151    tr_ctorSetDownloadDir (ctor, TR_FORCE, gtr_pref_string_get (TR_KEY_download_dir));
    11471152}
    11481153
     
    11511156{
    11521157  const gboolean do_notify = FALSE;
    1153   const gboolean do_prompt = gtr_pref_flag_get (PREF_KEY_OPTIONS_PROMPT);
     1158  const gboolean do_prompt = gtr_pref_flag_get (TR_KEY_show_options_window);
    11541159  core_apply_defaults (ctor);
    11551160  core_add_ctor (core, ctor, do_prompt, do_notify);
     
    12851290{
    12861291  bool handled;
    1287   const bool do_start = gtr_pref_flag_get (TR_PREFS_KEY_START);
    1288   const bool do_prompt = gtr_pref_flag_get (PREF_KEY_OPTIONS_PROMPT);
     1292  const bool do_start = gtr_pref_flag_get (TR_KEY_start_added_torrents);
     1293  const bool do_prompt = gtr_pref_flag_get (TR_KEY_show_options_window);
    12891294  const bool do_notify = false;
    12901295
     
    13491354    tr_ctorSetPaused (ctor, TR_FORCE, TRUE);
    13501355  tr_ctorSetPeerLimit (ctor, TR_FALLBACK,
    1351                        gtr_pref_int_get (TR_PREFS_KEY_PEER_LIMIT_TORRENT));
     1356                       gtr_pref_int_get (TR_KEY_peer_limit_per_torrent));
    13521357
    13531358  torrents = tr_sessionLoadTorrents (gtr_core_session (self), ctor, &count);
     
    15991604   * (a) the "inhibit" pref is turned off OR
    16001605   * (b) there aren't any active torrents */
    1601   const gboolean hibernation_allowed = !gtr_pref_flag_get (PREF_KEY_INHIBIT_HIBERNATION)
     1606  const gboolean hibernation_allowed = !gtr_pref_flag_get (TR_KEY_inhibit_desktop_hibernation)
    16021607                                    || !gtr_core_get_active_torrent_count (core);
    16031608  gtr_core_set_hibernation_allowed (core, hibernation_allowed);
     
    16091614
    16101615static void
    1611 core_commit_prefs_change (TrCore * core, const char * key)
     1616core_commit_prefs_change (TrCore * core, const tr_quark key)
    16121617{
    16131618  gtr_core_pref_changed (core, key);
     
    16161621
    16171622void
    1618 gtr_core_set_pref (TrCore * self, const char * key, const char * newval)
     1623gtr_core_set_pref (TrCore * self, const tr_quark key, const char * newval)
    16191624{
    16201625  if (tr_strcmp0 (newval, gtr_pref_string_get (key)))
     
    16261631
    16271632void
    1628 gtr_core_set_pref_bool (TrCore * self, const char * key, gboolean newval)
     1633gtr_core_set_pref_bool (TrCore * self, const tr_quark key, gboolean newval)
    16291634{
    16301635  if (newval != gtr_pref_flag_get (key))
     
    16361641
    16371642void
    1638 gtr_core_set_pref_int (TrCore * self, const char * key, int newval)
     1643gtr_core_set_pref_int (TrCore * self, const tr_quark key, int newval)
    16391644{
    16401645  if (newval != gtr_pref_int_get (key))
     
    16461651
    16471652void
    1648 gtr_core_set_pref_double (TrCore * self, const char * key, double newval)
     1653gtr_core_set_pref_double (TrCore * self, const tr_quark key, double newval)
    16491654{
    16501655  if (gtr_compare_double (newval, gtr_pref_double_get (key), 4))
     
    16851690  tr_variantFromJson (&top, evbuffer_pullup (response, -1), evbuffer_get_length (response));
    16861691
    1687   if (tr_variantDictFindInt (&top, "tag", &intVal))
     1692  if (tr_variantDictFindInt (&top, TR_KEY_tag, &intVal))
    16881693    {
    16891694      const int tag = (int)intVal;
     
    17561761  bool is_open = FALSE;
    17571762
    1758   if (tr_variantDictFindDict (response, "arguments", &args))
    1759     tr_variantDictFindBool (args, "port-is-open", &is_open);
     1763  if (tr_variantDictFindDict (response, TR_KEY_arguments, &args))
     1764    tr_variantDictFindBool (args, TR_KEY_port_is_open, &is_open);
    17601765
    17611766  core_emit_port_tested (core, is_open);
     
    17811786  int64_t ruleCount = -1;
    17821787
    1783   if (tr_variantDictFindDict (response, "arguments", &args))
    1784     tr_variantDictFindInt (args, "blocklist-size", &ruleCount);
     1788  if (tr_variantDictFindDict (response, TR_KEY_arguments, &args))
     1789    tr_variantDictFindInt (args, TR_KEY_blocklist_size, &ruleCount);
    17851790
    17861791  if (ruleCount > 0)
    1787     gtr_pref_int_set ("blocklist-date", tr_time ());
     1792    gtr_pref_int_set (TR_KEY_blocklist_date, tr_time ());
    17881793
    17891794  core_emit_blocklist_udpated (core, ruleCount);
  • trunk/gtk/tr-core.h

    r13667 r13683  
    6060    void (* blocklist_updated)(TrCore*, int ruleCount);
    6161    void (* busy)            (TrCore*, gboolean is_busy);
    62     void (* prefs_changed)   (TrCore*, const char* key);
     62    void (* prefs_changed)   (TrCore*, const tr_quark key);
    6363    void (* port_tested)     (TrCore*, gboolean is_open);
    6464    void (* quit)            (TrCore*);
     
    8585tr_torrent *   gtr_core_find_torrent (TrCore * core, int id);
    8686
    87 void           gtr_core_pref_changed (TrCore * core, const char * key);
     87void           gtr_core_pref_changed (TrCore * core, const tr_quark key);
    8888
    8989
     
    141141**/
    142142
    143 void gtr_core_set_pref     (TrCore * self, const char * key, const char * val);
    144 void gtr_core_set_pref_bool (TrCore * self, const char * key, gboolean val);
    145 void gtr_core_set_pref_int (TrCore * self, const char * key, int val);
    146 void gtr_core_set_pref_double (TrCore * self, const char * key, double val);
     143void gtr_core_set_pref        (TrCore * self, const tr_quark key, const char * val);
     144void gtr_core_set_pref_bool   (TrCore * self, const tr_quark key, gboolean val);
     145void gtr_core_set_pref_int    (TrCore * self, const tr_quark key, int val);
     146void gtr_core_set_pref_double (TrCore * self, const tr_quark key, double val);
    147147
    148148/**
  • trunk/gtk/tr-prefs.c

    r13625 r13683  
    5252            gpointer          core)
    5353{
    54     const char *   key = g_object_get_data (G_OBJECT (w), PREF_KEY);
     54    const tr_quark key = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (w), PREF_KEY));
    5555    const gboolean flag = gtk_toggle_button_get_active (w);
    5656
     
    5959
    6060static GtkWidget*
    61 new_check_button (const char * mnemonic,
    62                   const char * key,
    63                   gpointer     core)
     61new_check_button (const char      * mnemonic,
     62                  const tr_quark    key,
     63                  gpointer          core)
    6464{
    6565    GtkWidget * w = gtk_check_button_new_with_mnemonic (mnemonic);
    66 
    67     g_object_set_data_full (G_OBJECT (w), PREF_KEY, g_strdup (
    68                                 key), g_free);
     66    g_object_set_data (G_OBJECT(w), PREF_KEY, GINT_TO_POINTER(key));
    6967    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w),
    7068                                 gtr_pref_flag_get (key));
     
    102100    {
    103101        /* update the core */
    104         const char * key = g_object_get_data (o, PREF_KEY);
     102        const tr_quark key = GPOINTER_TO_INT (g_object_get_data (o, PREF_KEY));
    105103
    106104        if (data->isDouble)
     
    158156
    159157static GtkWidget*
    160 new_spin_button (const char * key,
    161                  gpointer     core,
    162                  int          low,
    163                  int          high,
    164                  int          step)
     158new_spin_button (const tr_quark key,
     159                 gpointer        core,
     160                 int             low,
     161                 int             high,
     162                 int             step)
    165163{
    166164    GtkWidget * w = gtk_spin_button_new_with_range (low, high, step);
    167     g_object_set_data_full (G_OBJECT (w), PREF_KEY, g_strdup (key), g_free);
     165    g_object_set_data (G_OBJECT(w), PREF_KEY, GINT_TO_POINTER(key));
    168166    gtk_spin_button_set_digits (GTK_SPIN_BUTTON (w), 0);
    169167    gtk_spin_button_set_value (GTK_SPIN_BUTTON (w), gtr_pref_int_get (key));
     
    173171
    174172static GtkWidget*
    175 new_spin_button_double (const char * key,
    176                        gpointer      core,
    177                        double        low,
    178                        double        high,
    179                        double        step)
     173new_spin_button_double (const tr_quark key,
     174                        gpointer        core,
     175                        double          low,
     176                        double          high,
     177                        double          step)
    180178{
    181179    GtkWidget * w = gtk_spin_button_new_with_range (low, high, step);
    182     g_object_set_data_full (G_OBJECT (w), PREF_KEY, g_strdup (key), g_free);
     180    g_object_set_data (G_OBJECT(w), PREF_KEY, GINT_TO_POINTER(key));
    183181    gtk_spin_button_set_digits (GTK_SPIN_BUTTON (w), 2);
    184182    gtk_spin_button_set_value (GTK_SPIN_BUTTON (w), gtr_pref_double_get (key));
     
    188186
    189187static void
    190 entry_changed_cb (GtkEntry * w, gpointer   core)
    191 {
    192     const char * key = g_object_get_data (G_OBJECT (w), PREF_KEY);
    193     const char * value = gtk_entry_get_text (w);
    194 
    195     gtr_core_set_pref (TR_CORE (core), key, value);
    196 }
    197 
    198 static GtkWidget*
    199 new_entry (const char * key,
    200            gpointer     core)
    201 {
    202     GtkWidget * w = gtk_entry_new ();
    203     const char * value = gtr_pref_string_get (key);
    204 
    205     if (value)
    206         gtk_entry_set_text (GTK_ENTRY (w), value);
    207     g_object_set_data_full (G_OBJECT (w), PREF_KEY, g_strdup (
    208                                 key), g_free);
    209     g_signal_connect (w, "changed", G_CALLBACK (entry_changed_cb), core);
    210     return w;
     188entry_changed_cb (GtkEntry * w, gpointer core)
     189{
     190  const tr_quark key = GPOINTER_TO_INT (g_object_get_data (G_OBJECT(w), PREF_KEY));
     191  const char * value = gtk_entry_get_text (w);
     192
     193  gtr_core_set_pref (TR_CORE(core), key, value);
     194}
     195
     196static GtkWidget*
     197new_entry (const tr_quark key,
     198           gpointer        core)
     199{
     200  GtkWidget * w = gtk_entry_new ();
     201  const char * value = gtr_pref_string_get (key);
     202
     203  if (value)
     204    gtk_entry_set_text (GTK_ENTRY (w), value);
     205
     206  g_object_set_data (G_OBJECT (w), PREF_KEY, GINT_TO_POINTER(key));
     207  g_signal_connect (w, "changed", G_CALLBACK (entry_changed_cb), core);
     208  return w;
    211209}
    212210
     
    214212chosen_cb (GtkFileChooser * w, gpointer core)
    215213{
    216     const char * key = g_object_get_data (G_OBJECT (w), PREF_KEY);
    217     char * value = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w));
    218     gtr_core_set_pref (TR_CORE (core), key, value);
    219     g_free (value);
    220 }
    221 
    222 static GtkWidget*
    223 new_path_chooser_button (const char * key, gpointer core)
    224 {
    225     GtkWidget *  w = gtk_file_chooser_button_new (NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
    226     const char * path = gtr_pref_string_get (key);
    227     g_object_set_data_full (G_OBJECT (w), PREF_KEY, g_strdup (key), g_free);
    228     g_signal_connect (w, "selection-changed", G_CALLBACK (chosen_cb), core);
    229     if (path != NULL)
    230         gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w), path);
    231     return w;
    232 }
    233 
    234 static GtkWidget*
    235 new_file_chooser_button (const char * key, gpointer core)
    236 {
    237     GtkWidget *  w = gtk_file_chooser_button_new (NULL, GTK_FILE_CHOOSER_ACTION_OPEN);
    238     const char * path = gtr_pref_string_get (key);
    239     g_object_set_data_full (G_OBJECT (w), PREF_KEY, g_strdup (key), g_free);
    240     if (path != NULL)
    241         gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (w), path);
    242     g_signal_connect (w, "selection-changed", G_CALLBACK (chosen_cb), core);
    243     return w;
     214  const tr_quark key = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (w), PREF_KEY));
     215  char * value = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w));
     216  gtr_core_set_pref (TR_CORE (core), key, value);
     217  g_free (value);
     218}
     219
     220static GtkWidget*
     221new_path_chooser_button (const tr_quark key, gpointer core)
     222{
     223  GtkWidget *  w = gtk_file_chooser_button_new (NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
     224  const char * path = gtr_pref_string_get (key);
     225  g_object_set_data (G_OBJECT (w), PREF_KEY, GINT_TO_POINTER(key));
     226  g_signal_connect (w, "selection-changed", G_CALLBACK (chosen_cb), core);
     227
     228  if (path != NULL)
     229    gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w), path);
     230
     231  return w;
     232}
     233
     234static GtkWidget*
     235new_file_chooser_button (const tr_quark key, gpointer core)
     236{
     237  GtkWidget *  w = gtk_file_chooser_button_new (NULL, GTK_FILE_CHOOSER_ACTION_OPEN);
     238  const char * path = gtr_pref_string_get (key);
     239  g_object_set_data (G_OBJECT(w), PREF_KEY, GINT_TO_POINTER(key));
     240  if (path != NULL)
     241    gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (w), path);
     242  g_signal_connect (w, "selection-changed", G_CALLBACK (chosen_cb), core);
     243  return w;
    244244}
    245245
     
    247247target_cb (GtkWidget * tb, gpointer target)
    248248{
    249     const gboolean b = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (tb));
    250 
    251     gtk_widget_set_sensitive (GTK_WIDGET (target), b);
     249  const gboolean b = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (tb));
     250
     251  gtk_widget_set_sensitive (GTK_WIDGET (target), b);
    252252}
    253253
     
    269269    hig_workarea_add_section_title (t, &row, _("Location"));
    270270
    271     w = new_path_chooser_button (TR_PREFS_KEY_DOWNLOAD_DIR, core);
     271    w = new_path_chooser_button (TR_KEY_download_dir, core);
    272272    hig_workarea_add_row (t, &row, _("Save to _Location:"), w, NULL);
    273273
     
    276276
    277277    s = _("Maximum active _downloads:");
    278     w = new_spin_button (TR_PREFS_KEY_DOWNLOAD_QUEUE_SIZE, core, 0, INT_MAX, 1);
     278    w = new_spin_button (TR_KEY_download_queue_size, core, 0, INT_MAX, 1);
    279279    hig_workarea_add_row (t, &row, s, w, NULL);
    280280
    281281    s = _("Downloads sharing data in the last N minutes are _active:");
    282     w = new_spin_button (TR_PREFS_KEY_QUEUE_STALLED_MINUTES, core, 1, INT_MAX, 15);
     282    w = new_spin_button (TR_KEY_queue_stalled_minutes, core, 1, INT_MAX, 15);
    283283    hig_workarea_add_row (t, &row, s, w, NULL);
    284284
     
    287287
    288288    s = _("Append \"._part\" to incomplete files' names");
    289     w = new_check_button (s, TR_PREFS_KEY_RENAME_PARTIAL_FILES, core);
     289    w = new_check_button (s, TR_KEY_rename_partial_files, core);
    290290    hig_workarea_add_wide_control (t, &row, w);
    291291
    292292    s = _("Keep _incomplete torrents in:");
    293     l = new_check_button (s, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, core);
    294     w = new_path_chooser_button (TR_PREFS_KEY_INCOMPLETE_DIR, core);
    295     gtk_widget_set_sensitive (GTK_WIDGET (w), gtr_pref_flag_get (TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED));
     293    l = new_check_button (s, TR_KEY_incomplete_dir_enabled, core);
     294    w = new_path_chooser_button (TR_KEY_incomplete_dir, core);
     295    gtk_widget_set_sensitive (GTK_WIDGET (w), gtr_pref_flag_get (TR_KEY_incomplete_dir_enabled));
    296296    g_signal_connect (l, "toggled", G_CALLBACK (target_cb), w);
    297297    hig_workarea_add_row_w (t, &row, l, w, NULL);
    298298
    299299    s = _("Call _script when torrent is completed:");
    300     l = new_check_button (s, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, core);
    301     w = new_file_chooser_button (TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, core);
    302     gtk_widget_set_sensitive (GTK_WIDGET (w), gtr_pref_flag_get (TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED));
     300    l = new_check_button (s, TR_KEY_script_torrent_done_enabled, core);
     301    w = new_file_chooser_button (TR_KEY_script_torrent_done_filename, core);
     302    gtk_widget_set_sensitive (GTK_WIDGET (w), gtr_pref_flag_get (TR_KEY_script_torrent_done_enabled));
    303303    g_signal_connect (l, "toggled", G_CALLBACK (target_cb), w);
    304304    hig_workarea_add_row_w (t, &row, l, w, NULL);
     
    325325
    326326    s = _("_Start when added");
    327     w = new_check_button (s, TR_PREFS_KEY_START, core);
     327    w = new_check_button (s, TR_KEY_start_added_torrents, core);
    328328    hig_workarea_add_wide_control (t, &row, w);
    329329
    330330    s = _("Show _options dialog");
    331     w = new_check_button (s, PREF_KEY_OPTIONS_PROMPT, core);
     331    w = new_check_button (s, TR_KEY_show_options_window, core);
    332332    hig_workarea_add_wide_control (t, &row, w);
    333333
    334334    s = _("Mo_ve .torrent file to the trash");
    335     w = new_check_button (s, TR_PREFS_KEY_TRASH_ORIGINAL, core);
     335    w = new_check_button (s, TR_KEY_trash_original_torrent_files, core);
    336336    hig_workarea_add_wide_control (t, &row, w);
    337337
    338338    s = _("Automatically _add torrents from:");
    339     l = new_check_button (s, PREF_KEY_DIR_WATCH_ENABLED, core);
    340     w = new_path_chooser_button (PREF_KEY_DIR_WATCH, core);
    341     gtk_widget_set_sensitive (GTK_WIDGET (w), gtr_pref_flag_get (PREF_KEY_DIR_WATCH_ENABLED));
     339    l = new_check_button (s, TR_KEY_watch_dir_enabled, core);
     340    w = new_path_chooser_button (TR_KEY_watch_dir, core);
     341    gtk_widget_set_sensitive (GTK_WIDGET (w), gtr_pref_flag_get (TR_KEY_watch_dir_enabled));
    342342    g_signal_connect (l, "toggled", G_CALLBACK (target_cb), w);
    343343    hig_workarea_add_row_w (t, &row, l, w, NULL);
     
    347347
    348348    s = _("Stop seeding at _ratio:");
    349     w = new_check_button (s, TR_PREFS_KEY_RATIO_ENABLED, core);
    350     w2 = new_spin_button_double (TR_PREFS_KEY_RATIO, core, 0, 1000, .05);
    351     gtk_widget_set_sensitive (GTK_WIDGET (w2), gtr_pref_flag_get (TR_PREFS_KEY_RATIO_ENABLED));
     349    w = new_check_button (s, TR_KEY_ratio_limit_enabled, core);
     350    w2 = new_spin_button_double (TR_KEY_ratio_limit, core, 0, 1000, .05);
     351    gtk_widget_set_sensitive (GTK_WIDGET (w2), gtr_pref_flag_get (TR_KEY_ratio_limit_enabled));
    352352    g_signal_connect (w, "toggled", G_CALLBACK (target_cb), w2);
    353353    hig_workarea_add_row_w (t, &row, w, w2, NULL);
    354354
    355355    s = _("Stop seeding if idle for _N minutes:");
    356     w = new_check_button (s, TR_PREFS_KEY_IDLE_LIMIT_ENABLED, core);
    357     w2 = new_spin_button (TR_PREFS_KEY_IDLE_LIMIT, core, 1, 9999, 5);
    358     gtk_widget_set_sensitive (GTK_WIDGET (w2), gtr_pref_flag_get (TR_PREFS_KEY_IDLE_LIMIT_ENABLED));
     356    w = new_check_button (s, TR_KEY_idle_seeding_limit_enabled, core);
     357    w2 = new_spin_button (TR_KEY_idle_seeding_limit, core, 1, 9999, 5);
     358    gtk_widget_set_sensitive (GTK_WIDGET (w2), gtr_pref_flag_get (TR_KEY_idle_seeding_limit_enabled));
    359359    g_signal_connect (w, "toggled", G_CALLBACK (target_cb), w2);
    360360    hig_workarea_add_row_w (t, &row, w, w2, NULL);
     
    379379
    380380    s = _("_Inhibit hibernation when torrents are active");
    381     w = new_check_button (s, PREF_KEY_INHIBIT_HIBERNATION, core);
     381    w = new_check_button (s, TR_KEY_inhibit_desktop_hibernation, core);
    382382    hig_workarea_add_wide_control (t, &row, w);
    383383
    384384    s = _("Show Transmission icon in the _notification area");
    385     w = new_check_button (s, PREF_KEY_SHOW_TRAY_ICON, core);
     385    w = new_check_button (s, TR_KEY_show_notification_area_icon, core);
    386386    hig_workarea_add_wide_control (t, &row, w);
    387387
     
    390390
    391391    s = _("Show a notification when torrents are a_dded");
    392     w = new_check_button (s, PREF_KEY_TORRENT_ADDED_NOTIFICATION_ENABLED, core);
     392    w = new_check_button (s, TR_KEY_torrent_added_notification_enabled, core);
    393393    hig_workarea_add_wide_control (t, &row, w);
    394394
    395395    s = _("Show a notification when torrents _finish");
    396     w = new_check_button (s, PREF_KEY_TORRENT_COMPLETE_NOTIFICATION_ENABLED, core);
     396    w = new_check_button (s, TR_KEY_torrent_complete_notification_enabled, core);
    397397    hig_workarea_add_wide_control (t, &row, w);
    398398
    399399    s = _("Play a _sound when torrents finish");
    400     w = new_check_button (s, PREF_KEY_TORRENT_COMPLETE_SOUND_ENABLED, core);
     400    w = new_check_button (s, TR_KEY_torrent_complete_sound_enabled, core);
    401401    hig_workarea_add_wide_control (t, &row, w);
    402402
     
    490490on_blocklist_url_changed (GtkEditable * e, gpointer gbutton)
    491491{
    492     gchar * url = gtk_editable_get_chars (e, 0, -1);
    493     const gboolean err = tr_urlParse (url, -1, NULL, NULL, NULL, NULL);
    494     gtk_widget_set_sensitive (GTK_WIDGET (gbutton), !err);
    495     g_free (url);
     492  gchar * url = gtk_editable_get_chars (e, 0, -1);
     493  const gboolean err = tr_urlParse (url, -1, NULL, NULL, NULL, NULL);
     494  gtk_widget_set_sensitive (GTK_WIDGET (gbutton), !err);
     495  g_free (url);
    496496}
    497497
     
    499499onIntComboChanged (GtkComboBox * combo_box, gpointer core)
    500500{
    501     const int val = gtr_combo_box_get_active_enum (combo_box);
    502     const char * key = g_object_get_data (G_OBJECT (combo_box), PREF_KEY);
    503     gtr_core_set_pref_int (TR_CORE (core), key, val);
    504 }
    505 
    506 static GtkWidget*
    507 new_encryption_combo (GObject * core, const char * key)
    508 {
    509     GtkWidget * w = gtr_combo_box_new_enum (_("Allow encryption"),   TR_CLEAR_PREFERRED,
    510                                             _("Prefer encryption"),  TR_ENCRYPTION_PREFERRED,
    511                                             _("Require encryption"), TR_ENCRYPTION_REQUIRED,
    512                                             NULL);
    513     gtr_combo_box_set_active_enum (GTK_COMBO_BOX (w), gtr_pref_int_get (key));
    514     g_object_set_data_full (G_OBJECT (w), PREF_KEY, tr_strdup (key), g_free);
    515     g_signal_connect (w, "changed", G_CALLBACK (onIntComboChanged), core);
    516     return w;
     501  const int val = gtr_combo_box_get_active_enum (combo_box);
     502  const tr_quark key = GPOINTER_TO_INT (g_object_get_data (G_OBJECT(combo_box), PREF_KEY));
     503  gtr_core_set_pref_int (TR_CORE (core), key, val);
     504}
     505
     506static GtkWidget*
     507new_encryption_combo (GObject * core, const tr_quark key)
     508{
     509  GtkWidget * w = gtr_combo_box_new_enum (_("Allow encryption"),   TR_CLEAR_PREFERRED,
     510                                          _("Prefer encryption"),  TR_ENCRYPTION_PREFERRED,
     511                                          _("Require encryption"), TR_ENCRYPTION_REQUIRED,
     512                                          NULL);
     513  gtr_combo_box_set_active_enum (GTK_COMBO_BOX (w), gtr_pref_int_get (key));
     514  g_object_set_data (G_OBJECT (w), PREF_KEY, GINT_TO_POINTER(key));
     515  g_signal_connect (w, "changed", G_CALLBACK (onIntComboChanged), core);
     516  return w;
    517517}
    518518
     
    535535    hig_workarea_add_section_title (t, &row, _("Blocklist"));
    536536
    537     b = new_check_button (_("Enable _blocklist:"), TR_PREFS_KEY_BLOCKLIST_ENABLED, core);
    538     e = new_entry (TR_PREFS_KEY_BLOCKLIST_URL, core);
     537    b = new_check_button (_("Enable _blocklist:"), TR_KEY_blocklist_enabled, core);
     538    e = new_entry (TR_KEY_blocklist_url, core);
    539539    gtk_widget_set_size_request (e, 300, -1);
    540540    hig_workarea_add_row_w (t, &row, b, e, NULL);
     
    560560
    561561    s = _("Enable _automatic updates");
    562     w = new_check_button (s, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, core);
     562    w = new_check_button (s, TR_KEY_blocklist_updates_enabled, core);
    563563    hig_workarea_add_wide_control (t, &row, w);
    564564    g_signal_connect (data->check, "toggled", G_CALLBACK (target_cb), w); target_cb (data->check, w);
     
    568568
    569569    s = _("_Encryption mode:");
    570     w = new_encryption_combo (core, "encryption");
     570    w = new_encryption_combo (core, TR_KEY_encryption);
    571571    hig_workarea_add_row (t, &row, s, w, NULL);
    572572
    573573    s = _("Use PE_X to find more peers");
    574     w = new_check_button (s, TR_PREFS_KEY_PEX_ENABLED, core);
     574    w = new_check_button (s, TR_KEY_pex_enabled, core);
    575575    s = _("PEX is a tool for exchanging peer lists with the peers you're connected to.");
    576576    gtk_widget_set_tooltip_text (w, s);
     
    578578
    579579    s = _("Use _DHT to find more peers");
    580     w = new_check_button (s, TR_PREFS_KEY_DHT_ENABLED, core);
     580    w = new_check_button (s, TR_KEY_dht_enabled, core);
    581581    s = _("DHT is a tool for finding peers without a tracker.");
    582582    gtk_widget_set_tooltip_text (w, s);
     
    584584
    585585    s = _("Use _Local Peer Discovery to find more peers");
    586     w = new_check_button (s, TR_PREFS_KEY_LPD_ENABLED, core);
     586    w = new_check_button (s, TR_KEY_lpd_enabled, core);
    587587    s = _("LPD is a tool for finding peers on your local network.");
    588588    gtk_widget_set_tooltip_text (w, s);
     
    660660    g_string_truncate (gstr, gstr->len - 1); /* remove the trailing comma */
    661661
    662     gtr_core_set_pref (page->core, TR_PREFS_KEY_RPC_WHITELIST, gstr->str);
     662    gtr_core_set_pref (page->core, TR_KEY_rpc_whitelist, gstr->str);
    663663
    664664    g_string_free (gstr, TRUE);
     
    768768onLaunchClutchCB (GtkButton * w UNUSED, gpointer data UNUSED)
    769769{
    770     const int port = gtr_pref_int_get (TR_PREFS_KEY_RPC_PORT);
    771     char * uri = g_strdup_printf ("http://localhost:%d/", port);
    772 
    773     gtr_open_uri (uri);
    774     g_free (uri);
     770  char * uri;
     771  const int port = gtr_pref_int_get (TR_KEY_rpc_port);
     772
     773  uri = g_strdup_printf ("http://localhost:%d/", port);
     774  gtr_open_uri (uri);
     775  g_free (uri);
    775776}
    776777
     
    805806    /* "enabled" checkbutton */
    806807    s = _("_Enable web client");
    807     w = new_check_button (s, TR_PREFS_KEY_RPC_ENABLED, core);
     808    w = new_check_button (s, TR_KEY_rpc_enabled, core);
    808809    page->rpc_tb = GTK_TOGGLE_BUTTON (w);
    809810    g_signal_connect (w, "clicked", G_CALLBACK (onRPCToggled), page);
     
    817818
    818819    /* port */
    819     w = new_spin_button (TR_PREFS_KEY_RPC_PORT, core, 0, USHRT_MAX, 1);
     820    w = new_spin_button (TR_KEY_rpc_port, core, 0, USHRT_MAX, 1);
    820821    page->widgets = g_slist_prepend (page->widgets, w);
    821822    w = hig_workarea_add_row (t, &row, _("HTTP _port:"), w, NULL);
     
    824825    /* require authentication */
    825826    s = _("Use _authentication");
    826     w = new_check_button (s, TR_PREFS_KEY_RPC_AUTH_REQUIRED, core);
     827    w = new_check_button (s, TR_KEY_rpc_authentication_required, core);
    827828    hig_workarea_add_wide_control (t, &row, w);
    828829    page->auth_tb = GTK_TOGGLE_BUTTON (w);
     
    832833    /* username */
    833834    s = _("_Username:");
    834     w = new_entry (TR_PREFS_KEY_RPC_USERNAME, core);
     835    w = new_entry (TR_KEY_rpc_username, core);
    835836    page->auth_widgets = g_slist_prepend (page->auth_widgets, w);
    836837    w = hig_workarea_add_row (t, &row, s, w, NULL);
     
    839840    /* password */
    840841    s = _("Pass_word:");
    841     w = new_entry (TR_PREFS_KEY_RPC_PASSWORD, core);
     842    w = new_entry (TR_KEY_rpc_password, core);
    842843    gtk_entry_set_visibility (GTK_ENTRY (w), FALSE);
    843844    page->auth_widgets = g_slist_prepend (page->auth_widgets, w);
     
    847848    /* require authentication */
    848849    s = _("Only allow these IP a_ddresses to connect:");
    849     w = new_check_button (s, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, core);
     850    w = new_check_button (s, TR_KEY_rpc_whitelist_enabled, core);
    850851    hig_workarea_add_wide_control (t, &row, w);
    851852    page->whitelist_tb = GTK_TOGGLE_BUTTON (w);
     
    855856    /* access control list */
    856857    {
    857         const char *        val = gtr_pref_string_get (TR_PREFS_KEY_RPC_WHITELIST);
     858        const char *        val = gtr_pref_string_get (TR_KEY_rpc_whitelist);
    858859        GtkTreeModel *      m = whitelist_tree_model_new (val);
    859860        GtkTreeViewColumn * c;
     
    927928struct BandwidthPage
    928929{
    929     TrCore *  core;
    930     GSList *  sched_widgets;
     930  TrCore *  core;
     931  GSList *  sched_widgets;
    931932};
    932933
     
    934935refreshSchedSensitivity (struct BandwidthPage * p)
    935936{
    936     GSList *      l;
    937     const gboolean sched_enabled = gtr_pref_flag_get (TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED);
    938 
    939     for (l = p->sched_widgets; l != NULL; l = l->next)
    940         gtk_widget_set_sensitive (GTK_WIDGET (l->data), sched_enabled);
     937  GSList * l;
     938  const gboolean sched_enabled = gtr_pref_flag_get (TR_KEY_alt_speed_time_enabled);
     939
     940  for (l=p->sched_widgets; l!=NULL; l=l->next)
     941    gtk_widget_set_sensitive (GTK_WIDGET (l->data), sched_enabled);
    941942}
    942943
     
    949950
    950951static void
    951 onTimeComboChanged (GtkComboBox * w,
    952                     gpointer      core)
    953 {
    954     GtkTreeIter iter;
    955 
    956     if (gtk_combo_box_get_active_iter (w, &iter))
     952onTimeComboChanged (GtkComboBox * w, gpointer core)
     953{
     954  GtkTreeIter iter;
     955
     956  if (gtk_combo_box_get_active_iter (w, &iter))
    957957    {
    958         const char * key = g_object_get_data (G_OBJECT (w), PREF_KEY);
    959         int          val = 0;
    960         gtk_tree_model_get (gtk_combo_box_get_model (
    961                                 w), &iter, 0, &val, -1);
    962         gtr_core_set_pref_int (TR_CORE (core), key, val);
     958      int val = 0;
     959      const tr_quark key = GPOINTER_TO_INT (g_object_get_data (G_OBJECT(w), PREF_KEY));
     960      gtk_tree_model_get (gtk_combo_box_get_model(w), &iter, 0, &val, -1);
     961      gtr_core_set_pref_int (TR_CORE(core), key, val);
    963962    }
    964963}
    965964
    966965static GtkWidget*
    967 new_time_combo (GObject *    core,
    968                 const char * key)
    969 {
    970     int               val;
    971     int               i;
    972     GtkWidget *       w;
    973     GtkCellRenderer * r;
    974     GtkListStore *    store;
    975 
    976     /* build a store at 15 minute intervals */
    977     store = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING);
    978     for (i = 0; i < 60 * 24; i += 15)
     966new_time_combo (GObject * core, const tr_quark key)
     967{
     968  int val;
     969  int i;
     970  GtkWidget * w;
     971  GtkCellRenderer * r;
     972  GtkListStore * store;
     973
     974  /* build a store at 15 minute intervals */
     975  store = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING);
     976  for (i=0; i<60*24; i+=15)
    979977    {
    980         char        buf[128];
    981         GtkTreeIter iter;
    982         struct tm   tm;
    983         tm.tm_hour = i / 60;
    984         tm.tm_min = i % 60;
    985         tm.tm_sec = 0;
    986         strftime (buf, sizeof (buf), "%H:%M", &tm);
    987         gtk_list_store_append (store, &iter);
    988         gtk_list_store_set (store, &iter, 0, i, 1, buf, -1);
     978      char buf[128];
     979      GtkTreeIter iter;
     980      struct tm   tm;
     981      tm.tm_hour = i / 60;
     982      tm.tm_min = i % 60;
     983      tm.tm_sec = 0;
     984      strftime (buf, sizeof (buf), "%H:%M", &tm);
     985      gtk_list_store_append (store, &iter);
     986      gtk_list_store_set (store, &iter, 0, i, 1, buf, -1);
    989987    }
    990988
    991     /* build the widget */
    992     w = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
    993     gtk_combo_box_set_wrap_width (GTK_COMBO_BOX (w), 4);
    994     r = gtk_cell_renderer_text_new ();
    995     gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (w), r, TRUE);
    996     gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (
    997                                         w), r, "text", 1, NULL);
    998     g_object_set_data_full (G_OBJECT (w), PREF_KEY, tr_strdup (
    999                                 key), g_free);
    1000     val = gtr_pref_int_get (key);
    1001     gtk_combo_box_set_active (GTK_COMBO_BOX (w), val / (15));
    1002     g_signal_connect (w, "changed", G_CALLBACK (onTimeComboChanged), core);
    1003 
    1004     /* cleanup */
    1005     g_object_unref (G_OBJECT (store));
    1006     return w;
    1007 }
    1008 
    1009 static GtkWidget*
    1010 new_week_combo (GObject * core, const char * key)
    1011 {
    1012     GtkWidget * w = gtr_combo_box_new_enum (_("Every Day"), TR_SCHED_ALL,
    1013                                             _("Weekdays"),  TR_SCHED_WEEKDAY,
    1014                                             _("Weekends"),  TR_SCHED_WEEKEND,
    1015                                             _("Sunday"),    TR_SCHED_SUN,
    1016                                             _("Monday"),    TR_SCHED_MON,
    1017                                             _("Tuesday"),   TR_SCHED_TUES,
    1018                                             _("Wednesday"), TR_SCHED_WED,
    1019                                             _("Thursday"),  TR_SCHED_THURS,
    1020                                             _("Friday"),    TR_SCHED_FRI,
    1021                                             _("Saturday"),  TR_SCHED_SAT,
    1022                                             NULL);
    1023     gtr_combo_box_set_active_enum (GTK_COMBO_BOX (w), gtr_pref_int_get (key));
    1024     g_object_set_data_full (G_OBJECT (w), PREF_KEY, tr_strdup (key), g_free);
    1025     g_signal_connect (w, "changed", G_CALLBACK (onIntComboChanged), core);
    1026     return w;
     989  /* build the widget */
     990  w = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
     991  gtk_combo_box_set_wrap_width (GTK_COMBO_BOX (w), 4);
     992  r = gtk_cell_renderer_text_new ();
     993  gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (w), r, TRUE);
     994  gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (w), r, "text", 1, NULL);
     995  g_object_set_data (G_OBJECT(w), PREF_KEY, GINT_TO_POINTER(key));
     996  val = gtr_pref_int_get (key);
     997  gtk_combo_box_set_active (GTK_COMBO_BOX (w), val / (15));
     998  g_signal_connect (w, "changed", G_CALLBACK (onTimeComboChanged), core);
     999
     1000  /* cleanup */
     1001  g_object_unref (G_OBJECT (store));
     1002  return w;
     1003}
     1004
     1005static GtkWidget*
     1006new_week_combo (GObject * core, const tr_quark key)
     1007{
     1008  GtkWidget * w = gtr_combo_box_new_enum (_("Every Day"), TR_SCHED_ALL,
     1009                                          _("Weekdays"),  TR_SCHED_WEEKDAY,
     1010                                          _("Weekends"),  TR_SCHED_WEEKEND,
     1011                                          _("Sunday"),    TR_SCHED_SUN,
     1012                                          _("Monday"),    TR_SCHED_MON,
     1013                                          _("Tuesday"),   TR_SCHED_TUES,
     1014                                          _("Wednesday"), TR_SCHED_WED,
     1015                                          _("Thursday"),  TR_SCHED_THURS,
     1016                                          _("Friday"),    TR_SCHED_FRI,
     1017                                          _("Saturday"),  TR_SCHED_SAT,
     1018                                          NULL);
     1019  gtr_combo_box_set_active_enum (GTK_COMBO_BOX (w), gtr_pref_int_get (key));
     1020  g_object_set_data (G_OBJECT(w), PREF_KEY, GINT_TO_POINTER(key));
     1021  g_signal_connect (w, "changed", G_CALLBACK (onIntComboChanged), core);
     1022  return w;
    10271023}
    10281024
     
    10531049
    10541050        g_snprintf (buf, sizeof (buf), _("_Upload (%s):"), _ (speed_K_str));
    1055         w = new_check_button (buf, TR_PREFS_KEY_USPEED_ENABLED, core);
    1056         w2 = new_spin_button (TR_PREFS_KEY_USPEED_KBps, core, 0, INT_MAX, 5);
    1057         gtk_widget_set_sensitive (GTK_WIDGET (w2), gtr_pref_flag_get (TR_PREFS_KEY_USPEED_ENABLED));
     1051        w = new_check_button (buf, TR_KEY_speed_limit_up_enabled, core);
     1052        w2 = new_spin_button (TR_KEY_speed_limit_up, core, 0, INT_MAX, 5);
     1053        gtk_widget_set_sensitive (GTK_WIDGET (w2), gtr_pref_flag_get (TR_KEY_speed_limit_up_enabled));
    10581054        g_signal_connect (w, "toggled", G_CALLBACK (target_cb), w2);
    10591055        hig_workarea_add_row_w (t, &row, w, w2, NULL);
    10601056
    10611057        g_snprintf (buf, sizeof (buf), _("_Download (%s):"), _ (speed_K_str));
    1062         w = new_check_button (buf, TR_PREFS_KEY_DSPEED_ENABLED, core);
    1063         w2 = new_spin_button (TR_PREFS_KEY_DSPEED_KBps, core, 0, INT_MAX, 5);
    1064         gtk_widget_set_sensitive (GTK_WIDGET (w2), gtr_pref_flag_get (TR_PREFS_KEY_DSPEED_ENABLED));
     1058        w = new_check_button (buf, TR_KEY_speed_limit_down_enabled, core);
     1059        w2 = new_spin_button (TR_KEY_speed_limit_down, core, 0, INT_MAX, 5);
     1060        gtk_widget_set_sensitive (GTK_WIDGET (w2), gtr_pref_flag_get (TR_KEY_speed_limit_down_enabled));
    10651061        g_signal_connect (w, "toggled", G_CALLBACK (target_cb), w2);
    10661062        hig_workarea_add_row_w (t, &row, w, w2, NULL);
     
    10851081
    10861082        g_snprintf (buf, sizeof (buf), _("U_pload (%s):"), _ (speed_K_str));
    1087         w = new_spin_button (TR_PREFS_KEY_ALT_SPEED_UP_KBps, core, 0, INT_MAX, 5);
     1083        w = new_spin_button (TR_KEY_alt_speed_up, core, 0, INT_MAX, 5);
    10881084        hig_workarea_add_row (t, &row, buf, w, NULL);
    10891085
    10901086        g_snprintf (buf, sizeof (buf), _("Do_wnload (%s):"), _ (speed_K_str));
    1091         w = new_spin_button (TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, core, 0, INT_MAX, 5);
     1087        w = new_spin_button (TR_KEY_alt_speed_down, core, 0, INT_MAX, 5);
    10921088        hig_workarea_add_row (t, &row, buf, w, NULL);
    10931089
    10941090        s = _("_Scheduled times:");
    10951091        h = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
    1096         w2 = new_time_combo (core, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN);
     1092        w2 = new_time_combo (core, TR_KEY_alt_speed_time_begin);
    10971093        page->sched_widgets = g_slist_prepend (page->sched_widgets, w2);
    10981094        gtk_box_pack_start (GTK_BOX (h), w2, TRUE, TRUE, 0);
     
    11001096        page->sched_widgets = g_slist_prepend (page->sched_widgets, w2);
    11011097        gtk_box_pack_start (GTK_BOX (h), w2, FALSE, FALSE, 0);
    1102         w2 = new_time_combo (core, TR_PREFS_KEY_ALT_SPEED_TIME_END);
     1098        w2 = new_time_combo (core, TR_KEY_alt_speed_time_end);
    11031099        gtk_label_set_mnemonic_widget (GTK_LABEL (l), w2);
    11041100        page->sched_widgets = g_slist_prepend (page->sched_widgets, w2);
    11051101        gtk_box_pack_start (GTK_BOX (h), w2, TRUE, TRUE, 0);
    1106         w = new_check_button (s, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, core);
     1102        w = new_check_button (s, TR_KEY_alt_speed_time_enabled, core);
    11071103        g_signal_connect (w, "toggled", G_CALLBACK (onSchedToggled), page);
    11081104        hig_workarea_add_row_w (t, &row, w, h, NULL);
    11091105
    11101106        s = _("_On days:");
    1111         w = new_week_combo (core, TR_PREFS_KEY_ALT_SPEED_TIME_DAY);
     1107        w = new_week_combo (core, TR_KEY_alt_speed_time_day);
    11121108        page->sched_widgets = g_slist_prepend (page->sched_widgets, w);
    11131109        w = hig_workarea_add_row (t, &row, s, w, NULL);
     
    11351131
    11361132static void
    1137 onCorePrefsChanged (TrCore * core UNUSED, const char * key, gpointer gdata)
    1138 {
    1139   if (!strcmp (key, TR_PREFS_KEY_PEER_PORT))
     1133onCorePrefsChanged (TrCore * core UNUSED, const tr_quark key, gpointer gdata)
     1134{
     1135  if (key == TR_KEY_peer_port)
    11401136    {
    11411137      struct network_page_data * data = gdata;
     
    11671163  const char * markup = isOpen ? _("Port is <b>open</b>") : _("Port is <b>closed</b>");
    11681164
    1169   gdk_threads_enter ();
     1165  //gdk_threads_enter ();
    11701166  gtk_label_set_markup (GTK_LABEL (data->portLabel), markup);
    11711167  gtk_widget_set_sensitive (data->portButton, TRUE);
    11721168  gtk_widget_set_sensitive (data->portSpin, TRUE);
    1173   gdk_threads_leave ();
     1169  //gdk_threads_leave ();
    11741170}
    11751171
     
    12061202
    12071203  s = _("_Port used for incoming connections:");
    1208   w = data->portSpin = new_spin_button (TR_PREFS_KEY_PEER_PORT, core, 1, USHRT_MAX, 1);
     1204  w = data->portSpin = new_spin_button (TR_KEY_peer_port, core, 1, USHRT_MAX, 1);
    12091205  hig_workarea_add_row (t, &row, s, w, NULL);
    12101206
     
    12211217
    12221218  s = _("Pick a _random port every time Transmission is started");
    1223   w = new_check_button (s, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, core);
     1219  w = new_check_button (s, TR_KEY_peer_port_random_on_start, core);
    12241220  hig_workarea_add_wide_control (t, &row, w);
    12251221
    12261222  s = _("Use UPnP or NAT-PMP port _forwarding from my router");
    1227   w = new_check_button (s, TR_PREFS_KEY_PORT_FORWARDING, core);
     1223  w = new_check_button (s, TR_KEY_port_forwarding_enabled, core);
    12281224  hig_workarea_add_wide_control (t, &row, w);
    12291225
     
    12311227  hig_workarea_add_section_title (t, &row, _("Peer Limits"));
    12321228
    1233   w = new_spin_button (TR_PREFS_KEY_PEER_LIMIT_TORRENT, core, 1, FD_SETSIZE, 5);
     1229  w = new_spin_button (TR_KEY_peer_limit_per_torrent, core, 1, FD_SETSIZE, 5);
    12341230  hig_workarea_add_row (t, &row, _("Maximum peers per _torrent:"), w, NULL);
    1235   w = new_spin_button (TR_PREFS_KEY_PEER_LIMIT_GLOBAL, core, 1, FD_SETSIZE, 5);
     1231  w = new_spin_button (TR_KEY_peer_limit_global, core, 1, FD_SETSIZE, 5);
    12361232  hig_workarea_add_row (t, &row, _("Maximum peers _overall:"), w, NULL);
    12371233
     
    12411237#ifdef WITH_UTP
    12421238  s = _("Enable _uTP for peer communication");
    1243   w = new_check_button (s, TR_PREFS_KEY_UTP_ENABLED, core);
     1239  w = new_check_button (s, TR_KEY_utp_enabled, core);
    12441240  s = _("uTP is a tool for reducing network congestion.");
    12451241  gtk_widget_set_tooltip_text (w, s);
  • trunk/gtk/tr-window.c

    r13657 r13683  
    188188
    189189static void
    190 prefsChanged (TrCore     * core UNUSED,
    191               const char *  key,
    192               gpointer      wind)
    193 {
     190prefsChanged (TrCore           * core UNUSED,
     191              const tr_quark     key,
     192              gpointer           wind)
     193{
     194  gboolean isEnabled;
    194195  PrivateData * p = get_private_data (GTK_WINDOW (wind));
    195196
    196   if (!strcmp (key, PREF_KEY_COMPACT_VIEW))
    197     {
    198       g_object_set (p->renderer, "compact", gtr_pref_flag_get (key), NULL);
    199       /* since the cell size has changed, we need gtktreeview to revalidate
    200        * its fixed-height mode values. Unfortunately there's not an API call
    201        * for that, but it *does* revalidate when it thinks the style's been tweaked */
    202       g_signal_emit_by_name (p->view, "style-updated", NULL, NULL);
    203     }
    204   else if (!strcmp (key, PREF_KEY_STATUSBAR))
    205     {
    206       const gboolean isEnabled = gtr_pref_flag_get (key);
    207       g_object_set (p->status, "visible", isEnabled, NULL);
    208     }
    209   else if (!strcmp (key, PREF_KEY_FILTERBAR))
    210     {
    211       const gboolean isEnabled = gtr_pref_flag_get (key);
    212       g_object_set (p->filter, "visible", isEnabled, NULL);
    213     }
    214   else if (!strcmp (key, PREF_KEY_TOOLBAR))
    215     {
    216       const gboolean isEnabled = gtr_pref_flag_get (key);
    217       g_object_set (p->toolbar, "visible", isEnabled, NULL);
    218     }
    219   else if (!strcmp (key, PREF_KEY_STATUSBAR_STATS))
    220     {
    221       gtr_window_refresh (wind);
    222     }
    223   else if (!strcmp (key, TR_PREFS_KEY_ALT_SPEED_ENABLED) ||
    224            !strcmp (key, TR_PREFS_KEY_ALT_SPEED_UP_KBps) ||
    225            !strcmp (key, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps))
    226     {
    227       syncAltSpeedButton (p);
     197  switch (key)
     198    {
     199      case TR_KEY_compact_view:
     200        g_object_set (p->renderer, "compact", gtr_pref_flag_get (key), NULL);
     201        /* since the cell size has changed, we need gtktreeview to revalidate
     202         * its fixed-height mode values. Unfortunately there's not an API call
     203         * for that, but it *does* revalidate when it thinks the style's been tweaked */
     204        g_signal_emit_by_name (p->view, "style-updated", NULL, NULL);
     205        break;
     206
     207      case TR_KEY_show_statusbar:
     208        isEnabled = gtr_pref_flag_get (key);
     209        g_object_set (p->status, "visible", isEnabled, NULL);
     210        break;
     211
     212      case TR_KEY_show_filterbar:
     213        isEnabled = gtr_pref_flag_get (key);
     214        g_object_set (p->filter, "visible", isEnabled, NULL);
     215        break;
     216
     217      case TR_KEY_show_toolbar:
     218        isEnabled = gtr_pref_flag_get (key);
     219        g_object_set (p->toolbar, "visible", isEnabled, NULL);
     220        break;
     221
     222      case TR_KEY_statusbar_stats:
     223        gtr_window_refresh (wind);
     224        break;
     225
     226      case TR_KEY_alt_speed_enabled:
     227      case TR_KEY_alt_speed_up:
     228      case TR_KEY_alt_speed_down:
     229        syncAltSpeedButton (p);
     230        break;
     231
     232      default:
     233        break;
    228234    }
    229235}
     
    267273      PrivateData * p = vprivate;
    268274      const char *  val = g_object_get_data (G_OBJECT (menu_item), STATS_MODE);
    269       gtr_core_set_pref (p->core, PREF_KEY_STATUSBAR_STATS, val);
     275      gtr_core_set_pref (p->core, TR_KEY_statusbar_stats, val);
    270276    }
    271277}
     
    278284  char * str;
    279285  const char * fmt;
    280   const gboolean b = gtr_pref_flag_get (TR_PREFS_KEY_ALT_SPEED_ENABLED);
     286  const gboolean b = gtr_pref_flag_get (TR_KEY_alt_speed_enabled);
    281287  const char * stock = b ? "alt-speed-on" : "alt-speed-off";
    282288  GtkWidget * w = p->alt_speed_button;
    283289
    284   tr_formatter_speed_KBps (u, gtr_pref_int_get (TR_PREFS_KEY_ALT_SPEED_UP_KBps), sizeof (u));
    285   tr_formatter_speed_KBps (d, gtr_pref_int_get (TR_PREFS_KEY_ALT_SPEED_DOWN_KBps), sizeof (d));
     290  tr_formatter_speed_KBps (u, gtr_pref_int_get (TR_KEY_alt_speed_up), sizeof (u));
     291  tr_formatter_speed_KBps (d, gtr_pref_int_get (TR_KEY_alt_speed_down), sizeof (d));
    286292  fmt = b ? _("Click to disable Alternative Speed Limits\n (%1$s down, %2$s up)")
    287293          : _("Click to enable Alternative Speed Limits\n (%1$s down, %2$s up)");
     
    301307  PrivateData * p = vprivate;
    302308  const gboolean b = gtk_toggle_button_get_active (button);
    303   gtr_core_set_pref_bool (p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED,  b);
     309  gtr_core_set_pref_bool (p->core, TR_KEY_alt_speed_enabled,  b);
    304310}
    305311
     
    364370  PrivateData * p = vp;
    365371  gboolean b = tr_sessionUsesAltSpeed (gtr_core_session (p->core));
    366   gtr_core_set_pref_bool (p->core, TR_PREFS_KEY_ALT_SPEED_ENABLED, b);
     372  gtr_core_set_pref_bool (p->core, TR_KEY_alt_speed_enabled, b);
    367373
    368374  return FALSE;
     
    390396  gboolean isEnabled = g_object_get_data (o, ENABLED_KEY) != 0;
    391397  tr_direction dir = GPOINTER_TO_INT (g_object_get_data (o, DIRECTION_KEY));
    392   const char * key = dir == TR_UP ? TR_PREFS_KEY_USPEED_ENABLED
    393                                   : TR_PREFS_KEY_DSPEED_ENABLED;
     398  const tr_quark key = dir == TR_UP ? TR_KEY_speed_limit_up_enabled
     399                                    : TR_KEY_speed_limit_down_enabled;
    394400
    395401  if (gtk_check_menu_item_get_active (check))
     
    400406onSpeedSet (GtkCheckMenuItem * check, gpointer vp)
    401407{
    402   const char * key;
     408  tr_quark key;
    403409  PrivateData * p = vp;
    404410  GObject * o = G_OBJECT (check);
     
    406412  tr_direction dir = GPOINTER_TO_INT (g_object_get_data (o, DIRECTION_KEY));
    407413
    408   key = dir==TR_UP ? TR_PREFS_KEY_USPEED_KBps : TR_PREFS_KEY_DSPEED_KBps;
     414  key = dir==TR_UP ? TR_KEY_speed_limit_up : TR_KEY_speed_limit_down;
    409415  gtr_core_set_pref_int (p->core, key, KBps);
    410416
    411   key = dir==TR_UP ? TR_PREFS_KEY_USPEED_ENABLED : TR_PREFS_KEY_DSPEED_ENABLED;
     417  key = dir==TR_UP ? TR_KEY_speed_limit_up_enabled : TR_KEY_speed_limit_down_enabled;
    412418  gtr_core_set_pref_bool (p->core, key, TRUE);
    413419}
     
    476482    {
    477483      gboolean f = g_object_get_data (G_OBJECT (check), ENABLED_KEY) != 0;
    478       gtr_core_set_pref_bool (p->core, TR_PREFS_KEY_RATIO_ENABLED, f);
     484      gtr_core_set_pref_bool (p->core, TR_KEY_ratio_limit_enabled, f);
    479485    }
    480486}
     
    485491  int i = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (check), RATIO_KEY));
    486492  const double ratio = stockRatios[i];
    487   gtr_core_set_pref_double (p->core, TR_PREFS_KEY_RATIO, ratio);
    488   gtr_core_set_pref_bool (p->core, TR_PREFS_KEY_RATIO_ENABLED, TRUE);
     493  gtr_core_set_pref_double (p->core, TR_KEY_ratio_limit, ratio);
     494  gtr_core_set_pref_bool (p->core, TR_KEY_ratio_limit_enabled, TRUE);
    489495}
    490496
     
    567573
    568574  w = p->speedlimit_on_item[TR_DOWN];
    569   tr_formatter_speed_KBps (buf1, gtr_pref_int_get (TR_PREFS_KEY_DSPEED_KBps), sizeof (buf1));
     575  tr_formatter_speed_KBps (buf1, gtr_pref_int_get (TR_KEY_speed_limit_down), sizeof (buf1));
    570576  gtr_label_set_text (GTK_LABEL (gtk_bin_get_child (GTK_BIN (w))), buf1);
    571577
    572   b = gtr_pref_flag_get (TR_PREFS_KEY_DSPEED_ENABLED);
     578  b = gtr_pref_flag_get (TR_KEY_speed_limit_down_enabled);
    573579  w = b ? p->speedlimit_on_item[TR_DOWN] : p->speedlimit_off_item[TR_DOWN];
    574580  gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), TRUE);
    575581
    576582  w = p->speedlimit_on_item[TR_UP];
    577   tr_formatter_speed_KBps (buf1, gtr_pref_int_get (TR_PREFS_KEY_USPEED_KBps), sizeof (buf1));
     583  tr_formatter_speed_KBps (buf1, gtr_pref_int_get (TR_KEY_speed_limit_up), sizeof (buf1));
    578584  gtr_label_set_text (GTK_LABEL (gtk_bin_get_child (GTK_BIN (w))), buf1);
    579585
    580   b = gtr_pref_flag_get (TR_PREFS_KEY_USPEED_ENABLED);
     586  b = gtr_pref_flag_get (TR_KEY_speed_limit_up_enabled);
    581587  w = b ? p->speedlimit_on_item[TR_UP] : p->speedlimit_off_item[TR_UP];
    582588  gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), TRUE);
    583589
    584   tr_strlratio (buf1, gtr_pref_double_get (TR_PREFS_KEY_RATIO), sizeof (buf1));
     590  tr_strlratio (buf1, gtr_pref_double_get (TR_KEY_ratio_limit), sizeof (buf1));
    585591  g_snprintf (buf2, sizeof (buf2), _("Stop at Ratio (%s)"), buf1);
    586592  gtr_label_set_text (GTK_LABEL (gtk_bin_get_child (GTK_BIN (p->ratio_on_item))), buf2);
    587593
    588   b = gtr_pref_flag_get (TR_PREFS_KEY_RATIO_ENABLED);
     594  b = gtr_pref_flag_get (TR_KEY_ratio_limit_enabled);
    589595  gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (b ? p->ratio_on_item : p->ratio_off_item), TRUE);
    590596
     
    617623  gtk_window_set_role (win, "tr-main");
    618624  gtk_window_set_default_size (win,
    619                                gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_WIDTH),
    620                                gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_HEIGHT));
    621   gtk_window_move (win, gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_X),
    622                         gtr_pref_int_get (PREF_KEY_MAIN_WINDOW_Y));
    623   if (gtr_pref_flag_get (PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED))
     625                               gtr_pref_int_get (TR_KEY_main_window_width),
     626                               gtr_pref_int_get (TR_KEY_main_window_height));
     627  gtk_window_move (win, gtr_pref_int_get (TR_KEY_main_window_x),
     628                        gtr_pref_int_get (TR_KEY_main_window_y));
     629  if (gtr_pref_flag_get (TR_KEY_main_window_is_maximized))
    624630    gtk_window_maximize (win);
    625631  gtk_window_add_accel_group (win, gtk_ui_manager_get_accel_group (ui_mgr));
     
    650656  menu = p->status_menu = gtk_menu_new ();
    651657  l = NULL;
    652   pch = gtr_pref_string_get (PREF_KEY_STATUSBAR_STATS);
     658  pch = gtr_pref_string_get (TR_KEY_statusbar_stats);
    653659  for (i=0, n=G_N_ELEMENTS (stats_modes); i<n; ++i)
    654660    {
     
    759765  /* listen for prefs changes that affect the window */
    760766  p->core = core;
    761   prefsChanged (core, PREF_KEY_COMPACT_VIEW, self);
    762   prefsChanged (core, PREF_KEY_FILTERBAR, self);
    763   prefsChanged (core, PREF_KEY_STATUSBAR, self);
    764   prefsChanged (core, PREF_KEY_STATUSBAR_STATS, self);
    765   prefsChanged (core, PREF_KEY_TOOLBAR, self);
    766   prefsChanged (core, TR_PREFS_KEY_ALT_SPEED_ENABLED, self);
     767  prefsChanged (core, TR_KEY_compact_view, self);
     768  prefsChanged (core, TR_KEY_show_filterbar, self);
     769  prefsChanged (core, TR_KEY_show_statusbar, self);
     770  prefsChanged (core, TR_KEY_statusbar_stats, self);
     771  prefsChanged (core, TR_KEY_show_toolbar, self);
     772  prefsChanged (core, TR_KEY_alt_speed_enabled, self);
    767773  p->pref_handler_id = g_signal_connect (core, "prefs-changed",
    768774                                         G_CALLBACK (prefsChanged), self);
     
    811817
    812818  /* update the stats */
    813   pch = gtr_pref_string_get (PREF_KEY_STATUSBAR_STATS);
     819  pch = gtr_pref_string_get (TR_KEY_statusbar_stats);
    814820  if (!strcmp (pch, "session-ratio"))
    815821    {
  • trunk/gtk/util.c

    r13625 r13683  
    302302gtr_file_trash_or_remove (const char * filename)
    303303{
    304     GFile * file;
    305     gboolean trashed = FALSE;
    306 
    307     g_return_val_if_fail (filename && *filename, 0);
    308 
    309     file = g_file_new_for_path (filename);
    310 
    311     if (gtr_pref_flag_get (PREF_KEY_TRASH_CAN_ENABLED)) {
    312         GError * err = NULL;
    313         trashed = g_file_trash (file, NULL, &err);
    314         if (err) {
    315             g_message ("Unable to trash file \"%s\": %s", filename, err->message);
    316             g_clear_error (&err);
     304  GFile * file;
     305  gboolean trashed = FALSE;
     306
     307  g_return_val_if_fail (filename && *filename, 0);
     308
     309  file = g_file_new_for_path (filename);
     310
     311  if (gtr_pref_flag_get (TR_KEY_trash_can_enabled))
     312    {
     313      GError * err = NULL;
     314      trashed = g_file_trash (file, NULL, &err);
     315      if (err)
     316        {
     317          g_message ("Unable to trash file \"%s\": %s", filename, err->message);
     318          g_clear_error (&err);
    317319        }
    318320    }
    319321
    320     if (!trashed) {
    321         GError * err = NULL;
    322         g_file_delete (file, NULL, &err);
    323         if (err) {
    324             g_message ("Unable to delete file \"%s\": %s", filename, err->message);
    325             g_clear_error (&err);
     322  if (!trashed)
     323    {
     324      GError * err = NULL;
     325      g_file_delete (file, NULL, &err);
     326      if (err)
     327        {
     328          g_message ("Unable to delete file \"%s\": %s", filename, err->message);
     329          g_clear_error (&err);
    326330        }
    327331    }
    328332
    329     g_object_unref (G_OBJECT (file));
    330     return 0;
     333  g_object_unref (G_OBJECT (file));
     334  return 0;
    331335}
    332336
  • trunk/libtransmission/Makefile.am

    r13667 r13683  
    4545    port-forwarding.c \
    4646    ptrarray.c \
     47    quark.c \
    4748    resume.c \
    4849    rpcimpl.c \
     
    100101    port-forwarding.h \
    101102    ptrarray.h \
     103    quark.h \
    102104    resume.h \
    103105    rpcimpl.h \
     
    132134    metainfo-test \
    133135    peer-msgs-test \
     136    quark-test \
    134137    rpc-test \
    135138    test-peer-id \
     
    177180json_test_LDFLAGS = ${apps_ldflags}
    178181
     182quark_test_SOURCES = quark-test.c $(TEST_SOURCES)
     183quark_test_LDADD = ${apps_ldadd}
     184quark_test_LDFLAGS = ${apps_ldflags}
     185
    179186magnet_test_SOURCES = magnet-test.c $(TEST_SOURCES)
    180187magnet_test_LDADD = ${apps_ldadd}
  • trunk/libtransmission/announcer-http.c

    r13667 r13683  
    138138        if (peer == NULL)
    139139            continue;
    140         if (!tr_variantDictFindStr (peer, "ip", &ip, NULL))
     140        if (!tr_variantDictFindStr (peer, TR_KEY_ip, &ip, NULL))
    141141            continue;
    142142        if (!tr_address_from_string (&addr, ip))
    143143            continue;
    144         if (!tr_variantDictFindInt (peer, "port", &port))
     144        if (!tr_variantDictFindInt (peer, TR_KEY_port, &port))
    145145            continue;
    146146        if ((port < 0) || (port > USHRT_MAX))
     
    234234            const uint8_t * raw;
    235235
    236             if (tr_variantDictFindStr (&benc, "failure reason", &str, &len))
     236            if (tr_variantDictFindStr (&benc, TR_KEY_failure_reason, &str, &len))
    237237                response->errmsg = tr_strndup (str, len);
    238238
    239             if (tr_variantDictFindStr (&benc, "warning message", &str, &len))
     239            if (tr_variantDictFindStr (&benc, TR_KEY_warning_message, &str, &len))
    240240                response->warning = tr_strndup (str, len);
    241241
    242             if (tr_variantDictFindInt (&benc, "interval", &i))
     242            if (tr_variantDictFindInt (&benc, TR_KEY_interval, &i))
    243243                response->interval = i;
    244244
    245             if (tr_variantDictFindInt (&benc, "min interval", &i))
     245            if (tr_variantDictFindInt (&benc, TR_KEY_min_interval, &i))
    246246                response->min_interval = i;
    247247
    248             if (tr_variantDictFindStr (&benc, "tracker id", &str, &len))
     248            if (tr_variantDictFindStr (&benc, TR_KEY_tracker_id, &str, &len))
    249249                response->tracker_id_str = tr_strndup (str, len);
    250250
    251             if (tr_variantDictFindInt (&benc, "complete", &i))
     251            if (tr_variantDictFindInt (&benc, TR_KEY_complete, &i))
    252252                response->seeders = i;
    253253
    254             if (tr_variantDictFindInt (&benc, "incomplete", &i))
     254            if (tr_variantDictFindInt (&benc, TR_KEY_incomplete, &i))
    255255                response->leechers = i;
    256256
    257             if (tr_variantDictFindInt (&benc, "downloaded", &i))
     257            if (tr_variantDictFindInt (&benc, TR_KEY_downloaded, &i))
    258258                response->downloads = i;
    259259
    260             if (tr_variantDictFindRaw (&benc, "peers6", &raw, &len)) {
     260            if (tr_variantDictFindRaw (&benc, TR_KEY_peers6, &raw, &len)) {
    261261                dbgmsg (data->log_name, "got a peers6 length of %zu", len);
    262262                response->pex6 = tr_peerMgrCompact6ToPex (raw, len,
     
    264264            }
    265265
    266             if (tr_variantDictFindRaw (&benc, "peers", &raw, &len)) {
     266            if (tr_variantDictFindRaw (&benc, TR_KEY_peers, &raw, &len)) {
    267267                dbgmsg (data->log_name, "got a compact peers length of %zu", len);
    268268                response->pex = tr_peerMgrCompactToPex (raw, len,
    269269                                               NULL, 0, &response->pex_count);
    270             } else if (tr_variantDictFindList (&benc, "peers", &tmp)) {
     270            } else if (tr_variantDictFindList (&benc, TR_KEY_peers, &tmp)) {
    271271                response->pex = listToPex (tmp, &response->pex_count);
    272272                dbgmsg (data->log_name, "got a peers list with %zu entries",
     
    383383        if (variant_loaded)
    384384        {
    385             if (tr_variantDictFindStr (&top, "failure reason", &str, &len))
     385            if (tr_variantDictFindStr (&top, TR_KEY_failure_reason, &str, &len))
    386386                response->errmsg = tr_strndup (str, len);
    387387
    388             if (tr_variantDictFindDict (&top, "flags", &flags))
    389                 if (tr_variantDictFindInt (flags, "min_request_interval", &intVal))
     388            if (tr_variantDictFindDict (&top, TR_KEY_flags, &flags))
     389                if (tr_variantDictFindInt (flags, TR_KEY_min_request_interval, &intVal))
    390390                    response->min_request_interval = intVal;
    391391
    392             if (tr_variantDictFindDict (&top, "files", &files))
     392            if (tr_variantDictFindDict (&top, TR_KEY_files, &files))
    393393            {
    394394                int i = 0;
     
    397397                {
    398398                    int j;
     399                    tr_quark key;
    399400                    tr_variant * val;
    400                     const char * key;
    401401
    402402                    /* get the next "file" */
     
    408408                    {
    409409                        struct tr_scrape_response_row * row = &response->rows[j];
    410                         if (!memcmp (key, row->info_hash, SHA_DIGEST_LENGTH))
     410                        if (!memcmp (tr_quark_get_string(key,NULL), row->info_hash, SHA_DIGEST_LENGTH))
    411411                        {
    412                             if (tr_variantDictFindInt (val, "complete", &intVal))
     412                            if (tr_variantDictFindInt (val, TR_KEY_complete, &intVal))
    413413                                row->seeders = intVal;
    414                             if (tr_variantDictFindInt (val, "incomplete", &intVal))
     414                            if (tr_variantDictFindInt (val, TR_KEY_incomplete, &intVal))
    415415                                row->leechers = intVal;
    416                             if (tr_variantDictFindInt (val, "downloaded", &intVal))
     416                            if (tr_variantDictFindInt (val, TR_KEY_downloaded, &intVal))
    417417                                row->downloads = intVal;
    418                             if (tr_variantDictFindInt (val, "downloaders", &intVal))
     418                            if (tr_variantDictFindInt (val, TR_KEY_downloaders, &intVal))
    419419                                row->downloaders = intVal;
    420420                            break;
  • trunk/libtransmission/json-test.c

    r13667 r13683  
    11#include <string.h> /* strlen () */
     2
     3#define __LIBTRANSMISSION_VARIANT_MODULE___
    24#include "transmission.h"
    35#include "utils.h" /* tr_free */
    46#include "variant.h"
    5 
     7#include "variant-common.h"
    68#include "libtransmission-test.h"
     9
     10static inline tr_quark
     11toQuark (const char * str)
     12{
     13  return tr_quark_new (str, strlen(str));
     14}
    715
    816static int
     
    1624    int64_t i;
    1725    int err = 0;
     26    tr_quark key;
    1827
    1928    in = "{ \"string\": \"hello world\","
     
    2938    check (tr_variantIsDict (&top));
    3039    str = NULL;
    31     check (tr_variantDictFindStr (&top, "string", &str, NULL));
     40    key = tr_quark_new ("string", 6);
     41    check (tr_variantDictFindStr (&top, key, &str, NULL));
    3242    check_streq ("hello world", str);
    33     check (tr_variantDictFindStr (&top, "escaped", &str, NULL));
     43    check (tr_variantDictFindStr (&top, tr_quark_new("escaped",7), &str, NULL));
    3444    check_streq ("bell \b formfeed \f linefeed \n carriage return \r tab \t", str);
    3545    i = 0;
    36     check (tr_variantDictFindInt (&top, "int", &i));
     46    check (tr_variantDictFindInt (&top, tr_quark_new("int",3), &i));
    3747    check_int_eq (5, i);
    3848    d = 0;
    39     check (tr_variantDictFindReal (&top, "float", &d));
     49    check (tr_variantDictFindReal (&top, tr_quark_new("float",5), &d));
    4050    check_int_eq (65, ((int)(d*10)));
    4151    f = false;
    42     check (tr_variantDictFindBool (&top, "true", &f));
     52    check (tr_variantDictFindBool (&top, tr_quark_new("true",4), &f));
    4353    check_int_eq (true, f);
    44     check (tr_variantDictFindBool (&top, "false", &f));
     54    check (tr_variantDictFindBool (&top, tr_quark_new("false",5), &f));
    4555    check_int_eq (false, f);
    46     check (tr_variantDictFindStr (&top, "null", &str, NULL));
     56    check (tr_variantDictFindStr (&top, tr_quark_new("null",4), &str, NULL));
    4757    check_streq ("", str);
    4858
     
    6070    char            * json;
    6171    int               err;
    62 
    63     err = tr_variantFromJson (&top, in, strlen(in));
    64     check (!err);
    65     check (tr_variantIsDict (&top));
    66     check (tr_variantDictFindStr (&top, "key", &str, NULL));
     72    const tr_quark key = tr_quark_new ("key", 3);
     73
     74    err = tr_variantFromJson (&top, in, strlen(in));
     75    check (!err);
     76    check (tr_variantIsDict (&top));
     77    check (tr_variantDictFindStr (&top, key, &str, NULL));
    6778    check_streq ("Letöltések", str);
    6879    if (!err)
     
    7384    check (!err);
    7485    check (tr_variantIsDict (&top));
    75     check (tr_variantDictFindStr (&top, "key", &str, NULL));
     86    check (tr_variantDictFindStr (&top, key, &str, NULL));
    7687    check_streq ("\\", str);
    7788    if (!err)