extensions/irc/xul/content/prefs.js

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  *
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is ChatZilla.
  17  *
  18  * The Initial Developer of the Original Code is
  19  * Netscape Communications Corporation.
  20  * Portions created by the Initial Developer are Copyright (C) 1998
  21  * the Initial Developer. All Rights Reserved.
  22  *
  23  * Contributor(s):
  24  *   Robert Ginda, <rginda@netscape.com>, original author
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either the GNU General Public License Version 2 or later (the "GPL"), or
  28  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40 const DEFAULT_NICK = "IRCMonkey"
  41
  42 function initPrefs()
  43 {
  44     function makeLogNameClient()
  45     {
  46         return makeLogName(client, "client");
  47     };
  48
  49     client.prefManager = new PrefManager("extensions.irc.",
  50                                          client.defaultBundle);
  51     client.prefManagers = [client.prefManager];
  52
  53     client.prefs = client.prefManager.prefs;
  54
  55     var profilePath = getSpecialDirectory("ProfD");
  56     profilePath.append("chatzilla");
  57
  58     client.prefManager.addPref("profilePath", profilePath.path, null, null,
  59                                                                       "hidden");
  60
  61     profilePath = new nsLocalFile(client.prefs["profilePath"]);
  62
  63     if (!profilePath.exists())
  64         mkdir(profilePath);
  65
  66     client.prefManager.profilePath = profilePath;
  67
  68     var scriptPath = profilePath.clone();
  69     scriptPath.append("scripts");
  70     if (!scriptPath.exists())
  71         mkdir(scriptPath);
  72     client.prefManager.scriptPath = scriptPath;
  73
  74     var logPath = profilePath.clone();
  75     logPath.append("logs");
  76     if (!logPath.exists())
  77         mkdir(logPath);
  78     client.prefManager.logPath = logPath;
  79
  80     var downloadsPath = profilePath.clone();
  81     downloadsPath.append("downloads");
  82     if (!downloadsPath.exists())
  83         mkdir(downloadsPath);
  84
  85     var logDefault = client.prefManager.logPath.clone();
  86     logDefault.append(escapeFileName("client.log"));
  87
  88     var gotos = ["goto-url",        "goto-url-newwin",
  89                  "goto-url-newtab", "goto-url-newtab"];
  90     if (client.host == "XULrunner")
  91     {
  92         gotos = ["goto-url-external", "goto-url-external",
  93                  "goto-url-external", "goto-url-external"];
  94     }
  95
  96     // Set up default nickname, if possible.
  97     var defaultNick = DEFAULT_NICK;
  98     var en = getService("@mozilla.org/process/environment;1", "nsIEnvironment");
  99     if (en)
 100     {
 101         /* Get the enviroment variables used by various OSes:
 102          *   USER     - Linux, Mac OSX and other *nix-types.
 103          *   USERNAME - Windows.
 104          *   LOGNAME  - *nix again.
 105          */
 106         const vars = ["USER", "USERNAME", "LOGNAME"];
 107
 108         for (var i = 0; i < vars.length; i++)
 109         {
 110             var nick = en.get(vars[i]);
 111             if (nick)
 112             {
 113                 defaultNick = nick;
 114                 break;
 115             }
 116         }
 117     }
 118
 119     // Set a property so network ident prefs get the same group later:
 120     client.prefManager.identGroup = ".connect";
 121     // Linux and OS X won't let non-root listen on port 113.
 122     if ((client.platform == "Linux") || (client.platform == "Mac"))
 123         client.prefManager.identGroup = "hidden";
 124
 125     var prefs =
 126         [
 127          ["activityFlashDelay", 200,      "hidden"],
 128          ["aliases",            [],       "lists.aliases"],
 129          ["autoAwayCap",        300,      "global"],
 130          ["autoAwayPeriod",     2,        "appearance.misc"],
 131          ["autoRejoin",         false,    ".connect"],
 132          ["away",               "",       "hidden"],
 133          ["awayNick",           "",       ".ident"],
 134          ["awayIdleTime",       0,        ".ident"],
 135          ["awayIdleMsg",        "",       ".ident"],
 136          ["bugURL",           "https://bugzilla.mozilla.org/show_bug.cgi?id=%s",
 137                                           "appearance.misc"],
 138          ["bugURL.comment",     "#c%s",   "appearance.misc"],
 139          ["channelHeader",      true,     "global.header"],
 140          ["channelLog",         false,    "global.log"],
 141          ["channelMaxLines",    500,      "global.maxLines"],
 142          ["charset",            "utf-8",  ".connect"],
 143          ["clientMaxLines",     200,      "global.maxLines"],
 144          ["collapseActions",    true,     "appearance.misc"],
 145          ["collapseMsgs",       false,    "appearance.misc"],
 146          ["conference.limit",   150,      "appearance.misc"],
 147          ["connectTries",       -1,       ".connect"],
 148          ["copyMessages",       true,     "global"],
 149          ["dccUserHeader",      true,     "global.header"],
 150          ["dccUserLog",         false,    "global.log"],
 151          ["dccUserMaxLines",    500,      "global.maxLines"],
 152          ["dcc.enabled",        true,     "dcc"],
 153          ["dcc.autoAccept.delay", 10000,  "hidden"],
 154          ["dcc.downloadsFolder", getURLSpecFromFile(downloadsPath.path), "dcc"],
 155          ["dcc.listenPorts",    [],       "dcc.ports"],
 156          ["dcc.useServerIP",    true,     "dcc"],
 157          ["debugMode",          "",       "hidden"],
 158          ["defaultQuitMsg",     "",       ".connect"],
 159          ["desc",               "New Now Know How", ".ident"],
 160          ["deleteOnPart",       true,     "global"],
 161          ["displayHeader",      true,     "appearance.misc"],
 162          ["guessCommands",      true,     "hidden"],
 163          ["hasPrefs",           false,    "hidden"],
 164          ["font.family",        "default", "appearance.misc"],
 165          ["font.size",          0,        "appearance.misc"],
 166          ["identd.enabled",     false,    client.prefManager.identGroup],
 167          ["initialURLs",        [],       "startup.initialURLs"],
 168          ["initialScripts",     [getURLSpecFromFile(scriptPath.path)],
 169                                           "startup.initialScripts"],
 170          ["instrumentation.key", 0,      "hidden"],
 171          ["instrumentation.inst1", 0,    "hidden"],
 172          ["link.focus",         true,     "global.links"],
 173          ["log",                false,                                  ".log"],
 174          ["logFileName",        makeLogNameClient,                    "hidden"],
 175          ["logFile.client",     "client.$y-$m-$d.log",                "hidden"],
 176          ["logFile.network",    "$(network)/$(network).$y-$m-$d.log", "hidden"],
 177          ["logFile.channel",    "$(network)/channels/$(channel).$y-$m-$d.log",
 178                                                                       "hidden"],
 179          ["logFile.user",       "$(network)/users/$(user).$y-$m-$d.log",
 180                                                                       "hidden"],
 181          ["logFile.dccuser",    "dcc/$(user)/$(user).$y-$m-$d.log",   "hidden"],
 182          ["logFolder",          getURLSpecFromFile(logPath.path), ".log"],
 183          ["messages.click",     gotos[0],   "global.links"],
 184          ["messages.ctrlClick", gotos[1],   "global.links"],
 185          ["messages.metaClick", gotos[2],   "global.links"],
 186          ["messages.middleClick", gotos[3], "global.links"],
 187          ["motif.dark",         "chrome://chatzilla/skin/output-dark.css",
 188                                           "appearance.motif"],
 189          ["motif.light",        "chrome://chatzilla/skin/output-light.css",
 190                                           "appearance.motif"],
 191          ["motif.default",      "chrome://chatzilla/skin/output-default.css",
 192                                           "appearance.motif"],
 193          ["motif.current",      "chrome://chatzilla/skin/output-default.css",
 194                                           "appearance.motif"],
 195          //["msgBeep",            "beep beep", "global.sounds"],
 196          ["multiline",          false,    "hidden"],
 197          ["munger.bold",        true,     "munger"],
 198          ["munger.bugzilla-link", true,   "munger"],
 199          ["munger.channel-link",true,     "munger"],
 200          ["munger.colorCodes",  true,     "munger"],
 201          ["munger.ctrl-char",   true,     "munger"],
 202          ["munger.face",        true,     "munger"],
 203          ["munger.italic",      true,     "munger"],
 204          ["munger.link",        true,     "munger"],
 205          ["munger.mailto",      true,     "munger"],
 206          ["munger.quote",       true,     "munger"],
 207          ["munger.rheet",       true,     "munger"],
 208          ["munger.talkback-link", true,   "munger"],
 209          ["munger.teletype",    true,     "munger"],
 210          ["munger.underline",   true,     "munger"],
 211          ["munger.word-hyphenator", true, "munger"],
 212          ["networkHeader",      true,     "global.header"],
 213          ["networkLog",         false,    "global.log"],
 214          ["networkMaxLines",    200,      "global.maxLines"],
 215          ["newTabLimit",        15,       "global"],
 216          ["notify.aggressive",  true,     "global"],
 217          ["nickCompleteStr",    ":",      "global"],
 218          ["nickname",           defaultNick, ".ident"],
 219          ["nicknameList",       [],       "lists.nicknameList"],
 220          ["outgoing.colorCodes",  false,  "global"],
 221          ["outputWindowURL",   "chrome://chatzilla/content/output-window.html",
 222                                           "hidden"],
 223          ["proxy.typeOverride", "",       ".connect"],
 224          ["sortUsersByMode",    true,     "appearance.userlist"],
 225          //["queryBeep",          "beep",   "global.sounds"],
 226          ["reconnect",          true,     ".connect"],
 227          ["showModeSymbols",    false,    "appearance.userlist"],
 228          //["stalkBeep",          "beep",   "global.sounds"],
 229          ["stalkWholeWords",    true,     "lists.stalkWords"],
 230          ["stalkWords",         [],       "lists.stalkWords"],
 231          // Start == When view it opened.
 232          // Event == "Superfluous" activity.
 233          // Chat  == "Activity" activity.
 234          // Stalk == "Attention" activity.
 235          ["sound.enabled",       true,        "global.sounds"],
 236          ["sound.overlapDelay",  2000,        "global.sounds"],
 237          //["sound.surpressActive",false,       "global.sounds"],
 238          ["sound.channel.start", "",          "global.soundEvts"],
 239          ["sound.channel.event", "",          "global.soundEvts"],
 240          ["sound.channel.chat",  "",          "global.soundEvts"],
 241          ["sound.channel.stalk", "beep",      "global.soundEvts"],
 242          ["sound.user.start",    "beep beep", "global.soundEvts"],
 243          ["sound.user.stalk",    "beep",      "global.soundEvts"],
 244          ["inputSpellcheck",     true,                  "global"],
 245          ["timestamps",         false,        "appearance.timestamps"],
 246          ["timestamps.display", "[%H:%M]",    "appearance.timestamps"],
 247          ["timestamps.log",     "[%Y-%m-%d %H:%M:%S]", "hidden"],
 248          ["urls.list",          [],       "hidden"],
 249          ["urls.store.max",     100,      "global"],
 250          ["urls.display",       10,       "hidden"],
 251          ["username",           "chatzilla", ".ident"],
 252          ["usermode",           "+i",     ".ident"],
 253          ["userHeader",         true,     "global.header"],
 254          ["userlistLeft",       true,     "appearance.userlist"],
 255          ["userLog",            false,    "global.log"],
 256          ["userMaxLines",       200,      "global.maxLines"],
 257          ["warnOnClose",        true,     "global"]
 258         ];
 259
 260     client.prefManager.addPrefs(prefs);
 261     client.prefManager.addObserver({ onPrefChanged: onPrefChanged });
 262
 263     CIRCNetwork.prototype.stayingPower  = client.prefs["reconnect"];
 264     CIRCNetwork.prototype.MAX_CONNECT_ATTEMPTS = client.prefs["connectTries"];
 265     CIRCNetwork.prototype.INITIAL_NICK  = client.prefs["nickname"];
 266     CIRCNetwork.prototype.INITIAL_NAME  = client.prefs["username"];
 267     CIRCNetwork.prototype.INITIAL_DESC  = client.prefs["desc"];
 268     CIRCNetwork.prototype.INITIAL_UMODE = client.prefs["usermode"];
 269     CIRCNetwork.prototype.MAX_MESSAGES  = client.prefs["networkMaxLines"];
 270     CIRCNetwork.prototype.PROXY_TYPE_OVERRIDE = client.prefs["proxy.typeOverride"];
 271     CIRCChannel.prototype.MAX_MESSAGES  = client.prefs["channelMaxLines"];
 272     CIRCChanUser.prototype.MAX_MESSAGES = client.prefs["userMaxLines"];
 273     var dccUserMaxLines = client.prefs["dccUserMaxLines"];
 274     CIRCDCCChat.prototype.MAX_MESSAGES  = dccUserMaxLines;
 275     CIRCDCCFileTransfer.prototype.MAX_MESSAGES = dccUserMaxLines;
 276     CIRCDCC.prototype.listenPorts       = client.prefs["dcc.listenPorts"];
 277     client.MAX_MESSAGES                 = client.prefs["clientMaxLines"];
 278     client.charset                      = client.prefs["charset"];
 279
 280     initAliases();
 281 }
 282
 283 function makeLogName(obj, type)
 284 {
 285     function replaceNonPrintables(ch) {
 286         var rv = ch.charCodeAt().toString(16);
 287         if (rv.length == 1)
 288             rv = "0" + rv;
 289         else if (rv.length == 3)
 290             rv = "u0" + rv;
 291         else if (rv.length == 4)
 292             rv = "u" + rv;
 293
 294         return "%" + rv;
 295     };
 296
 297     function encode(text)
 298     {
 299         text = text.replace(/[^-A-Z0-9_#!.,'@~\[\]{}()%$"]/gi, replaceNonPrintables);
 300
 301         return encodeURIComponent(text);
 302     };
 303
 304     /*  /\$\(([^)]+)\)|\$(\w)/g   *
 305      *       <----->     <-->     *
 306      *      longName   shortName  *
 307      */
 308     function replaceParam(match, longName, shortName)
 309     {
 310         if (typeof longName != "undefined" && longName)
 311         {
 312             // Remember to encode these, don't want some dodgy # breaking stuff.
 313             if (longName in longCodes)
 314                 return encode(longCodes[longName]);
 315
 316             dd("Unknown long code: " + longName);
 317         }
 318         else if (typeof shortName != "undefined" && shortName)
 319         {
 320             if (shortName in shortCodes)
 321                 return encode(shortCodes[shortName]);
 322
 323             dd("Unknown short code: " + shortName);
 324         }
 325         else
 326         {
 327             dd("Unknown match: " + match);
 328         }
 329
 330         return match;
 331     };
 332
 333     var base = client.prefs["logFolder"];
 334     var specific = client.prefs["logFile." + type];
 335
 336     // Make sure we got ourselves a slash, or we'll be in trouble with the
 337     // concatenation.
 338     if (!base.match(/\/$/))
 339         base = base + "/";
 340     var file = base + specific;
 341
 342     // Get details for $-replacement variables.
 343     var info = getObjectDetails(obj);
 344
 345     // Store the most specific time short code on the object.
 346     obj.smallestLogInterval = "";
 347     if (file.indexOf("$y") != -1)
 348         obj.smallestLogInterval = "y";
 349     if (file.indexOf("$m") != -1)
 350         obj.smallestLogInterval = "m";
 351     if (file.indexOf("$d") != -1)
 352         obj.smallestLogInterval = "d";
 353     if (file.indexOf("$h") != -1)
 354         obj.smallestLogInterval = "h";
 355
 356     // Three longs codes: $(network), $(channel) and $(user).
 357     // Each is available only if appropriate for the object.
 358     var longCodes = new Object();
 359     if (info.network)
 360         longCodes["network"] = info.network.unicodeName;
 361     if (info.channel)
 362         longCodes["channel"] = info.channel.unicodeName;
 363     if (info.user)
 364         longCodes["user"] = info.user.unicodeName;
 365
 366     // 4 short codes: $y, $m, $d, $h.
 367     // These are time codes, each replaced with a fixed-length number.
 368     var d = new Date();
 369     var shortCodes = { y: padNumber(d.getFullYear(), 4),
 370                        m: padNumber(d.getMonth() + 1, 2),
 371                        d: padNumber(d.getDate(), 2),
 372                        h: padNumber(d.getHours(), 2)
 373                      };
 374
 375     // Replace all $-variables in one go.
 376     file = file.replace(/\$\(([^)]+)\)|\$(\w)/g, replaceParam);
 377
 378     // Convert from file: URL to local OS format.
 379     try
 380     {
 381         file = getFileFromURLSpec(file).path;
 382     }
 383     catch(ex)
 384     {
 385         dd("Error converting '" + base + specific + "' to a local file path.");
 386     }
 387
 388     return file;
 389 }
 390
 391 function pref_mungeName(name)
 392 {
 393     var safeName = name.replace(/\./g, "-").replace(/:/g, "_").toLowerCase();
 394     return ecmaEscape(safeName);
 395 }
 396
 397 function getNetworkPrefManager(network)
 398 {
 399     function defer(prefName)
 400     {
 401         return client.prefs[prefName];
 402     };
 403
 404     function makeLogNameNetwork()
 405     {
 406         return makeLogName(network, "network");
 407     };
 408
 409     function onPrefChanged(prefName, newValue, oldValue)
 410     {
 411         onNetworkPrefChanged (network, prefName, newValue, oldValue);
 412     };
 413
 414     var logDefault = client.prefManager.logPath.clone();
 415     logDefault.append(escapeFileName(pref_mungeName(network.encodedName)) + ".log");
 416
 417     var prefs =
 418         [
 419          ["autoAwayPeriod",   defer, "appearance.misc"],
 420          ["autoRejoin",       defer, ".connect"],
 421          ["away",             defer, "hidden"],
 422          ["awayNick",         defer, ".ident"],
 423          ["bugURL",           defer, "appearance.misc"],
 424          ["bugURL.comment",   defer, "appearance.misc"],
 425          ["charset",          defer, ".connect"],
 426          ["collapseActions",  defer, "appearance.misc"],
 427          ["collapseMsgs",     defer, "appearance.misc"],
 428          ["conference.limit", defer, "appearance.misc"],
 429          ["connectTries",     defer, ".connect"],
 430          ["dcc.useServerIP",  defer, "dcc"],
 431          ["dcc.downloadsFolder", defer, "dcc"],
 432          ["dcc.autoAccept.list", [], "dcc.autoAccept"],
 433          ["defaultQuitMsg",   defer, ".connect"],
 434          ["desc",             defer, ".ident"],
 435          ["displayHeader",    client.prefs["networkHeader"],
 436                                                              "appearance.misc"],
 437          ["font.family",      defer, "appearance.misc"],
 438          ["font.size",        defer, "appearance.misc"],
 439          ["hasPrefs",         false, "hidden"],
 440          ["identd.enabled",   defer, client.prefManager.identGroup],
 441          ["ignoreList",       [],    "hidden"],
 442          ["log",              client.prefs["networkLog"], ".log"],
 443          ["logFileName",      makeLogNameNetwork, "hidden"],
 444          ["motif.current",    defer, "appearance.motif"],
 445          ["nickname",         defer, ".ident"],
 446          ["nicknameList",     defer, "lists.nicknameList"],
 447          ["notifyList",       [],    "lists.notifyList"],
 448          ["outputWindowURL",  defer, "hidden"],
 449          ["proxy.typeOverride", defer, ".connect"],
 450          ["reconnect",        defer, ".connect"],
 451          ["timestamps",         defer, "appearance.timestamps"],
 452          ["timestamps.display", defer, "appearance.timestamps"],
 453          ["timestamps.log",     defer, "hidden"],
 454          ["username",         defer, ".ident"],
 455          ["usermode",         defer, ".ident"],
 456          ["autoperform",      [],    "lists.autoperform"]
 457         ];
 458
 459     var branch = "extensions.irc.networks." + pref_mungeName(network.encodedName) +
 460         ".";
 461     var prefManager = new PrefManager(branch, client.defaultBundle);
 462     prefManager.addPrefs(prefs);
 463     prefManager.addObserver({ onPrefChanged: onPrefChanged });
 464     client.prefManager.addObserver(prefManager);
 465
 466     var value = prefManager.prefs["nickname"];
 467     if (value != CIRCNetwork.prototype.INITIAL_NICK)
 468         network.INITIAL_NICK = value;
 469
 470     value = prefManager.prefs["username"];
 471     if (value != CIRCNetwork.prototype.INITIAL_NAME)
 472         network.INITIAL_NAME = value;
 473
 474     value = prefManager.prefs["desc"];
 475     if (value != CIRCNetwork.prototype.INITIAL_DESC)
 476         network.INITIAL_DESC = value;
 477
 478     value = prefManager.prefs["usermode"];
 479     if (value != CIRCNetwork.prototype.INITIAL_UMODE)
 480         network.INITIAL_UMODE = value;
 481
 482     value = prefManager.prefs["proxy.typeOverride"];
 483     if (value != CIRCNetwork.prototype.PROXY_TYPE_OVERRIDE)
 484         network.PROXY_TYPE_OVERRIDE = value;
 485
 486     network.stayingPower  = prefManager.prefs["reconnect"];
 487     network.MAX_CONNECT_ATTEMPTS = prefManager.prefs["connectTries"];
 488
 489     client.prefManagers.push(prefManager);
 490
 491     return prefManager;
 492 }
 493
 494 function getChannelPrefManager(channel)
 495 {
 496     var network = channel.parent.parent;
 497
 498     function defer(prefName)
 499     {
 500         return network.prefs[prefName];
 501     };
 502
 503     function makeLogNameChannel()
 504     {
 505         return makeLogName(channel, "channel");
 506     };
 507
 508     function onPrefChanged(prefName, newValue, oldValue)
 509     {
 510         onChannelPrefChanged (channel, prefName, newValue, oldValue);
 511     };
 512
 513     var logDefault = client.prefManager.logPath.clone();
 514     var filename = pref_mungeName(network.encodedName) + "," +
 515         pref_mungeName(channel.encodedName);
 516
 517     logDefault.append(escapeFileName(filename) + ".log");
 518
 519     var prefs =
 520         [
 521          ["autoRejoin",       defer, ".connect"],
 522          ["bugURL",           defer, "appearance.misc"],
 523          ["bugURL.comment",   defer, "appearance.misc"],
 524          ["charset",          defer, ".connect"],
 525          ["collapseActions",  defer, "appearance.misc"],
 526          ["collapseMsgs",     defer, "appearance.misc"],
 527          ["conference.enabled", false, "hidden"],
 528          ["conference.limit", defer, "appearance.misc"],
 529          ["displayHeader",    client.prefs["channelHeader"],
 530                                                              "appearance.misc"],
 531          ["font.family",      defer, "appearance.misc"],
 532          ["font.size",        defer, "appearance.misc"],
 533          ["hasPrefs",         false, "hidden"],
 534          ["log",              client.prefs["channelLog"], ".log"],
 535          ["logFileName",      makeLogNameChannel, "hidden"],
 536          ["motif.current",    defer, "appearance.motif"],
 537          ["timestamps",         defer, "appearance.timestamps"],
 538          ["timestamps.display", defer, "appearance.timestamps"],
 539          ["timestamps.log",     defer, "hidden"],
 540          ["outputWindowURL",  defer, "hidden"]
 541         ];
 542
 543     var branch = "extensions.irc.networks." + pref_mungeName(network.encodedName) +
 544         ".channels." + pref_mungeName(channel.encodedName) + "."
 545     var prefManager = new PrefManager(branch, client.defaultBundle);
 546     prefManager.addPrefs(prefs);
 547     prefManager.addObserver({ onPrefChanged: onPrefChanged });
 548     network.prefManager.addObserver(prefManager);
 549
 550     client.prefManagers.push(prefManager);
 551
 552     return prefManager;
 553 }
 554
 555 function getUserPrefManager(user)
 556 {
 557     var network = user.parent.parent;
 558
 559     function defer(prefName)
 560     {
 561         return network.prefs[prefName];
 562     };
 563
 564     function makeLogNameUser()
 565     {
 566         return makeLogName(user, "user");
 567     };
 568
 569     function onPrefChanged(prefName, newValue, oldValue)
 570     {
 571         onUserPrefChanged (user, prefName, newValue, oldValue);
 572     };
 573
 574     var logDefault = client.prefManager.logPath.clone();
 575     var filename = pref_mungeName(network.encodedName);
 576     filename += "," + pref_mungeName(user.encodedName);
 577     logDefault.append(escapeFileName(filename) + ".log");
 578
 579     var prefs =
 580         [
 581          ["charset",          defer, ".connect"],
 582          ["collapseActions",  defer, "appearance.misc"],
 583          ["collapseMsgs",     defer, "appearance.misc"],
 584          ["displayHeader",    client.prefs["userHeader"], "appearance.misc"],
 585          ["font.family",      defer, "appearance.misc"],
 586          ["font.size",        defer, "appearance.misc"],
 587          ["hasPrefs",         false, "hidden"],
 588          ["motif.current",    defer, "appearance.motif"],
 589          ["outputWindowURL",  defer, "hidden"],
 590          ["log",              client.prefs["userLog"], ".log"],
 591          ["logFileName",      makeLogNameUser, "hidden"],
 592          ["timestamps",         defer, "appearance.timestamps"],
 593          ["timestamps.display", defer, "appearance.timestamps"],
 594          ["timestamps.log",     defer, "hidden"]
 595         ];
 596
 597     var branch = "extensions.irc.networks." + pref_mungeName(network.encodedName) +
 598         ".users." + pref_mungeName(user.encodedName) + ".";
 599     var prefManager = new PrefManager(branch, client.defaultBundle);
 600     prefManager.addPrefs(prefs);
 601     prefManager.addObserver({ onPrefChanged: onPrefChanged });
 602     network.prefManager.addObserver(prefManager);
 603
 604     client.prefManagers.push(prefManager);
 605
 606     return prefManager;
 607 }
 608
 609 function getDCCUserPrefManager(user)
 610 {
 611     function defer(prefName)
 612     {
 613         return client.prefs[prefName];
 614     };
 615
 616     function makeLogNameUser()
 617     {
 618         return makeLogName(user, "dccuser");
 619     };
 620
 621     function onPrefChanged(prefName, newValue, oldValue)
 622     {
 623         onDCCUserPrefChanged(user, prefName, newValue, oldValue);
 624     };
 625
 626     var prefs =
 627         [
 628          ["charset",          defer, ".connect"],
 629          ["collapseMsgs",     defer, "appearance.misc"],
 630          ["displayHeader",    client.prefs["dccUserHeader"], "appearance.misc"],
 631          ["font.family",      defer, "appearance.misc"],
 632          ["font.size",        defer, "appearance.misc"],
 633          ["hasPrefs",         false, "hidden"],
 634          ["motif.current",    defer, "appearance.motif"],
 635          ["outputWindowURL",  defer, "hidden"],
 636          ["log",              client.prefs["dccUserLog"], ".log"],
 637          ["logFileName",      makeLogNameUser, "hidden"],
 638          ["timestamps",         defer, "appearance.timestamps"],
 639          ["timestamps.display", defer, "appearance.timestamps"],
 640          ["timestamps.log",     defer, "hidden"]
 641         ];
 642
 643     var branch = "extensions.irc.dcc.users." +
 644                  pref_mungeName(user.canonicalName) + ".";
 645     var prefManager = new PrefManager(branch, client.defaultBundle);
 646     prefManager.addPrefs(prefs);
 647     prefManager.addObserver({ onPrefChanged: onPrefChanged });
 648     client.prefManager.addObserver(prefManager);
 649
 650     client.prefManagers.push(prefManager);
 651
 652     return prefManager;
 653 }
 654
 655 function destroyPrefs()
 656 {
 657     if ("prefManagers" in client)
 658     {
 659         for (var i = 0; i < client.prefManagers.length; ++i)
 660             client.prefManagers[i].destroy();
 661         client.prefManagers = [];
 662     }
 663 }
 664
 665 function onPrefChanged(prefName, newValue, oldValue)
 666 {
 667     switch (prefName)
 668     {
 669         case "awayIdleTime":
 670             uninitIdleAutoAway(oldValue);
 671             initIdleAutoAway(newValue);
 672             break;
 673
 674         case "channelMaxLines":
 675             CIRCChannel.prototype.MAX_MESSAGES = newValue;
 676             break;
 677
 678         case "charset":
 679             client.charset = newValue;
 680             break;
 681
 682         case "clientMaxLines":
 683             client.MAX_MESSAGES = newValue;
 684             break;
 685
 686         case "connectTries":
 687             CIRCNetwork.prototype.MAX_CONNECT_ATTEMPTS = newValue;
 688             break;
 689
 690         case "dcc.listenPorts":
 691             CIRCDCC.prototype.listenPorts = newValue;
 692             break;
 693
 694         case "dccUserMaxLines":
 695             CIRCDCCFileTransfer.prototype.MAX_MESSAGES  = newValue;
 696             CIRCDCCChat.prototype.MAX_MESSAGES  = newValue;
 697             break;
 698
 699         case "font.family":
 700         case "font.size":
 701             client.dispatch("sync-font");
 702             break;
 703
 704         case "instrumentation.inst1":
 705             if ((oldValue == 0) && (newValue == 1))
 706                 runInstrumentation("inst1", true);
 707             else
 708                 runInstrumentation("inst1", false);
 709             break;
 710
 711         case "proxy.typeOverride":
 712             CIRCNetwork.prototype.PROXY_TYPE_OVERRIDE = newValue;
 713             break;
 714
 715         case "reconnect":
 716             CIRCNetwork.prototype.stayingPower = newValue;
 717             break;
 718
 719         case "showModeSymbols":
 720             if (newValue)
 721                 setListMode("symbol");
 722             else
 723                 setListMode("graphic");
 724             break;
 725
 726         case "nickname":
 727             CIRCNetwork.prototype.INITIAL_NICK = newValue;
 728             break;
 729
 730         case "username":
 731             CIRCNetwork.prototype.INITIAL_NAME = newValue;
 732             break;
 733
 734         case "usermode":
 735             CIRCNetwork.prototype.INITIAL_UMODE = newValue;
 736             break;
 737
 738         case "userMaxLines":
 739             CIRCChanUser.prototype.MAX_MESSAGES = newValue;
 740             break;
 741
 742         case "userlistLeft":
 743             updateUserlistSide(newValue);
 744             break;
 745
 746         case "debugMode":
 747             setDebugMode(newValue);
 748             break;
 749
 750         case "desc":
 751             CIRCNetwork.prototype.INITIAL_DESC = newValue;
 752             break;
 753
 754         case "stalkWholeWords":
 755         case "stalkWords":
 756             updateAllStalkExpressions();
 757             break;
 758
 759         case "sortUsersByMode":
 760             if (client.currentObject.TYPE == "IRCChannel")
 761                 updateUserList();
 762
 763         case "motif.current":
 764             client.dispatch("sync-motif");
 765             break;
 766
 767         case "multiline":
 768             multilineInputMode(newValue);
 769             break;
 770
 771         case "munger.colorCodes":
 772             client.enableColors = newValue;
 773             break;
 774
 775         case "networkMaxLines":
 776             CIRCNetwork.prototype.MAX_MESSAGES = newValue;
 777             break;
 778
 779         case "outputWindowURL":
 780             client.dispatch("sync-window");
 781             break;
 782
 783         case "displayHeader":
 784             client.dispatch("sync-header");
 785             break;
 786
 787         case "timestamps":
 788         case "timestamps.display":
 789             client.dispatch("sync-timestamp");
 790             break;
 791
 792         case "log":
 793             client.dispatch("sync-log");
 794             break;
 795
 796         case "aliases":
 797             initAliases();
 798             break;
 799
 800         case "inputSpellcheck":
 801             updateSpellcheck(newValue);
 802             break;
 803
 804         default:
 805             // Make munger prefs apply without a restart
 806             var m, rule;
 807             if ((m = prefName.match(/^munger\.(\S+)$/)) &&
 808                 (rule = client.munger.getRule(m[1])))
 809             {
 810                 rule.enabled = newValue;
 811             }
 812     }
 813 }
 814
 815 function onNetworkPrefChanged(network, prefName, newValue, oldValue)
 816 {
 817     if (network != client.networks[network.canonicalName])
 818     {
 819         /* this is a stale observer, remove it */
 820         network.prefManager.destroy();
 821         return;
 822     }
 823
 824     network.updateHeader();
 825
 826     switch (prefName)
 827     {
 828         case "nickname":
 829             network.INITIAL_NICK = newValue;
 830             break;
 831
 832         case "username":
 833             network.INITIAL_NAME = newValue;
 834             break;
 835
 836         case "usermode":
 837             network.INITIAL_UMODE = newValue;
 838             if (network.isConnected())
 839             {
 840                 network.primServ.sendData("mode " + network.server.me + " :" +
 841                                           newValue + "\n");
 842             }
 843             break;
 844
 845         case "desc":
 846             network.INITIAL_DESC = newValue;
 847             break;
 848
 849         case "proxy.typeOverride":
 850             network.PROXY_TYPE_OVERRIDE = newValue;
 851             break;
 852
 853         case "reconnect":
 854             network.stayingPower = newValue;
 855             break;
 856
 857         case "font.family":
 858         case "font.size":
 859             network.dispatch("sync-font");
 860             break;
 861
 862         case "motif.current":
 863             network.dispatch("sync-motif");
 864             break;
 865
 866         case "outputWindowURL":
 867             network.dispatch("sync-window");
 868             break;
 869
 870         case "displayHeader":
 871             network.dispatch("sync-header");
 872             break;
 873
 874         case "timestamps":
 875         case "timestamps.display":
 876             network.dispatch("sync-timestamp");
 877             break;
 878
 879         case "log":
 880             network.dispatch("sync-log");
 881             break;
 882
 883         case "connectTries":
 884             network.MAX_CONNECT_ATTEMPTS = newValue;
 885             break;
 886     }
 887 }
 888
 889 function onChannelPrefChanged(channel, prefName, newValue, oldValue)
 890 {
 891     var network = channel.parent.parent;
 892
 893     if (network != client.networks[network.canonicalName] ||
 894         channel.parent != network.primServ ||
 895         channel != network.primServ.channels[channel.canonicalName])
 896     {
 897         /* this is a stale observer, remove it */
 898         channel.prefManager.destroy();
 899         return;
 900     }
 901
 902     channel.updateHeader();
 903
 904     switch (prefName)
 905     {
 906         case "conference.enabled":
 907             // Wouldn't want to display a message to a hidden view.
 908             if ("messages" in channel)
 909             {
 910                 if (newValue)
 911                     channel.display(MSG_CONF_MODE_ON);
 912                 else
 913                     channel.display(MSG_CONF_MODE_OFF);
 914             }
 915             break;
 916
 917         case "conference.limit":
 918             channel._updateConferenceMode();
 919             break;
 920
 921         case "font.family":
 922         case "font.size":
 923             channel.dispatch("sync-font");
 924             break;
 925
 926         case "motif.current":
 927             channel.dispatch("sync-motif");
 928             break;
 929
 930         case "outputWindowURL":
 931             channel.dispatch("sync-window");
 932             break;
 933
 934         case "displayHeader":
 935             channel.dispatch("sync-header");
 936             break;
 937
 938         case "timestamps":
 939         case "timestamps.display":
 940             channel.dispatch("sync-timestamp");
 941             break;
 942
 943         case "log":
 944             channel.dispatch("sync-log");
 945             break;
 946     }
 947 }
 948
 949 function onUserPrefChanged(user, prefName, newValue, oldValue)
 950 {
 951     var network = user.parent.parent;
 952
 953     if (network != client.networks[network.canonicalName] ||
 954         user.parent != network.primServ ||
 955         user != network.primServ.users[user.canonicalName])
 956     {
 957         /* this is a stale observer, remove it */
 958         user.prefManager.destroy();
 959         return;
 960     }
 961
 962     user.updateHeader();
 963
 964     switch (prefName)
 965     {
 966         case "font.family":
 967         case "font.size":
 968             user.dispatch("sync-font");
 969             break;
 970
 971         case "motif.current":
 972             user.dispatch("sync-motif");
 973             break;
 974
 975         case "outputWindowURL":
 976             user.dispatch("sync-window");
 977             break;
 978
 979         case "displayHeader":
 980             user.dispatch("sync-header");
 981             break;
 982
 983         case "timestamps":
 984         case "timestamps.display":
 985             user.dispatch("sync-timestamp");
 986             break;
 987
 988         case "log":
 989             user.dispatch("sync-log");
 990             break;
 991     }
 992 }
 993
 994 function onDCCUserPrefChanged(user, prefName, newValue, oldValue)
 995 {
 996     if (client.dcc.users[user.key] != user)
 997     {
 998         /* this is a stale observer, remove it */
 999         user.prefManager.destroy();
1000         return;
1001     }
1002
1003     // DCC Users are a pain, they can have multiple views!
1004     function updateDCCView(view)
1005     {
1006         switch (prefName)
1007         {
1008             case "font.family":
1009             case "font.size":
1010                 view.dispatch("sync-font");
1011                 break;
1012
1013             case "motif.current":
1014                 view.dispatch("sync-motif");
1015                 break;
1016
1017             case "outputWindowURL":
1018                 view.dispatch("sync-window");
1019                 break;
1020
1021             case "displayHeader":
1022                 view.dispatch("sync-header");
1023                 break;
1024
1025             case "timestamps":
1026             case "timestamps.display":
1027                 view.dispatch("sync-timestamp");
1028                 break;
1029
1030             case "log":
1031                 view.dispatch("sync-log");
1032                 break;
1033         }
1034     };
1035
1036     for (var i = 0; client.dcc.chats.length; i++)
1037     {
1038         var chat = client.dcc.chats[i];
1039         if (chat.user == user)
1040             updateDCCView(chat);
1041     }
1042 }
1043
1044 function initAliases()
1045 {
1046     var aliasDefs = client.prefs["aliases"];
1047
1048     for (var i = 0; i < aliasDefs.length; ++i)
1049     {
1050         var ary = aliasDefs[i].match(/^(.*?)\s*=\s*(.*)$/);
1051         if (ary)
1052         {
1053             var name = ary[1];
1054             var list = ary[2];
1055
1056             client.commandManager.defineCommand(name, list);
1057         }
1058         else
1059         {
1060             dd("Malformed alias: " + aliasDefs[i]);
1061         }
1062     }
1063 }