Minami 80/MINAMI80.iso/Extra/DivXInstaller.exe/$PLUGINSDIR/GoogleToolbarFirefox.msi/xpi/chrome/google-toolbar.jar/content/gtb.js

Text File | 2006-05-15 | 387KB | 9,769 lines

// Copyright 2006 Google Inc.
// All Rights Reserved.

var GTB_MAIL_PREF_PROVIDERS = "mailto.providers";
var GTB_PREF_OPT_MAIL = "mailto.opt";
var GTB_MAIL_HANDLER_CONFIGURED = "mailto.gmail.configured";
function GTB_MailtoLink(opt_to, opt_cc, opt_bcc, opt_subject, opt_body) {
  this.to = opt_to;
  this.cc = opt_cc;
  this.bcc = opt_bcc;
  this.subject = opt_subject;
  this.body = opt_body}

function GTB_MailProvider(opt_url, opt_name, opt_to, opt_cc, opt_bcc, opt_subject, opt_body) {
  this.url = opt_url;
  this.name = opt_name;
  this.to = opt_to;
  this.cc = opt_cc;
  this.bcc = opt_bcc;
  this.subject = opt_subject;
  this.body = opt_body}

function GTB_mailtoDump(message) {
  GTB_Dump(GTB_Dump.MT, message)}

function GTB_contentAreaClick(event, opt_fieldNormalClicks) {
  var processed = false;
  opt_fieldNormalClicks = !(!opt_fieldNormalClicks);
  try {
    processed = GTB_getToolbar().mailto.onContentAreaClick(event)}
  catch(e) {
    processed = false}
  GTB_mailtoDump("processed: " + processed);
  if(!processed) {
    window.contentAreaClick(event, opt_fieldNormalClicks)}
  else {
    return false}
}

function GTB_mailto_FirstRun_onAccept(event) {
  GTB_getPrefs().setBoolPref(GTB_PREF_OPT_MAIL, true)}

function GTB_mailto_FirstRun_onCancel(event) {
  GTB_getPrefs().setBoolPref(GTB_PREF_OPT_MAIL, false)}

function GTB_Mailto() {
  this.checkURLFlag_ = true;
  var content = document.getElementById("content");
  content.addEventListener("click", GTB_contentAreaClick, true)}

GTB_Mailto.prototype.onPageLoad = function(event) {
  GTB_mailtoDump("mailto.onPageLoad");
  var doc = event.target;
  if(this.checkURLFlag_) {
    this.checkURL_(doc)}
}

;
GTB_Mailto.prototype.onGmailURL = function() {
  var psvc = GTB_getPrefs();
  var isMailtoConfigured = psvc.getBoolPrefWithDefault(GTB_MAIL_HANDLER_CONFIGURED, false);
  var useMailto = psvc.getBoolPref(GTB_PREF_OPT_MAIL);
  if(isMailtoConfigured || useMailto) {
    return}
  window.openDialog("chrome://google-toolbar/content/mailto-first-run.xul", "gtbMailtoFirstRun", "modal,centerscreen,chrome,resizable=no", this.languageCode);
  psvc.setBoolPref(GTB_MAIL_HANDLER_CONFIGURED, true)}

;
GTB_Mailto.prototype.checkURL_ = function(doc) {
  var ios = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
  var xpcomUrl = ios.newURI(doc.location.href, null, null);
  if(!(xpcomUrl  instanceof Components.interfaces.nsIURL)) {
    return}
  var url = GTB_convertToUrl(xpcomUrl);
  GTB_mailtoDump("testing if gmail url: " + url.host);
  if(this.isGMail_(url.host)) {
    this.onGmailURL()}
}

;
GTB_Mailto.prototype.isGMail_ = function(domain) {
  return GTB_isGoogleDomain(domain) && domain.indexOf("mail.") != -1}

;
GTB_Mailto.prototype.onContentAreaClick = function(event) {
  GTB_mailtoDump("onContentAreaClick");
  var psvc = GTB_getPrefs();
  var useMailto = false;
  if(psvc.getBoolPref(GTB_PREF_OPT_MAIL) && event.button == 0) {
    var linkString;
    var target = null;
    try {
      linkString = event.originalTarget.getAttribute("href").toString();
      target = event.originalTarget}
    catch(e) {
      target = null}
    if(!linkString) {
      try {
        linkString = event.originalTarget.parentNode.getAttribute("href").toString();
        target = event.originalTarget.parentNode}
      catch(e) {
        linkString = "";
        target = null}
    }
    var mailtoStr = linkString.toLowerCase();
    if(mailtoStr.indexOf("mailto:") > -1 && mailtoStr.indexOf("mailto:") < 7 && !target.hasAttribute("onclick")) {
      GTB_mailtoDump("found mailto link");
      useMailto = true;
      this.ComposeDefault_(linkString)}
    else {
      useMailto = false}
  }
  if(useMailto)event.preventDefault();
  return useMailto}

;
GTB_Mailto.prototype.ComposeDefault_ = function(aURI) {
  var psvc = GTB_getPrefs();
  var default_provider = psvc.getStringPref("mailto.default");
  GTB_mailtoDump("Default Provider" + default_provider);
  this.ComposeSelected(aURI, default_provider)}

;
GTB_Mailto.prototype.ComposeSelected = function(aURI, mail_provider) {
  var psvc = GTB_getPrefs();
  var mailProviderUrl = psvc.getStringPref(GTB_MAIL_PREF_PROVIDERS + "." + mail_provider);
  GTB_mailtoDump("Default ProviderURL" + mailProviderUrl);
  var provider = this.parseProvider_(mailProviderUrl);
  GTB_mailtoDump("Get Provider");
  aURI = aURI.split(" ").join("%20");
  var mailto = this.parseMailto_(aURI);
  GTB_mailtoDump("Get mailto");
  var url = this.getUrl_(provider, mailto);
  var browserAccess = new nsBrowserAccess;
  var ios = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
  var xpcomUrl = ios.newURI(url, null, null);
  browserAccess.openURI(xpcomUrl, null, nsCI.nsIBrowserDOMWindow.OPEN_DEFAULTWINDOW, null)}

;
GTB_Mailto.prototype.parseMailto_ = function(uri) {
  var re1 = /mailto:(\S*)(\?)(\S*)/i;
  var rv = uri.match(re1);
  if(!rv) {
    var re2 = /mailto:(\S*)/i;
    rv = uri.match(re2)}
  if(!rv || rv[1] == "") {
    return null}
  var mailto = new GTB_MailtoLink;
  mailto.to = rv[1];
  if(rv.length > 3) {
    this.parseParm_(rv[3], mailto)}
  return mailto}

;
GTB_Mailto.prototype.parseParm_ = function(str, obj) {
  var propertyPairs = str.split("&");
  for(var i = 0;i < propertyPairs.length; ++ i) {
    var propertyData = propertyPairs[i].split("=");
    obj[propertyData[0]] = propertyData[1]}
}

;
GTB_Mailto.prototype.parseProvider_ = function(uri) {
  var re = /firetool-mail:(\S*)(\@)(\S*)/;
  var rv = uri.match(re);
  if(!rv || rv[1] == "") {
    return null}
  var provider = new GTB_MailProvider;
  provider.url = rv[1];
  this.parseParm_(rv[3], provider);
  if(provider.name != null) {
    var r = /(\S*)\.(\w*)\.(\w*)\/(\S*)/;
    var se = rv[1].match(r);
    if(se != null && this.notSpam_(provider.name, se[2])) {
      return provider}
  }
  return null}

;
GTB_Mailto.prototype.clearDynaMenu_ = function() {
  var contextPopup = document.getElementById("contentAreaContextMenu");
  var children = contextPopup.childNodes;
  for(var i = children.length - 1;i >= 0; -- i) {
    var id = children[i].getAttribute("id");
    if(id.indexOf("mailto_") >= 0) {
      contextPopup.removeChild(children[i])}
  }
}

;
GTB_Mailto.prototype.loadDynaMenu = function() {
  GTB_mailtoDump("loading Dynamic Menu ...");
  this.clearDynaMenu_();
  var prefs = GTB_getPrefs();
  if(!prefs.getBoolPref(GTB_PREF_OPT_MAIL)) {
    return}
  var mailtoLink = this.getSelectedEmail_();
  var mailto = this.parseMailto_(mailtoLink);
  if(!mailto) {
    return}
  var children = prefs.getNamesOfChildren(GTB_MAIL_PREF_PROVIDERS, {});
  var contextPopup = document.getElementById("contentAreaContextMenu");
  var firstChild = contextPopup.firstChild;
  var menuSeparator = document.createElement("menuseparator");
  menuSeparator.setAttribute("id", "mailto_menuseparator");
  contextPopup.insertBefore(menuSeparator, firstChild);
  firstChild = contextPopup.firstChild;
  if(children.length > 0) {
    for(var i = 0;i < children.length; ++ i) {
      var current = children[i];
      var newElement = document.createElement("menuitem");
      var uri = prefs.getStringPref(GTB_MAIL_PREF_PROVIDERS + "." + current);
      var provider = this.parseProvider_(uri);
      var name = provider.name;
      newElement.setAttribute("id", "mailto_=" + i);
      newElement.setAttribute("label", name);
      newElement.setAttribute("oncommand", "GTB_ComposeSelected('" + mailto + "','" + name + "')");
      contextPopup.insertBefore(newElement, firstChild)}
  }
}

;
GTB_Mailto.prototype.getSelectedEmail_ = function() {
  var elem = document.popupNode;
  var email = null;
  if(elem) {
    if(elem  instanceof Components.interfaces.nsIDOMHTMLAnchorElement && elem.href) {
      email = elem.href.toString()}
    else {
      email = elem.parentNode.toString()}
  }
  return email}

;
GTB_Mailto.prototype.notSpam_ = function(name, domainName) {
  if(domainName == "yahoo" || domainName == "google" || domainName == "msn") {
    return true}
  if(domainName.toLowerCase() == name.toLowerCase()) {
    return true}
  document.writeln(domainName + " " + name);
  return false}

;
GTB_Mailto.prototype.addMailtoContent_ = function(para, value) {
  if(para && value) {
    var str = "&" + para + "=" + value;
    return str}
  else {
    return""}
}

;
GTB_Mailto.prototype.getUrl_ = function(provider, mailto) {
  var url = provider.url + "&" + provider.to + "=" + mailto.to;
  url += this.addMailtoContent_(provider.cc, mailto.cc);
  url += this.addMailtoContent_(provider.bcc, mailto.bcc);
  url += this.addMailtoContent_(provider.subject, mailto.subject);
  url += this.addMailtoContent_(provider.body, mailto.body);
  return url}

;
var GTB_PREF_OPT_IN = "opted_into_advanced_features_1";
var GTB_PREF_ADVANCED_DEFAULT = "button_option.safebrowsing.advancedprotection.default";
var GTB_PREF_REMEMBER_SEARCH_TYPE = "remember_search_type";
var GTB_PREF_GOOGLE_HOME = "google_home";
var GTB_PREF_SC_IGNORE_DUPS = "spell_check_ignore_dups";
var GTB_PREF_SC_IGNORE_DIGITS = "spell_check_ignore_digits";
var GTB_PREF_SC_IGNORE_ALL_CAPS = "spell_check_ignore_all_caps";
var GTB_PREF_SAVE_HISTORY = "search_box_save_history";
var GTB_PREF_SEARCH_ON_SELECT = "search_box_search_on_select";
var GTB_PREF_USE_SUGGEST = "search_box_use_suggest";
var GTB_PREF_AUTO_TRANSLATE = "auto_translate";
var GTB_PREF_FIRST_SEARCH = "first_search";
var GTB_PREF_FIRST_SEARCH_PING_RETRIES = "first_search_ping_retires";
var GTB_PREF_INSTALL_PING_ACKED = "install_ping_acked";
var GTB_PREF_INSTALL_PING_RETRIES = "install_ping_retires";
var GTB_PREF_INSTALL_ID = "install_id";
var GTB_LAST_PING_ATTEMPT = "last_ping_attempt";
var GTB_PREF_AUTO_LINK_NEW_WINDOW = "autolink.new_window";
var GTB_PREF_AUTO_FILL_SHOW_WARNING = "autofill.show_warning";
function GTB_Assert(condition, message) {
}

function GTB_Dump(zone, message) {
}

function GTB_Prefs() {
  this._registry = null;
  var registryClass = Components.classes["@google.com/regutil;1"];
  if(registryClass != null && Components.interfaces.GTBIRegUtil != null) {
    try {
      this._registry = registryClass.createInstance(Components.interfaces.GTBIRegUtil)}
    catch(e) {
      this._registry = null}
  }
}

GTB_Prefs.prototype = {USER_STATS_PREF:"userstats", REGISTRY_PATH:"SOFTWARE\\Google\\Toolbar for Firefox", _NAMESPACE_PREFIX:"google.toolbar.", _stringBundle:null, getLocaleDefault:function(key) {
  if(this._stringBundle == null) {
    this._stringBundle = document.getElementById("gtb-localized_prefs")}
  try {
    var value = this._stringBundle.getString(key + "_default")}
  catch(e) {
    return null}
  if(!value) {
    return null}
  if(value.toLowerCase() == "true" || value.toLowerCase == "t") {
    return"true"}
  if(value.toLowerCase() == "false" || value.toLowerCase == "f") {
    return"false"}
  return value}

, setBoolPref:function(key, value) {
  var psvc = this._getPreferences();
  psvc.setBoolPref(this._NAMESPACE_PREFIX + key, value)}

, getBoolPref:function(key) {
  var psvc = this._getPreferences();
  try {
    return psvc.getBoolPref(this._NAMESPACE_PREFIX + key)}
  catch(e) {
    var value = this.getLocaleDefault(key);
    if(value == "true") {
      psvc.setBoolPref(this._NAMESPACE_PREFIX + key, true)}
    else if(value == "false") {
      psvc.setBoolPref(this._NAMESPACE_PREFIX + key, false)}
    return psvc.getBoolPref(this._NAMESPACE_PREFIX + key)}
}

, getBoolPrefWithDefault:function(key, defaultValue) {
  var psvc = this._getPreferences();
  try {
    return psvc.getBoolPref(this._NAMESPACE_PREFIX + key)}
  catch(e) {
    var value = this.getLocaleDefault(key);
    if(value == "true") {
      psvc.setBoolPref(this._NAMESPACE_PREFIX + key, true)}
    else if(value == "false") {
      psvc.setBoolPref(this._NAMESPACE_PREFIX + key, false)}
    else {
      psvc.setBoolPref(this._NAMESPACE_PREFIX + key, defaultValue)}
    return psvc.getBoolPref(this._NAMESPACE_PREFIX + key)}
}

, setStringPref:function(key, value) {
  var psvc = this._getPreferences();
  psvc.setCharPref(this._NAMESPACE_PREFIX + key, value)}

, getStringPref:function(key) {
  var psvc = this._getPreferences();
  try {
    return psvc.getCharPref(this._NAMESPACE_PREFIX + key)}
  catch(e) {
    var value = this.getLocaleDefault(key);
    if(value) {
      psvc.setCharPref(this._NAMESPACE_PREFIX + key, value)}
    return psvc.getCharPref(this._NAMESPACE_PREFIX + key)}
}

, setLocalMachineString:function(key, value) {
  if(this._registry == null || !this._registry.setLocalMachineString(this.REGISTRY_PATH, key, value)) {
    this.setStringPref(key, value)}
}

, getLocalMachineString:function(key) {
  var result = null;
  if(this._registry != null) {
    result = this._registry.getLocalMachineString(this.REGISTRY_PATH, key)}
  if(result == null) {
    try {
      result = this.getStringPref(key)}
    catch(exception) {
      result = null}
  }
  return result}

, setLocalMachineInt:function(key, value) {
  if(this._registry == null || !this._registry.setLocalMachineString(this.REGISTRY_PATH, key, value.toString())) {
    this.setIntPref(key, value)}
}

, getLocalMachineIntWithDefault:function(key, defaultValue) {
  var result = null;
  if(this._registry != null) {
    var temp = this._registry.getLocalMachineString(this.REGISTRY_PATH, key);
    if(temp != null) {
      result = parseInt(temp)}
  }
  if(result == null) {
    result = this.getIntPrefWithDefault(key, defaultValue)}
  return result}

, getLocalMachineInt:function(key) {
  return this.getLocalMachineIntWithDefault(key, null)}

, getIntPrefWithDefault:function(key, defaultValue) {
  var psvc = this._getPreferences();
  try {
    return psvc.getIntPref(this._NAMESPACE_PREFIX + key)}
  catch(e) {
    return defaultValue}
}

, getIntPref:function(key) {
  return this.getIntPrefWithDefault(key, null)}

, setIntPref:function(key, value) {
  var psvc = this._getPreferences();
  try {
    psvc.setIntPref(this._NAMESPACE_PREFIX + key, value);
    return value}
  catch(e) {
    return null}
}

, setUnicodePref:function(key, value) {
  var psvc = this._getPreferences();
  var str = Components.classes["@mozilla.org/supports-string;1"].createInstance(Components.interfaces.nsISupportsString);
  str.data = value;
  psvc.setComplexValue(this._NAMESPACE_PREFIX + key, Components.interfaces.nsISupportsString, str)}

, getUnicodePref:function(key) {
  var psvc = this._getPreferences();
  return psvc.getComplexValue(this._NAMESPACE_PREFIX + key, Components.interfaces.nsISupportsString).data}

, getUnicodePrefWithDefault:function(key, defaultValue) {
  var psvc = this._getPreferences();
  try {
    return psvc.getComplexValue(this._NAMESPACE_PREFIX + key, Components.interfaces.nsISupportsString).data}
  catch(e) {
    var str = Components.classes["@mozilla.org/supports-string;1"].createInstance(Components.interfaces.nsISupportsString);
    str.data = defaultValue;
    psvc.setComplexValue(this._NAMESPACE_PREFIX + key, Components.interfaces.nsISupportsString, str);
    return psvc.getComplexValue(this._NAMESPACE_PREFIX + key, Components.interfaces.nsISupportsString).data}
}

, getNamesOfChildren:function(key) {
  var psvc = this._getPreferences();
  var service = Components.classes["@mozilla.org/preferences;1"].getService(Components.interfaces.nsIPrefService);
  var branch = service.getBranch(this._NAMESPACE_PREFIX + key + ".");
  var children = branch.getChildList("", {});
  return children}

, resetToDefault:function(key) {
  var psvc = this._getPreferences();
  try {
    psvc.clearUserPref(this._NAMESPACE_PREFIX + key)}
  catch(e) {
  }
}

, hasUserValue:function(key) {
  var psvc = this._getPreferences();
  return psvc.prefHasUserValue(this._NAMESPACE_PREFIX + key)}

, deleteBranch:function(key) {
  var psvc = this._getPreferences();
  psvc.deleteBranch(this._NAMESPACE_PREFIX + key)}

, _getPreferences:function() {
  var psvc = Components.classes["@mozilla.org/preferences;1"].getService(Components.interfaces.nsIPrefBranch);
  return psvc}

, _getRegistry:function() {
}

, selectValueFromMenu:function(key, menulist) {
  var value = this.getStringPref(key);
  menulist.selectedIndex = 0;
  var item = menulist.selectedItem;
  while(item != null) {
    if(this.getSelection(menulist) == value) {
      return}
    menulist.selectedIndex ++ ;
    item = menulist.selectedItem}
  menulist.selectedIndex = 0;
  this.setStringPref(key, this.getSelection(menulist))}

, getSelection:function(menulist) {
  var sel = menulist.selectedItem.value;
  if(sel == null || sel.length == 0) {
    sel = menulist.selectedItem.label}
  return sel}

};
function GTB_safeUrlEscape(url, len) {
  url = encodeURIComponent(url).substr(0, len);
  if("%" == url[url.length - 2])url = url.substr(0, url.length - 2);
  else if("%" == url[url.length - 1])url = url.substr(0, url.length - 1);
  return url}

;
function GTB_urlSplit(url) {
  return/^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/.exec(url)}

function GTB_parseQueryString(query) {
  var args = {};
  if(query) {
    var pairs = query.split("&");
    for(var p in pairs) {
      var tokens = pairs[p].split("=");
      if(tokens) {
        var key = decodeURIComponent(tokens.shift().replace(/[+]/g, " "));
        args[key] = decodeURIComponent(tokens.join("=").replace(/[+]/g, " "))}
    }
  }
  return args}

function GTB_isGoogleDomain(domain) {
  var tokens = domain.toLowerCase().split(".");
  for(var i = tokens.length - 1;i >= 0; -- i) {
    var token = tokens[i];
    if(validTldList.indexOf("." + token + ".") == -1) {
      return token == "google"}
  }
  return false}

function GTB_isCachedGoogleDomain(url) {
  var query = url.spec.match(/q=cache:\S*/);
  if(query == null) {
    return false}
  var cachedurl = query[0].match(/http:\S*/);
  if(!cachedurl) {
    return false}
  return GTB_isGoogleUrl(cachedurl[0])}

function GTB_convertToUrl(url) {
  if(typeof url == "string") {
    var ios = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
    url = ios.newURI(url, null, null)}
  return url}

function GTB_isGoogleResultUrl(url) {
  url = GTB_convertToUrl(url);
  return url != null && GTB_isGoogleUrl(url) && url.path.substring(0, 7) == "/search"}

function GTB_isGoogleDesktopSearchUrl(url) {
  url = GTB_convertToUrl(url);
  return url != null && url.scheme == "http" && (url.host == "127.0.0.1" || url.host == "localhost") && url.port == 4664}

function GTB_isGoogleUrl(url) {
  url = GTB_convertToUrl(url);
  return url != null && url.scheme == "http" && (GTB_isGoogleDesktopSearchUrl(url) || GTB_isGoogleDomain(url.host) || GTB_isCachedGoogleDomain(url))}

;
function GTB_NextPrevTooltip() {
  var stringBundle = document.getElementById("google-toolbar-strings");
  this.prevEnabled = stringBundle.getString("prop.google-nextprev.prevenabled.tooltip");
  this.prevDisabled = stringBundle.getString("prop.google-nextprev.prevdisabled.tooltip");
  this.nextEnabled = stringBundle.getString("prop.google-nextprev.nextenabled.tooltip");
  this.nextDisabled = stringBundle.getString("prop.google-nextprev.nextdisabled.tooltip")}

function GTB_NP_TabData() {
  this.initialize("")}

GTB_NP_TabData.prototype.initialize = function(query) {
  this.query = query;
  this.position = -1;
  this.clickedPosition = -1;
  this.links = [];
  this.linkToPosition = {}}

;
GTB_NP_TabData.prototype.copy = function(otherTabData) {
  if(otherTabData == this) {
    return}
  this.query = otherTabData.query;
  this.position = otherTabData.position;
  this.clickedPosition = otherTabData.clickedPosition;
  this.links = otherTabData.links;
  this.linkToPosition = otherTabData.linkToPosition}

;
function GTB_NextPrev() {
  this.npTooltip = new GTB_NextPrevTooltip;
  GTB_NextPrev.setTooltipText("gtbPrevTooltip", this.npTooltip.prevDisabled);
  GTB_NextPrev.setTooltipText("gtbNextTooltip", this.npTooltip.nextDisabled);
  this.observe = GTB_MessageObserve;
  this.xpcWindowMediator = Components.classes["@mozilla.org/appshell/window-mediator;1"].getService(Components.interfaces.nsIWindowMediator)}

GTB_NextPrev.setTooltipText = function(id, line1, opt_line2) {
  var tooltip = document.getElementById(id);
  if(tooltip == null) {
    return}
  var descs = tooltip.getElementsByTagName("description");
  if(descs && descs.length == 2) {
    descs[0].value = line1;
    if(opt_line2) {
      descs[1].value = opt_line2;
      descs[1].hidden = false}
    else {
      descs[1].hidden = true}
  }
}

;
GTB_NextPrev.prototype.doPageLoad = function(browser) {
  var button = document.getElementById("gtbNextResult");
  if(!button || !browser)return;
  if(!browser.GTB_NextPrevData) {
    browser.GTB_NextPrevData = new GTB_NP_TabData}
  var tabData = browser.GTB_NextPrevData;
  var doc = browser.contentWindow.document;
  if(GTB_isGoogleResultUrl(doc.location.href)) {
    this._newGoogleResultPage(doc, tabData)}
  else {
    var pos = tabData.linkToPosition[doc.location.href];
    if(pos != null) {
      tabData.position = pos}
  }
  if(browser == GTB_GoogleToolbarOverlay._getCurrentBrowser()) {
    this._updateButtons(tabData)}
}

;
GTB_NextPrev.prototype._newGoogleResultPage = function(doc, tabData) {
  var url_tokens = GTB_urlSplit(doc.location.href);
  var args = GTB_parseQueryString(url_tokens[7]);
  if(!args.q) {
    return}
  tabData.initialize(args.q);
  var links = this._getResultLinks(doc);
  var link;
  for(var pos = 0;link = links[pos]; ++ pos) {
    tabData.links.push(link.href);
    tabData.linkToPosition[link.href] = pos;
    link.setAttribute("__gg_", pos)}
  var win = doc.defaultView;
  if(win) {
    GTB_Dump(GTB_Dump.NP, "nextprev: adding event listener\n");
    win.addEventListener("click", GTB_NP_onPageClick, true)}
}

;
GTB_NextPrev.prototype._getResultLinks = function(doc) {
  var links = doc.getElementsByTagName("a");
  var results = [];
  var link;
  for(var i = 0;link = links[i]; ++ i) {
    var className = link.className;
    if(className) {
      className = " " + className + " ";
      if(className.indexOf(" l ") != -1) {
        results.push(link)}
    }
  }
  if(results.length > 0) {
    return results}
  var paras = doc.getElementsByTagName("p");
  var para;
  for(var p = 0;para = paras[p]; ++ p) {
    var pos = 0;
    var child = para.childNodes[pos];
    while(child && child.nodeType == Node.COMMENT_NODE) {
       ++ pos;
      child = para.childNodes[pos]}
    if(child && child.nodeType == Node.ELEMENT_NODE && "A" == child.nodeName) {
      results.push(child)}
  }
  return results}

;
GTB_NextPrev.prototype.doPageHide = function(event) {
  var doc = event.target;
  var win = doc && doc.defaultView;
  if(win && GTB_isGoogleResultUrl(doc.location.href)) {
    GTB_Dump(GTB_Dump.NP, "nextprev: removing event listener\n");
    win.removeEventListener("click", GTB_NP_onPageClick, true)}
}

;
GTB_NextPrev.prototype._updateButtons = function(tabData) {
  var button = document.getElementById("gtbPreviousResult");
  if(!button)return;
  var tooltip = "";
  if(tabData && tabData.position > 0) {
    tooltip = this.npTooltip.prevEnabled;
    tooltip = tooltip.replace("$lastq;", tabData.query);
    tooltip = tooltip.replace("$lf;", ":");
    tooltip = tooltip.replace("$prev;", "");
    GTB_NextPrev.setTooltipText("gtbPrevTooltip", tooltip, tabData.links[tabData.position - 1]);
    if(button) {
      button.disabled = false;
      button.image = "chrome://google-toolbar/skin/previous.png"}
  }
  else {
    GTB_NextPrev.setTooltipText("gtbPrevTooltip", this.npTooltip.prevDisabled);
    if(button) {
      button.disabled = true;
      button.image = "chrome://google-toolbar/skin/previous_disabled.png"}
  }
  button = document.getElementById("gtbNextResult");
  if(tabData && tabData.position != -1 && tabData.position < tabData.links.length - 1) {
    tooltip = this.npTooltip.nextEnabled;
    tooltip = tooltip.replace("$lastq;", tabData.query);
    tooltip = tooltip.replace("$lf;", ":");
    tooltip = tooltip.replace("$next;", "");
    GTB_NextPrev.setTooltipText("gtbNextTooltip", tooltip, tabData.links[tabData.position + 1]);
    if(button) {
      button.disabled = false;
      button.image = "chrome://google-toolbar/skin/next.png"}
  }
  else {
    GTB_NextPrev.setTooltipText("gtbNextTooltip", this.npTooltip.nextDisabled);
    if(button) {
      button.disabled = true;
      button.image = "chrome://google-toolbar/skin/next_disabled.png"}
  }
}

;
GTB_NextPrev.prototype.doTabSwitch = function(event) {
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  var tabData = browser.GTB_NextPrevData;
  if(!tabData)return;
  this._updateButtons(tabData)}

;
GTB_NextPrev.prototype.doNavigate = function(event, offset) {
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  var tabData = browser.GTB_NextPrevData;
  var newpos = tabData.position + parseInt(offset);
  if(tabData.position != -1 && newpos < tabData.links.length && newpos >= 0) {
    var url = tabData.links[newpos];
    var newBrowser = GTB_GoogleToolbarOverlay.loadUrlWithModifiers(url, event);
    if(!newBrowser)return;
    if(browser != newBrowser) {
      newBrowser.GTB_NextPrevData = new GTB_NP_TabData;
      newBrowser.GTB_NextPrevData.copy(tabData);
      newBrowser.GTB_NextPrevData.position = newpos;
      this._updateButtons(newBrowser.GTB_NextPrevData)}
    else {
      tabData.position = newpos;
      GTB_GoogleToolbarOverlay.nextPrev._updateButtons(tabData)}
  }
}

;
GTB_NextPrev.prototype._maybeUpdateNextPrevData = function(req) {
  var button = document.getElementById("gtbPreviousResult");
  if(!button)return;
  if(!req.loadGroup || !req.loadGroup.groupObserver) {
    return}
  var referrer = null;
  if(req.referrer && req.referrer.spec) {
    referrer = req.referrer.spec}
  if(referrer && GTB_isGoogleResultUrl(referrer)) {
    var groupObs = req.loadGroup.groupObserver;
    groupObs.QueryInterface(Components.interfaces.nsIWebProgress);
    var wbrowser = groupObs.DOMWindow;
    var wm = this.xpcWindowMediator;
    var enumerator = wm.getEnumerator("navigator:browser");
    var win, browser;
    while(enumerator.hasMoreElements()) {
      win = enumerator.getNext();
      browser = win.GTB_GoogleToolbarOverlay._getBrowserFromDoc(wbrowser.document);
      if(browser) {
        break}
    }
    if(!browser) {
      return}
    if(!browser.GTB_NextPrevData) {
      browser.GTB_NextPrevData = new GTB_NP_TabData}
    this._updateNextPrevData(browser.GTB_NextPrevData, referrer)}
}

;
GTB_NextPrev.prototype._updateNextPrevData = function(tabData, referrer) {
  var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"].getService(Components.interfaces.nsIWindowMediator);
  var enumerator = wm.getEnumerator("navigator:browser");
  while(enumerator.hasMoreElements()) {
    var win = enumerator.getNext();
    var tabBrowser = win.document.getElementById("content");
    var origBrowser;
    for(var b = 0;b < tabBrowser.browsers.length; ++ b) {
      origBrowser = tabBrowser.browsers[b];
      if(origBrowser.contentWindow.document.location.href == referrer) {
        var origData = origBrowser.GTB_NextPrevData;
        tabData.copy(origData);
        tabData.position = origData.clickedPosition;
        var curBrowser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
        if(tabData == curBrowser.GTB_NextPrevData) {
          this._updateButtons(tabData)}
        return}
    }
  }
}

;
GTB_NextPrev.prototype.GTB_MESSAGES = {"http-on-modify-request":function(data, subject) {
  subject.QueryInterface(Components.interfaces.nsIHttpChannel);
  if(subject.loadFlags & Components.interfaces.nsIChannel.LOAD_DOCUMENT_URI) {
    GTB_GoogleToolbarOverlay.nextPrev._maybeUpdateNextPrevData(subject)}
}

, "GTB_OPTION.button_option.gtbNextPrev":function(data) {
  var toolbar = GTB_getToolbar();
  var browser = toolbar._getCurrentBrowser();
  if("true" == data) {
    toolbar.nextPrev.doPageLoad(browser)}
  else if("false" == data) {
    if(browser.GTB_NextPrevData) {
      browser.GTB_NextPrevData = null}
  }
}

};
function GTB_NP_onPageClick(event) {
  var target = event.target;
  while(target) {
    if("A" == target.tagName && target.hasAttribute("__gg_")) {
      var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
      var tabData = browser.GTB_NextPrevData;
      var pos = parseInt(target.getAttribute("__gg_"));
      tabData.clickedPosition = pos;
      break}
    target = target.parentNode}
}

function GTB_GTO_onPreviousResult(event) {
  GTB_GoogleToolbarOverlay.nextPrev.doNavigate(event, -1)}

function GTB_GTO_onNextResult(event) {
  GTB_GoogleToolbarOverlay.nextPrev.doNavigate(event, +1)}

;
function GTB_hitch(obj, meth) {
  return function() {
    return meth.apply(obj, arguments)}

}

GTB_GoogleToolbar.doSuggestSearch = function() {
  if(GTB_getPrefs().getBoolPref(GTB_PREF_SEARCH_ON_SELECT) && !document.getElementById("gtbGoogleSearchBox").alreadySearched) {
    GTB_GoogleToolbarOverlay.doGoogleSearchType(null, "search", false, false)}
}

;
function GTB_MessageObserve(subject, topic, data) {
  for(var message in this.GTB_MESSAGES) {
    if(message == topic) {
      this.GTB_MESSAGES[message](data, subject);
      return}
  }
}

function GTB_getBrowserWindows() {
  var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"].getService(Components.interfaces.nsIWindowMediator);
  var enumerator = wm.getEnumerator("navigator:browser");
  var browsers = [];
  while(enumerator.hasMoreElements()) {
    browsers.push(enumerator.getNext())}
  return browsers}

function GTB_isGoogleToolbarItem(node) {
  return node && node.id && node.id.indexOf("gtb") == 0}

function GTB_isGoogleToolbarWrapperItem(node) {
  return node && node.id && node.id.indexOf("wrapper-gtb") == 0}

function GTB_GetAllItemsInPalette() {
  var toolbox = document.getElementById("navigator-toolbox");
  var ids = [];
  for(var i = 0;i < toolbox.palette.childNodes.length;i ++ ) {
    if(GTB_isGoogleToolbarItem(toolbox.palette.childNodes[i])) {
      ids.push(toolbox.palette.childNodes[i].id)}
  }
  return ids}

function GTB_GetAllItemsInGoogleToolbar() {
  var ids = {};
  var toolbar = document.getElementById("gtbToolbar");
  var child = toolbar.firstChild;
  while(child) {
    if(GTB_isGoogleToolbarItem(child)) {
      ids[child.id] = 1}
    child = child.nextSibling}
  return ids}

function GTB_SearchObserver() {
}

GTB_SearchObserver.prototype.getSupportedFlavours = function() {
  var flavours = new FlavourSet;
  if(GTB_getToolbar().languageCode != "ru") {
    flavours.appendFlavour("text/html")}
  flavours.appendFlavour("text/unicode");
  return flavours}

;
GTB_SearchObserver.prototype.onDragOver = function(evt, flavour, session) {
}

;
GTB_SearchObserver.prototype.onDrop = function(evt, dropdata, session) {
  if(!dropdata || !dropdata.data || dropdata.data == "") {
    return}
  var searchBox = document.getElementById("gtbGoogleSearchBox");
  if(evt.target != searchBox) {
    return}
  setTimeout(GTB_DragDropLoadSearch, 0, dropdata.data)}

;
function GTB_GetTextContent(node) {
  if(node.nodeType == Node.TEXT_NODE) {
    return node.nodeValue}
  else {
    var str = "";
    for(var i = 0;i < node.childNodes.length;i ++ ) {
      if(node.childNodes[i].nodeName != "SCRIPT") {
        str += GTB_GetTextContent(node.childNodes[i])}
    }
    return str}
}

function GTB_DragDropLoadSearch(data) {
  var searchBox = document.getElementById("gtbGoogleSearchBox");
  if(searchBox == null) {
    return}
  var tmpDiv = GTB_GoogleToolbarOverlay._getCurrentDocument().createElement("div");
  tmpDiv.innerHTML = data;
  var str = GTB_GetTextContent(tmpDiv);
  str = str.replace(/[\r\n]/g, "");
  str = Trim(str);
  if(str.length > 0) {
    if(str[0] != '"' && str[0] != "'") {
      if(str[str.length - 1] == "'") {
        str = "'" + str}
      else {
        str = '"' + str}
    }
    if(str[str.length - 1] != str[0]) {
      str = str + str[0]}
  }
  searchBox.value = str;
  var answer = GTB_GoogleToolbarOverlay.highlighter.onSearchTextChanged(str);
  GTB_GoogleToolbarOverlay._enableDisableQueryButtons(answer.hasTerms, answer.hasOps);
  GTB_GTO_onGoogleSearchType(null, GTB_GoogleToolbarOverlay._SEARCH_TYPE)}

function GTB_GoogleToolbar() {
  this.prefs = new GTB_Prefs}

GTB_GoogleToolbar.prototype._observerService = null;
GTB_GoogleToolbar.prototype.lastQuery = "";
GTB_GoogleToolbar.prototype.autoFill = null;
GTB_GoogleToolbar.prototype.autoLink = null;
GTB_GoogleToolbar.prototype.feedSubscribe = null;
GTB_GoogleToolbar.prototype.autoTranslate = null;
GTB_GoogleToolbar.prototype.chevron = null;
GTB_GoogleToolbar.prototype.customSearch = null;
GTB_GoogleToolbar.prototype.highlighter = null;
GTB_GoogleToolbar.prototype.mailto = null;
GTB_GoogleToolbar.prototype.infoButton = null;
GTB_GoogleToolbar.prototype.upButton = null;
GTB_GoogleToolbar.prototype.spellCheck = null;
GTB_GoogleToolbar.prototype.perTabData = null;
GTB_GoogleToolbar.prototype.npTooltip = null;
GTB_GoogleToolbar.prototype.prefs = null;
GTB_GoogleToolbar.toolboxCustomizeDone = null;
GTB_GoogleToolbar.prototype.pageRank = null;
GTB_GoogleToolbar.prototype.history = null;
GTB_GoogleToolbar.prototype.tabBrowser = null;
GTB_GoogleToolbar.prototype.GTB_MESSAGES = {ALERT:function(data) {
  alert("ALERT: " + data)}

, GTB_ADD_BUTTON:function(data) {
  GTB_GoogleToolbarOverlay._addButton(data)}

, GTB_REMOVE_BUTTON:function(data) {
  GTB_GoogleToolbarOverlay._removeButton(data)}

, GTB_SEARCH_PERFORMED:function(data) {
  GTB_GoogleToolbarOverlay.history.addToHistory(data)}

, "GTB_OPTION.remember_search_type":function(data) {
  if(data == "false") {
    GTB_GoogleToolbarOverlay.switchButton("search")}
}

, "GTB_OPTION.word_find":function(data) {
  GTB_GoogleToolbarOverlay.highlighter.toggleWordFindEnabled()}

, "GTB_OPTION.button_text_level":function(data) {
  GTB_GoogleToolbarOverlay._setButtonTextLevel(data)}

, "GTB_OPTION.button_option.gtbPageRank":function(data) {
  if(data != "false") {
    setTimeout(GTB_hitch(GTB_GoogleToolbarOverlay.pageRank, GTB_GoogleToolbarOverlay.pageRank.GPR_getPageRank), 0)}
}

, "GTB_OPTION.button_option.safebrowsing.advancedprotection":function(data) {
}

, "GTB_OPTION.button_option.safebrowsing.enabled":function(data) {
}

, "GTB_AutoFill.new_user_pref":function(data) {
  GTB_GoogleToolbarOverlay.autoFill._autofillUserPreferences = GTB_AutoFillManager.loadUserPreferences();
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  GTB_GoogleToolbarOverlay.autoFill._highlightFoundFields(browser.GTB_AutoFillData)}

, "GTB_SpellCheck.reload_dictionary":function(data) {
  GTB_GoogleToolbarOverlay.spellCheck.userDictionary.reload();
  GTB_getToolbar().spellCheck.maybeRerun(true)}

, "GTB_SpellCheck.resetButton":function(data) {
  GTBSC_setMode(GTBSC_getMode())}

, "GTB_OPTION.button_option.gtbAutoFill":function(data) {
  if(data != "false") {
    GTB_GoogleToolbarOverlay.autoFill.doPageLoad(null)}
}

, GPTD_PAGELOAD:function(data) {
}

, GTB_TABSWITCH:function(data) {
}

, "GTB_OPTION.google_home":function(data) {
  GTB_Dump(GTB_Dump.PR, "### PAGERANK trace: changing TLD preferences\n");
  GTB_GoogleToolbarOverlay.pageRank.GPR_getDefaultTld()}

};
GTB_GoogleToolbar.prototype.observe = GTB_MessageObserve;
GTB_GoogleToolbar.prototype.messageObjects = [];
GTB_GoogleToolbar.prototype.GTB_SEARCH_TYPES = {};
GTB_GoogleToolbar.prototype._GTB_NEXT_SEARCH_LOOKUP = {};
GTB_GoogleToolbar.prototype._GTB_PREV_SEARCH_LOOKUP = {};
GTB_GoogleToolbar.prototype._firstRunShown = false;
GTB_GoogleToolbar.prototype._searchBoxBeforeCustomize = true;
GTB_GoogleToolbar.prototype._addSearchType = function(search) {
  this.GTB_SEARCH_TYPES[search.name] = search}

;
GTB_GoogleToolbar.prototype._initSearchTypes = function() {
  var stringBundle = document.getElementById("google-toolbar-strings");
  var searchType;
  this._addSearchType(GTB_GoogleSearchType("search", "chrome://google-toolbar/skin/search.png", stringBundle));
  this._addSearchType(GTB_GoogleSearchType("lucky", "chrome://google-toolbar/skin/lucky.png", stringBundle, {lucky:true}));
  this._addSearchType(GTB_StandardSearchType("images", "chrome://google-toolbar/skin/images.png", stringBundle));
  this._addSearchType(GTB_StandardSearchType("groups", "chrome://google-toolbar/skin/groups.png", stringBundle));
  this._addSearchType(GTB_StandardSearchType("news", "chrome://google-toolbar/skin/news.png", stringBundle));
  this._addSearchType(GTB_StandardSearchType("local", "chrome://google-toolbar/skin/local.png", stringBundle));
  var func = function(query, home) {
    return GTB_SearchUrl("www", home, "froogle", query)}

  ;
  this._addSearchType(new GTB_SearchType("froogle", "chrome://google-toolbar/skin/froogle.png", stringBundle.getString("prop.gtb.froogle"), stringBundle.getString("prop.gtb.froogle.tip"), func));
  searchType = {name:"site", image:"chrome://google-toolbar/skin/search-site.png", url:function(query, home) {
    var url = GTB_GoogleToolbarOverlay._getCurrentLocation().href;
    var url_tokens = GTB_urlSplit(url);
    var site = url_tokens[4];
    return GTB_SearchUrl("www", home, "search", query, {site:site})}

  };
  searchType.label = stringBundle.getString("prop.gtb.site");
  searchType.tip = stringBundle.getString("prop.gtb.site.tip");
  this._addSearchType(searchType);
  var l = this.customSearch._searches.length;
  for(var i = 0;i < l;i ++ ) {
    this._addSearchType(GTB_CustomSearchType(this.customSearch, i))}
  this._GTB_PREV_SEARCH_LOOKUP["search"] = "froogle";
  if(l > 0) {
    this._GTB_PREV_SEARCH_LOOKUP["search"] = "GTB_Custom_Search_" + (l - 1)}
  this._GTB_NEXT_SEARCH_LOOKUP["search"] = "site";
  this._GTB_PREV_SEARCH_LOOKUP["site"] = "search";
  this._GTB_NEXT_SEARCH_LOOKUP["site"] = "lucky";
  this._GTB_PREV_SEARCH_LOOKUP["lucky"] = "site";
  this._GTB_NEXT_SEARCH_LOOKUP["lucky"] = "images";
  this._GTB_PREV_SEARCH_LOOKUP["images"] = "lucky";
  this._GTB_NEXT_SEARCH_LOOKUP["images"] = "groups";
  this._GTB_PREV_SEARCH_LOOKUP["groups"] = "images";
  this._GTB_NEXT_SEARCH_LOOKUP["groups"] = "news";
  this._GTB_PREV_SEARCH_LOOKUP["news"] = "groups";
  this._GTB_NEXT_SEARCH_LOOKUP["news"] = "local";
  this._GTB_PREV_SEARCH_LOOKUP["local"] = "news";
  this._GTB_NEXT_SEARCH_LOOKUP["local"] = "froogle";
  this._GTB_PREV_SEARCH_LOOKUP["froogle"] = "local";
  this._GTB_NEXT_SEARCH_LOOKUP["froogle"] = "search";
  if(l > 0) {
    this._GTB_NEXT_SEARCH_LOOKUP["froogle"] = "GTB_Custom_Search_0"}
  for(i = 0;i < l;i ++ ) {
    this._GTB_NEXT_SEARCH_LOOKUP["GTB_Custom_Search_" + i] = "GTB_Custom_Search_" + (i + 1);
    if(i == l - 1) {
      this._GTB_NEXT_SEARCH_LOOKUP["GTB_Custom_Search_" + i] = "search"}
    this._GTB_PREV_SEARCH_LOOKUP["GTB_Custom_Search_" + i] = "GTB_Custom_Search_" + (i - 1);
    if(i == 0) {
      this._GTB_PREV_SEARCH_LOOKUP["GTB_Custom_Search_" + i] = "froogle"}
  }
}

;
GTB_GoogleToolbar.prototype._SEARCH_TYPE = "search";
GTB_GoogleToolbar.prototype.languageCode = "en";
GTB_GoogleToolbar.prototype.availableButtons = {};
GTB_GoogleToolbar.prototype.buttonOptions = [{checkboxId:"gtbOptionsBrowsingSpellCheckbox", property:"gtbSpellCheck", dependentWidget:"gtbOptionsBrowsingSpellButton"}, {checkboxId:"gtbOptionsBrowsingAutoLinkCheckbox", property:"gtbAutoLink", dependentWidget:"gtbOptionsBrowsingAutoLinkButton"}, {checkboxId:"gtbOptionsBrowsingFeedSubscribeCheckbox", property:"gtbFeedSubscribe", dependentWidget:"gtbOptionsBrowsingFeedSubscribeButton"}, {checkboxId:"gtbOptionsBrowsingAutoFillCheckbox", property:"gtbAutoFill"
, dependentWidget:"gtbOptionsBrowsingAutoFillButton"}, {checkboxId:"gtbOptionsBrowsingPageRankCheckbox", optIn:true, property:"gtbPageRank"}, {checkboxId:"gtbOptionsBrowsingSafeBrowsingCheckbox", property:"safebrowsing.enabled", dependentWidget:"gtbOptionsBrowsingSafeBrowsingButton"}, {checkboxId:"gtbOptionsMoreHighlightCheckbox", property:"gtbHighlight"}, {checkboxId:"gtbOptionsSearchButtonsSiteCheckbox", property:"gtbSearchSite"}, {checkboxId:"gtbOptionsSearchButtonsLuckyCheckbox", property:"gtbFeelingLucky"
}, {checkboxId:"gtbOptionsSearchButtonsImagesCheckbox", property:"gtbSearchImages"}, {checkboxId:"gtbOptionsSearchButtonsGroupsCheckbox", property:"gtbSearchGroups"}, {checkboxId:"gtbOptionsSearchButtonsFroogleCheckbox", property:"gtbSearchFroogle"}, {checkboxId:"gtbOptionsMoreNewsCheckbox", property:"gtbSearchNews"}, {checkboxId:"gtbOptionsSearchButtonsLocalCheckbox", property:"gtbSearchLocal"}, {checkboxId:"gtbOptionsMoreBlogThisCheckbox", property:"gtbBlogger"}, {checkboxId:"gtbOptionsMoreUpCheckbox"
, property:"gtbGoUp"}, {checkboxId:"gtbOptionsMoreOptionsCheckbox", property:"gtbOptions"}, {checkboxId:"gtbOptionsMoreNextPreviousCheckbox", property:"gtbNextPrev"}, {checkboxId:"gtbOptionsMorePageInfoCheckbox", property:"gtbInfo"}, {checkboxId:"gtbOptionsMoreWordFindCheckbox", property:"gtbFindTerms"}];
GTB_GoogleToolbar.prototype.menuItemIds = {gtbSearchSite:"gtbSearchButtonPopupSite", gtbFeelingLucky:"gtbSearchButtonPopupLucky", gtbSearchImages:"gtbSearchButtonPopupImages", gtbSearchGroups:"gtbSearchButtonPopupGroups", gtbSearchFroogle:"gtbSearchButtonPopupFroogle", gtbSearchNews:"gtbSearchButtonPopupNews", gtbSearchLocal:"gtbSearchButtonPopupLocal"};
function GTB_sortMenuPopup(menuPopup, opt_startIndex, opt_stopIndex) {
  if(opt_startIndex == null) {
    opt_startIndex = 0}
  if(opt_stopIndex == null) {
    opt_stopIndex = menuPopup.childNodes.length - 1}
  var arr = [];
  for(var i = opt_startIndex;i <= opt_stopIndex;i ++ ) {
    arr[i - opt_startIndex] = menuPopup.childNodes[i]}
  var sortFunction = function(x, y) {
    var result = 0;
    if(x != null && y != null) {
      var xLabel = x.getAttribute("label");
      var yLabel = y.getAttribute("label");
      if(xLabel != null && yLabel != null) {
        if(xLabel < yLabel) {
          result = -1}
        else if(xLabel > yLabel) {
          result = 1}
      }
    }
    return result}

  ;
  arr.sort(sortFunction);
  for(i = opt_stopIndex - 1;i >= opt_startIndex;i -- ) {
    menuPopup.removeChild(menuPopup.childNodes[i])}
  menuPopup.replaceChild(arr[arr.length - 1], menuPopup.childNodes[opt_startIndex]);
  for(i = 0;i < opt_stopIndex - opt_startIndex;i ++ ) {
    menuPopup.insertBefore(arr[i], arr[arr.length - 1])}
}

GTB_GoogleToolbar.prototype.autoTransLibAvailable = null;
GTB_GoogleToolbar.prototype.init = function() {
  this.tabBrowser = document.getElementById("content");
  var stringBundle = document.getElementById("gtb-localized_prefs");
  this.languageCode = stringBundle.getString("lang");
  var autoXpcomObj = Components.classes["@google.com/autotranslate;1"];
  this.autoTransLibAvailable = autoXpcomObj != null;
  GTB_SendDailyPing();
  window.setInterval(GTB_SendDailyPing, 3600000);
  this.chevron = new GTB_Chevron;
  this.chevron.init();
  var buttonList = stringBundle.getString("buttonList");
  var localeButtons = buttonList.split(",");
  for(var i = 0;i < localeButtons.length;i ++ ) {
    this.availableButtons[localeButtons[i]] = true}
  var googleSpellCheckMenu = document.getElementById("googleSpellCheckLangMenu");
  if(googleSpellCheckMenu != null) {
    GTB_sortMenuPopup(googleSpellCheckMenu, 2)}
  var paletteItems = GTB_GetAllItemsInPalette();
  for(i = 0;i < paletteItems.length;i ++ ) {
    if(!this.availableButtons[paletteItems[i]]) {
      var button = document.getElementById(paletteItems[i]);
      if(button && button.parentNode) {
        GTB_GoogleToolbar.removeFromToolbarAndDefaultSet(button, button.parentNode)}
      GTB_GoogleToolbar.removeButtonFromPalette(paletteItems[i])}
    else {
      try {
        var button = document.getElementById(paletteItems[i]);
        var option = GTB_getPrefs().getBoolPref("button_option." + paletteItems[i]);
        if(button && !option) {
          this._removeButton(paletteItems[i])}
        else if(option && !button) {
          this._addButton(paletteItems[i])}
      }
      catch(e) {
      }
    }
  }
  this.customSearch = new GTB_CustomSearch;
  this.customSearch.init();
  var customSearches = this.customSearch._searches;
  for(var i = 0;i < customSearches.length;i ++ ) {
    var buttonName = this.customSearch.searchToButtonId(customSearches[i]);
    this.availableButtons[buttonName] = true}
  var textLevel = GTB_getPrefs().getStringPref("button_text_level");
  this._setButtonTextLevel(textLevel);
  this._observerService = Components.classes["@mozilla.org/observer-service;1"].getService(Components.interfaces.nsIObserverService);
  var tabbox = this._getTabBrowser().mTabBox;
  tabbox.addEventListener("load", GTB_GTO_onPageLoad, true);
  tabbox.addEventListener("unload", GTB_GTO_onPageUnLoad, true);
  tabbox.addEventListener("select", GTB_GTO_onTabSwitch, true);
  tabbox.addEventListener("pageshow", GTB_GTO_onPageShow, true);
  tabbox.addEventListener("pagehide", GTB_GTO_onPageHide, true);
  window.addEventListener("popupshowing", GTB_TT_maybeSurpressTooltip, false);
  window.addEventListener("resize", GTB_hitch(this.chevron, this.chevron.doResize), false);
  this.perTabData = new GTB_TabManager;
  this.autoFill = new GTB_AutoFillManager;
  this.autoFill.init();
  this.autoTranslate = new GTB_AutoTranslate;
  this.autoTranslate.init();
  this.pageRank = new GTB_PageRank;
  this.pageRank.GPR_startup();
  this.infoButton = new GTB_InfoButton;
  this.upButton = new GTB_UpButton;
  this.nextPrev = new GTB_NextPrev;
  this.highlighter = new GTB_Highlighter;
  this.highlighter.init();
  this.mailto = new GTB_Mailto;
  this.history = new GTB_SearchHistory;
  this.history.init();
  this.suggest = new GTB_Suggest;
  this.autoLink = new GTB_AutoLink;
  this.feedSubscribe = new GTB_FeedSubscribe;
  var tippers = [this.autoLink, this.autoFill, new GTB_TooltipDefault, this.autoTranslate];
  this.tooltip = new GTB_Tooltip(tippers);
  this.spellCheck = new GTB_SpellCheck;
  this.spellCheck.init(this);
  this.registerMessages(this);
  this.registerMessages(this.history);
  this.registerMessages(this.suggest);
  this.registerMessages(this.nextPrev);
  this.registerMessages(this.highlighter);
  this.registerMessages(this.upButton);
  this.registerMessages(this.infoButton);
  this.registerMessages(this.autoLink);
  this.registerMessages(this.feedSubscribe);
  var contextMenu = document.getElementById("contentAreaContextMenu");
  contextMenu.addEventListener("popupshowing", GTB_hitch(this.autoTranslate, this.autoTranslate.maybeShowTranslateMenuItem), false);
  contextMenu.addEventListener("popupshowing", GTB_hitch(this.autoLink, this.autoLink.maybeShowAutoLinkMenuItems), false);
  this._initSearchTypes();
  this.switchButton("search");
  if(window.opener != null) {
    var openerOverlay = window.opener.GTB_GoogleToolbarOverlay;
    if(openerOverlay != null) {
      var searchBox = document.getElementById("gtbGoogleSearchBox");
      if(searchBox) {
        searchBox.value = openerOverlay.getSearchText()}
    }
  }
  GTB_GTO_onGoogleSearchInput(null);
  Components.classes["@google.com/uninstaller;1"].getService(Components.interfaces.nsIObserver);
  setTimeout(GTB_hitch(this, this.delayedInit), 1);
  this.handleCustomize()}

;
GTB_GoogleToolbar.prototype.delayedInit = function() {
  var toolbox = document.getElementById("navigator-toolbox");
  this.toolboxCustomizeDone = toolbox.customizeDone;
  toolbox.customizeDone = GTB_hitch(this, this.onToolboxCustomizeDone)}

;
GTB_GoogleToolbar.advancedFeatureData = [{id:"gtbPageRank", option:"button_option.gtbPageRank"}, {option:"button_option.safebrowsing.advancedprotection"}, {option:"button_option.safebrowsing.advancedprotection.default"}];
GTB_GoogleToolbar.removeButtonFromPalette = function(id) {
  var toolbox = document.getElementById("navigator-toolbox");
  var toolbarPalette = toolbox.palette;
  for(var index = 0;index < toolbarPalette.childNodes.length;index ++ ) {
    if(toolbarPalette.childNodes[index].id == id) {
      toolbarPalette.removeChild(toolbarPalette.childNodes[index]);
      break}
  }
}

;
GTB_GoogleToolbar.removeFromToolbarAndDefaultSet = function(button, toolbar) {
  toolbar.removeChild(button);
  var toolbox = document.getElementById("navigator-toolbox");
  var currentSet = toolbar.currentSet;
  toolbar.setAttribute("currentset", currentSet);
  toolbox.ownerDocument.persist(toolbar.id, "currentset");
  var defaultSet = toolbar.getAttribute("defaultset");
  var r = new RegExp("," + button.id);
  defaultSet = defaultSet.replace(r, "");
  toolbar.setAttribute("defaultset", defaultSet);
  toolbox.ownerDocument.persist(toolbar.id, "defaultset")}

;
GTB_GoogleToolbar.prototype.showFirstRunDialog = function() {
  this.chevron.doResize();
  while(!GTB_getPrefs().hasUserValue(GTB_PREF_OPT_IN)) {
    window.openDialog("chrome://google-toolbar/content/first-run.xul", "gtbFirstRun", "modal,centerscreen,chrome,resizable=no", this.languageCode);
    if(GTB_getPrefs().hasUserValue(GTB_PREF_OPT_IN)) {
      GTB_getPrefs().setBoolPref("button_option.gtbPageRank", true);
      GTB_getPrefs().setBoolPref("button_option.safebrowsing.enabled", true);
      GTB_getPrefs().setBoolPref("button_option.safebrowsing.advancedprotection", true);
      GTB_getPrefs().setBoolPref(GTB_PREF_ADVANCED_DEFAULT, true);
      var optedIn = GTB_getPrefs().getBoolPref(GTB_PREF_OPT_IN);
      if(!optedIn) {
        for(var i = 0;i < GTB_GoogleToolbar.advancedFeatureData.length; ++ i) {
          var feature = GTB_GoogleToolbar.advancedFeatureData[i];
          GTB_getPrefs().setBoolPref(feature.option, false);
          if(feature.id == null) {
            continue}
          var featureButton = document.getElementById(feature.id);
          if(featureButton && featureButton.parentNode) {
            var toolbar = featureButton.parentNode;
            GTB_GoogleToolbar.removeFromToolbarAndDefaultSet(featureButton, toolbar)}
        }
        this.chevron.doResize()}
    }
  }
}

;
GTB_GoogleToolbar.prototype.tearDown = function(event) {
  while(this.messageObjects.length > 0) {
    this.unregisterMessages(this.messageObjects.pop())}
}

;
GTB_GoogleToolbar.prototype.registerMessages = function(obj) {
  this.messageObjects.push(obj);
  for(var message in obj.GTB_MESSAGES) {
    this._observerService.addObserver(obj, message, false)}
}

;
GTB_GoogleToolbar.prototype.unregisterMessages = function(obj) {
  for(var message in obj.GTB_MESSAGES) {
    this._observerService.removeObserver(obj, message)}
}

;
GTB_GoogleToolbar.prototype.sendMessage = function(mesg, opt_data) {
  this._observerService.notifyObservers(null, mesg, opt_data)}

;
GTB_GoogleToolbar.prototype._setButtonTextLevel = function(level) {
  var toolbar = document.getElementById("gtbToolbar");
  toolbar.setAttribute("mode", level);
  document.persist("gtbToolbar", "mode");
  this.chevron.doResize()}

;
GTB_GoogleToolbar.prototype._addButton = function(id) {
  var button = document.getElementById(id);
  if(button) {
    return}
  var all_ids = GTB_GetAllItemsInPalette();
  var toolbar_ids = GTB_GetAllItemsInGoogleToolbar();
  var index = -1;
  var i = 0;
  for(i = 0;i < all_ids.length;i ++ ) {
    if(all_ids[i] == id) {
      index = i;
      break}
  }
  var beforeElement = null;
  for(i = index + 1;i < all_ids.length;i ++ ) {
    if(toolbar_ids[all_ids[i]] == 1) {
      beforeElement = document.getElementById(all_ids[i]);
      break}
  }
  var toolbar = document.getElementById("gtbToolbar");
  toolbar.insertItem(id, beforeElement);
  this.chevron.doResize()}

;
GTB_GoogleToolbar.prototype._removeButton = function(id) {
  var button = document.getElementById(id);
  if(!button) {
    return}
  button.parentNode.removeChild(button);
  this.chevron.doResize()}

;
GTB_GoogleToolbar.prototype.addButtons = function(buttons) {
  for(var i = 0;i < buttons.length;i ++ ) {
    this.sendMessage("GTB_ADD_BUTTON", buttons[i])}
}

;
GTB_GoogleToolbar.prototype.removeButtons = function(removeThese) {
  for(var i = 0;i < removeThese.length;i ++ ) {
    var button = removeThese[i];
    this.sendMessage("GTB_REMOVE_BUTTON", button)}
}

;
GTB_GoogleToolbar._privacyItems = {gtbPageRank:true, "safebrowsing.enabled":true, gtbSpellCheck:true, gtbAutoLink:true};
GTB_GoogleToolbar.prototype.propogateToolbarChanges = function(restoringDefaults) {
  var changedToolbox = document.getElementById("navigator-toolbox");
  var changedToolbar = document.getElementById("gtbToolbar");
  var browserWindows = GTB_getBrowserWindows();
  for(var bi = 0, win = null;win = browserWindows[bi]; ++ bi) {
    var overlay = win.GTB_GoogleToolbarOverlay;
    if(win == window) {
      continue}
    var toolbox = win.document.getElementById("navigator-toolbox");
    var toolbar = win.document.getElementById("gtbToolbar");
    if(restoringDefaults) {
      for(var i = toolbox.childNodes.length - 1;i >= 0;i -- ) {
        if(toolbox.childNodes[i].hasAttribute("customindex")) {
          toolbox.removeChild(toolbox.childNodes[i])}
      }
      for(var t = 0;t < toolbox.childNodes.size;t ++ ) {
        var currentToolbar = toolbox.childNodes[t];
        for(i = currentToolbar.childNodes.length - 1;i >= 0;i -- ) {
          if(currentToolbar.id != "gtbToolbar") {
            var item = currentToolbar.childNodes[i];
            if(GTB_isGoogleToolbarItem(item)) {
              currentToolbar.removeChild(item)}
          }
        }
      }
    }
    var toolboxMode = changedToolbox.getAttribute("mode");
    var toolboxIconsize = changedToolbox.getAttribute("iconsize");
    toolbox.setAttribute("mode", toolboxMode);
    toolbox.setAttribute("iconsize", toolboxIconsize);
    for(var i = 0;i < changedToolbox.childNodes.length;i ++ ) {
      var changedToolbar = changedToolbox.childNodes[i];
      var toolbarId = changedToolbar.id;
      var toolbarToUpdate = win.document.getElementById(toolbarId);
      if(changedToolbar.getAttribute("customizable") != "true") {
        continue}
      if(toolbarToUpdate) {
        if(restoringDefaults) {
          toolbarToUpdate.currentSet = changedToolbar.getAttribute("defaultset");
          toolbarToUpdate.collapsed = changedToolbar.collapsed}
        else {
          toolbarToUpdate.currentSet = changedToolbar.currentSet}
        toolbarToUpdate.setAttribute("mode", changedToolbar.getAttribute("mode"));
        toolbarToUpdate.setAttribute("iconsize", changedToolbar.getAttribute("iconsize"))}
      else if(changedToolbar.hasAttribute("customindex")) {
        var name = changedToolbar.getAttribute("toolbarname");
        var set = changedToolbar.currentSet;
        var toolbarToUpdate = toolbox.appendCustomToolbar(name, set);
        toolbarToUpdate.setAttribute("mode", changedToolbar.getAttribute("mode"));
        toolbarToUpdate.setAttribute("iconsize", changedToolbar.getAttribute("iconsize"))}
    }
    overlay.updateSearchTextAfterCustomize();
    if(restoringDefaults) {
      overlay.restoreDefaultsFixUi()}
    overlay.handleCustomize();
    overlay.toolboxCustomizeDone(true)}
}

;
GTB_GoogleToolbar.prototype.getCustomizeToolbarWindow = function() {
  var result = null;
  try {
    var windowMediator = Components.classes["@mozilla.org/appshell/window-mediator;1"].getService(Components.interfaces.nsIWindowMediator)}
  catch(e) {
  }
  if(windowMediator) {
    var windowEnumerator = windowMediator.getZOrderDOMWindowEnumerator(null, false);
    while(windowEnumerator.hasMoreElements()) {
      var win = windowEnumerator.getNext();
      if(win && win.document && win.document.documentElement && "CustomizeToolbarWindow" == win.document.documentElement.getAttribute("id")) {
        result = win;
        break}
    }
  }
  return result}

;
GTB_GoogleToolbar.prototype.focusCustomizeToolbarWindow = function() {
  var customizeToolbarWindow = this.getCustomizeToolbarWindow();
  if(customizeToolbarWindow) {
    customizeToolbarWindow.focus()}
}

;
GTB_GoogleToolbar.prototype.onToolboxCustomizeDone = function(aToolboxChanged) {
  var ids = GTB_GetAllItemsInPalette();
  var prefs = GTB_getPrefs();
  if(!document.getElementById("gtbSearchBox") && this._searchBoxBeforeCustomize) {
    window.openDialog("chrome://google-toolbar/content/confirm-customize.xul", "gtbConfirmCustomize", "modal,centerscreen,chrome,resizable=no")}
  var toolbar = document.getElementById("gtbToolbar");
  var currentSet = toolbar.currentSet;
  toolbar.setAttribute("currentset", currentSet);
  document.persist(toolbar.id, "currentset");
  this.propogateToolbarChanges(false);
  this.handleCustomize();
  this.updateSearchTextAfterCustomize();
  for(var i = 0;i < ids.length;i ++ ) {
    try {
      var pref = prefs.getBoolPref("button_option." + ids[i])}
    catch(e) {
      continue}
    var element = document.getElementById(ids[i]);
    if(pref && element == null) {
      GTB_setBoolPrefWithMessage("button_option." + ids[i], false, this)}
    else if(element != null) {
      GTB_setBoolPrefWithMessage("button_option." + ids[i], true, this)}
  }
  var mode = toolbar.getAttribute("mode");
  GTB_setStringPrefWithMessage("button_text_level", mode, this);
  this.toolboxCustomizeDone(aToolboxChanged)}

;
function GTB_ConfirmCustomize_onCancel() {
  GTB_getToolbar().doCustomizeCancel()}

GTB_GoogleToolbar.prototype.doCustomizeCancel = function() {
  this._addButton("gtbSearchBox");
  var toolbar = document.getElementById("gtbToolbar");
  var currentSet = toolbar.currentSet;
  toolbar.setAttribute("currentset", currentSet);
  document.persist("gtbToolbar", "currentset")}

;
function GTB_CP_onToolboxCustomizeStarted(event) {
  GTB_getToolbar().doToolboxCustomizeStarted(event)}

GTB_GoogleToolbar.prototype.doToolboxCustomizeStarted = function(event) {
  GTB_GoogleToolbar.applyStyles();
  var searchbox = document.getElementById("gtbSearchBox");
  this._searchBoxBeforeCustomize = searchbox ? true : false}

;
GTB_GoogleToolbar.prototype.updateSearchTextAfterCustomize = function() {
  var searchbox = document.getElementById("gtbGoogleSearchBox");
  if(!this._searchBoxBeforeCustomize && searchbox) {
    searchbox.value = "";
    this.lastQuery = ""}
  if(this._searchBoxBeforeCustomize && searchbox) {
    searchbox.value = this.lastQuery}
  if(this._searchBoxBeforeCustomize && !searchbox) {
    this.lastQuery = ""}
  this.highlighter._currentWords = [];
  var answer = this.highlighter.onSearchTextChanged(this.lastQuery);
  this._enableDisableQueryButtons(answer.hasTerms, answer.hasOps)}

;
function GTB_CP_onToolboxRestoreDefaults(event) {
  var toolbar = GTB_getToolbar();
  setTimeout(GTB_hitch(toolbar, toolbar.doToolboxCustomizeRestoreDefaults), 1)}

GTB_GoogleToolbar.prototype.doToolboxCustomizeRestoreDefaults = function() {
  var toolbox = document.getElementById("navigator-toolbox");
  for(var i = 0;i < toolbox.childNodes.length;i ++ ) {
    var toolbar = toolbox.childNodes[i];
    if(toolbar.id != "gtbToolbar") {
      for(var j = toolbar.childNodes.length - 1;j >= 0;j -- ) {
        var item = toolbar.childNodes[j];
        if(GTB_isGoogleToolbarWrapperItem(item)) {
          toolbar.removeChild(item)}
      }
    }
  }
  this._setButtonTextLevel("gtb-selective-text");
  this.propogateToolbarChanges(true);
  window.focus();
  this.focusCustomizeToolbarWindow();
  this.handleCustomize();
  this.updateSearchTextAfterCustomize();
  this.restoreDefaultsFixUi()}

;
GTB_GoogleToolbar.prototype.restoreDefaultsFixUi = function() {
  if(GTB_PageRank.GPR_pageRankEnabled()) {
    var tabData = GTB_perTabData().getSelectedTabContainer("page_rank");
    var pr = tabData ? tabData.pageRank : null;
    this.pageRank.GPR_displayPageRank(pr)}
  this.spellCheck.initUi();
  tabData = this._getCurrentBrowser().GTB_AutolinkData;
  if(tabData) {
    this.autoLink._updateButton(tabData);
    this.autoLink.relink()}
  this.switchButton(this._SEARCH_TYPE)}

;
GTB_GoogleToolbar.prototype.handleCustomize = function() {
  var toolbar = document.getElementById("gtbToolbar");
  toolbar.setAttribute("iconsize", "small");
  var leftResize = document.getElementById("gtbSearchBoxResizeLeft");
  if(leftResize) {
    leftResize.handleCustomize()}
  var rightResize = document.getElementById("gtbSearchBoxResizeRight");
  if(rightResize) {
    rightResize.handleCustomize()}
  var answer = this.highlighter.onSearchTextChanged(this.lastQuery);
  this._enableDisableQueryButtons(answer.hasTerms, answer.hasOps);
  var doc = GTB_GoogleToolbarOverlay._getCurrentDocument();
  GTB_GoogleToolbarOverlay._enableDisableNonHttpOrGoogleButtons(doc.location.href);
  var searchBox = document.getElementById("gtbGoogleSearchBox");
  if(searchBox) {
    GTB_GoogleToolbar.applyStyles();
    this.suggest.doToggleSuggest(GTB_getPrefs().getBoolPref(GTB_PREF_USE_SUGGEST));
    this.customSearch.addSearchesToDropDown();
    var oldValue = searchBox.value;
    var oldLastQuery = this.lastQuery;
    this.history.init();
    searchBox.value = oldValue;
    this.lastQuery = oldLastQuery;
    var e;
    if(searchBox.gtbListeners) {
      for(e in searchBox.gtbListeners) {
        searchBox.removeEventListener(e, searchBox.gtbListeners[e], true)}
    }
    var searchObserver = new GTB_SearchObserver;
    searchBox.gtbListeners = {dragover:function(ev) {
      nsDragAndDrop.dragOver(ev, searchObserver)}

    , dragdrop:function(ev) {
      nsDragAndDrop.drop(ev, searchObserver)}

    };
    for(e in searchBox.gtbListeners) {
      searchBox.addEventListener(e, searchBox.gtbListeners[e], true)}
  }
  GTB_GTO_onGoogleSearchInput(null)}

;
GTB_GoogleToolbar.prototype._getTabBrowser = function() {
  var tabBrowser = this.tabBrowser;
  return tabBrowser}

;
GTB_GoogleToolbar.prototype._getCurrentBrowser = function() {
  var currentBrowser = this._getTabBrowser().selectedBrowser;
  return currentBrowser}

;
GTB_GoogleToolbar.prototype._getCurrentWindow = function() {
  var currentWindow = this._getCurrentBrowser().contentWindow;
  return currentWindow}

;
GTB_GoogleToolbar.prototype._getCurrentLocation = function() {
  var currentLocation = this._getCurrentWindow().location;
  return currentLocation}

;
GTB_GoogleToolbar.prototype._getCurrentDocument = function() {
  var d = this.tabBrowser.selectedBrowser.contentWindow.document;
  return d}

;
GTB_GoogleToolbar.prototype._getBrowserFromDoc = function(doc) {
  var win = doc && doc.defaultView;
  if(!win) {
    GTB_Dump(GTB_Dump.TB, "window not found while trying to find doc owner\n");
    return null}
  win = win.top;
  var browsers = this._getTabBrowser().browsers;
  var browser = null;
  for(var b = 0;b < browsers.length; ++ b) {
    if(browsers[b].contentWindow == win) {
      browser = browsers[b];
      break}
  }
  return browser}

;
GTB_GoogleToolbar.prototype._loadSearchURL = function(url, opt_useNewTab, opt_event) {
  var loadTarget = null;
  if(!opt_useNewTab && opt_event && ("click" == opt_event.type || "command" == opt_event.type)) {
    loadTarget = this.getLoadUrlTarget(opt_event);
    if(loadTarget == nsCI.nsIBrowserDOMWindow.OPEN_NEWTAB) {
      opt_useNewTab = true}
  }
  var tabbrowser = this._getTabBrowser();
  if(opt_useNewTab) {
    tabbrowser.selectedTab = tabbrowser.addTab(url)}
  else if(loadTarget == nsCI.nsIBrowserDOMWindow.OPEN_NEWWINDOW) {
    window.openDialog(getBrowserURL(), "_blank", "chrome,all,dialog=no", url)}
  else if(GTB_getPrefs().getBoolPref("search_new_tab")) {
    if(GTB_getPrefs().getBoolPref("select_new_tab")) {
      tabbrowser.selectedTab = tabbrowser.addTab(url)}
    else {
      tabbrowser.addTab(url)}
  }
  else {
    this._getCurrentBrowser().loadURI(url, null, null)}
}

;
GTB_GoogleToolbar.prototype.loadUrlWithModifiers = function(url, opt_event) {
  var target = nsCI.nsIBrowserDOMWindow.OPEN_DEFAULTWINDOW;
  if(opt_event) {
    target = this.getLoadUrlTarget(opt_event)}
  if(nsCI.nsIBrowserDOMWindow.OPEN_NEWTAB == target) {
    var tabbrowser = this._getTabBrowser();
    tabbrowser.selectedTab = tabbrowser.addTab(url);
    return tabbrowser.selectedBrowser}
  else if(nsCI.nsIBrowserDOMWindow.OPEN_NEWWINDOW == target) {
    var win = window.openDialog(getBrowserURL(), "_blank", "chrome,all,dialog=no", url);
    return null}
  var browser = this._getCurrentBrowser();
  browser.loadURI(url, null, null);
  return browser}

;
GTB_GoogleToolbar.prototype.getLoadUrlTarget = function(event) {
  var platform = GTB_GoogleToolbar.getPlatform();
  if(event.button == 1 || 2 == platform && event.metaKey || 2 != platform && event.ctrlKey) {
    return nsCI.nsIBrowserDOMWindow.OPEN_NEWTAB}
  else if(event.shiftKey) {
    return nsCI.nsIBrowserDOMWindow.OPEN_NEWWINDOW}
  return nsCI.nsIBrowserDOMWindow.OPEN_DEFAULTWINDOW}

;
GTB_GoogleToolbar.prototype._nonHttpOrGoogleDisableButtons = {gtbSearchSite:{enabled:"chrome://google-toolbar/skin/search-site.png", disabled:"chrome://google-toolbar/skin/search-site-disabled.png"}};
GTB_GoogleToolbar.prototype._enableDisableNonHttpOrGoogleButtons = function(url) {
  url = GTB_convertToUrl(url);
  var status = !GTB_isGoogleUrl(url) && url.scheme == "http";
  this._enableDisableButtons(status, this._nonHttpOrGoogleDisableButtons)}

;
GTB_GoogleToolbar.prototype._noTermsDisableButtons = {gtbHighlight:{enabled:"chrome://google-toolbar/skin/highlight.png", disabled:"chrome://google-toolbar/skin/highlight-disabled.png"}};
GTB_GoogleToolbar.prototype._noTermsOrOpsDisableButtons = {gtbFeelingLucky:{enabled:"chrome://google-toolbar/skin/lucky.png", disabled:"chrome://google-toolbar/skin/lucky-disabled.png"}};
GTB_GoogleToolbar.prototype._enableDisableQueryButtons = function(hasTerms, hasOps) {
  this._enableDisableButtons(hasTerms, this._noTermsDisableButtons);
  this._enableDisableButtons(hasTerms || hasOps, this._noTermsOrOpsDisableButtons)}

;
GTB_GoogleToolbar.prototype._enableDisableButtons = function(status, buttons) {
  for(var name in buttons) {
    var button = document.getElementById(name);
    if(button != null) {
      button.disabled = !status;
      var data = buttons[name];
      var image = data[status ? "enabled" : "disabled"];
      if(image) {
        button.image = image}
    }
  }
}

;
GTB_GoogleToolbar.prototype.doGoogleSearch = function(event) {
  if(event.type == "click" && event.target.nodeName == "menuitem") {
    return}
  var forceNewTab = false;
  var searchType = this._SEARCH_TYPE;
  if(event.type == "keypress") {
    if(GTB_getPrefs().getBoolPref(GTB_PREF_REMEMBER_SEARCH_TYPE)) {
      if(event.keyCode == 38 && event.ctrlKey && this._GTB_PREV_SEARCH_LOOKUP[this._SEARCH_TYPE]) {
        this.switchButton(this._GTB_PREV_SEARCH_LOOKUP[this._SEARCH_TYPE])}
      if(event.keyCode == 40 && event.ctrlKey && this._GTB_NEXT_SEARCH_LOOKUP[this._SEARCH_TYPE]) {
        this.switchButton(this._GTB_NEXT_SEARCH_LOOKUP[this._SEARCH_TYPE])}
    }
    if(event.keyCode != 13) {
      return}
    if(event.altKey) {
      forceNewTab = true}
    if(GTB_LooksLikeUrl(this.getSearchText())) {
      this._setSuggestAlreadySearched(true);
      this._loadSearchURL(this.rememberSearchText(), forceNewTab);
      return}
    if(event.shiftKey) {
      searchType = "lucky"}
  }
  if(event.type == "command" && event.target.id != "gtbSearchButton") {
    searchType = "search"}
  this.doGoogleSearchType(event, searchType, false, forceNewTab)}

;
GTB_GoogleToolbar.prototype._setSuggestAlreadySearched = function(alreadySearched) {
  var searchBox = document.getElementById("gtbGoogleSearchBox");
  if(searchBox != null) {
    searchBox.alreadySearched = alreadySearched}
}

;
GTB_GoogleToolbar.prototype.doGoogleSearchType = function(event, name, opt_switchableSelection, opt_newTab) {
  var query = this.rememberSearchText();
  var search = this.GTB_SEARCH_TYPES[name];
  this._setSuggestAlreadySearched(true);
  this._loadSearchURL(search.url(query, this.getGoogleHome()), opt_newTab, event);
  if(opt_switchableSelection && GTB_getPrefs().getBoolPref(GTB_PREF_REMEMBER_SEARCH_TYPE)) {
    this.switchButton(search)}
  if(!GTB_getPrefs().hasUserValue(GTB_PREF_FIRST_SEARCH)) {
    GTB_getPrefs().setBoolPref(GTB_PREF_FIRST_SEARCH, true)}
  if(event) {
    event.preventBubble()}
}

;
GTB_GoogleToolbar.prototype.switchButton = function(search) {
  if(typeof search == "string") {
    search = this.GTB_SEARCH_TYPES[search]}
  this._SEARCH_TYPE = search.name;
  var button = document.getElementById("gtbSearchButton");
  if(button == null) {
    return}
  button.image = search.image;
  button.label = search.label;
  button.setAttribute("tooltiptext", search.tip);
  this.chevron.doResize()}

;
GTB_GoogleToolbar.prototype._ignoreClick = false;
GTB_GoogleToolbar.prototype._removeQueryOperators = function(query) {
  var return_query = query;
  var delete_ops = ["allinanchor:", "allintext:", "allintitle:", "allinurl:", /\band\b/gi, "author:", "bphonebook:", "define:", "ext:", "filetype:", "group:", "inanchor:", "insubject:", "intext:", "intitle:", "inurl:", "location:", "lucky:", "movie:", "msgid:", /\bor\b/gi, "phonebook:", "rphonebook:", "safesearch:", "source:", "spell:", "stocks:", "store:", /site:\S+\s*/, /link:\S+\s*/, /related:\S+\s*/];
  var quoteOffsetsList = [];
  var curOffset = query.indexOf('"');
  while(curOffset != -1) {
    quoteOffsetsList.push(curOffset);
    curOffset = query.indexOf('"', curOffset + 1)}
  var operatorReplaceString = function(str, offset, query) {
    var inScope = false;
    for(var quoteOffset in quoteOffsetsList) {
      if(offset < quoteOffsetsList[quoteOffset]) {
        break}
      else {
        inScope = !inScope}
    }
    if(inScope == true) {
      return str}
    else {
      return""}
  }

  ;
  var op;
  for(op in delete_ops) {
    return_query = return_query.replace(delete_ops[op], operatorReplaceString)}
  return return_query}

;
GTB_GoogleToolbar.prototype._fillSearchBox = function(doc) {
  var ios = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
  var xpcomUrl = ios.newURI(doc.location.href, null, null);
  if(!(xpcomUrl  instanceof Components.interfaces.nsIURL))return;
  if(!GTB_isGoogleUrl(xpcomUrl)) {
    return}
  if(!xpcomUrl.query || xpcomUrl.query.length == 0) {
    return}
  var textBox = document.getElementById("gtbGoogleSearchBox");
  var args = GTB_parseQueryString(xpcomUrl.query);
  if(xpcomUrl.filePath != "/url" && args && args != {}) {
    var queryString = args["q"];
    if(!queryString) {
      queryString = args["as_q"]}
    if(queryString && (!textBox || queryString != textBox.value)) {
      if(textBox) {
        textBox.value = queryString;
        this.rememberSearchText()}
      var answer = this.highlighter.onSearchTextChanged(queryString);
      this._enableDisableQueryButtons(answer.hasTerms, answer.hasOps)}
  }
}

;
GTB_GoogleToolbar.prototype.getGoogleHome = function() {
  return GTB_getPrefs().getStringPref(GTB_PREF_GOOGLE_HOME)}

;
GTB_GoogleToolbar.prototype.getSearchText = function() {
  var textBox = document.getElementById("gtbGoogleSearchBox");
  if(textBox == null) {
    return""}
  return textBox.value}

;
GTB_GoogleToolbar.prototype.rememberSearchText = function() {
  var text = this.getSearchText();
  this.sendMessage("GTB_SEARCH_PERFORMED", text);
  return text}

;
GTB_GoogleToolbar.prototype.getHlFlag = function() {
  return"?hl=" + this.languageCode}

;
GTB_GoogleToolbar.prototype.maybeShowUsage = function(pref, url, opt_flags) {
  if(!GTB_getPrefs().getBoolPrefWithDefault(pref, false)) {
    GTB_getPrefs().setBoolPref(pref, true);
    OptionsDialog.more(window, this.languageCode, url, opt_flags);
    return true}
  return false}

;
GTB_GoogleToolbar._eventHack_onFieldKeyPress = function(event) {
  if(event.keyCode != KeyEvent.DOM_VK_RETURN) {
    return}
  var field = event.target;
  var acfield = field;
  if("mTextbox"  in  field) {
    acfield = field.mTextbox}
  var contractIDKey = acfield.getAttribute("autocompletesearch");
  var contractID = "@mozilla.org/autocomplete/search;1?name=" + contractIDKey;
  var searchService = Components.classes[contractID].getService(Components.interfaces.nsIAutoCompleteSearch);
  acfield.mEnterEvent = null;
  acfield.onTextEntered(event);
  searchService.stopSearch()}

;
GTB_GoogleToolbar.applyStyles = function() {
  var platform = GTB_GoogleToolbar.getPlatform();
  var googleSearchBox = document.getElementById("gtbGoogleSearchBox");
  if(!googleSearchBox) {
    return}
  var searchBox = googleSearchBox.textBox;
  searchBox.maxLength = 256;
  switch(platform) {
    case 1:searchBox.style.MozAppearance = "none";
    searchBox.style.border = "none";
    break;
    case 2:searchBox.style.marginTop = "1px";
    break;
    case 3:var innerBox = document.getAnonymousElementByAttribute(searchBox, "class", "autocomplete-textbox-container");
    innerBox.style.MozAppearance = "none";
    innerBox.style.border = "none";
    googleSearchBox.style.MozAppearance = "menulist-textfield";
    break}
}

;
GTB_GoogleToolbar.getPlatform = function() {
  var platform = Components.classes["@mozilla.org/network/protocol;1?name=http"].getService(Components.interfaces.nsIHttpProtocolHandler).oscpu;
  if(platform.indexOf("Win") != -1) {
    return 1}
  else if(platform.indexOf("Mac") != -1) {
    return 2}
  else if(platform.indexOf("Linux") != -1 || platform.indexOf("FreeBSD") != -1) {
    return 3}
}

;
function GTB_findContainingWindow(varname) {
  var candidate = window;
  while(candidate != null) {
    if(candidate[varname]) {
      return candidate}
    candidate = candidate.opener}
  try {
    var windowMediator = Components.classes["@mozilla.org/appshell/window-mediator;1"].getService(Components.interfaces.nsIWindowMediator)}
  catch(e) {
    return null}
  if(windowMediator) {
    var browser = windowMediator.getMostRecentWindow("navigator:browser");
    if(browser && browser[varname]) {
      return browser}
  }
}

function GTB_getToolbar() {
  var varname = "GTB_GoogleToolbarOverlay";
  var candidate = GTB_findContainingWindow(varname);
  if(!candidate) {
    return null}
  return candidate[varname]}

function GTB_getPrefs() {
  var prefs = GTB_getToolbar().prefs;
  return prefs}

function GTB_perTabData() {
  var ptd = GTB_getToolbar().perTabData;
  return ptd}

function GTB_GTO_onfocus(event) {
  if(!GTB_GoogleToolbarOverlay._firstRunShown) {
    GTB_GoogleToolbarOverlay._firstRunShown = true;
    GTB_GoogleToolbarOverlay.showFirstRunDialog()}
}

function GTB_GTO_onGoogleSearchInput(event) {
  var answer = GTB_GoogleToolbarOverlay.highlighter.onSearchTextChanged(null);
  GTB_GoogleToolbarOverlay._enableDisableQueryButtons(answer.hasTerms, answer.hasOps)}

function GTB_GTO_onGoogleSearch(event) {
  GTB_GoogleToolbarOverlay.doGoogleSearch(event)}

function GTB_GTO_onGoogleSearchType(event, name, opt_switchableSelection, opt_newTab) {
  GTB_GoogleToolbarOverlay.doGoogleSearchType(event, name, opt_switchableSelection, opt_newTab)}

function GTB_GTO_onGoogleSearchSelect(event) {
  if(GTB_getPrefs().getBoolPref(GTB_PREF_SEARCH_ON_SELECT)) {
    GTB_GTO_onGoogleSearch(event)}
  var overlay = GTB_getToolbar();
  var query = overlay.getSearchText();
  var answer = overlay.highlighter.onSearchTextChanged(query);
  overlay._enableDisableQueryButtons(answer.hasTerms, answer.hasOps)}

function GTB_GTO_onSearchBoxMouseDown(event, element) {
  if(element.hasAttribute("focused")) {
    GTB_GoogleToolbarOverlay._ignoreClick = true}
  else {
    GTB_GoogleToolbarOverlay._ignoreClick = false;
    element.inputField.setSelectionRange(0, 0)}
}

function GTB_GTO_onSearchBoxClick(event, element) {
  if(!GTB_GoogleToolbarOverlay._ignoreClick && (!element.inputField.selectionStart || !element.inputField.selectionEnd || element.inputField.selectionStart == element.inputField.selectionEnd)) {
    element.select()}
}

function GTB_GTO_onSearchBoxFocusKey(event) {
  var toolbar = document.getElementById("gtbToolbar");
  if(toolbar != null) {
    var element = document.getElementById("gtbGoogleSearchBox");
    if(element != null && (!element.parentNode || element.parentNode.parentNode != toolbar || !toolbar.collapsed)) {
      if(!element.inputField.selectionStart || !element.inputField.selectionEnd || element.inputField.selectionStart == element.inputField.selectionEnd) {
        element.select()}
      GTB_GoogleToolbarOverlay._ignoreClick = true;
      element.focus()}
  }
}

function GTB_GTO_onAutoFill(event) {
  GTB_GoogleToolbarOverlay.autoFill.doAutoFill(event)}

function GTB_GTO_onBlogger(event) {
  var htmldoc = GTB_GoogleToolbarOverlay._getCurrentDocument();
  var title = GTB_safeUrlEscape(htmldoc.title, 1000);
  var location = GTB_safeUrlEscape(htmldoc.location.href, 256);
  var text = htmldoc.getSelection();
  var url;
  try {
    url = GTB_getPrefs().getStringPref("blogthis_url")}
  catch(e) {
    url = "http://www.blogger.com/blog-this.g?source=toolbar-firefox&u=$1&n=$2&t=$3"}
  url = url.replace("$1", location);
  url = url.replace("$2", title);
  url = url.replace("$3", GTB_safeUrlEscape(text, 2048 - url.length - 4));
  var target = GTB_GoogleToolbarOverlay.getLoadUrlTarget(event);
  if(nsCI.nsIBrowserDOMWindow.OPEN_NEWTAB == target) {
    var tabbrowser = GTB_GoogleToolbarOverlay._getTabBrowser();
    tabbrowser.selectedTab = tabbrowser.addTab(url)}
  else {
    window.open(url, null, "width=500,height=350,toolbar=no,location=no,directores=no,menubar=no,status=yes,scrollbars=yes")}
}

function GTB_GTO_onSpellCheck(event) {
  if(event.type == "click" && event.target.nodeName == "menuitem" || event.type == "command" && event.target.nodeName == "menuitem") {
    return}
  GTB_GoogleToolbarOverlay.spellCheck.run()}

function GTB_GTO_onSpellCheckAutoFix(event) {
  GTB_GoogleToolbarOverlay.spellCheck.runAutoFix()}

function GTB_GTO_onGoogleOptions(event) {
  window.openDialog("chrome://google-toolbar/content/options.xul", "gtbOptions", "modal,centerscreen,chrome,resizable=no");
  event.preventBubble()}

function GTB_GTO_onHighlight(event) {
  GTB_GoogleToolbarOverlay.highlighter.toggle()}

function GTB_GTO_onFindTerm(event, index) {
  GTB_GoogleToolbarOverlay.highlighter.findTerm(index, !event.shiftKey);
  event.preventBubble()}

function GTB_GTO_onGoogleHomePage(event) {
  var url = GTB_SearchUrl("www", GTB_GoogleToolbarOverlay.getGoogleHome(), "webhp", "");
  GTB_GoogleToolbarOverlay.loadUrlWithModifiers(url, event);
  event.preventBubble()}

function GTB_GTO_onGoogleClearSearchHist(event) {
  GTB_GoogleToolbarOverlay.sendMessage("GTB_CLEAR_HISTORY", null);
  event.preventBubble()}

function GTB_GTO_onGoogleHelp(event) {
  var url = "http://www.google.com/support/toolbar" + GTB_GoogleToolbarOverlay.getHlFlag();
  GTB_GoogleToolbarOverlay.loadUrlWithModifiers(url, event);
  event.preventBubble()}

function GTB_GTO_onGooglePrivacy(event) {
  GTB_FirstRun_onPageRankConfirmHelp();
  event.preventBubble()}

function GTB_GTO_onGoogleUninstall(event) {
  window.openDialog("chrome://google-toolbar/content/uninstall.xul", null, "width=640,height=400", GTB_GoogleToolbarOverlay.languageCode);
  event.preventBubble()}

function GTB_GTO_onAboutGoogleToolbar(event) {
  window.openDialog("chrome://google-toolbar/content/about.xul", "gtbAbout", "modal,centerscreen,chrome,resizable=no");
  event.preventBubble()}

function GTB_GTO_onPageLoad(event) {
  var doc = event.target;
  var tabBrowser = GTB_GoogleToolbarOverlay._getTabBrowser();
  var browser;
  for(var b = 0;b < tabBrowser.browsers.length;b ++ ) {
    if(tabBrowser.browsers[b].contentWindow.document == doc) {
      browser = tabBrowser.browsers[b];
      break}
  }
  if(GTB_GoogleToolbarOverlay._getCurrentBrowser() == browser) {
    GTB_GoogleToolbarOverlay._fillSearchBox(doc);
    GTB_GoogleToolbarOverlay.highlighter.onPageLoad();
    GTB_GoogleToolbarOverlay.mailto.onPageLoad(event);
    GTB_GoogleToolbarOverlay._enableDisableNonHttpOrGoogleButtons(doc.location.href)}
  GTB_perTabData().onPageLoad(event);
  GTB_GoogleToolbarOverlay.nextPrev.doPageLoad(browser);
  GTB_GoogleToolbarOverlay.upButton._setUpButton(event);
  GTB_GoogleToolbarOverlay.infoButton.onPageChange(event);
  GTB_GoogleToolbarOverlay.spellCheck.doPageLoad(event);
  GTB_GoogleToolbarOverlay.pageRank.doPageLoad(event);
  GTB_GoogleToolbarOverlay.autoLink.doPageLoad(event);
  GTB_GoogleToolbarOverlay.autoFill.doPageLoad(event);
  GTB_GoogleToolbarOverlay.feedSubscribe.doPageShowOrLoad(event)}

function GTB_GTO_onPageUnLoad(event) {
  GTB_GoogleToolbarOverlay.autoLink.doPageUnload(event);
  GTB_GoogleToolbarOverlay.feedSubscribe.doPageHideOrUnload(event)}

function GTB_GTO_onPageShow(event) {
  if(!event.persisted) {
    return}
  var doc = event.target;
  var tabBrowser = GTB_GoogleToolbarOverlay._getTabBrowser();
  var browser;
  for(var b = 0;b < tabBrowser.browsers.length;b ++ ) {
    if(tabBrowser.browsers[b].contentWindow.document == doc) {
      browser = tabBrowser.browsers[b];
      break}
  }
  if(GTB_GoogleToolbarOverlay._getCurrentBrowser() == browser) {
    GTB_GoogleToolbarOverlay._fillSearchBox(doc);
    GTB_GoogleToolbarOverlay.highlighter.onPageLoad();
    GTB_GoogleToolbarOverlay._enableDisableNonHttpOrGoogleButtons(doc.location.href)}
  GTB_GoogleToolbarOverlay.nextPrev.doPageLoad(browser);
  GTB_GoogleToolbarOverlay.upButton._setUpButton(event);
  GTB_GoogleToolbarOverlay.infoButton.onPageChange(event);
  GTB_GoogleToolbarOverlay.spellCheck.doPageLoad(event);
  GTB_GoogleToolbarOverlay.pageRank.doPageLoad(event);
  GTB_GoogleToolbarOverlay.autoLink.doPageShow(event);
  GTB_GoogleToolbarOverlay.autoFill.doPageLoad(event);
  GTB_GoogleToolbarOverlay.feedSubscribe.doPageShowOrLoad(event)}

function GTB_GTO_onPageHide(event) {
  GTB_GoogleToolbarOverlay.spellCheck.doPageHide(event);
  GTB_GoogleToolbarOverlay.highlighter.doPageHide(event);
  GTB_GoogleToolbarOverlay.autoLink.doPageHide(event);
  GTB_GoogleToolbarOverlay.nextPrev.doPageHide(event);
  GTB_GoogleToolbarOverlay.feedSubscribe.doPageHideOrUnload(event)}

function GTB_GTO_onTabSwitch(event) {
  if(event.target == null || event.target.localName != "tabs") {
    return}
  var doc = GTB_GoogleToolbarOverlay._getCurrentDocument();
  GTB_GoogleToolbarOverlay._enableDisableNonHttpOrGoogleButtons(doc.location.href);
  GTB_GoogleToolbarOverlay.upButton._setUpButton(event);
  GTB_GoogleToolbarOverlay.infoButton.onPageChange(event);
  GTB_GoogleToolbarOverlay._fillSearchBox(doc);
  GTB_GoogleToolbarOverlay.highlighter.onTabSwitch();
  GTB_GoogleToolbarOverlay.nextPrev.doTabSwitch(event);
  GPR_onTabSwitch(event);
  GTB_GoogleToolbarOverlay.autoLink.doTabSwitch(event);
  GTB_GoogleToolbarOverlay.feedSubscribe.doTabSwitch();
  GTB_GoogleToolbarOverlay.autoFill.doTabSwitch(event);
  GTB_GoogleToolbarOverlay.spellCheck.doTabSwitch(event);
  GTB_GoogleToolbarOverlay.sendMessage("GTB_TABSWITCH", 0)}

function GTB_GTO_onMouseMove(event) {
  GTB_GoogleToolbarOverlay.tooltip.doMouseMove(event)}

function GTB_GTO_onGoogleShowToolbar(opt_event) {
  GTB_GTO_setGoogleToolbarCollapsed(false);
  if(opt_event) {
    opt_event.preventBubble()}
}

function GTB_GTO_setGoogleToolbarCollapsed(isCollapsed) {
  var windows = GTB_getBrowserWindows();
  for(var win = null, i = 0;win = windows[i]; ++ i) {
    var toolbar = win.document.getElementById("gtbToolbar");
    toolbar.collapsed = isCollapsed;
    win.document.persist(toolbar.id, "collapsed")}
}

function GTB_GTO_onSearchButtonPopup(event) {
  var toolbar = document.getElementById("gtbToolbar");
  var showToolbarMenuItem = document.getElementById("gtbSearchMenuShowToolbar");
  var showToolbarSep = document.getElementById("gtbShowToolbarSep");
  showToolbarMenuItem.hidden = !toolbar.collapsed;
  showToolbarSep.hidden = !toolbar.collapsed;
  var gto = GTB_getToolbar();
  for(var buttonId in gto.menuItemIds) {
    if(!gto.availableButtons[buttonId]) {
      var menuItemId = gto.menuItemIds[buttonId];
      var mi = document.getElementById(menuItemId);
      mi.hidden = true}
  }
}

function GTB_GTO_replaceSearchBox(useGoogleBox) {
  var windows = GTB_getBrowserWindows();
  for(var win = null, i = 0;win = windows[i]; ++ i) {
    var doc = win.document;
    var overlay = win.GTB_GoogleToolbarOverlay;
    var navToolbar = doc.getElementById("nav-bar");
    var searchBox = doc.getElementById("gtbSearchBox");
    var searchContainer = doc.getElementById("search-container");
    if(navToolbar != null) {
      var origWindow = window;
      var origDocument = document;
      window = win;
      document = doc;
      try {
        if(useGoogleBox) {
          overlay._removeButton("gtbSearchBox");
          navToolbar.insertItem("gtbSearchBox", null, null, false);
          if(searchContainer != null) {
            navToolbar.removeChild(searchContainer)}
        }
        else {
          if(searchContainer == null) {
            navToolbar.insertItem("search-container", null, null, false)}
          if(searchBox != null && searchBox.parent == navToolbar) {
            navToolbar.removeChild(searchBox)}
          overlay._removeButton("gtbSearchBox");
          overlay._addButton("gtbSearchBox")}
      }
      catch(e) {
        GTB_Dump(GTB_Dump.TB, e)}
      overlay.handleCustomize();
      window = origWindow;
      document = origDocument}
  }
}

function GTB_GTO_onClickMiddleMouse(event) {
  if("click" != event.type || 1 != event.button) {
    return}
  if(event.currentTarget) {
    var cmd = event.currentTarget.getAttribute("oncommand");
    if(cmd && cmd.length > 0) {
      eval(cmd);
      var target = event.target;
      if("menuitem" == target.nodeName && target.parentNode && "menupopup" == target.parentNode.nodeName) {
        target.parentNode.hidePopup()}
    }
  }
}

function GTB_AT_onTranslationAlert(value) {
  GTB_GoogleToolbarOverlay.autoTranslate.showTranslationAlert(value)}

function GTB_Chevron_onShowMenu(event, menu) {
  GTB_GoogleToolbarOverlay.chevron.onShowMenu(event, menu)}

function GTB_AutoFillManager() {
}

GTB_AutoFillManager._CONTAINER_TAG = "autofill";
GTB_AutoFillManager._initRegexp = function() {
  var regexps = GTB_AutoFillManager._fieldRegexps;
  for(var j = 0;j < regexps.length; ++ j) {
    if(!regexps[j].disable && !regexps[j].regexp) {
      var theRegexp = "";
      for(var k = 0;k < regexps[j].reg.length; ++ k) {
        if(k != 0) {
          theRegexp += "|"}
        theRegexp += "(\\b" + regexps[j].reg[k] + "\\b)"}
      regexps[j].regexp = null;
      if(theRegexp.length > 0) {
        regexps[j].regexp = new RegExp(theRegexp, "i")}
    }
  }
}

;
GTB_AutoFillManager._stringTrim = function(theString, minimal_trim) {
  var temp = theString;
  temp = temp.replace(/\n/g, " ");
  if(!minimal_trim) {
    temp = temp.replace(/\ \;/g, " ").replace(/[^\w\s\d#\/-]/g, " ");
    if(/^\s*[\/-]\s*$/.test(temp)) {
      return""}
  }
  var regexp = /^\s*(.*\S)\s*$/;
  if(regexp.test(temp)) {
    return temp.replace(regexp, "$1").replace(/\s\s+/g, " ")}
  else {
    return""}
}

;
GTB_AutoFillManager._decorateInputTags = function(node, tableHead, row, column) {
  var doc = node && node.ownerDocument;
  var nodes = doc.evaluate(".//input[@type='text'] | .//select[@type='select-one']", node, null, XPathResult.UNORDERED_NODE_ITERATOR_TYPE, null);
  var first = nodes.iterateNext();
  var node = first;
  while(node) {
    node.GTB_AUTOFILL_tableInfo = {tableHead:tableHead, row:row, column:column};
    node = nodes.iterateNext()}
  return first != null}

;
GTB_AutoFillManager._lookForText = function(node, allowOptionsTag) {
  if(node.nodeName == "SCRIPT" || !allowOptionsTag && node.nodeName == "OPTION") {
    return null}
  var text = "";
  if(node.nodeType == Node.TEXT_NODE) {
    text = GTB_AutoFillManager._stringTrim(node.nodeValue, allowOptionsTag);
    if(text.length) {
      return{node:node, text:text}}
  }
  text = "";
  var firstNode = null;
  var kids = node.childNodes;
  for(var i = 0;i < kids.length; ++ i) {
    var result = GTB_AutoFillManager._lookForText(kids[i], allowOptionsTag);
    if(result) {
      if(text.length) {
        text = text + " " + result.text}
      else {
        firstNode = result.node;
        text = result.text}
      if(text.length > 100) {
        return{node:firstNode, text:text}}
    }
  }
  if(text.length) {
    return{node:firstNode, text:text}}
  else {
    return null}
}

;
GTB_AutoFillManager._findOptionsText = function(node, number) {
  var resultArray = [];
  var count = 0;
  for(var i = 0;i < node.options.length; ++ i) {
    var result = GTB_AutoFillManager._lookForText(node.options[i], true);
     ++ count;
    if(result) {
      resultArray.push(result.text)}
    else {
      resultArray.push("")}
    if(count > number) {
      break}
  }
  return resultArray}

;
GTB_AutoFillManager._findLabelFromSibling = function(node) {
  var prevWalker = node;
  while(prevWalker) {
    var result = GTB_AutoFillManager._lookForText(prevWalker, false);
    if(result) {
      return result}
    prevWalker = prevWalker.previousSibling}
  return null}

;
GTB_AutoFillManager._findLabelGeneric = function(inputNode, reallySimple) {
  var parentWalker = inputNode;
  while(parentWalker && parentWalker.nodeName != "BODY") {
    var result = GTB_AutoFillManager._findLabelFromSibling(parentWalker.previousSibling);
    if(result) {
      return result}
    if(reallySimple) {
      return null}
    parentWalker = parentWalker.parentNode}
  return null}

;
GTB_AutoFillManager._constructTableInMemory = function(tableHead) {
  var tableMatrix = [];
  var rowNum = 0;
  var tableRows = tableHead.rows;
  for(var i = 0;i < tableRows.length; ++ i) {
    var columnNum = 0;
    var tableColumns = tableRows[i].cells;
    for(var j = 0;j < tableColumns.length; ++ j) {
      var tableEntry = tableColumns[j];
      var columnWidth = 1;
      if(tableEntry.getAttribute("colspan")) {
        columnWidth = parseInt(tableEntry.getAttribute("colspan"))}
      if(tableEntry.getAttribute("rowspan") && parseInt(tableEntry.getAttribute("rowspan")) != 1) {
        GTB_AutoFillManager._dump("Ignoring the rowspan!\n");
        continue}
      var foundInputTags = GTB_AutoFillManager._decorateInputTags(tableEntry, tableHead, rowNum, columnNum);
      var textResults = null;
      if(!foundInputTags) {
        textResults = GTB_AutoFillManager._lookForText(tableEntry, false)}
      if(textResults || foundInputTags) {
        for(var k = 0;k < columnWidth; ++ k) {
          tableMatrix[rowNum + "," + columnNum] = {textData:textResults, hasInputTags:foundInputTags};
           ++ columnNum}
      }
      else {
        columnNum += columnWidth}
    }
     ++ rowNum}
  return tableMatrix}

;
GTB_AutoFillManager._findTableHead = function(node) {
  var walker = node;
  while(walker != null && walker.nodeName != "BODY" && walker.nodeName != "TABLE" && walker.nodeName != "TBODY") {
    walker = walker.parentNode}
  if(walker.nodeName != "TABLE" && walker.nodeName != "TBODY") {
    return null}
  return walker}

;
GTB_AutoFillManager._findInputNodeInTable = function(inputNode) {
  var tableHead = GTB_AutoFillManager._findTableHead(inputNode);
  if(tableHead == null) {
    return null}
  var tableMatrix = null;
  if(tableHead.GTB_AUTOFILL_tableMatrix != null) {
    tableMatrix = tableHead.GTB_AUTOFILL_tableMatrix}
  else {
    tableMatrix = GTB_AutoFillManager._constructTableInMemory(tableHead);
    if(tableMatrix == null) {
      return null}
    tableHead.GTB_AUTOFILL_tableMatrix = tableMatrix}
  if(inputNode.GTB_AUTOFILL_tableInfo != null) {
    var row = inputNode.GTB_AUTOFILL_tableInfo.row;
    var column = inputNode.GTB_AUTOFILL_tableInfo.column;
    return{table:tableMatrix, row:row, column:column}}
  GTB_AutoFillManager._dump("Input element not found in table\n");
  return null}

;
GTB_AutoFillManager._lookupTableElement = function(table, row, column) {
  return table[row + "," + column]}

;
GTB_AutoFillManager._findLabelsInSameColumn = function(nodeLoc) {
  var columnResult = null;
  var startRow = nodeLoc.row - 2;
  if(startRow < 0) {
    startRow = 0}
  for(var i = startRow;i < nodeLoc.row; ++ i) {
    var result = GTB_AutoFillManager._lookupTableElement(nodeLoc.table, i, nodeLoc.column);
    if(result) {
      if(result.hasInputTags) {
        GTB_AutoFillManager._dump(" +c " + i + " null\n");
        columnResult = null}
      else if(result.textData) {
        GTB_AutoFillManager._dump(" +c " + i + " " + result.textData.text + "\n");
        columnResult = result.textData}
    }
  }
  return columnResult}

;
GTB_AutoFillManager._findLabelsInSameRow = function(nodeLoc) {
  var rowResult = null;
  if(nodeLoc.column == 0) {
    return null}
  for(var i = nodeLoc.column - 1;i >= 0; -- i) {
    var result = GTB_AutoFillManager._lookupTableElement(nodeLoc.table, nodeLoc.row, i);
    if(result) {
      if(result.hasInputTags) {
        GTB_AutoFillManager._dump(" +r " + i + " null\n");
        return rowResult}
      else if(result.textData) {
        GTB_AutoFillManager._dump(" +r " + i + " " + result.textData.text + "\n");
        rowResult = result.textData}
    }
  }
  return rowResult}

;
GTB_AutoFillManager._findLabelFromTable = function(inputNode) {
  var columnResults = {text:null, node:null};
  var rowResults = {text:null, node:null};
  var findResult = GTB_AutoFillManager._findInputNodeInTable(inputNode);
  if(findResult == null) {
    GTB_AutoFillManager._dump("No node found in table\n");
    return{rowResults:rowResults, columnResults:columnResults}}
  var result = GTB_AutoFillManager._findLabelsInSameRow(findResult);
  if(result) {
    rowResults = result}
  result = GTB_AutoFillManager._findLabelsInSameColumn(findResult);
  if(result) {
    columnResults = result}
  return{rowResults:rowResults, columnResults:columnResults}}

;
GTB_AutoFillManager._findFormInfo = function(doc) {
  var results = [];
  if(!doc || !doc.forms) {
    return results}
  var forms = doc.forms;
  var formsLength = forms.length;
  for(var i = 0;i < formsLength; ++ i) {
    var form = forms[i];
    var formLength = form.length;
    for(var j = 0;j < formLength; ++ j) {
      var input = form[j];
      if(input.name != null && input.name != "" && input.getAttribute("onclick") == null) {
        var typeName = input.type;
        if(typeName == "text" || typeName == "select-one") {
          var newElem = {input:input, type:typeName};
          results.push(newElem)}
      }
    }
  }
  return results}

;
GTB_AutoFillManager._dump = function(string) {
}

;
GTB_AutoFillManager._setTheDropDownSelection = function(input, text, index) {
  input.selectedIndex = -1;
  input.selectedIndex = index;
  if(input.selectedIndex == -1) {
    input.value = text}
}

;
GTB_AutoFillManager._chooseDropDownSelection = function(autofillFieldsEntry, userPref, autofillUserPreferences) {
  var optionsArray = this._findOptionsText(autofillFieldsEntry.input, 1000);
  if(optionsArray.length == 0) {
    return null}
  var userPrefLower = userPref.toLowerCase();
  var substringMatchIndex = -1;
  var userPrefRegexp = new RegExp("\\b" + userPrefLower + "\\b");
  var optionsHash = [];
  for(var i = 0;i < optionsArray.length; ++ i) {
    var optionString = optionsArray[i].toLowerCase();
    optionsHash[optionString] = i;
    if(optionString == userPrefLower) {
      return{value:optionsArray[i], index:i}}
    if(substringMatchIndex == -1 && userPrefRegexp.test(optionString)) {
      substringMatchIndex = i}
  }
  var index = optionsHash[userPrefLower];
  if(index != null) {
    return{value:optionsArray[index], index:index}}
  if(autofillFieldsEntry.fillFieldDataType == "state") {
    var stateAlt = autofillUserPreferences.stateAlt;
    if(stateAlt) {
      var index = optionsHash[stateAlt.toLowerCase()];
      if(index != null) {
        return{value:optionsArray[index], index:index}}
    }
  }
  if(autofillFieldsEntry.fillFieldDataType == "country" && userPref == GTB_AutoFillManager.US) {
    var index = optionsHash["usa"];
    if(index != null) {
      return{value:optionsArray[index], index:index}}
    var index = optionsHash["us"];
    if(index != null) {
      return{value:optionsArray[index], index:index}}
  }
  if(substringMatchIndex != -1) {
    index = substringMatchIndex;
    return{value:optionsArray[index], index:index}}
  return null}

;
function GTB_AutoFillPreview_onLoad(event) {
  var matches = window.arguments[0];
  var rows = document.getElementById("gtbAutoFillPreviewRows");
  var stringBundle = document.getElementById("google-toolbar-strings");
  for(var i = 0;i < matches.length;i ++ ) {
    var match = matches[i];
    if(match.shown) {
      continue}
    var value = "";
    if(match.entry.inputLabelNode == null) {
      value = match.value;
      match.shown = true}
    else {
      var inSameGroup = [];
      for(var j = 0;j < matches.length;j ++ ) {
        if(match.entry.inputLabelNode == matches[j].entry.inputLabelNode && (match.entry.match == "generic" || matches[j].entry.match == "generic" || match.entry.match == matches[j].entry.match)) {
          inSameGroup.push(matches[j])}
      }
      for(var j = 0;j < inSameGroup.length;j ++ ) {
        value += inSameGroup[j].value + " ";
        inSameGroup[j].shown = true}
      GTB_AutoFillManager._dump("For " + match.entry.inputLabelText + ", computed value is " + value)}
    var labelText = "";
    var displayName = match.entry.regexpEntry.displayName;
    if(displayName.length) {
      labelText = stringBundle.getString(displayName)}
    else {
      labelText = match.entry.inputLabelText}
    var row = document.createElement("row");
    var label = document.createElement("label");
    label.setAttribute("value", labelText);
    row.appendChild(label);
    label = document.createElement("label");
    label.setAttribute("value", value);
    row.appendChild(label);
    rows.appendChild(row)}
}

function GTB_AutoFillPreview_onAccept(event) {
  var retVal = window.arguments[1];
  retVal.accepted = true}

function GTB_AutoFillWarning_onLoad(event) {
  var shown = window.arguments[0];
  var checkbox = document.getElementById("gtbAutoFillWarningDoNotShow");
  if(!shown) {
    checkbox.checked = true}
}

function GTB_AutoFillWarning_onDone(accepted) {
  var checkbox = document.getElementById("gtbAutoFillWarningDoNotShow");
  var retVal = window.arguments[1];
  retVal.accepted = accepted;
  retVal.show = !checkbox.checked}

GTB_AutoFillManager._AUTOFILL_PREF = "AUTOFILL_Preferences";
GTB_AutoFillManager._DEFAULT_PREFERENCES = {highlight:true};
GTB_AutoFillManager.saveUserPreferences = function(theData) {
  var saveString = "";
  for(var i in theData) {
    if(saveString != "") {
      saveString += "\n"}
    saveString += i;
    saveString += "\n";
    saveString += theData[i]}
  GTB_getPrefs().setUnicodePref(GTB_AutoFillManager._AUTOFILL_PREF, saveString)}

;
GTB_AutoFillManager._patchUpBool = function(array, name) {
  if(array[name] && array[name] != "false") {
    return true}
  else {
    return false}
}

;
GTB_AutoFillManager.loadUserPreferences = function() {
  var restoreString = GTB_getPrefs().getUnicodePrefWithDefault(GTB_AutoFillManager._AUTOFILL_PREF, "");
  if(restoreString == "") {
    return GTB_AutoFillManager._DEFAULT_PREFERENCES}
  var splitStringArray = restoreString.split("\n");
  if(splitStringArray.length % 2 != 0) {
    return GTB_AutoFillManager._DEFAULT_PREFERENCES}
  var result = [];
  for(var i = 0;i < splitStringArray.length;i += 2) {
    result[splitStringArray[i]] = splitStringArray[i + 1]}
  result.highlight = GTB_AutoFillManager._patchUpBool(result, "highlight");
  for(var type in GTB_AutoFillOpts._PHONE_TYPES) {
    var typeString = GTB_AutoFillOpts._PHONE_TYPES[type];
    result["defaultPhone" + typeString] = GTB_AutoFillManager._patchUpBool(result, "defaultPhone" + typeString);
    result["alternativePhone" + typeString] = GTB_AutoFillManager._patchUpBool(result, "alternativePhone" + typeString)}
  return result}

;
GTB_AutoFillManager.prototype._autofillFields = [];
GTB_AutoFillManager.prototype._autofillUserPreferences = GTB_AutoFillManager.TEST_PREFS;
GTB_AutoFillManager.prototype.init = function() {
  GTB_AutoFillManager._initRegexp();
  this._autofillUserPreferences = GTB_AutoFillManager.loadUserPreferences();
  GTB_AutoFillOpts._fixupUserPref(this._autofillUserPreferences)}

;
GTB_AutoFillManager.prototype._startTime = 0;
GTB_AutoFillManager.prototype.doPageLoad = function(event) {
  if(!document.getElementById("gtbAutoFill"))return;
  if(!window.toolbar.visible)return;
  var doc = null;
  if(event) {
    doc = event.target}
  else {
    doc = GTB_GoogleToolbarOverlay._getCurrentDocument()}
  var browser = GTB_GoogleToolbarOverlay._getBrowserFromDoc(doc);
  if(!browser)return;
  this._parseThePageForAutofillFields(doc);
  browser.GTB_AutoFillData = this._autofillFields;
  var found = this._highlightFoundFields(browser.GTB_AutoFillData);
  if(browser == GTB_GoogleToolbarOverlay._getCurrentBrowser()) {
    this._enableAutoFillIcon(found)}
}

;
GTB_AutoFillManager.prototype.doTabSwitch = function(event) {
  if(!document.getElementById("gtbAutoFill"))return;
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  if(browser.GTB_AutoFillData) {
    var found = this._highlightFoundFields(browser.GTB_AutoFillData);
    this._enableAutoFillIcon(found)}
  else {
    this._enableAutoFillIcon(false)}
}

;
GTB_AutoFillManager.prototype.doAutoFill = function(event) {
  if(!document.getElementById("gtbAutoFill"))return;
  GTB_GoogleToolbarOverlay.maybeShowUsage("autofill_used", OptionsDialog.MORE_URL_AUTOFILL);
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  var found = this._fillTheFields(browser.GTB_AutoFillData, event.shiftKey);
  if(!found) {
    window.openDialog("chrome://google-toolbar/content/options-auto-fill.xul", "gtbAutoFillOptions", "modal,centerscreen,chrome,resizable=no");
    this._fillTheFields(browser.GTB_AutoFillData, event.shiftKey)}
}

;
function GTB_AutoFillMatch(entry, value) {
  this.entry = entry;
  this.value = value}

function GTB_AutoFillMatchDropDown(entry, value, index) {
  this.entry = entry;
  this.value = value;
  this.index = index}

GTB_AutoFillManager.prototype._fillTheFields = function(autofillFields, showPreview) {
  var found = false;
  var matches = [];
  var i;
  for(i = 0;i < autofillFields.length; ++ i) {
    var autofillFieldsEntry = autofillFields[i];
    var regexpEntry = autofillFieldsEntry.regexpEntry;
    GTB_AutoFillManager._dump(autofillFieldsEntry.inputLabelText + ", " + autofillFieldsEntry.inputLabelNode + "  " + regexpEntry.reg[0] + "\n");
    var fieldType = autofillFieldsEntry.fillFieldDataType;
    var fillData = this._autofillUserPreferences[fieldType];
    if(fillData && fillData.length > 0) {
      found = true;
      if(autofillFieldsEntry.input.type == "select-one") {
        var dropDown = GTB_AutoFillManager._chooseDropDownSelection(autofillFieldsEntry, fillData, this._autofillUserPreferences);
        if(dropDown != null) {
          matches.push(new GTB_AutoFillMatchDropDown(autofillFieldsEntry, dropDown.value, dropDown.index))}
      }
      else {
        if(autofillFieldsEntry.fillFieldDataType == "state" && (autofillFieldsEntry.input.size && autofillFieldsEntry.input.size <= 5 || autofillFieldsEntry.input.maxLength > 0 && autofillFieldsEntry.input.maxLength <= 5) && this._autofillUserPreferences.stateAbbrev && this._autofillUserPreferences.stateAbbrev.length == 2) {
          matches.push(new GTB_AutoFillMatch(autofillFieldsEntry, this._autofillUserPreferences.stateAbbrev))}
        else if(autofillFieldsEntry.fillFieldDataType == "fullName" && this._autofillUserPreferences.fullName && this._autofillUserPreferences.fullName.length > autofillFieldsEntry.input.maxLength) {
          matches.push(new GTB_AutoFillMatch(autofillFieldsEntry, this._autofillUserPreferences.firstLastName))}
        else {
          matches.push(new GTB_AutoFillMatch(autofillFieldsEntry, fillData))}
      }
    }
  }
  if(showPreview) {
    var retVal = {accepted:false};
    window.openDialog("chrome://google-toolbar/content/auto-fill-preview.xul", "gtbAutoFillPreview", "modal,centerscreen,resizable=no", matches, retVal);
    if(!retVal.accepted) {
      return found}
  }
  else {
    var shown = GTB_getPrefs().hasUserValue(GTB_PREF_AUTO_FILL_SHOW_WARNING);
    var showWarning = GTB_getPrefs().getBoolPrefWithDefault(GTB_PREF_AUTO_FILL_SHOW_WARNING, true);
    if(showWarning) {
      var ret = {accepted:false, show:null};
      window.openDialog("chrome://google-toolbar/content/auto-fill-warning.xul", "gtbAutoFillWarning", "modal,centerscreen,resizable=no", shown, ret);
      GTB_getPrefs().setBoolPref(GTB_PREF_AUTO_FILL_SHOW_WARNING, ret.show);
      if(!ret.accepted) {
        return found}
    }
  }
  for(var i = 0;i < matches.length;i ++ ) {
    var match = matches[i];
    if(match.entry.input.type == "select-one") {
      GTB_AutoFillManager._setTheDropDownSelection(match.entry.input, match.value, match.index)}
    else {
      match.entry.input.value = match.value}
  }
  return found}

;
GTB_AutoFillManager._tooltiptext = null;
GTB_AutoFillManager.getToolTipText = function() {
  if(GTB_AutoFillManager._tooltiptext == null) {
    var stringBundle = document.getElementById("google-toolbar-strings");
    GTB_AutoFillManager._tooltiptext = stringBundle.getString("google-autofill.input.tooltiptext")}
  return GTB_AutoFillManager._tooltiptext}

;
GTB_AutoFillManager.prototype._highlightFoundFields = function(autofillFields) {
  var found = false;
  for(var i = 0;i < autofillFields.length; ++ i) {
    var autofillFieldsEntry = autofillFields[i];
    if(autofillFieldsEntry.fillFieldDataType == null) {
      continue}
    found = true;
    if(this._autofillUserPreferences.highlight) {
      if(!autofillFieldsEntry.originalColor) {
        if(autofillFieldsEntry.input.style.backgroundColor) {
          autofillFieldsEntry.originalColor = autofillFieldsEntry.input.style.backgroundColor}
        else {
          autofillFieldsEntry.originalColor = "#FFFFFF"}
      }
      autofillFieldsEntry.input.style.backgroundColor = "#FFFFA0"}
    else if(autofillFieldsEntry.originalColor) {
      autofillFieldsEntry.input.style.backgroundColor = autofillFieldsEntry.originalColor}
    autofillFieldsEntry.input.tooltiptext = GTB_AutoFillManager.getToolTipText()}
  return found}

;
GTB_AutoFillManager.prototype._enableAutoFillIcon = function(enable) {
  var autofillIcon = document.getElementById("gtbAutoFill");
  if(autofillIcon) {
    if(enable) {
      autofillIcon.image = "chrome://google-toolbar/skin/auto-fill.png";
      autofillIcon.disabled = false}
    else {
      autofillIcon.image = "chrome://google-toolbar/skin/auto-fill-off.png";
      autofillIcon.disabled = true}
  }
}

;
GTB_AutoFillManager.prototype._findAndFillMatchingECML = function(formInfoText, formInfoNode, formInfo, matchString) {
  var regexps = GTB_AutoFillManager._fieldRegexps;
  for(var j = 0;j < regexps.length; ++ j) {
    var ecml = regexps[j].ecml;
    if(!regexps[j].disable && formInfoText.toLowerCase().lastIndexOf(ecml) != -1 && (!regexps[j].type || regexps[j].type == formInfo.type)) {
      GTB_AutoFillManager._dump("using " + matchString + ": " + ecml + " matching " + formInfoText + "\n");
      var label = GTB_AutoFillManager._findLabelGeneric(formInfo.input, false);
      var text = formInfoText;
      if(label) {
        text = label.text}
      var newElement = {input:formInfo.input, inputLabelText:text, inputLabelNode:formInfoNode, match:matchString, regexpEntry:regexps[j]};
      this._autofillFields.push(newElement);
      return true}
  }
  return false}

;
GTB_AutoFillManager.prototype._findAndFillMatchingRegexp = function(formInfoText, formInfoNode, formInfo, matchString) {
  var regexps = GTB_AutoFillManager._fieldRegexps;
  for(var j = 0;j < regexps.length; ++ j) {
    var regexp = regexps[j].regexp;
    if(!regexps[j].disable && regexp != null && (!regexps[j].type || regexps[j].type == formInfo.type) && regexp.test(formInfoText)) {
      var label = GTB_AutoFillManager._findLabelGeneric(formInfo.input, false);
      var text = formInfoText;
      if(label) {
        text = label.text}
      var newElement = {input:formInfo.input, inputLabelText:text, inputLabelNode:formInfoNode, match:matchString, regexpEntry:regexps[j]};
      GTB_AutoFillManager._dump("using " + matchString + " for text:" + formInfoText + ", regexp:" + regexp + "\n");
      this._autofillFields.push(newElement);
      return true}
  }
  return false}

;
GTB_AutoFillManager.prototype._parseThePageForAutofillFields = function(doc) {
  this._startTime = (new Date).getTime();
  this._autofillFields = [];
  var formInfo = GTB_AutoFillManager._findFormInfo(doc);
  GTB_AutoFillManager._dump("Found " + formInfo.length + " input elements to explore\n");
  var formItem;
  for(var i = 0;formItem = formInfo[i]; ++ i) {
    var runningTime = (new Date).getTime() - this._startTime;
    if(runningTime > 1000) {
      GTB_AutoFillManager._dump("Running time too long: " + runningTime + "ms\n");
      break}
    if(formItem.input.offsetHeight == 0 || formItem.input.offsetWidth == 0) {
      GTB_AutoFillManager._dump("Excluding " + formItem.input.name + " for zero length\n");
      continue}
    if(this._findAndFillMatchingECML(formItem.input.name, null, formItem, "ecml")) {
      continue}
    if(formItem.input.type == "select-one") {
      var optionsResult = GTB_AutoFillManager._findOptionsText(formItem.input, 4);
      if(optionsResult.length > 0) {
        var optionsString = optionsResult.join(" ");
        if(this._findAndFillMatchingRegexp(optionsString, null, formItem, "option")) {
          continue}
      }
    }
    var simpleResult = GTB_AutoFillManager._findLabelGeneric(formItem.input, true);
    if(simpleResult) {
      GTB_AutoFillManager._dump(" " + formItem.input.name + " s-> " + simpleResult.text + "\n");
      if(this._findAndFillMatchingRegexp(simpleResult.text, simpleResult.node, formItem, "generic")) {
        continue}
    }
    var tableResult = GTB_AutoFillManager._findLabelFromTable(formItem.input);
    if(tableResult.rowResults.text && this._findAndFillMatchingRegexp(tableResult.rowResults.text, tableResult.rowResults.node, formItem, "row")) {
      continue}
    if(tableResult.columnResults.text && this._findAndFillMatchingRegexp(tableResult.columnResults.text, tableResult.columnResults.node, formItem, "column")) {
      continue}
    var genericResult = GTB_AutoFillManager._findLabelGeneric(formItem.input, false);
    if(genericResult) {
      GTB_AutoFillManager._dump(" " + formItem.input.name + " g-> " + genericResult.text + "\n");
      if(this._findAndFillMatchingRegexp(genericResult.text, genericResult.node, formItem, "generic")) {
        continue}
    }
  }
  GTB_Dump(GTB_Dump.AF, "AF Running time: " + ((new Date).getTime() - this._startTime) + "\n");
  this._findTextToFillIn()}

;
GTB_AutoFillManager.prototype._findTextToFillIn = function() {
  var autofillFieldsLen = this._autofillFields.length;
  for(var i = 1;i < autofillFieldsLen;i ++ ) {
    var curData = this._autofillFields[i].regexpEntry.fillData[0][0];
    if(curData == "defaultPhoneExt") {
      var prevData = this._autofillFields[i - 1].regexpEntry.fillData[0][0];
      if(prevData.lastIndexOf("PhoneAll") != -1) {
        this._autofillFields[i].fillFieldDataType = curData.replace("default", prevData.substring(0, prevData.length - "PhoneAll".length))}
    }
  }
  for(var i = 0;i < autofillFieldsLen; ++ i) {
    if(this._autofillFields[i].fillFieldDataType) {
      continue}
    var labelNode = this._autofillFields[i].inputLabelNode;
    var match = this._autofillFields[i].match;
    if(labelNode == null) {
      this._autofillFields[i].fillFieldDataType = this._autofillFields[i].regexpEntry.fillData[0][0];
      continue}
    var autofillFieldsEntry;
    var inSameGroup = [];
    for(var j = 0;j < autofillFieldsLen; ++ j) {
      autofillFieldsEntry = this._autofillFields[j];
      if(labelNode == autofillFieldsEntry.inputLabelNode && (match == "generic" || autofillFieldsEntry.match == match || autofillFieldsEntry.match == "generic")) {
        inSameGroup.push(autofillFieldsEntry)}
    }
    var countGroup = inSameGroup.length - 1;
    for(j = 0;j < inSameGroup.length; ++ j) {
      autofillFieldsEntry = inSameGroup[j];
      var regexpEntry = autofillFieldsEntry.regexpEntry;
      var countElem = j;
      if(regexpEntry.fillData.length > countGroup && regexpEntry.fillData[countGroup].length > countElem - 1) {
        autofillFieldsEntry.fillFieldDataType = regexpEntry.fillData[countGroup][countElem]}
    }
  }
  for(var i = 1;i < autofillFieldsLen; ++ i) {
    if(this._autofillFields[i].fillFieldDataType == "addressLine2" && this._autofillFields[i - 1].fillFieldDataType == "address") {
      this._autofillFields[i - 1].fillFieldDataType = "addressLine1"}
  }
}

;
GTB_AutoFillManager.prototype._debugWrongFieldFound = function() {
}

;
GTB_AutoFillManager.prototype._debugCheckHasData = function(regexpEntry, autofillFieldsEntry, countGroup, countElem) {
}

;
GTB_AutoFillManager.prototype.getTooltipBody = function(parent, offset, target) {
  if(parent.nodeType == Node.ELEMENT_NODE) {
    var gp = parent.parentNode;
    if(parent.tagName == "div" && gp) {
      if(gp.nodeType == Node.ELEMENT_NODE && gp.tagName == "INPUT" && gp.tooltiptext) {
        var desc = document.createElement("description");
        desc.appendChild(document.createTextNode(gp.tooltiptext));
        return[desc]}
    }
  }
  return null}

;
GTB_AutoFillManager.prototype._debugVerifyTestFields = function() {
}

;
function GTB_AutoFillOpts() {
}

GTB_AutoFillOpts._PREFERENCE_DIALOG_FIELDS = ["fullName", "email", "defaultPhone", "alternativePhone", "addressLine1", "addressLine2", "addressLine3", "city", "state", "zipcode", "country"];
GTB_AutoFillOpts._PREF_PREFIX = "GTB_Autofill_Pref_";
GTB_AutoFillOpts._NAME_SUFFIX = ["JR", "SR", "II", "III", "IV", "V", "PHD", "MD"];
GTB_AutoFillOpts._LASTNAME_PREFIX = ["mac", "mc", "maol", "mael", "ui", "ni", "nic", "bean", "von", "van", "de", "het", "t", "der"];
GTB_AutoFillOpts._PHONE_TAGS = ["default", "alternative", "work", "home", "cell"];
GTB_AutoFillOpts._PHONE_TYPES = ["Work", "Home", "Cell"];
GTB_AutoFillOpts._PHONE_NUMBER_MAX_LENGTH = 20;
GTB_AutoFillOpts._PHONE_NUMBER_MIN_LENGTH = 5;
GTB_AutoFillOpts._readPref = function(attr) {
  return document.getElementById(GTB_AutoFillOpts._PREF_PREFIX + attr)}

;
GTB_AutoFillOpts._writePref = function(attr, val) {
  document.getElementById(GTB_AutoFillOpts._PREF_PREFIX + attr).value = val}

;
GTB_AutoFillOpts._checkPhoneNumber = function(number, typeString) {
  var stringBundle = document.getElementById("google-toolbar-strings");
  var retVal = true;
  if(number.length > GTB_AutoFillOpts._PHONE_NUMBER_MAX_LENGTH) {
    var errorString = stringBundle.getString("prop.gtb.autofill.phonenumbertoolong");
    errorString = errorString.replace("%s", typeString);
    alert(errorString);
    retVal = false}
  if(number.length < GTB_AutoFillOpts._PHONE_NUMBER_MIN_LENGTH) {
    var errorString = stringBundle.getString("prop.gtb.autofill.phonenumbertooshort");
    errorString = errorString.replace("%s", typeString);
    alert(errorString);
    retVal = false}
  if(!/\d/.test(number)) {
    var errorString = stringBundle.getString("prop.gtb.autofill.phonenumbernodigits");
    errorString = errorString.replace("%s", typeString);
    alert(errorString);
    retVal = false}
  return retVal}

;
GTB_AutoFillOpts._sanityCheckPhoneNumbers = function(userPref) {
  var foundDefaultType = false;
  var foundAlternativeType = false;
  var retVal = true;
  var stringBundle = document.getElementById("google-toolbar-strings");
  var typeString = stringBundle.getString("prop.gtb.autofill.defaultphone");
  retVal &= !userPref["defaultPhoneAll"] || GTB_AutoFillOpts._checkPhoneNumber(userPref["defaultPhoneAll"], typeString);
  var typeString = stringBundle.getString("prop.gtb.autofill.alternativephone");
  retVal &= !userPref["alternativePhoneAll"] || GTB_AutoFillOpts._checkPhoneNumber(userPref["alternativePhoneAll"], typeString);
  for(var type in GTB_AutoFillOpts._PHONE_TYPES) {
    var typeString = GTB_AutoFillOpts._PHONE_TYPES[type];
    foundDefaultType |= userPref["defaultPhone" + typeString];
    foundAlternativeType |= userPref["alternativePhone" + typeString];
    if(userPref["defaultPhone" + typeString] && userPref["defaultPhone" + typeString] == userPref["alternativePhone" + typeString]) {
      alert(stringBundle.getString("prop.gtb.autofill.selectdifferenttypes"));
      retVal = false}
  }
  if(userPref["defaultPhoneAll"] && !foundDefaultType) {
    alert(stringBundle.getString("prop.gtb.autofill.selectdefaulttype"));
    retVal = false}
  if(userPref["alternativePhoneAll"] && !foundAlternativeType) {
    alert(stringBundle.getString("prop.gtb.autofill.selectalternativetype"));
    retVal = false}
  return retVal}

;
function GTB_AutoFillOptions_onDialogOK(event) {
  var userPref = [];
  for(var i = 0;i < GTB_AutoFillOpts._PREFERENCE_DIALOG_FIELDS.length; ++ i) {
    var key = GTB_AutoFillOpts._PREFERENCE_DIALOG_FIELDS[i];
    var pref = GTB_AutoFillOpts._readPref(key).value;
    pref = pref.replace(/^\s*(.*\S)\s*$/, "$1");
    pref = pref.replace(/\s\s+/g, " ");
    if(key == "defaultPhone" || key == "alternativePhone") {
      userPref[key + "All"] = pref}
    else {
      userPref[key] = pref}
  }
  userPref.highlight = GTB_AutoFillOpts._readPref("highlight").checked == true;
  for(var type in GTB_AutoFillOpts._PHONE_TYPES) {
    var typeString = GTB_AutoFillOpts._PHONE_TYPES[type];
    userPref["defaultPhone" + typeString] = GTB_AutoFillOpts._readPref("defaultPhone" + typeString).selected;
    userPref["alternativePhone" + typeString] = GTB_AutoFillOpts._readPref("alternativePhone" + typeString).selected}
  if(!GTB_AutoFillOpts._sanityCheckPhoneNumbers(userPref)) {
    return false}
  GTB_AutoFillOpts._fixupUserPref(userPref);
  GTB_getToolbar().sendMessage("GTB_AutoFill.new_user_pref", true)}

GTB_AutoFillOpts._parsePhoneNumber = function(userPref, tag) {
  var phone = userPref[tag + "PhoneAll"];
  var phoneParse = phone.replace(/[^0-9]/g, "");
  if(phoneParse.length == 11 && phoneParse.charAt(0) == "1") {
    phoneParse = phoneParse.substr(1, 10)}
  if(phoneParse.length >= 10) {
    userPref[tag + "PhoneArea"] = phoneParse.substr(0, 3);
    userPref[tag + "PhonePrefix"] = phoneParse.substr(3, 3);
    userPref[tag + "PhoneSuffix"] = phoneParse.substr(6, 4);
    userPref[tag + "PhoneExt"] = phoneParse.substr(10);
    userPref[tag + "Phone"] = userPref[tag + "PhonePrefix"] + userPref[tag + "PhoneSuffix"]}
  userPref[tag + "PhoneAll"] = phone}

;
GTB_AutoFillOpts._fixupUserPref = function(userPref) {
  for(var i = 0;i < GTB_AutoFillOpts._PREFERENCE_DIALOG_FIELDS.length; ++ i) {
    var key = GTB_AutoFillOpts._PREFERENCE_DIALOG_FIELDS[i];
    if(!userPref[key]) {
      userPref[key] = ""}
  }
  for(var tag in GTB_AutoFillOpts._PHONE_TAGS) {
    var tagString = GTB_AutoFillOpts._PHONE_TAGS[tag];
    if(!userPref[tagString + "PhoneAll"]) {
      userPref[tagString + "PhoneAll"] = ""}
  }
  userPref.firstName = "";
  userPref.middleName = "";
  userPref.middleInit = "";
  userPref.lastName = "";
  userPref.firstLastName = "";
  if(userPref.fullName.length > 0) {
    var parsedName = userPref.fullName;
    parsedName = parsedName.replace(/,/g, " ");
    parsedName = parsedName.replace(/ +/g, " ");
    var namesArray = parsedName.split(" ");
    userPref.firstName = namesArray[0];
    userPref.firstLastName = userPref.firstName;
    if(namesArray.length > 1) {
      var lastIndex = namesArray.length - 1;
      userPref.lastName = namesArray[lastIndex];
      var lastWord = namesArray[lastIndex].replace(/\./g, "").toUpperCase();
      for(var i = 0;i < GTB_AutoFillOpts._NAME_SUFFIX.length;i ++ ) {
        if(lastWord == GTB_AutoFillOpts._NAME_SUFFIX[i]) {
          lastIndex -- ;
          userPref.lastName = namesArray[lastIndex];
          break}
      }
      if(lastIndex >= 2) {
        var penultimateWord = namesArray[lastIndex - 1].toLowerCase();
        for(var i = 0;i < GTB_AutoFillOpts._LASTNAME_PREFIX.length;i ++ ) {
          if(penultimateWord == GTB_AutoFillOpts._LASTNAME_PREFIX[i]) {
            var prefix = namesArray[lastIndex - 1];
            lastIndex -- ;
            userPref.lastName = prefix + " " + userPref.lastName;
            break}
        }
      }
      for(var i = 1;i < lastIndex;i ++ ) {
        if(i != 1) {
          userPref.middleName += " " + namesArray[i]}
        else {
          userPref.middleName += namesArray[i]}
      }
      userPref.firstLastName += " " + userPref.lastName}
  }
  if(userPref.middleName.length > 0) {
    userPref.middleInit = userPref.middleName.charAt(0)}
  userPref.address = "";
  userPref.addressFull = "";
  if(userPref.addressLine1 != "" || userPref.addressLine2 != "" || userPref.addressLine3 != "") {
    userPref.address = userPref.addressLine1 + " " + userPref.addressLine2 + " " + userPref.addressLine3}
  if(userPref.addressLine1 != "" || userPref.city != "" || userPref.state != "") {
    userPref.addressFull = userPref.addressLine1 + " " + userPref.city + ", " + userPref.state}
  userPref.zipshort = userPref.zipcode;
  var dash = userPref.zipcode.indexOf("-");
  if(dash != -1) {
    userPref.zipshort = userPref.zipcode.substr(0, dash);
    userPref.zipext = userPref.zipcode.substr(dash + 1)}
  var stateLower = userPref.state.toLowerCase();
  for(i = 0;i < GTB_AutoFillManager.STATES.length; ++ i) {
    if(GTB_AutoFillManager.STATES[i] == stateLower) {
      if(i % 2 == 0) {
        userPref.stateAlt = GTB_AutoFillManager.STATES[i + 1]}
      else {
        userPref.stateAlt = GTB_AutoFillManager.STATES[i - 1]}
      if(userPref.stateAlt.length == 2) {
        userPref.stateAbbrev = userPref.stateAlt.toUpperCase()}
      else {
        userPref.stateAbbrev = userPref.state.toUpperCase()}
      break}
  }
  for(var type in GTB_AutoFillOpts._PHONE_TYPES) {
    var typeString = GTB_AutoFillOpts._PHONE_TYPES[type];
    if(userPref["alternativePhone" + typeString]) {
      userPref[typeString.toLowerCase() + "PhoneAll"] = userPref["alternativePhoneAll"];
      break}
  }
  for(var type in GTB_AutoFillOpts._PHONE_TYPES) {
    var typeString = GTB_AutoFillOpts._PHONE_TYPES[type];
    if(userPref["defaultPhone" + typeString]) {
      userPref[typeString.toLowerCase() + "PhoneAll"] = userPref["defaultPhoneAll"];
      break}
  }
  for(var tag in GTB_AutoFillOpts._PHONE_TAGS) {
    GTB_AutoFillOpts._parsePhoneNumber(userPref, GTB_AutoFillOpts._PHONE_TAGS[tag])}
  GTB_AutoFillManager.saveUserPreferences(userPref);
  return true}

;
GTB_AutoFillOpts._setCountryMenu = function() {
  function createMenuItem(countryMenu, label, index) {
    var theMenuitem = document.createElement("menuitem");
    theMenuitem.setAttribute("label", label);
    theMenuitem.setAttribute("index", index);
    theMenuitem.setAttribute("value", label);
    countryMenu.firstChild.appendChild(theMenuitem)}

  var countryMenu = document.getElementById(GTB_AutoFillOpts._PREF_PREFIX + "country");
  for(var i = 0;i < GTB_AutoFillManager.COUNTRIES.length; ++ i) {
    createMenuItem(countryMenu, GTB_AutoFillManager.COUNTRIES[i], i)}
}

;
function GTB_AutoFillOptions_onDialogLoadSettings(event) {
  var userPref = GTB_AutoFillManager.loadUserPreferences();
  GTB_AutoFillOpts._setCountryMenu();
  for(var i = 0;i < GTB_AutoFillOpts._PREFERENCE_DIALOG_FIELDS.length; ++ i) {
    var key = GTB_AutoFillOpts._PREFERENCE_DIALOG_FIELDS[i];
    if(userPref[key] && userPref[key].length > 0) {
      GTB_AutoFillOpts._writePref(key, userPref[key])}
  }
  if(userPref.phoneAll && userPref.phoneAll.length > 0) {
    GTB_AutoFillOpts._writePref("defaultPhone", userPref.phoneAll)}
  if(userPref.defaultPhoneAll && userPref.defaultPhoneAll.length > 0) {
    GTB_AutoFillOpts._writePref("defaultPhone", userPref.defaultPhoneAll)}
  if(userPref.alternativePhoneAll && userPref.alternativePhoneAll.length > 0) {
    GTB_AutoFillOpts._writePref("alternativePhone", userPref.alternativePhoneAll)}
  for(var type in GTB_AutoFillOpts._PHONE_TYPES) {
    var typeString = GTB_AutoFillOpts._PHONE_TYPES[type];
    if(userPref["defaultPhone" + typeString]) {
      var element = document.getElementById("GTB_Autofill_Pref_defaultPhone" + typeString);
      element.radioGroup.selectedItem = element}
    if(userPref["alternativePhone" + typeString]) {
      var element = document.getElementById("GTB_Autofill_Pref_alternativePhone" + typeString);
      element.radioGroup.selectedItem = element}
  }
  document.getElementById("GTB_Autofill_Pref_highlight").checked = userPref.highlight}

GTB_AutoFillManager.TEST_PREFS = {title:"title", firstName:"firstName", middleInit:"middleInitial", middleName:"middleName", lastName:"lastName", fullName:"name", company:"company", email:"email", address:"address", addressLine1:"address1", addressLine2:"address2", addressLine3:"address3", addressFull:"addressFull", suite:"suite", city:"city", state:"state", province:"province", country:"country", zipcode:"zip", defaultPhoneAll:"phoneNumber", defaultPhoneArea:"area", defaultPhone:"phone", defaultPhonePrefix:
"prefix", defaultPhoneSuffix:"suffix", defaultPhoneExt:"extension", cardName:"cardholder", cardType:"cardType", cardNumber:"cardNumber", cardNumber1:"cardNumber1", cardNumber2:"cardNumber2", cardNumber3:"cardNumber3", cardNumber4:"cardNumber4", cardExpMonth:"expirationMonth", cardExpYear:"expirationYear", dob:"birth", dobDay:"birthDay", dobMonth:"birthMonth", dobYear:"birthYear", highlight:true};
GTB_AutoFillManager._fieldRegexps = [{fillData:[["title"]], disable:true, reg:["title"], displayName:"", ecml:"name_prefix"}, {fillData:[["firstName"], ["firstName", "lastName"]], reg:["first name", "fname", "initials"], ecml:"name_first", displayName:"prop.gtb.autofill.firstname", type:"text"}, {fillData:[["middleInit"]], reg:["m ?i", "initial"], displayName:"prop.gtb.autofill.middleinitial", type:"text"}, {fillData:[["middleName"]], reg:["middle"], ecml:"name_middle", displayName:"prop.gtb.autofill.middlename"
, type:"text"}, {fillData:[["lastName"]], reg:["last name", "lname", "surname"], ecml:"name_last", displayName:"prop.gtb.autofill.lastname", type:"text"}, {fillData:[["fullName"]], reg:["^[\\W\\s]*name", "full name", "recipient ?s? name", "attention", "attn", "to name", "my name"], displayName:"prop.gtb.autofill.fullname", type:"text"}, {fillData:[["email"]], reg:["e[ -]?mail"], ecml:"online_email", displayName:"prop.gtb.autofill.email", type:"text"}, {fillData:[["addressLine1"]], reg:["line ?1",
"address ?1", "street ?1"], ecml:"street_line1", displayName:"prop.gtb.autofill.primaryaddressline1", type:"text"}, {fillData:[["addressLine2"]], reg:["line ?2", "address ?2", "street ?2"], ecml:"street_line2", displayName:"prop.gtb.autofill.primaryaddressline2", type:"text"}, {fillData:[["addressLine3"]], reg:["line ?3", "address ?3", "street ?3"], ecml:"street_line3", displayName:"prop.gtb.autofill.primaryaddressline3", type:"text"}, {fillData:[["address"], ["addressLine1", "addressLine2"], ["addressLine1"
, "addressLine2", "addressLine3"]], reg:["address", "street"], displayName:"prop.gtb.autofill.primaryaddress", type:"text"}, {fillData:[["suite"]], reg:["apt", "suite", "unit"], disable:true, displayName:"", type:"text"}, {fillData:[["city"], ["city", "state"], ["city", "state", "zipcode"]], reg:["city"], ecml:"city", displayName:"prop.gtb.autofill.primaryaddresscity", type:"text"}, {fillData:[["zipcode"], ["zipshort", "zipext"]], reg:["zip", "postal code"], ecml:"postalcode", displayName:"prop.gtb.autofill.primaryaddresspostalcode"
, type:"text"}, {fillData:[["state"]], reg:["alabama", "state"], ecml:"stateprov", displayName:"prop.gtb.autofill.primaryaddressstate", type:"select-one"}, {fillData:[["state"]], reg:["state"], ecml:"stateprov", displayName:"prop.gtb.autofill.primaryaddressstate", type:"text"}, {fillData:[["province"]], disable:true, displayName:"prop.gtb.autofill.primaryaddressstate", reg:["province", "region"]}, {fillData:[["country"]], reg:["afghanistan", "united states", "country"], ecml:"countrycode", displayName:
"prop.gtb.autofill.primaryaddresscountry", type:"select-one"}, {fillData:[["country"]], reg:["country"], ecml:"countrycode", displayName:"prop.gtb.autofill.primaryaddresscountry", type:"text"}, {fillData:[["addressFull"]], reg:[], ecml:"near", displayName:"prop.gtb.autofill.primaryaddress", type:"text"}, {fillData:[["company"]], disable:true, reg:["company"], ecml:"company", displayName:"", type:"text"}, {fillData:[["workPhoneAll"], ["workPhoneArea", "workPhone"], ["workPhoneArea", "workPhonePrefix"
, "workPhoneSuffix"], ["workPhoneArea", "workPhonePrefix", "workPhoneSuffix", "workPhoneExt"]], reg:["(work|business|office|daytime) (phone|telephone)"], displayName:"prop.gtb.autofill.workphone", type:"text"}, {fillData:[["homePhoneAll"], ["homePhoneArea", "homePhone"], ["homePhoneArea", "homePhonePrefix", "homePhoneSuffix"], ["homePhoneArea", "homePhonePrefix", "homePhoneSuffix", "homePhoneExt"]], reg:["(home|residence|evening) (phone|telephone)"], displayName:"prop.gtb.autofill.homephone", type:
"text"}, {fillData:[["cellPhoneAll"], ["cellPhoneArea", "cellPhone"], ["cellPhoneArea", "cellPhonePrefix", "cellPhoneSuffix"], ["cellPhoneArea", "cellPhonePrefix", "cellPhoneSuffix", "cellPhoneExt"]], reg:["(cell|mobile) (phone|telephone)"], displayName:"prop.gtb.autofill.cellphone", type:"text"}, {fillData:[["alternativePhoneAll"], ["alternativePhoneArea", "alternativePhone"], ["alternativePhoneArea", "alternativePhonePrefix", "alternativePhoneSuffix"], ["alternativePhoneArea", "alternativePhonePrefix"
, "alternativePhoneSuffix", "alternativePhoneExt"]], reg:["(alternative|alternate|second|secondary|another) (phone|telephone)"], displayName:"prop.gtb.autofill.alternativephone", type:"text"}, {fillData:[["defaultPhoneAll"], ["defaultPhoneArea", "defaultPhone"], ["defaultPhoneArea", "defaultPhonePrefix", "defaultPhoneSuffix"], ["defaultPhoneArea", "defaultPhonePrefix", "defaultPhoneSuffix", "defaultPhoneExt"]], reg:["(default |primary )?(phone|telephone)"], ecml:"phone_number", displayName:"prop.gtb.autofill.defaultphone"
, type:"text"}, {fillData:[["defaultPhoneArea"]], reg:["area"], displayName:"prop.gtb.autofill.phonearea", type:"text"}, {fillData:[["defaultPhoneExt"]], reg:["ext", "extension"], displayName:"prop.gtb.autofill.phoneext", type:"text"}, {fillData:[["cardName"]], disable:true, reg:["cardholder ?s? name", "card holder"], ecml:"card_name", displayName:"", type:"text"}, {fillData:[["cardType"]], disable:true, reg:["visa", "credit card"], ecml:"card_type", displayName:"", type:"select-one"}, {fillData:
[["cardNumber"], [], [], ["cardNumber1", "cardNumber2", "cardNumber3", "cardNumber4"]], disable:true, reg:["card number", "card no", "card #", "account number"], ecml:"card_number", displayName:"", type:"text"}, {fillData:[["cardExpMonth"]], disable:true, reg:["expiration month"], displayName:"", ecml:"card_expdate_month"}, {fillData:[["cardExpYear"]], disable:true, reg:["expiration year"], displayName:"", ecml:"card_expdate_year"}, {fillData:[[], ["cardExpMonth", "cardExpYear"]], disable:true, displayName:
"", reg:["expiration"]}, {fillData:[["dobYear"]], disable:true, displayName:"", reg:["birth.*year", "year.*birth"]}, {fillData:[["dobDay"], ["dobMonth", "dobDay"], ["dobMonth", "dobDay", "dobYear"]], disable:true, displayName:"", reg:["birth"]}];
GTB_AutoFillManager.STATES = ["alabama", "al", "alaska", "ak", "arizona", "az", "arkansas", "ar", "california", "ca", "colorado", "co", "connecticut", "ct", "delaware", "de", "district of columbia", "dc", "florida", "fl", "georgia", "ga", "hawaii", "hi", "idaho", "id", "illinois", "il", "indiana", "in", "iowa", "ia", "kansas", "ks", "kentucky", "ky", "louisiana", "la", "maine", "me", "maryland", "md", "massachusetts", "ma", "michigan", "mi", "minnesota", "mn", "mississippi", "ms", "missouri", "mo"
, "montana", "mt", "nebraska", "ne", "nevada", "nv", "new hampshire", "nh", "new jersey", "nj", "new mexico", "nm", "new york", "ny", "north carolina", "nc", "north dakota", "nd", "ohio", "oh", "oklahoma", "ok", "oregon", "or", "pennsylvania", "pa", "puerto rico", "pr", "rhode island", "ri", "south carolina", "sc", "south dakota", "sd", "tennessee", "tn", "texas", "tx", "utah", "ut", "vermont", "vt", "virginia", "va", "washington", "wa", "west virginia", "wv", "wisconsin", "wi", "wyoming", "wy"];

GTB_AutoFillManager.US = "United States";
GTB_AutoFillManager.COUNTRIES = [GTB_AutoFillManager.US, "Afghanistan", "Albania", "Algeria", "American Samoa", "Andorra", "Angola", "Antigua and Barbuda", "Argentina", "Armenia", "Aruba", "Australia", "Austria", "Azerbaijan", "Bahamas", "Bahrain", "Bangladesh", "Barbados", "Belarus", "Belgium", "Belize", "Benin", "Bermuda", "Bhutan", "Bolivia", "Bosnia-Herzegovina", "Botswana", "Brazil", "British Virgin Islands", "Brunei", "Bulgaria", "Burkina Faso", "Burundi", "Cambodia", "Cameroon", "Canada",
"Cape Verde", "Cayman Islands", "Central Africa", "Chad", "Chile", "China", "Colombia", "Comoros", "Congo", "Congo Dem. Rep.", "Costa Rica", "Croatia", "Cuba", "Cyprus", "Czech Republic", "Denmark", "Djibouti", "Dominica", "Dominican Republic", "East Timor", "Ecuador", "Egypt", "El Salvador", "Equatorial Guinea", "Eritrea", "Estonia", "Ethiopia", "Faroe Islands", "Fiji", "Finland", "France", "French Guiana", "French Polynesia", "Gabon", "Gambia", "Georgia", "Germany", "Ghana", "Gibraltar", "Greece"
, "Greenland", "Grenada", "Guadeloupe", "Guam", "Guatemala", "Guernsey and Alderney", "Guinea", "Guinea Bissau", "Guyana", "Haiti", "Honduras", "Hong Kong", "Hungary", "Iceland", "India", "Indonesia", "Iran", "Iraq", "Ireland", "Isle of Man", "Israel", "Italy", "Ivory Coast", "Jamaica", "Japan", "Jersey", "Jordan", "Kazakhstan", "Kenya", "Kiribati", "Korea North", "Korea South", "Kuwait", "Kyrgyzstan", "Laos", "Latvia", "Lebanon", "Lesotho", "Liberia", "Libya", "Liechtenstein", "Lithuania", "Luxembourg"
, "Macedonia", "Madagascar", "Malawi", "Malaysia", "Maldives", "Mali", "Malta", "Marshall Islands", "Martinique", "Mauritania", "Mauritius", "Mayotte", "Mexico", "Micronesia", "Moldova", "Monaco", "Mongolia", "Morocco", "Mozambique", "Myanmar", "Namibia", "Nepal", "Netherlands", "Netherlands Antilles", "New Caledonia", "New Zealand", "Nicaragua", "Niger", "Nigeria", "Northern Mariana Islands", "Norway", "Oman", "Pakistan", "Palestine", "Panama", "Papua New Guinea", "Paraguay", "Peru", "Philippines"
, "Poland", "Portugal", "Puerto Rico", "Qatar", "Romania", "Russia", "Rwanda", "Reunion", "Sahara", "Saint Kitts and Nevis", "Saint Lucia", "Saint Vincent", "Samoa", "Sao Tome and Principe", "Saudi Arabia", "Senegal", "Serbia and Montenegro", "Seychelles", "Sierra Leone", "Singapore", "Slovakia", "Slovenia", "Solomon Islands", "Somalia", "South Africa", "Spain", "Sri Lanka", "Sudan", "Suriname", "Swaziland", "Sweden", "Switzerland", "Syria", "Taiwan", "Tajikistan", "Tanzania", "Thailand", "Togo",
"Tonga", "Trinidad and Tobago", "Tunisia", "Turkey", "Turkmenistan", "Uganda", "Ukraine", "United Arab Emirates", "United Kingdom", "U.S. Virgin Islands", "Uruguay", "Uzbekistan", "Vanuatu", "Vatican City", "Venezuela", "Vietnam", "Yemen", "Zambia", "Zimbabwe"];
function GTB_AL_RemoveFromArray(arr, pos) {
  var value;
  for(var i = pos;value = arr[i + 1]; ++ i) {
    arr[i] = value}
  arr.pop()}

function GTB_AL_MatchFinder() {
  this.docRange = null;
  this.startRange = null;
  this.stopRange = null;
  this.text = null;
  this.findRange = null}

GTB_AL_MatchFinder.prototype.firstMatch = function(doc, text, isCaseSensitive) {
  if(!doc)return null;
  this.text = text;
  var body = doc.body;
  var docRange = doc.createRange();
  docRange.selectNode(body);
  this.docRange = docRange;
  var startRange = docRange.cloneRange();
  startRange.collapse(true);
  this.startRange = startRange;
  var stopRange = docRange.cloneRange();
  stopRange.collapse(false);
  this.stopRange = stopRange;
  var objectName = "@mozilla.org/embedcomp/rangefind;1";
  var findRange = Components.classes[objectName].createInstance();
  if(findRange != null && findRange  instanceof Components.interfaces.nsIFind) {
    findRange.caseSensitive = isCaseSensitive;
    findRange.findBackwards = false;
    this.findRange = findRange;
    return this.nextMatch(startRange)}
  return null}

, GTB_AL_MatchFinder.prototype.nextMatch = function(startRange) {
  startRange = startRange.cloneRange();
  startRange.collapse(false);
  return this.findRange.Find(this.text, this.docRange, startRange, this.stopRange)}

;
function GTB_AL_Token(type, offset, contents, node) {
  this.type = type;
  this.offset = offset;
  this.contents = contents;
  this.node = node;
  this._isNumeric = null;
  if(contents != null) {
    this.length = contents.length}
  else {
    this.length = null}
  this.visited = false}

GTB_AL_Token.prototype.isNumeric = function() {
  if(this._isNumeric == null)this._isNumeric = /^\d+$/.test(this.contents);
  return this._isNumeric}

;
GTB_AL_Token.prototype.toString = function() {
  return"[type:   " + this.type + ", offset:   " + this.offset + ", node:   " + this.node + ", isNumeric:  " + this.isNumeric() + ", length:   " + this.length + "\ncontents:" + this.contents + "]\n\n"}

;
function GTB_AL_Tokenizer() {
}

GTB_AL_Tokenizer.TYPE_OPEN_SCOPE = 0;
GTB_AL_Tokenizer.TYPE_CLOSE_SCOPE = 1;
GTB_AL_Tokenizer.TYPE_NO_SCOPE = 2;
GTB_AL_Tokenizer.TYPE_TEXT = 3;
GTB_AL_Tokenizer.dumpTree = function(d, n) {
  GTB_Dump(GTB_Dump.AL, n + "\t" + d + "\n");
  if(d.nodeType == Node.ELEMENT_NODE) {
    for(var i = d.firstChild;i != null;i = i.nextSibling) {
      GTB_AL_Tokenizer.dumpTree(i, n + 1)}
  }
}

;
GTB_AL_Tokenizer.tokenizeRange = function(r, retVal) {
  var start = r.startContainer;
  var end = r.endContainer;
  if(start.nodeType == Node.TEXT_NODE && start == end) {
    GTB_AL_Tokenizer._tokenizeText(start.nodeValue.substring(r.startOffset, r.endOffset), start, retVal, r.startOffset);
    return retVal}
  var curNode, endNode;
  if(start.nodeType == Node.TEXT_NODE) {
    curNode = start;
    GTB_AL_Tokenizer._tokenizeText(curNode.nodeValue.substring(r.startOffset), curNode, retVal, r.startOffset)}
  else if(start.nodeType == Node.ELEMENT_NODE) {
    if(r.startOffset == start.childNodes.length) {
      curNode = GTB_AL_Tokenizer.nextNodeSibling(start)}
    else {
      curNode = start.childNodes[r.startOffset]}
  }
  else {
    curNode = start}
  if(end.nodeType == Node.TEXT_NODE) {
    endNode = end}
  else if(end.nodeType == Node.ELEMENT_NODE) {
    if(r.endOffset == end.childNodes.length) {
      endNode = GTB_AL_Tokenizer.nextNodeSibling(end)}
    else {
      endNode = end.childNodes[r.endOffset]}
  }
  else {
    endNode = end}
  while(curNode != endNode) {
    if(curNode.nodeType == Node.TEXT_NODE) {
      GTB_AL_Tokenizer._tokenizeText(curNode.nodeValue, curNode, retVal, 0)}
    curNode = GTB_AL_Tokenizer.nextNode(curNode)}
  if(endNode && endNode.nodeType == Node.TEXT_NODE) {
    GTB_AL_Tokenizer._tokenizeText(endNode.nodeValue.substring(0, r.endOffset), endNode, retVal, 0)}
  return retVal}

;
GTB_AL_Tokenizer.nextNode = function(node) {
  if(node.childNodes && node.childNodes.length > 0) {
    return node.childNodes[0]}
  return GTB_AL_Tokenizer.nextNodeSibling(node)}

;
GTB_AL_Tokenizer.prevNode = function(node) {
  if(node.childNodes && node.childNodes.length > 0) {
    return node.childNodes[node.childNodes.length - 1]}
  return GTB_AL_Tokenizer.prevNodeSibling(node)}

;
GTB_AL_Tokenizer.nextNodeSibling = function(node) {
  while(node && node.nextSibling == null) {
    node = node.parentNode}
  return node ? node.nextSibling : null}

;
GTB_AL_Tokenizer.prevNodeSibling = function(node) {
  while(node && node.previousSibling == null) {
    node = node.parentNode}
  return node ? node.previousSibling : null}

;
GTB_AL_Tokenizer.TOKEN_REGEX = (new RegExp).compile(/([^\x30-\x39\x41-\x5a\x61-\x7a\xc0-\xff]+)/);
GTB_AL_Tokenizer._tokenizeText = function(text, node, retVal, offsetAdjustment) {
  var tokens = text.split(GTB_AL_Tokenizer.TOKEN_REGEX);
  var offsetCounter = offsetAdjustment;
  for(var i = 0;i < tokens.length; ++ i) {
    var t = tokens[i];
    if(t.length == 0)continue;
    retVal.push(new GTB_AL_Token(GTB_AL_Tokenizer.TYPE_TEXT, offsetCounter, t, node));
    offsetCounter += t.length}
}

;
function GTB_AL_RangeExpander() {
}

GTB_AL_RangeExpander.RANGE_INVALID_TAGS = {SCRIPT:true, INPUT:true, TEXTAREA:true, HEAD:true};
GTB_AL_RangeExpander.WINDOW_SIZE = 100;
GTB_AL_RangeExpander.ITERATIONS = 10;
GTB_AL_RangeExpander.expandRange = function(range) {
  var currentContainer = range.startContainer;
  while(currentContainer != null) {
    if(currentContainer.nodeName  in  GTB_AL_RangeExpander.RANGE_INVALID_TAGS) {
      return null}
    currentContainer = currentContainer.parentNode}
  GTB_AL_RangeExpander._expandRangeForward(range);
  GTB_AL_RangeExpander._expandRangeBackward(range);
  return range}

;
GTB_AL_RangeExpander._expandRangeForward = function(range) {
  var iterations = GTB_AL_RangeExpander.ITERATIONS;
  var remainingSize = GTB_AL_RangeExpander.WINDOW_SIZE;
  while(iterations --  > 0 && remainingSize > 0) {
    var node = range.endContainer;
    var offset = range.endOffset;
    if(node.nodeType == Node.TEXT_NODE) {
      var txtLen = node.nodeValue.length;
      if(offset + remainingSize > txtLen) {
        range.setEnd(node, txtLen);
        node = GTB_AL_Tokenizer.nextNode(node);
        remainingSize -= txtLen - offset}
      else {
        range.setEnd(node, offset + remainingSize);
        return}
    }
    else if(node.nodeType == Node.ELEMENT_NODE) {
      var len = node.childNodes.length;
      if(offset < len && len > 0) {
        node = node.childNodes[offset]}
      else if(offset >= len) {
        node = GTB_AL_Tokenizer.nextNodeSibling(node)}
    }
    if(!node || node.nodeName  in  GTB_AL_RangeExpander.RANGE_INVALID_TAGS) {
      return}
    range.setEnd(node, 0)}
}

;
GTB_AL_RangeExpander._expandRangeBackward = function(range) {
  var iterations = GTB_AL_RangeExpander.ITERATIONS / 2;
  var remainingSize = GTB_AL_RangeExpander.WINDOW_SIZE;
  while(iterations --  > 0 && remainingSize > 0) {
    var node = range.startContainer;
    var offset = range.startOffset;
    if(node.nodeType == Node.TEXT_NODE) {
      if(offset - remainingSize < 0) {
        node = GTB_AL_RangeExpander._prevChildNode(node);
        if(!node) {
          return}
        remainingSize -= offset;
        if(node.nodeType == Node.TEXT_NODE) {
          range.setStart(node, node.nodeValue.length)}
        else {
          range.setStart(node, 0)}
      }
      else {
        range.setStart(node, offset - remainingSize);
        return}
    }
    else {
      var len = node.childNodes.length;
      if(offset < len && len > 0) {
        node = node.childNodes[offset]}
      node = GTB_AL_RangeExpander._prevChildNode(node);
      if(!node) {
        return}
      range.setStart(node, 0)}
  }
}

;
GTB_AL_RangeExpander._prevChildNode = function(node) {
  node = GTB_AL_Tokenizer.prevNode(node);
  if(!node || node.nodeName  in  GTB_AL_RangeExpander.RANGE_INVALID_TAGS) {
    return null}
  while(node && node.childNodes.length > 0) {
    node = GTB_AL_Tokenizer.prevNode(node);
    if(!node || node.nodeName  in  GTB_AL_RangeExpander.RANGE_INVALID_TAGS) {
      return null}
  }
  return node}

;
function GTB_AL_Scanner(triggers, matcherFxns, validFxn, isCaseSensitive, prefKey, parent) {
  this.triggerDict = {};
  for(var i = 0;i < triggers.length;i ++ ) {
    var trigger = triggers[i];
    if(!isCaseSensitive) {
      trigger = trigger.toLowerCase()}
    this.triggerDict[triggers[i]] = true}
  this.captures = matcherFxns;
  this.isValid = validFxn;
  this.isCaseSensitive = isCaseSensitive;
  this.prefKey = prefKey;
  this.parent = parent}

GTB_AL_Scanner.prototype.checkTokens = function(tokenlist, insertions, tabData) {
  var token;
  for(var i = 0;token = tokenlist[i]; ++ i) {
    if(token.visited)continue;
    var tokenText = token.contents;
    if(!tokenText) {
      continue}
    if(this.possibleMatch(tokenText)) {
      var matches = this.getMatches(tokenlist, i);
      if(matches.length > 0) {
        var match;
        for(var j = 0;match = matches[j]; ++ j) {
          var urlparts = ["hl=" + GTB_GoogleToolbarOverlay.languageCode, "lt=" + this.prefKey, "q=" + encodeURIComponent(match.contents)];
          if(this.prefKey == "isbn" || this.prefKey == "vin") {
            var provNum = GTB_getPrefs().getStringPref("autolink." + this.prefKey);
            var provName = this.parent.getProviderName(this.prefKey, provNum);
            urlparts = urlparts.concat(["lpi=" + provNum])}
          var url = "http://www.google.com/tbproxy/redir?" + urlparts.join("&");
          var range = document.createRange();
          range.setStart(match.startToken.node, match.startToken.offset);
          range.setEnd(match.endToken.node, match.endToken.offset + match.endToken.length);
          var duplicate = false;
          for(var ins = 0;ins < insertions.length; ++ ins) {
            var otherRange = insertions[ins].range;
            if(0 == range.compareBoundaryPoints(range.START_TO_START, otherRange) && 0 == range.compareBoundaryPoints(range.END_TO_END, otherRange)) {
              duplicate = true;
              break}
          }
          if(!duplicate) {
            var displayValue = match.contents;
            insertions.push(new GTB_AL_InsertionObject(range, url, provName, displayValue, this.prefKey))}
        }
      }
    }
  }
}

;
GTB_AL_Scanner.prototype.possibleMatch = function(tokenText) {
  if(this.isCaseSensitive) {
    return this.triggerDict[tokenText] != null}
  return this.triggerDict[tokenText.toLowerCase()] != null}

;
GTB_AL_Scanner.prototype.getMatches = function(tokenlist, pos) {
  var curPos;
  var result;
  var i;
  var j;
  var matches = [];
  for(i = 1;i < 64; ++ i) {
    curPos = pos + i;
    if(curPos >= tokenlist.length) {
      break}
    for(j = 0;j < this.captures.length; ++ j) {
      result = this.captures[j](tokenlist, curPos);
      if(result && this.isValid(result.contents)) {
        matches.push(result)}
    }
    tokenlist[curPos].visited = true}
  for(i = 1;i < 64; ++ i) {
    curPos = pos - i;
    if(curPos < 0) {
      break}
    for(j = 0;j < this.captures.length; ++ j) {
      result = this.captures[j](tokenlist, curPos);
      if(result && this.isValid(result.contents)) {
        matches.push(result)}
    }
    tokenlist[curPos].visited = true}
  return matches}

;
function GTB_AL_Match(startToken, endToken, contents) {
  this.startToken = startToken;
  this.endToken = endToken;
  this.contents = contents}

function GTB_AL_getChecksum(value, ndigits, multipliers) {
  var sum = 0;
  for(var i = 0;i < value.length - 1; ++ i) {
    if(GTB_AL_isDigit(value[i])) {
      sum += multipliers[i] * (value.charCodeAt(i) - 48)}
  }
  return sum}

function GTB_AL_getCheckDigit(value) {
  return value.charCodeAt(value.length - 1) - 48}

function GTB_AL_isDigit(value) {
  return/^\d+$/.test(value)}

function GTB_AL_Request(tabData, url, parent) {
  this.tabData = tabData;
  this.candidates = [];
  this.url = url;
  this.length = 0;
  this.parent = parent}

GTB_AL_Request.prototype.addRequest = function(tokenlist) {
  var candidate = new GTB_AL_RequestCandidate(tokenlist);
  var duplicate = false;
  for(var c = 0;c < this.candidates.length; ++ c) {
    var otherRange = this.candidates[c].range;
    var range = candidate.range;
    if(0 == range.compareBoundaryPoints(range.START_TO_START, otherRange) && 0 == range.compareBoundaryPoints(range.END_TO_END, otherRange)) {
      duplicate = true;
      break}
  }
  if(!duplicate && candidate.text.length + this.length <= 32000) {
    this.candidates.push(candidate)}
}

;
GTB_AL_Request.prototype.sendAutolinkRequest = function() {
  if(this.candidates.length > 0) {
    var texts = [];
    this.candidates.sort(GTB_AL_RequestCandidateCompare);
    for(var c in this.candidates) {
      var candidate = this.candidates[c];
      texts.push(candidate.text)}
    this.sendText = texts.join("\n");
    this._sendAutolinkRequest(this.sendText)}
  else {
    this.parent._showLinks(this.tabData)}
}

;
GTB_AL_Request.prototype._sendAutolinkRequest = function(text) {
  var request = new XMLHttpRequest;
  var self = this;
  request.onreadystatechange = function(ev) {
    if(4 == request.readyState) {
      var status = -1;
      try {
        status = request.status}
      catch(e) {
      }
      if(200 == status) {
        var items = request.responseXML.getElementsByTagName("items");
        for(var i = 0;i < items.length; ++ i) {
          self._insertLink(items[i])}
        self.candidates = [];
        self.sendText = ""}
      else {
        GTB_Dump(GTB_Dump.AL, "request to autolink server failed")}
      self.parent._showLinks(self.tabData);
      request.onreadystatechange = null}
  }

  ;
  var provNum = GTB_getPrefs().getStringPref("autolink.map");
  var query_string = ["url=" + encodeURIComponent(this.url), "hl=" + GTB_GoogleToolbarOverlay.languageCode, "map=" + provNum].join("&");
  request.open("POST", "https://www.google.com/tbproxy/autolink?" + query_string, true);
  request.setRequestHeader("X-CompressionType", "none");
  request.setRequestHeader("Pragma", "no-cache");
  request.send(text)}

;
GTB_AL_Request.prototype._insertLink = function(itemxml) {
  var type, begin, end, url, text;
  var insertions = this.tabData.getInsertionsUnsafe();
  var nodes = itemxml.getElementsByTagName("type");
  if(nodes.length == 1)type = nodes[0].getAttribute("data");
  if(type == "postal_address") {
    nodes = itemxml.getElementsByTagName("begin");
    if(nodes.length == 1)begin = parseInt(nodes[0].getAttribute("int"));
    nodes = itemxml.getElementsByTagName("end");
    if(nodes.length == 1)end = parseInt(nodes[0].getAttribute("int"));
    nodes = itemxml.getElementsByTagName("url");
    if(nodes.length == 1)url = nodes[0].getAttribute("data");
    nodes = itemxml.getElementsByTagName("text");
    if(nodes.length == 1)text = nodes[0].getAttribute("data");
    if(this.sendText.substring(begin, end).indexOf("\n") == -1) {
      var startToken = this._getToken(begin);
      var endToken = this._getToken(end - 1);
      if(startToken && endToken) {
        var range = document.createRange();
        range.setStart(startToken.node, startToken.offset);
        var offset = Math.min(endToken.node.length, endToken.offset + endToken.length);
        if(1 == range.comparePoint(endToken.node, offset)) {
          range.setEnd(endToken.node, offset);
          var provNum = GTB_getPrefs().getStringPref("autolink.map");
          var provider = this.parent.getProviderName("map", provNum);
          var match = new GTB_AL_InsertionObject(range, url, provider, text, "map");
          if(!this.isDuplicateLink(match, insertions)) {
            insertions.push(match)}
        }
      }
    }
  }
}

;
GTB_AL_Request.prototype.isDuplicateLink = function(match, insertions) {
  var range = match.range;
  for(var i = 0;i < insertions.length;i ++ ) {
    var otherRange = insertions[i].range;
    if(range.compareBoundaryPoints(range.START_TO_START, otherRange) >= 0 && range.compareBoundaryPoints(range.END_TO_END, otherRange) <= 0) {
      return true}
    if(range.compareBoundaryPoints(range.START_TO_START, otherRange) <= 0 && range.compareBoundaryPoints(range.END_TO_END, otherRange) >= 0) {
      insertions[i] = match;
      return true}
  }
  return false}

;
GTB_AL_Request.prototype._getToken = function(offset) {
  var c = 0;
  var pos = 0;
  while(!(pos <= offset && offset <= pos + this.candidates[c].text.length)) {
    pos += this.candidates[c].text.length + 1;
     ++ c}
  var candidate = this.candidates[c];
  var t = 0;
  while(!(pos <= offset && offset <= pos + candidate.tokens[t].contents.length)) {
    pos += candidate.tokens[t].length + 1;
     ++ t}
  return candidate.tokens[t]}

;
function GTB_AL_RequestCandidate(tokenlist) {
  this.tokens = [];
  this.range = document.createRange();
  var words = [];
  for(var t in tokenlist) {
    var token = tokenlist[t];
    if(token.type == GTB_AL_Tokenizer.TYPE_TEXT && token.contents.search(GTB_AL_Tokenizer.TOKEN_REGEX) == -1) {
      this.tokens.push(token);
      words.push(token.contents)}
  }
  if(this.tokens.length > 0) {
    this.range.setStart(this.tokens[0].node, this.tokens[0].offset);
    this.range.collapse(true)}
  this.text = words.join(" ")}

function GTB_AL_RequestCandidateCompare(lhs, rhs) {
  return lhs.range.compareBoundaryPoints(lhs.range.START_TO_START, rhs.range)}

function GTB_AL_InsertionObject(range, url, displaySite, displayValue, type) {
  this.range = range;
  this.linkURL = url;
  this.displaySite = displaySite;
  this.displayValue = displayValue;
  this.type = type;
  this.id = null;
  this.isLinkable = this._checkForLinks()}

GTB_AL_InsertionObject.prototype.toString = function() {
  return this.linkURL + ": " + this.range + "\n" + this.displayValue + ":" + this.type}

;
GTB_AL_InsertionObject.prototype._checkForLinks = function() {
  var curNode = this.range.startContainer;
  var endNode = this.range.endContainer;
  while(curNode != endNode) {
    if(curNode.nodeName == "A") {
      return false}
    curNode = GTB_AL_Tokenizer.nextNode(curNode)}
  curNode = this.range.startContainer;
  while(curNode.nodeName != "BODY") {
    if(curNode.nodeName == "A")return false;
    curNode = curNode.parentNode}
  curNode = this.range.endContainer;
  while(curNode.nodeName != "BODY") {
    if(curNode.nodeName == "A")return false;
    curNode = curNode.parentNode}
  return true}

;
GTB_AL_InsertionObject.prototype.selectAndFocus = function() {
  var doc = this.range.startContainer.ownerDocument;
  var win = doc && doc.defaultView;
  var link = doc && doc.getElementById(this.id);
  if(!doc || !win) {
    return false}
  var sel = win.getSelection();
  var range;
  if(link) {
    range = doc.createRange();
    range.selectNode(link)}
  else {
    range = this.range}
  if(link) {
    link.focus()}
  else {
    var focusNode = range.startContainer;
    while(focusNode.nodeType != Node.ELEMENT_NODE) {
      focusNode = focusNode.parentNode}
    var pt = GetPageOffset(focusNode);
    win.scrollTo(pt.x, pt.y - 20)}
  changeSelectionColor(false);
  sel.removeAllRanges();
  sel.addRange(range);
  return true}

;
GTB_AL_InsertionObject.prototype.insertAutolink = function(id) {
  var target = GTB_AutoLink.getTarget();
  if(this.isLinkable) {
    var anchorNode = this.range.startContainer.ownerDocument.createElement("a");
    anchorNode.href = this.linkURL;
    anchorNode.target = target;
    anchorNode.style.backgroundColor = "#C0D4EE";
    anchorNode.style.color = "blue";
    anchorNode.id = id;
    this.id = id;
    var docfrag = this.range.extractContents();
    anchorNode.appendChild(docfrag);
    this.range.insertNode(anchorNode)}
}

;
GTB_AL_InsertionObject.prototype.removeAutolink = function() {
  if(!this.isLinkable)return;
  var doc = this.range.startContainer.ownerDocument;
  var link = doc && doc.getElementById(this.id);
  if(!link) {
    return}
  var range = doc.createRange();
  range.selectNodeContents(link);
  var placeholderStart = doc.createElement("span");
  placeholderStart.style.display = "none";
  link.parentNode.insertBefore(placeholderStart, link);
  var placeholderEnd = doc.createElement("span");
  placeholderEnd.style.display = "none";
  if(link.nextSibling) {
    link.parentNode.insertBefore(placeholderEnd, link.nextSibling)}
  else {
    link.parentNode.appendChild(placeholderEnd)}
  link.parentNode.replaceChild(range.extractContents(), link);
  this.range = doc.createRange();
  this.range.setStartAfter(placeholderStart);
  this.range.setEndBefore(placeholderEnd);
  placeholderStart.parentNode.removeChild(placeholderStart);
  placeholderEnd.parentNode.removeChild(placeholderEnd)}

;
function GTB_AL_Strings() {
  var strings = document.getElementById("google-toolbar-strings");
  var propPrefix = "prop.google-autolink.";
  this.AUTOLINK = strings.getString(propPrefix + "label");
  this.TOOLTIP_TITLE = strings.getString(propPrefix + "tooltip-title");
  this.NO_ITEMS = strings.getString(propPrefix + "no-items");
  this.ITEM_LINKED = strings.getString(propPrefix + "item-linked");
  this.ITEMS_LINKED = strings.getString(propPrefix + "items-linked");
  this.NO_MORE_ITEMS = strings.getString(propPrefix + "no-more-items");
  this.BUTTON_TOOLTIP = strings.getString(propPrefix + "button-tooltip");
  this.TOOLTIP_BODY = {map:strings.getString(propPrefix + "tooltip-map"), vin:strings.getString(propPrefix + "tooltip-vin"), isbn:strings.getString(propPrefix + "tooltip-isbn"), ups:strings.getString(propPrefix + "tooltip-ups"), fedex_ground:strings.getString(propPrefix + "tooltip-fedex-ground"), fedex_express:strings.getString(propPrefix + "tooltip-fedex-express"), usps:strings.getString(propPrefix + "tooltip-usps")};
  this.PROMO = {map:strings.getString(propPrefix + "promo-map"), vin:strings.getString(propPrefix + "promo-vin"), isbn:strings.getString(propPrefix + "promo-isbn"), ups:strings.getString(propPrefix + "promo-package"), fedex_ground:strings.getString(propPrefix + "promo-package"), fedex_express:strings.getString(propPrefix + "promo-package"), usps:strings.getString(propPrefix + "promo-package")};
  this.PROMO_TOOLTIP = {map:strings.getString(propPrefix + "promo-map-tip"), vin:strings.getString(propPrefix + "promo-vin-tip"), isbn:strings.getString(propPrefix + "promo-isbn-tip"), ups:strings.getString(propPrefix + "promo-package-tip"), fedex_ground:strings.getString(propPrefix + "promo-package-tip"), fedex_express:strings.getString(propPrefix + "promo-package-tip"), usps:strings.getString(propPrefix + "promo-package-tip")};
  this.DROPDOWN = {map:strings.getString(propPrefix + "dropdown-map"), vin:strings.getString(propPrefix + "dropdown-vin"), isbn:strings.getString(propPrefix + "dropdown-isbn"), ups:strings.getString(propPrefix + "dropdown-ups"), fedex_ground:strings.getString(propPrefix + "dropdown-fedex-ground"), fedex_express:strings.getString(propPrefix + "dropdown-fedex-express"), usps:strings.getString(propPrefix + "dropdown-usps")};
  this.PROVIDERS = {};
  for(var type in GTB_AutoLink.providerIndices) {
    var values = GTB_AutoLink.providerIndices[type];
    var value;
    for(var i = 0;value = values[i]; ++ i) {
      this.PROVIDERS[type + value] = strings.getString(propPrefix + "providers." + type + "." + value)}
  }
}

function GTB_AL_TabData(doc, autoLink) {
  this.document = doc;
  this._insertions = [];
  this.requester = new GTB_AL_Request(this, doc.location.href, autoLink);
  this.linkStatus = 0;
  this.position = 0;
  this.runningTime = 0}

GTB_AL_TabData.prototype.getInsertionsSafe = function(opt_updateButton) {
  var size = this._insertions.length;
  var ins;
  for(var i = 0;ins = this._insertions[i]; ++ i) {
    var elt = ins.range.startContainer.ownerDocument;
    if(1 == this.linkStatus && ins.isLinkable) {
      elt = elt && elt.getElementById(ins.id)}
    else if(1 != this.linkStatus && Trim(ins.range.toString()) == "") {
      elt = null}
    if(!elt) {
      GTB_AL_RemoveFromArray(this._insertions, i);
       -- i}
  }
  if(size != this._insertions.length) {
    GTB_GoogleToolbarOverlay.autoLink._updateButton(this)}
  return this._insertions}

;
GTB_AL_TabData.prototype.getInsertionsUnsafe = function() {
  return this._insertions}

;
function GTB_AutoLink() {
  this.strings = new GTB_AL_Strings;
  this.matchFinder = new GTB_AL_MatchFinder;
  this.scanners = this._makeScanners();
  this.menuItemTimer = null;
  this.observe = GTB_MessageObserve}

GTB_AutoLink.getTarget = function() {
  var target = "_blank";
  if(!GTB_getPrefs().getBoolPref(GTB_PREF_AUTO_LINK_NEW_WINDOW)) {
    target = "_top"}
  return target}

;
GTB_AutoLink.prototype._spliceInsertions = function(insertions) {
  var insertOrder = [];
  var i, insertion;
  for(i = 0;insertion = insertions[i]; ++ i) {
    insertOrder.push([i, insertion])}
  insertOrder.sort(function(lhs, rhs) {
    var range = rhs[1].range;
    return range.compareBoundaryPoints(range.START_TO_START, lhs[1].range)}

  );
  var insertPair, id;
  for(i = 0;insertPair = insertOrder[i]; ++ i) {
    insertion = insertPair[1];
    id = "_goog_" + insertPair[0];
    insertion.insertAutolink(id)}
}

;
GTB_AutoLink.prototype._scanBody = function(doc, tabData) {
  if(!doc || !doc.body)return;
  var foundTriggers = this._preScan(doc, tabData);
  var startTime = (new Date).getTime();
  var runningTime = 0;
  var remainingTime = 1000 - tabData.runningTime;
  for(var key in foundTriggers) {
    var preScanResult = foundTriggers[key];
    var scanner = preScanResult.scanner;
    var trigger = preScanResult.word;
    var match = this.matchFinder.firstMatch(doc, trigger, scanner.isCaseSensitive);
    while(match != null) {
      var expandedRange = GTB_AL_RangeExpander.expandRange(match);
      if(expandedRange == null) {
        match = this.matchFinder.nextMatch(match);
        continue}
      var tokenlist = GTB_AL_Tokenizer.tokenizeRange(expandedRange, []);
      scanner.checkTokens(tokenlist, tabData.getInsertionsUnsafe(), tabData);
      match = this.matchFinder.nextMatch(expandedRange);
      runningTime = (new Date).getTime() - startTime;
      if(runningTime > remainingTime)break}
    runningTime = (new Date).getTime() - startTime;
    if(runningTime > remainingTime)break}
  var endTime = (new Date).getTime();
  var timeDiff = endTime - startTime;
  tabData.runningTime += timeDiff;
  GTB_Dump(GTB_Dump.AL, "autolink time: " + tabData.runningTime + "\n");
  this._updateButton(tabData)}

;
GTB_AutoLink.prototype.doAutoLinkButton = function() {
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  GTB_GoogleToolbarOverlay.maybeShowUsage("autolink_used", OptionsDialog.MORE_URL_AUTOLINK);
  var tabData = browser.GTB_AutolinkData;
  if(1 == tabData.linkStatus) {
    this._selectInsertion(tabData, tabData.position)}
  else {
    tabData.requester.sendAutolinkRequest()}
}

;
GTB_AutoLink.prototype._showLinks = function(tabData) {
  if(1 == tabData.linkStatus)return;
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  var insertions = tabData.getInsertionsSafe(true);
  if(insertions) {
    if(insertions.length > 0) {
      this._spliceInsertions(insertions)}
    tabData.linkStatus = 1;
    tabData.position = 0;
    if(browser.GTB_AutolinkData == tabData) {
      this._updateButton(tabData);
      this._notifyUser(insertions.length)}
  }
}

;
GTB_AutoLink.prototype._updateButton = function(tabData) {
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  if(browser.GTB_AutolinkData != tabData) {
    return}
  var autoLinkIcon = document.getElementById("gtbAutoLink");
  if(autoLinkIcon == null) {
    return}
  var oldTooltipText = autoLinkIcon.tooltipText;
  var insertions = tabData.getInsertionsUnsafe();
  if(insertions.length == 0 && tabData.requester.candidates.length == 0) {
    this._disableAutoLinkButton()}
  else if(insertions.length == 0 && tabData.requester.candidates.length > 0) {
    autoLinkIcon.image = "chrome://google-toolbar/skin/autolink.png";
    autoLinkIcon.tooltipText = this.strings.BUTTON_TOOLTIP;
    autoLinkIcon.label = this.strings.AUTOLINK;
    autoLinkIcon.disabled = false;
    autoLinkIcon.type = "button"}
  else {
    autoLinkIcon.image = "chrome://google-toolbar/skin/autolink.png";
    var type = insertions[0].type;
    autoLinkIcon.tooltipText = this.strings.PROMO_TOOLTIP[type];
    autoLinkIcon.label = this.strings.PROMO[type];
    autoLinkIcon.disabled = false;
    if(0 == tabData.requester.candidates.length || 1 == tabData.linkStatus) {
      autoLinkIcon.type = "menu-button"}
    else {
      autoLinkIcon.type = "button"}
  }
  if(oldTooltipText != autoLinkIcon.tooltipText) {
    GTB_GoogleToolbarOverlay.chevron.doResize()}
}

;
GTB_AutoLink.prototype._disableAutoLinkButton = function() {
  var autoLinkIcon = document.getElementById("gtbAutoLink");
  autoLinkIcon.image = "chrome://google-toolbar/skin/autolink-off.png";
  autoLinkIcon.tooltipText = this.strings.NO_ITEMS;
  autoLinkIcon.label = this.strings.AUTOLINK;
  autoLinkIcon.disabled = true;
  autoLinkIcon.type = "button"}

;
GTB_AutoLink.prototype._notifyUser = function(num_items) {
  var autoLinkIcon = document.getElementById("gtbAutoLink");
  var msg;
  if(0 == num_items) {
    msg = this.strings.NO_ITEMS}
  else if(1 == num_items) {
    msg = this.strings.ITEM_LINKED.replace("%i", 1)}
  else {
    msg = this.strings.ITEMS_LINKED.replace("%i", num_items)}
  GTB_TT_XULTooltipAlert(autoLinkIcon, msg, true)}

;
GTB_AutoLink.prototype.doUpdatePopupMenu = function(menu) {
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  var tabData = browser.GTB_AutolinkData;
  var i;
  var items = menu.getElementsByTagName("menuitem");
  while(items.length > 3) {
    items[0].removeEventListener("click", GTB_AL_onButtonMenuCommand, false);
    menu.removeChild(items[0])}
  var separator = menu.getElementsByTagName("menuseparator")[0];
  var menuLabels = {};
  var insertions = tabData.getInsertionsSafe(true);
  var insertion;
  for(i = 0;insertion = insertions[i]; ++ i) {
    var linkType = insertion.type;
    if("ups" == linkType || "fedex_express" == linkType || "fedex" == linkType || "fedex_ground" == linkType || "usps" == linkType) {
      linkType = "package"}
    var mi = document.createElement("menuitem");
    var labelText = this._getLabelFromMatch(insertion);
    var dupCheckKey = labelText.toLowerCase();
    if(!menuLabels[dupCheckKey]) {
      mi.setAttribute("label", labelText);
      mi.index = i;
      mi.setAttribute("class", "menuitem-iconic");
      mi.setAttribute("image", "chrome://google-toolbar/skin/autolink-" + linkType + ".png");
      menu.insertBefore(mi, separator);
      mi.addEventListener("click", GTB_AL_onButtonMenuCommand, false);
      menuLabels[dupCheckKey] = true}
  }
  var menuItem = document.getElementById("gtbAutoLinkMenuRemove");
  menuItem.hidden = 1 != tabData.linkStatus;
  menuItem = document.getElementById("gtbAutoLinkMenuAdd");
  menuItem.hidden = 1 == tabData.linkStatus;
  if(0 == tabData.linkStatus) {
    this._showLinks(tabData)}
}

;
GTB_AutoLink.prototype._getLabelFromMatch = function(match) {
  var labelText = match.displayValue.replace("\n", "");
  return this.strings.DROPDOWN[match.type].replace("%7", labelText)}

;
GTB_AutoLink.prototype.doMaybeLoadAutolink = function(event) {
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  var menuitem = event.target;
  if(menuitem.index != null) {
    this._selectInsertion(browser.GTB_AutolinkData, menuitem.index);
    var insertions = browser.GTB_AutolinkData.getInsertionsUnsafe();
    if(insertions && insertions[menuitem.index]) {
      var url = insertions[menuitem.index].linkURL;
      var where = GTB_GoogleToolbarOverlay.getLoadUrlTarget(event);
      var browserAccess = new nsBrowserAccess;
      var ios = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
      var xpcomUrl = ios.newURI(url, null, null);
      browserAccess.openURI(xpcomUrl, null, where, null);
      var button = document.getElementById("gtbAutoLink");
      if(button.getAttribute("open")) {
        button.removeAttribute("open")}
    }
  }
}

;
GTB_AutoLink.prototype.doMaybeSetLinkFocusTimer = function(menuitem) {
  var index = menuitem.index;
  if(index != null) {
    var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
    var match = browser.GTB_AutolinkData.getInsertionsUnsafe()[index];
    this.menuItemTimer = setTimeout(GTB_hitch(match, match.selectAndFocus), 400)}
}

;
GTB_AutoLink.prototype.doClearMenuFocusTimer = function() {
  if(this.menuItemTimer) {
    window.clearTimeout(this.menuItemTimer)}
}

;
GTB_AutoLink.prototype._selectInsertion = function(tabData, i) {
  var insertions = tabData.getInsertionsSafe(true);
  var win, sel;
  if(i >= insertions.length) {
    GTB_TT_XULTooltipAlert(document.getElementById("gtbAutoLink"), this.strings.NO_MORE_ITEMS, true);
    win = GTB_GoogleToolbarOverlay._getCurrentWindow();
    sel = win.getSelection();
    sel.removeAllRanges();
    tabData.position = 0}
  else if(i < insertions.length) {
    this._showLinks(tabData);
    insertions[i].selectAndFocus();
    tabData.position = i + 1}
}

;
GTB_AutoLink.prototype.doPageLoad = function(event) {
  var button = document.getElementById("gtbAutoLink");
  if(!button)return;
  var doc = event.target;
  var browser = GTB_GoogleToolbarOverlay._getBrowserFromDoc(doc);
  if(!browser) {
    return}
  var win = browser.contentWindow;
  if(!browser.GTB_AutolinkData || browser.GTB_AutolinkData.document != win.document) {
    browser.GTB_AutolinkData = new GTB_AL_TabData(win.document, this)}
  var tabData = browser.GTB_AutolinkData;
  if(doc.location.href.indexOf("http:") == 0 && win.document.location.href.indexOf("http:") == 0) {
    window.setTimeout(GTB_hitch(this, this._scanBody), 500, doc, tabData)}
  this._updateButton(tabData)}

;
GTB_AutoLink.prototype.doPageShow = function(event) {
  this.doPageLoad(event)}

;
GTB_AutoLink.prototype.doPageHide = function(event) {
  var doc = event.target;
  var browser = GTB_GoogleToolbarOverlay._getBrowserFromDoc(doc);
  if(!browser)return;
  this.clearState(browser)}

;
GTB_AutoLink.prototype.doPageUnload = function(event) {
  var doc = event.target;
  var browser = GTB_GoogleToolbarOverlay._getBrowserFromDoc(doc);
  if(!browser || !browser.GTB_AutolinkData)return;
  var tabData = browser.GTB_AutolinkData;
  if(tabData.document != doc) {
    this._removeDocLinks(doc, tabData)}
}

;
GTB_AutoLink.prototype._removeDocLinks = function(doc, tabData) {
  var insertion;
  var i;
  var insertions = tabData.getInsertionsSafe();
  for(i = insertions.length - 1;i >= 0; -- i) {
    insertion = insertions[i];
    if(insertion.range.startContainer.ownerDocument == doc) {
      GTB_AL_RemoveFromArray(insertions, i)}
  }
  if(1 == tabData.linkStatus) {
    this._removeLinks(insertions)}
  tabData.linkStatus = 0;
  var candidates = tabData.requester.candidates;
  var candidate;
  var keepCandidates = [];
  for(i = 0;candidate = candidates[i]; ++ i) {
    if(candidate.range.startContainer.ownerDocument != doc) {
      keepCandidates.push(candidate)}
  }
  tabData.requester.candidates = keepCandidates;
  tabData.runningTime = 0;
  this._updateButton(tabData)}

;
GTB_AutoLink.prototype.doTabSwitch = function(event) {
  var button = document.getElementById("gtbAutoLink");
  if(!button)return;
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  var tabData = browser.GTB_AutolinkData;
  if(tabData && tabData.document == browser.contentWindow.document) {
    this._updateButton(tabData)}
  else {
    if(tabData) {
      this._removeDocLinks(tabData.document, tabData)}
    this._disableAutoLinkButton()}
}

;
function GTB_AL_PrescanResult(word, scanner) {
  this.word = word;
  this.scanner = scanner}

GTB_AutoLink.TOKEN_REGEX = (new RegExp).compile(/[^\x30-\x39\x41-\x5a\x61-\x7a\xc0-\xff]+/);
GTB_AutoLink.prototype._preScan = function(doc, tabData) {
  var startTime = new Date;
  var i;
  var found = {};
  if(tabData.runningTime > 1000) {
    return found}
  if(!doc || !doc.body) {
    return found}
  var body = "";
  try {
    body = doc.body.innerHTML.replace(/<.*?>/g, " ")}
  catch(e) {
  }
  if(body.length > 32000) {
    body = body.substring(0, 32000)}
  var words = body.split(GTB_AutoLink.TOKEN_REGEX);
  var lcwords = body.toLowerCase().split(GTB_AutoLink.TOKEN_REGEX);
  var len = words.length;
  var word;
  for(var s in this.scanners) {
    var scanner = this.scanners[s];
    if(scanner.isCaseSensitive) {
      for(i = 0;i < len; ++ i) {
        word = words[i];
        if(true == scanner.triggerDict[word]) {
          found[word + scanner.prefKey] = new GTB_AL_PrescanResult(word, scanner)}
      }
    }
    else {
      for(i = 0;i < len; ++ i) {
        word = lcwords[i];
        if(true == scanner.triggerDict[word]) {
          found[word + scanner.prefKey] = new GTB_AL_PrescanResult(word, scanner)}
      }
    }
  }
  var endTime = new Date;
  var diff = endTime.getTime() - startTime.getTime();
  tabData.runningTime += diff;
  return found}

;
GTB_AutoLink.GOOG_PATTERN = /^_goog_\d+$/;
GTB_AutoLink.prototype.getMatchFromClick = function(target) {
  var elt = target;
  while(elt) {
    if(elt.id) {
      var regexed = GTB_AutoLink.GOOG_PATTERN.exec(elt.id);
      if(regexed) {
        var id = regexed[0];
        var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
        var insertions = browser.GTB_AutolinkData.getInsertionsUnsafe();
        var insertion;
        for(var i = 0;insertion = insertions[i]; ++ i) {
          if(insertion.id == id) {
            return insertion}
        }
        return null}
    }
    elt = elt.parentNode}
  return null}

;
GTB_AutoLink.prototype.getTooltipBody = function(parent, offset, target) {
  var match = this.getMatchFromClick(parent.parentNode);
  if(match == null) {
    return null}
  var contents = [];
  var img = document.createElement("image");
  img.setAttribute("src", "chrome://google-toolbar/skin/autolink.png");
  img.style.verticalAlign = "middle";
  var desc = document.createElement("description");
  desc.style.fontWeight = "bold";
  desc.appendChild(img);
  desc.appendChild(document.createTextNode(this.strings.TOOLTIP_TITLE));
  contents.push(desc);
  var body = this.strings.TOOLTIP_BODY[match.type];
  body = body.replace(/%8/, match.displaySite);
  body = body.replace(/%7/, match.displayValue);
  var lines = body.split("\n");
  for(var i in lines) {
    desc = document.createElement("description");
    desc.appendChild(document.createTextNode(lines[i]));
    contents.push(desc)}
  return contents}

;
GTB_AutoLink.providerIndices = {map:["0", "1", "2"], isbn:["0", "1", "2", "3", "7"], vin:["0", "1"]};
GTB_AutoLink.prototype.maybeShowAutoLinkMenuItems = function() {
  var target = gContextMenu.target;
  var match = this.getMatchFromClick(target);
  if(match == null) {
    document.getElementById("gtbAutoLinkContextMenu").hidden = true;
    return}
  else {
    var key = match.type;
    document.getElementById("gtbAutoLinkContextMenu").hidden = false;
    var i = 0;
    var list = GTB_AutoLink.providerIndices[key];
    var item;
    if(list) {
      var existingPref = GTB_getPrefs().getStringPref("autolink." + key);
      for(;i < list.length; ++ i) {
        item = document.getElementById("gtbAutoLinkMenuItemProvider" + i);
        item.hidden = false;
        var thisIndex = list[i];
        item.label = this.getProviderName(key, thisIndex);
        if(thisIndex == existingPref) {
          item.setAttribute("checked", true)}
        else {
          item.setAttribute("checked", false)}
      }
      document.getElementById("gtbAutoLinkMenuItemPackage").hidden = true}
    else {
      item = document.getElementById("gtbAutoLinkMenuItemPackage");
      item.label = this._getLabelFromMatch(match);
      item.hidden = false}
    for(;i < 5; ++ i) {
      item = document.getElementById("gtbAutoLinkMenuItemProvider" + i);
      item.hidden = true}
  }
}

;
GTB_AutoLink.prototype.doChangePref = function(idx) {
  var target = gContextMenu.target;
  var match = this.getMatchFromClick(target);
  var type = match.type;
  var list = GTB_AutoLink.providerIndices[type];
  var newProvNum = list[idx];
  GTB_getPrefs().setStringPref("autolink." + type, newProvNum);
  this.relink();
  if(GTB_getPrefs().getBoolPref(GTB_PREF_AUTO_LINK_NEW_WINDOW)) {
    openNewWindowWith(match.linkURL, null, false, null)}
  else {
    GTB_GoogleToolbarOverlay._getCurrentBrowser().loadURI(match.linkURL, null, null)}
}

;
GTB_AutoLink.prototype.getProviderName = function(type, index) {
  return this.strings.PROVIDERS[type + index]}

;
GTB_AutoLink.prototype.doOpenPrefs = function() {
  window.openDialog("chrome://google-toolbar/content/options-auto-link.xul", "gtbAutoLinkOptions", "modal,centerscreen,chrome,resizable=no")}

;
GTB_AutoLink.prototype.doRemoveLinks = function() {
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  if(1 == browser.GTB_AutolinkData.linkStatus) {
    var insertions = browser.GTB_AutolinkData.getInsertionsSafe();
    this._removeLinks(insertions)}
  browser.GTB_AutolinkData.linkStatus = 2}

;
GTB_AutoLink.prototype._removeLinks = function(insertions) {
  var insertion;
  for(var i = 0;insertion = insertions[i]; ++ i) {
    insertion.removeAutolink()}
}

;
GTB_AutoLink.prototype.doShowLinks = function() {
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  this._showLinks(browser.GTB_AutolinkData)}

;
GTB_AutoLink.prototype.relink = function() {
  var wm = Components.classes["@mozilla.org/appshell/window-mediator;1"].getService(Components.interfaces.nsIWindowMediator);
  var enumerator = wm.getEnumerator("navigator:browser");
  while(enumerator.hasMoreElements()) {
    var curWindow = enumerator.getNext();
    var tabBrowser = curWindow.GTB_GoogleToolbarOverlay._getTabBrowser();
    for(var b = 0;b < tabBrowser.browsers.length; ++ b) {
      var browser = tabBrowser.browsers[b];
      this._relinkBrowser(browser)}
  }
}

;
GTB_AutoLink.prototype._relinkBrowser = function(browser) {
  var tabData = browser.GTB_AutolinkData;
  if(tabData) {
    var insertions = tabData.getInsertionsSafe();
    var ins;
    for(var i = 0;ins = insertions[i]; ++ i) {
      var doc = ins.range.startContainer.ownerDocument;
      if(ins.type  in  GTB_AutoLink.providerIndices) {
        var provNum = GTB_getPrefs().getStringPref("autolink." + ins.type);
        var provName = this.getProviderName(ins.type, provNum);
        ins.linkURL = ins.linkURL.replace(/lpi=\d/, "lpi=" + provNum);
        ins.displaySite = provName}
      if(1 == tabData.linkStatus) {
        var link = doc && doc.getElementById(ins.id);
        if(link) {
          if(ins.type  in  GTB_AutoLink.providerIndices) {
            link.href = ins.linkURL}
          link.target = GTB_AutoLink.getTarget()}
      }
    }
  }
}

;
GTB_AutoLink.prototype.scanAllFrames = function(win) {
  var docs = [];
  var windows = [win];
  var frame, i, curWin;
  while(windows.length > 0) {
    curWin = windows.shift();
    docs.unshift(curWin.document);
    for(i = 0;frame = curWin.frames[i]; ++ i) {
      windows.push(frame)}
  }
  var doc;
  for(i = 0;doc = docs[i]; ++ i) {
    this.doPageLoad({target:doc})}
}

;
GTB_AutoLink.prototype.clearState = function(browser) {
  var tabData = browser.GTB_AutolinkData;
  if(tabData) {
    if(1 == tabData.linkStatus) {
      this._removeLinks(tabData.getInsertionsSafe())}
    browser.removeAttribute("GTB_AutolinkData")}
}

;
GTB_AutoLink._isOneOrTwoSpaces = function(tokenlist, pos) {
  var t = tokenlist[pos];
  if(t) {
    var c = t.contents;
    return c == " " || c == "  "}
  return false}

;
GTB_AutoLink._isValidFedexNumberSection = function(token) {
  return token.length == 4 && token.isNumeric()}

;
GTB_AutoLink._uspsNumberGroupCapture = function(tokenlist, pos, token_sizes) {
  var startToken = tokenlist[pos];
  var thisToken;
  var inProgress = "";
  for(var i = 0;i < token_sizes.length; ++ i) {
    thisToken = tokenlist[pos];
    pos += 2;
    if(thisToken && thisToken.length == token_sizes[i] && thisToken.isNumeric()) {
      inProgress += thisToken.contents}
    else {
      return null}
  }
  return new GTB_AL_Match(startToken, thisToken, inProgress)}

;
GTB_AutoLink._addressScannerCheckTokens = function(tokenlist, insertions, tabData) {
  for(var i = 0;i < tokenlist.length; ++ i) {
    var tokenText = tokenlist[i].contents;
    if(!tokenText) {
      continue}
    if(this.possibleMatch(tokenText)) {
      tabData.requester.addRequest(tokenlist);
      break}
  }
}

;
GTB_AutoLink.prototype._makeScanners = function() {
  var isOneOrTwoSpaces = GTB_AutoLink._isOneOrTwoSpaces;
  var isbnScanner = new GTB_AL_Scanner(["isbn", "book", "publication"], [function(tokenlist, pos) {
    var thisToken = tokenlist[pos];
    if(thisToken.length == 10) {
      return new GTB_AL_Match(thisToken, thisToken, thisToken.contents)}
  }

  , function(tokenlist, pos) {
    var startToken = tokenlist[pos];
    var thisToken = tokenlist[pos ++ ];
    if(thisToken.length == 1 && thisToken.isNumeric()) {
      var inProgress = thisToken.contents;
      if(tokenlist[pos] && tokenlist[pos ++ ].contents == "-") {
        thisToken = tokenlist[pos ++ ];
        if(thisToken && thisToken.isNumeric() && thisToken.length <= 6 && thisToken.length >= 2) {
          inProgress += thisToken.contents;
          if(tokenlist[pos] && tokenlist[pos ++ ].contents == "-") {
            thisToken = tokenlist[pos ++ ];
            if(thisToken && thisToken.isNumeric() && thisToken.length <= 6 && thisToken.length >= 2) {
              inProgress += thisToken.contents;
              if(tokenlist[pos] && tokenlist[pos ++ ].contents == "-") {
                thisToken = tokenlist[pos ++ ];
                if(thisToken && thisToken.length == 1) {
                  inProgress += thisToken.contents;
                  return new GTB_AL_Match(startToken, thisToken, inProgress)}
              }
            }
          }
        }
      }
    }
  }

  ], function(c) {
    var mult = [1, 2, 3, 4, 5, 6, 7, 8, 9];
    var checksum = GTB_AL_getChecksum(c, 9, mult) % 11;
    var checkdigit = GTB_AL_getCheckDigit(c);
    if(checksum == 10) {
      return c[c.length - 1].toLowerCase() == "x"}
    else {
      return checksum == checkdigit}
  }

  , false, "isbn", this);
  var isValidNumberSection = GTB_AutoLink._isValidFedexNumberSection;
  var fedexExpressScanner = new GTB_AL_Scanner(["fedex", "fed"], [function(tokenlist, pos) {
    var thisToken = tokenlist[pos];
    if(thisToken.length == 12 && thisToken.isNumeric()) {
      return new GTB_AL_Match(thisToken, thisToken, thisToken.contents)}
    return null}

  , function(tokenlist, pos) {
    var startPos = pos;
    var number = "";
    if(isValidNumberSection(tokenlist[pos ++ ])) {
      number += tokenlist[pos - 1].contents;
      if(isOneOrTwoSpaces(tokenlist, pos ++ )) {
        if(isValidNumberSection(tokenlist[pos ++ ])) {
          number += tokenlist[pos - 1].contents;
          if(isOneOrTwoSpaces(tokenlist, pos ++ )) {
            if(isValidNumberSection(tokenlist[pos])) {
              number += tokenlist[pos].contents;
              return new GTB_AL_Match(tokenlist[startPos], tokenlist[pos], number)}
          }
        }
      }
    }
    return null}

  ], function(c) {
    var mult = [3, 1, 7, 3, 1, 7, 3, 1, 7, 3, 1];
    var checksum = GTB_AL_getChecksum(c, 11, mult) % 11 % 10;
    var checkdigit = GTB_AL_getCheckDigit(c);
    return checksum == checkdigit}

  , false, "fedex_express", this);
  var fedexGroundScanner = new GTB_AL_Scanner(["fedex", "fed"], [function(tokenlist, pos) {
    var thisToken = tokenlist[pos];
    if(thisToken.length == 15 && thisToken.isNumeric()) {
      return new GTB_AL_Match(thisToken, thisToken, thisToken.contents)}
    return null}

  , function(tokenlist, pos) {
    var startPos = pos;
    var number = "";
    if(isValidNumberSection(tokenlist[pos ++ ])) {
      number += tokenlist[pos - 1].contents;
      if(isOneOrTwoSpaces(tokenlist, pos ++ )) {
        if(isValidNumberSection(tokenlist[pos ++ ])) {
          number += tokenlist[pos - 1].contents;
          if(isOneOrTwoSpaces(tokenlist, pos ++ )) {
            if(isValidNumberSection(tokenlist[pos ++ ])) {
              number += tokenlist[pos - 1].contents;
              if(isOneOrTwoSpaces(tokenlist, pos ++ )) {
                if(tokenlist[pos].length == 3 && tokenlist[pos].isNumeric()) {
                  number += tokenlist[pos].contents;
                  return new GTB_AL_Match(tokenlist[startPos], tokenlist[pos], number)}
              }
            }
          }
        }
      }
    }
    return null}

  ], function(c) {
    var mult = [9, 7, 9, 7, 9, 7, 9, 7, 9, 7, 9, 7, 9, 7];
    var checksum = GTB_AL_getChecksum(c, 14, mult) % 10;
    var checkdigit = GTB_AL_getCheckDigit(c);
    return checksum == checkdigit}

  , false, "fedex_ground", this);
  var isAlphaOrNumeric = /[0-9a-zA-Z]+/;
  var upsScanner = new GTB_AL_Scanner(["ups"], [function(tokenlist, pos) {
    var thisToken = tokenlist[pos];
    if(thisToken.length == 18 && isAlphaOrNumeric.test(thisToken.contents)) {
      return new GTB_AL_Match(thisToken, thisToken, thisToken.contents)}
    return null}

  , function(tokenlist, pos) {
    var longToken = tokenlist[pos];
    var shortToken = tokenlist[pos + 2];
    if(shortToken && longToken.length == 17 && shortToken.length == 1 && isAlphaOrNumeric.test(longToken) && isAlphaOrNumeric.test(shortToken)) {
      var num = longToken.contents + shortToken.contents;
      return new GTB_AL_Match(longToken, shortToken, num)}
    return null}

  , function(tokenlist, pos) {
    var startToken = tokenlist[pos];
    var thisToken;
    var inProgress = "";
    var token_sizes = [2, 3, 3, 2, 4, 3, 1];
    for(var i = 0;i < token_sizes.length; ++ i) {
      thisToken = tokenlist[pos];
      pos += 2;
      if(thisToken && thisToken.length == token_sizes[i] && isAlphaOrNumeric.test(thisToken.contents)) {
        inProgress += thisToken.contents}
      else {
        return null}
    }
    return new GTB_AL_Match(startToken, thisToken, inProgress)}

  ], function(c) {
    if(c.charAt(0) == "1" && c.charAt(1).toLowerCase() == "z" && isAlphaOrNumeric.test(c) && c.length == 18) {
      return true}
    return false}

  , false, "ups", this);
  var numberGroupCapture = GTB_AutoLink._uspsNumberGroupCapture;
  var uspsScanner = new GTB_AL_Scanner(["usps"], [function(tokenlist, pos) {
    var thisToken = tokenlist[pos];
    if(thisToken.contents.indexOf("91") != 0) {
      return null}
    if(thisToken.length == 22 && thisToken.isNumeric()) {
      return new GTB_AL_Match(thisToken, thisToken, thisToken.contents)}
    return numberGroupCapture(tokenlist, pos, [4, 4, 4, 4, 4, 2])}

  , function(tokenlist, pos) {
    var thisToken = tokenlist[pos];
    if(thisToken.length == 20 && thisToken.isNumeric()) {
      return new GTB_AL_Match(thisToken, thisToken, thisToken.contents)}
    return numberGroupCapture(tokenlist, pos, [4, 4, 4, 4, 4])}

  , function(tokenlist, pos) {
    var startToken = tokenlist[pos ++ ];
    if(!startToken.isNumeric() && startToken.length == 2) {
      if(isOneOrTwoSpaces(tokenlist, pos ++ )) {
        var num = numberGroupCapture(tokenlist, pos, [9]);
        if(num) {
          pos += 1}
        else {
          var num = numberGroupCapture(tokenlist, pos, [3, 3, 3]);
          if(!num) {
            num = numberGroupCapture(tokenlist, pos, [4, 4, 1])}
          pos += 5}
        if(num) {
          var contents = num.contents;
          if(isOneOrTwoSpaces(tokenlist, pos ++ ) && tokenlist[pos]) {
            var lastContents = tokenlist[pos].contents;
            if(lastContents == "US" || lastContents == "XX") {
              return new GTB_AL_Match(startToken, tokenlist[pos], startToken.contents + " " + contents + " " + lastContents)}
          }
        }
      }
    }
    return null}

  ], function(c) {
    if(c.length > 19) {
      var mult = [3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3];
      var checksum = GTB_AL_getChecksum(c, 21, mult);
      var checkdigit = GTB_AL_getCheckDigit(c);
      return(checksum + checkdigit) % 10 == 0}
    else {
      c = c.substring(3, 12);
      var mult_mod10 = [1, 3, 1, 3, 1, 3, 1, 3];
      if((GTB_AL_getChecksum(c, 8, mult_mod10) + GTB_AL_getCheckDigit(c)) % 10 == 0)return true;
      var mult_mod11 = [8, 6, 4, 2, 3, 5, 9, 7];
      var mod = GTB_AL_getChecksum(c, 8, mult_mod11) % 11;
      var dig = GTB_AL_getCheckDigit(c);
      return mod == 0 && dig == 5 || mod == 1 && dig == 0 || 11 - mod == dig}
  }

  , false, "usps", this);
  var isAlphanumeric = /\d\D|\D\d/;
  var vinLookup = [1, 2, 3, 4, 5, 6, 7, 8, -1, 1, 2, 3, 4, 5, -1, 7, -1, 9, 2, 3, 4, 5, 6, 7, 8, 9];
  var vinScanner = new GTB_AL_Scanner(["vin", "vehicle", "auto", "car", "bus", "pickup", "truck", "suv", "bike", "moto", "numbers", "number"], [function(tokenlist, pos) {
    var thisToken = tokenlist[pos];
    if(thisToken.length == 17 && isAlphanumeric.test(thisToken.contents)) {
      return new GTB_AL_Match(thisToken, thisToken, thisToken.contents)}
    return null}

  ], function(c) {
    var mult = [8, 7, 6, 5, 4, 3, 2, 10, 0, 9, 8, 7, 6, 5, 4, 3, 2];
    var sum = 0;
    c = c.toLowerCase();
    for(var i = 0;i < c.length; ++ i) {
      var dig = c.charAt(i);
      var digit = c.charCodeAt(i);
      var digitValue = null;
      if(GTB_AL_isDigit(dig)) {
        digitValue = parseInt(dig)}
      else {
        if(digit < 97 || digit > 122) {
          return false}
        digit = digit - 97;
        digitValue = vinLookup[digit]}
      sum += mult[i] * digitValue}
    sum = sum % 11;
    var checkChar = c.charCodeAt(8);
    if(sum == 10) {
      return checkChar == 120}
    else {
      return sum == parseInt(checkChar - 48)}
  }

  , false, "vin", this);
  var addressStateScanner = new GTB_AL_Scanner(["Alabama", "AL", "Alaska", "AK", "American Samoa", "AS", "Arizona", "AZ", "Arkansas", "AR", "California", "CA", "Colorado", "CO", "Connecticut", "CT", "Delaware", "DE", "District Of Columbia", "DC", "Federated States of Micronesia", "FM", "Florida", "FL", "Georgia", "GA", "Guam", "GU", "Hawaii", "HI", "Idaho", "ID", "Illinois", "IL", "Indiana", "IN", "Iowa", "IA", "Kansas", "KS", "Kentucky", "KY", "Louisiana", "LA", "Maine", "ME", "Marshall Islands"
  , "MH", "Maryland", "MD", "Massachusetts", "MA", "Michigan", "MI", "Minnesota", "MN", "Mississippi", "MS", "Missouri", "MO", "Montana", "MT", "Nebraska", "NE", "Nevada", "NV", "New Hampshire", "NH", "New Jersey", "NJ", "New Mexico", "NM", "New York", "NY", "North Carolina", "NC", "North Dakota", "ND", "Northern Mariana Islands", "MP", "Ohio", "OH", "Oklahoma", "OK", "Oregon", "OR", "Palau", "PW", "Pennsylvania", "PA", "Puerto Rico", "PR", "Rhode Island", "RI", "South Carolina", "SC", "South Dakota"
  , "SD", "Tennessee", "TN", "Texas", "TX", "Utah", "UT", "Vermont", "VT", "Virgin Islands", "VI", "Virginia", "VA", "Washington", "WA", "West Virginia", "WV", "Wisconsin", "WI", "Wyoming", "WY"], [], null, true, null, this);
  var addressStreetScanner = new GTB_AL_Scanner(["street", "st", "ave", "road", "avenue", "rd", "san", "blvd", "dr", "drive", "new", "york", "west", "east", "north", "south", "ct", "park", "way", "los", "city", "parkway", "beach", "main", "boulevard", "santa", "se", "ne", "sw", "nw"], [], null, false, null, this);
  addressStateScanner.checkTokens = GTB_AutoLink._addressScannerCheckTokens;
  addressStreetScanner.checkTokens = GTB_AutoLink._addressScannerCheckTokens;
  return[upsScanner, fedexGroundScanner, fedexExpressScanner, uspsScanner, vinScanner, isbnScanner, addressStateScanner, addressStreetScanner]}

;
GTB_AutoLink.prototype.GTB_MESSAGES = {"GTB_OPTION.button_option.gtbAutoLink":function(data) {
  var toolbar = GTB_getToolbar();
  if("true" == data) {
    var win = toolbar._getCurrentWindow();
    toolbar.autoLink.scanAllFrames(win)}
  else if("false" == data) {
    var browsers = toolbar._getTabBrowser().browsers;
    var browser;
    for(var b = 0;browser = browsers[b]; ++ b) {
      toolbar.autoLink.clearState(browser)}
  }
}

};
function GTB_AL_onAutoLink(event) {
  if(event.type == "click" && event.target.nodeName == "menuitem") {
    return}
  GTB_GoogleToolbarOverlay.autoLink.doAutoLinkButton()}

function GTB_AL_onRemoveLinks(event) {
  GTB_GoogleToolbarOverlay.autoLink.doRemoveLinks()}

function GTB_AL_onAddLinks(event) {
  GTB_GoogleToolbarOverlay.autoLink.doShowLinks()}

function GTB_AL_onOpenPrefs(event) {
  GTB_GoogleToolbarOverlay.autoLink.doOpenPrefs()}

function GTB_AL_onChangePref(idx) {
  GTB_GoogleToolbarOverlay.autoLink.doChangePref(idx)}

function GTB_AL_onButtonMenuPopupShowing(event) {
  GTB_GoogleToolbarOverlay.autoLink.doUpdatePopupMenu(event.target)}

function GTB_AL_onButtonMenuCommand(event) {
  if("click" == event.type && 1 != event.button) {
    return}
  GTB_GoogleToolbarOverlay.autoLink.doMaybeLoadAutolink(event);
  event.preventBubble()}

function GTB_AL_onButtonMenuMouseOver(event) {
  var target = event.target;
  if(target.nodeName == "menuitem") {
    GTB_GoogleToolbarOverlay.autoLink.doMaybeSetLinkFocusTimer(target)}
}

function GTB_AL_onButtonMenuMouseOut(event) {
  GTB_GoogleToolbarOverlay.autoLink.doClearMenuFocusTimer()}

function GTB_AL_onOpenUrl(url) {
  if(GTB_getPrefs().getBoolPref(GTB_PREF_AUTO_LINK_NEW_WINDOW)) {
    openNewWindowWith(url, null, false, null)}
  else {
    GTB_GoogleToolbarOverlay._getCurrentBrowser().loadURI(url, null, null)}
}

function DictFileDownloadObserver(translator) {
  this.translator = translator}

DictFileDownloadObserver.prototype = {onDownloadComplete:function(downloader, request, ctxt, status, result) {
  this.translator.dictFileDownloading = false;
  this.translator.dictFileDownloads ++ ;
  var failure = null;
  if(!Components.isSuccessCode(status)) {
    failure = "unable to download dict file!"}
  else if(!this.translator.dictFileTmpLocation.exists()) {
    failure = "new dict file not found!"}
  else if(this.translator.dictFileLocation.exists()) {
    failure = "unable to remove old dict file!"}
  if(failure == null) {
    try {
      this.translator.dictFileTmpLocation.copyTo(null, this.translator.dictFileLocation.leafName)}
    catch(e) {
    }
    GTB_Assert(this.translator.dictFileTmpLocation.exists(), "after move, tmp file doesn't exist!");
    GTB_Assert(this.translator.dictFileLocation.exists(), "after move, dict file doesn't exist!");
    if(this.translator.dictFileLocation.exists() && this.translator.dictFileLocation.isReadable()) {
      this.translator.dictFileReady = true}
    else {
      this.translator.dictFileReady = false}
  }
  else {
    this.translator.dictFileReady = false}
}

};
function GTB_AutoTranslate() {
}

GTB_AutoTranslate.prototype = {TRANSLATE_TERM:"", NO_TRANSLATION:"", DOWNLOAD_FAILED:"", GTB_DATA_DIR:"GoogleToolbarData", TMP_DICT_FILE:"dict.tmp", FINAL_DICT_FILE:"dict.dat", MAX_FAILED_DOWNLOADS:10, dictFileDownloads:null, dictFileDownloading:null, dictFileReady:null, dictFileLocation:null, dictFileTmpLocation:null, init:function() {
  var stringBundle = document.getElementById("google-toolbar-strings");
  this.TRANSLATE_TERM = stringBundle.getString("google-translate.translateTerm");
  this.NO_TRANSLATION = stringBundle.getString("google-translate.noTranslation");
  this.DOWNLOAD_FAILED = stringBundle.getString("google-translate.disableWarning");
  GTB_GoogleToolbarOverlay.registerMessages(this);
  var dirsvc = Components.classes["@mozilla.org/file/directory_service;1"].getService(Components.interfaces.nsIProperties);
  this.dictFileLocation = dirsvc.get("ProfD", Components.interfaces.nsIFile);
  GTB_Assert(this.dictFileLocation.exists(), "no profile directory!");
  this.dictFileLocation.append(this.GTB_DATA_DIR);
  if(!this.dictFileLocation.exists()) {
    this.dictFileLocation.create(1, parseInt("0700", 8))}
  this.dictFileTmpLocation = this.dictFileLocation.clone();
  this.dictFileLocation.append(this.FINAL_DICT_FILE);
  this.dictFileTmpLocation.append(this.TMP_DICT_FILE);
  this.dictFileDownloads = 0;
  if(this.dictFileTmpLocation.exists()) {
    try {
      this.dictFileTmpLocation.remove(false)}
    catch(e) {
    }
  }
  this.dictFileDownloading = false;
  this.dictFileReady = this.dictFileLocation.exists()}

, getCurrWindow:function() {
  return document.getElementById("content").selectedBrowser.contentWindow}

, observe:GTB_MessageObserve, GTB_MESSAGES:{"GTB_OPTION.auto_translate":function(data) {
  if("false" == data) {
    GTB_GoogleToolbarOverlay.autoTranslate.deleteDictFile()}
}

}, deleteDictFile:function() {
  this.dictFileReady = false;
  try {
    this.dictFileTmpLocation.remove(false)}
  catch(e) {
  }
  try {
    this.dictFileLocation.remove(false)}
  catch(e) {
  }
}

, downloadToLangDict:function(to_lang) {
  if(this.dictFileDownloading)return;
  this.dictFileDownloading = true;
  this.deleteDictFile();
  var ios = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
  var downloader = Components.classes["@mozilla.org/network/downloader;1"].createInstance(Components.interfaces.nsIDownloader);
  var url = "http://google.com/tools/toolbar/intl/" + to_lang + "/googledict.dat";
  var channel = ios.newChannel(url, null, null);
  var observer = new DictFileDownloadObserver(this);
  downloader.init(observer, this.dictFileTmpLocation);
  channel.asyncOpen(downloader, null)}

, getTranslation:function(text) {
  if(this.dictFileDownloads > this.MAX_FAILED_DOWNLOADS) {
    alert(this.DOWNLOAD_FAILED);
    GTB_getPrefs().setBoolPref(GTB_PREF_AUTO_TRANSLATE, false);
    this.dictFileDownloads = 0;
    return}
  var from_lang = "en";
  var to_lang = GTB_getPrefs().getStringPref("autotranslate_to_lang");
  if(!this.dictFileReady && !this.dictFileDownloading) {
    this.downloadToLangDict(to_lang)}
  if(this.dictFileReady && GTB_GoogleToolbarOverlay.autoTransLibAvailable) {
    var xpcomobj = Components.classes["@google.com/autotranslate;1"];
    var autotrans = xpcomobj.createInstance(Components.interfaces.GTBIAutoTranslate);
    var langpair = from_lang + "2" + to_lang;
    var translation = autotrans.getTranslation(text, langpair);
    if(translation) {
      return translation}
    else {
      return""}
  }
  else {
    var host = GTB_GoogleToolbarOverlay.getGoogleHome();
    var lang = from_lang + "|" + to_lang;
    var url = GTB_DictionaryUrl(host, text, lang, GTB_GoogleToolbarOverlay.languageCode);
    var request = new XMLHttpRequest;
    request.open("GET", url, false);
    request.send(null);
    var response = "";
    if(request.status == 200) {
      response = request.responseText}
    return response}
}

, _enabled:function() {
  return GTB_GoogleToolbarOverlay.autoTransLibAvailable && GTB_getPrefs().getBoolPref(GTB_PREF_AUTO_TRANSLATE)}

, getTooltipBody:function(parent, offset, target) {
  if(!this._enabled()) {
    return null}
  if(parent.parentNode != target) {
    return null}
  if(parent.nodeType != Node.TEXT_NODE) {
    return null}
  var container = parent.parentNode;
  if(container) {
    var foundNode = false;
    for(var c = container.firstChild;c != null;c = c.nextSibling) {
      if(c == parent) {
        foundNode = true;
        break}
    }
    if(!foundNode) {
      return null}
  }
  var range = parent.ownerDocument.createRange();
  range.selectNode(parent);
  var str = range.toString();
  if(offset < 0 || offset >= str.length) {
    return null}
  var start = offset;
  var end = offset + 1;
  var valid_chars = /\w/;
  if(!valid_chars.test(str.substring(start, start + 1))) {
    return null}
  while(start > 0) {
    if(valid_chars.test(str.substring(start - 1, start))) {
      start -- }
    else {
      break}
  }
  while(end < str.length) {
    if(valid_chars.test(str.substring(end, end + 1))) {
      end ++ }
    else {
      break}
  }
  var text = str.substring(start, end);
  var translation = this.getTranslation(text);
  if(translation != "") {
    var str_to_display = text + ": " + translation;
    var desc = document.createElement("description");
    var img = document.createElement("image");
    img.setAttribute("src", "chrome://google-toolbar/skin/translator.png");
    img.style.verticalAlign = "middle";
    desc.appendChild(img);
    desc.appendChild(document.createTextNode(str_to_display));
    return[desc]}
}

, maybeShowTranslateMenuItem:function() {
  var menuItem = document.getElementById("gtbAutoTranslateMenuItem");
  if(!this._enabled()) {
    menuItem.hidden = true;
    return}
  var text = this.getCurrWindow().getSelection();
  if(!/^\W*([a-zA-Z]+)\W*$/.test(text)) {
    text = ""}
  else {
    text = RegExp.$1}
  if(menuItem) {
    if(text == "") {
      menuItem.hidden = true}
    else {
      menuItem.value = text;
      var localized_str = this.TRANSLATE_TERM;
      menuItem.label = localized_str.replace("&term;", text);
      menuItem.hidden = text == ""}
  }
}

, showTranslationAlert:function(text) {
  var translation = this.getTranslation(text);
  if(translation != "") {
    translation = text + ": " + translation}
  else {
    var localized_str = this.NO_TRANSLATION;
    translation = localized_str.replace("&term;", text)}
  alert(translation)}

};
function GTB_Chevron() {
}

GTB_Chevron.prototype = {_menus:[], _buttons:[], _nonWindowEventsBlocked:false, _unblockNonWindowEvents:function() {
  this._nonWindowEventsBlocked = false}

, _addLookup:function(buttonName, menuName) {
  this._menus[buttonName] = menuName;
  this._buttons[menuName] = buttonName}

, init:function() {
  this._addLookup("gtbSearchButton", "gtbSearchButtonPopup");
  this._addLookup("gtbInfo", "gtbInfoPopup");
  this._addLookup("gtbSpellCheck", "gtbSpellCheckPopup");
  this._addLookup("gtbAutoLink", "gtbAutoLinkMenu");
  this._addLookup("gtbFeedSubscribe", "gtbFeedSubscribeMenu");
  this._addLookup("gtbGoUp", "gtbGoUpPopup");
  this._addLookup("gtbGoogleMenu", "gtbGoogleMenuPopup")}

, _getChevronElements:function() {
  var toolbar = document.getElementById("gtbToolbar");
  var items = [];
  var item;
  for(var i = 0;item = toolbar.childNodes[i]; ++ i) {
    if(item.id == "gtbNextPrev" || item.id == "gtbFindTerms") {
      var itemChild;
      for(var j = 0;itemChild = item.childNodes[j]; ++ j) {
        if(itemChild.nodeName == "hbox") {
          var hbox = itemChild;
          for(var k = 0;k < hbox.childNodes.length;k ++ ) {
            items.push(hbox.childNodes[k])}
        }
        else if(itemChild.nodeName != "tooltip" && itemChild.nodeName != "label") {
          items.push(itemChild)}
      }
    }
    else if(item.nodeName != "tooltip" && item.nodeType != Node.TEXT_NODE) {
      items.push(item)}
  }
  return items}

, onShowMenu:function(event, menu) {
  var children = menu.childNodes;
  var index = 0;
  for(var i = children.length - 1;i >= 0; -- i) {
    index = children[i].getAttribute("index");
    if(index) {
      var cmenu = children[i].firstChild;
      if(cmenu && cmenu.nodeName == "menupopup") {
        var button = document.getElementById(this._buttons[cmenu.id]);
        if(button) {
          button.appendChild(children[i].firstChild)}
      }
    }
    menu.removeChild(children[i])}
  var items = this._getChevronElements();
  index = 0;
  for(i = 0;i < items.length;i ++ ) {
    var item = items[i];
    if(item.collapsed && !item.hidden) {
      if(item.localName == "toolbarseparator") {
        if(menu.firstChild) {
          var sep = document.createElement("menuseparator");
          menu.appendChild(sep)}
        continue}
      if(!GTB_isGoogleToolbarItem(item) && item.localName != "toolbarbutton") {
        continue}
      if(item.id == "gtbSearchBox") {
        item = document.getElementById("gtbSearchButton")}
      var menuItem = null;
      if("menu" == item.type || "menu-button" == item.type) {
        menuItem = document.createElement("menu");
        menuItem.setAttribute("class", "menu-iconic");
        if(item.attributes["oncommand"] && !item.disabled) {
          menuItem.setAttribute("onclick", item.attributes["oncommand"].value)}
      }
      else {
        menuItem = document.createElement("menuitem");
        menuItem.setAttribute("class", "menuitem-iconic");
        if(item.attributes["oncommand"]) {
          menuItem.setAttribute("oncommand", item.attributes["oncommand"].value)}
      }
      if(item.id == "gtbPageRank") {
        var image = document.getElementById("gtbPageRankImage");
        menuItem.setAttribute("image", image.attributes["src"].value);
        menuItem.setAttribute("tooltiptext", image.tooltipText);
        menuItem.setAttribute("disabled", true)}
      else {
        menuItem.setAttribute("label", item.label);
        if(item.image) {
          menuItem.setAttribute("image", item.image)}
        else {
          var style = document.defaultView.getComputedStyle(item, "");
          menuItem.style.listStyleImage = style["listStyleImage"];
          menuItem.style.MozImageRegion = style["MozImageRegion"]}
        menuItem.setAttribute("disabled", item.disabled);
        var tooltip = null;
        var descs = null;
        if(item.id == "gtbNextResult") {
          tooltip = document.getElementById("gtbNextTooltip");
          descs = tooltip.getElementsByTagName("description");
          menuItem.setAttribute("tooltiptext", descs[0].value)}
        else if(item.id == "gtbPreviousResult") {
          tooltip = document.getElementById("gtbPrevTooltip");
          descs = tooltip.getElementsByTagName("description");
          menuItem.setAttribute("tooltiptext", descs[0].value)}
        else {
          menuItem.setAttribute("tooltiptext", item.tooltipText)}
      }
      if("menu" == item.type || "menu-button" == item.type) {
        var popup = document.getElementById(this._menus[item.id]);
        if(popup) {
          menuItem.appendChild(popup)}
      }
      menuItem.setAttribute("index", index);
      if(GTB_isGoogleToolbarItem(item)) {
        menuItem.id = "gtbChevronMenu" + item.id}
      menu.appendChild(menuItem)}
  }
}

, _getWidth:function(element) {
  try {
    var style = document.defaultView.getComputedStyle(element, "")}
  catch(e) {
    return 0}
  var leftMargin = style.getPropertyValue("margin-left");
  if(leftMargin) {
    leftMargin = Math.round(parseFloat(leftMargin))}
  else {
    leftMargin = 0}
  var rightMargin = style.getPropertyValue("margin-right");
  if(rightMargin) {
    rightMargin = Math.round(parseFloat(rightMargin))}
  else {
    rightMargin = 0}
  if(element.localName == "toolbarspring") {
    return leftMargin + rightMargin}
  else if(element.id == "urlbar-container" || element.id == "personal-bookmarks") {
    return leftMargin + rightMargin + 100}
  return element.boxObject.width + leftMargin + rightMargin}

, doResize:function(opt_event) {
  if(opt_event && opt_event.target != document && opt_event.target != window) {
    if(this._nonWindowEventsBlocked) {
      return}
    else {
      this._nonWindowEventsBlocked = true;
      setTimeout(GTB_hitch(this, this._unblockNonWindowEvents), 500)}
  }
  var chevron = document.getElementById("gtbChevron");
  chevron.collapsed = false;
  var chevronWidth = chevron.boxObject.width;
  var toolbar = document.getElementById("gtbToolbar");
  var totalSize = toolbar.boxObject.width;
  var roomLeft = totalSize;
  var items = this._getChevronElements();
  var lastVisible = null;
  for(var i = 0;i < items.length;i ++ ) {
    if(items[i].id != "gtbChevron" && !items[i].hidden) {
      lastVisible = items[i].id}
  }
  var overflowed = false;
  var atEnd = false;
  for(i = 0;i < items.length;i ++ ) {
    var item = items[i];
    if(item.id == "gtbChevron") {
      continue}
    item.collapsed = false;
    roomLeft -= this._getWidth(item);
    if(item.id == lastVisible) {
      atEnd = true}
    var roomNeeded = atEnd ? 0 : chevronWidth;
    if(roomLeft < roomNeeded) {
      overflowed = true}
    if(overflowed && item.id == "gtbSearchBox") {
      var searchBox = document.getElementById("gtbGoogleSearchBox");
      var sbStyle = document.defaultView.getComputedStyle(searchBox, "");
      var currentWidth = parseInt(sbStyle["width"]);
      var minWidth = parseInt(sbStyle["minWidth"]);
      var resizeBy = roomNeeded - roomLeft;
      var canResizeBy = currentWidth - minWidth;
      if(canResizeBy >= resizeBy) {
        var style = document.defaultView.getComputedStyle(item, "");
        var oldWidth = parseInt(style["width"]);
        var newWidth = oldWidth - resizeBy;
        item.setAttribute("width", newWidth);
        continue}
    }
    item.collapsed = overflowed;
    if(this._menus[item.id] && !item.collapsed) {
      var found = false;
      for(var j = 0;j < item.childNodes.length;j ++ ) {
        var child = item.childNodes[j];
        if(child.id == this._menus[item.id]) {
          found = true}
      }
      if(!found) {
        var popup = document.getElementById(this._menus[item.id]);
        if(popup != null) {
          item.appendChild(popup)}
      }
    }
  }
  chevron.collapsed = !overflowed}

};
function GTB_CustomSearch() {
}

GTB_CustomSearch.prototype = {_GmailSearch:{title:"Gmail", tip:"Gmail", url:"http://gmail.google.com/gmail?search=query&view=tl&start=0&init=1&fs=1&q={query}", site:"http://gmail.google.com/", searchId:"Gmail", priority:"0", icon:"data:image/x-icon,%00%00%01%00%01%00%10%10%00%00%01%00%20%00h%04%00%00%16%00%00%00%28%00%00%00%10%00%00%00%20%00%00%00%01%00%20%00%00%00%00%00%00%00%00%00%13%0B%00%00%13%0B%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%0088%DA%FF88%DA%FF%A7%A7%F9%FF%A7%A7%F9%FF%A7%A7%F9%FF%A7%A7%F9%FF%A7%A7%F9%FF%A7%A7%F9%FF%A7%A7%F9%FF%A7%A7%F9%FF%A7%A7%F9%FF%A7%A7%F9%FF%A7%A7%F9%FF%A7%A7%F9%FF88%DA%FF88%DA%FF88%DA%FF88%DA%FF%E2%E2%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%E2%E2%FF%FF88%DA%FF88%DA%FF88%DA%FF88%DA%FF%A7%A7%F9%FF%E2%E2%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%E2%E2%FF%FF%A7%A7%F9%FF88%DA%FF88%DA%FF88%DA%FF88%DA%FF%E2%E2%FF%FF%A7%A7%F9%FF%E2%E2%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%81%81%F2%FF%81%81%F2%FF%FF%FF%FF%FF%FF%FF%FF%FF%E2%E2%FF%FF%A7%A7%F9%FF%E2%E2%FF%FF88%DA%FF88%DA%FF88%DA%FF88%DA%FF%FF%FF%FF%FF%E2%E2%FF%FF%A7%A7%F9%FF%B6%B6%FF%FF%81%81%F2%FFZZ%E9%FFZZ%E9%FF%81%81%F2%FF%B6%B6%FF%FF%A7%A7%F9%FF%E2%E2%FF%FF%FF%FF%FF%FF88%DA%FF88%DA%FF88%DA%FF88%DA%FF%FF%FF%FF%FF%FF%FF%FF%FF%B6%B6%FF%FF%81%81%F2%FFZZ%E9%FF88%DA%FF88%DA%FFZZ%E9%FF%81%81%F2%FF%B6%B6%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF88%DA%FF88%DA%FF88%DA%FF88%DA%FF%FF%FF%FF%FF%FF%FF%FF%FF%81%81%F2%FFZZ%E9%FF88%DA%FF%B6%B6%FF%FF%B6%B6%FF%FF88%DA%FFZZ%E9%FF%81%81%F2%FF%FF%FF%FF%FF%FF%FF%FF%FF88%DA%FF88%DA%FF88%DA%FF88%DA%FF%FF%FF%FF%FF%81%81%F2%FFZZ%E9%FF88%DA%FF%B6%B6%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%B6%B6%FF%FF88%DA%FFZZ%E9%FF%81%81%F2%FF%FF%FF%FF%FF88%DA%FF88%DA%FF88%DA%FF88%DA%FF%81%81%F2%FFZZ%E9%FF88%DA%FF%B6%B6%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%B6%B6%FF%FF88%DA%FFZZ%E9%FF%81%81%F2%FF88%DA%FF88%DA%FF88%DA%FF88%DA%FF88%DA%FF88%DA%FF%B6%B6%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%FF%B6%B6%FF%FF88%DA%FF88%DA%FF88%DA%FF88%DA%FF88%DA%FF88%DA%FF88%DA%FF%81%81%F2%FF%A7%A7%F9%FF%A7%A7%F9%FF%A7%A7%F9%FF%A7%A7%F9%FF%A7%A7%F9%FF%A7%A7%F9%FF%A7%A7%F9%FF%A7%A7%F9%FF%81%81%F2%FF88%DA%FF88%DA%FF88%DA%FF%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%FF%FF%00%00%FF%FF%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%FF%FF%00%00%FF%FF%00%00%FF%FF%00%00"
}, _searches:[], comparePriorities:function(a, b) {
  if(a.priority < b.priority)return-1;
  if(a.priority > b.priority)return 1;
  if(a.searchId < b.searchId)return-1;
  if(a.searchId > b.searchId)return 1;
  return 0}

, init:function() {
  var cs = Components.classes["@google.com/customsearch;1"];
  if(cs) {
    var obj = cs.createInstance(Components.interfaces.GTBICustomSearch);
    if(obj) {
      while(obj.searchId) {
        var newsearch = {};
        var searchId = obj.searchId.toLowerCase();
        var prefix = searchId.substr(0, 5);
        if(prefix == "hkcu_" || prefix == "hklm_")searchId = searchId.substr(5);
        newsearch["searchId"] = searchId;
        newsearch["priority"] = "0";
        while(obj.attr) {
          var attr = obj.attr.toLowerCase();
          if(attr == "icon") {
            var value = obj.value;
            if(!obj.isBinary) {
              value = window.atob(obj.value)}
            newsearch[attr] = "data:image/x-icon," + escape(value)}
          else if(!obj.isBinary) {
            newsearch[attr] = obj.value;
            if(attr == "title") {
              newsearch[attr] = newsearch[attr].replace("&", "")}
          }
          obj.nextAttr()}
        if(newsearch.icon == null) {
          newsearch.icon = "chrome://google-toolbar/skin/custom-unknown.png"}
        this._searches.push(newsearch);
        obj.nextSearch()}
      obj.finish()}
  }
  if(GTB_GoogleToolbarOverlay.languageCode == "en") {
    var addGmail = true;
    for(var i = 0;i < this._searches.length;i ++ ) {
      if(this._searches[i].searchId == "gmail") {
        addGmail = false;
        break}
    }
    if(addGmail) {
      this._searches.push(this._GmailSearch)}
  }
  this._searches.sort(this.comparePriorities);
  var toolbox = document.getElementById("navigator-toolbox");
  var toolbarPalette = toolbox.palette;
  var beforeThis = null;
  for(var index = 0;index < toolbarPalette.childNodes.length;index ++ ) {
    if(toolbarPalette.childNodes[index].id == "gtbNextPrev") {
      beforeThis = toolbarPalette.childNodes[index];
      break}
  }
  for(var i = 0;i < this._searches.length;i ++ ) {
    var search = this._searches[i];
    var button = document.createElement("toolbarbutton");
    button.setAttribute("id", this.searchToButtonId(search));
    button.setAttribute("oncommand", 'GTB_GTO_onGoogleSearchType(event, "GTB_Custom_Search_' + i + '")');
    button.setAttribute("onclick", "GTB_GTO_onClickMiddleMouse(event);");
    button.setAttribute("image", search.icon);
    button.setAttribute("label", search.title);
    button.setAttribute("class", "gtb-toolbarbutton");
    if(this._searches[i].tip) {
      button.setAttribute("tooltiptext", search.tip)}
    else {
      button.setAttribute("tooltiptext", search.title)}
    button = toolbarPalette.insertBefore(button, beforeThis);
    var prefName = "button_option." + button.id;
    var prefs = GTB_getPrefs();
    var on = prefs.getBoolPrefWithDefault(prefName, false);
    if(on) {
      var inserted = false;
      for(var t = 0;t < toolbox.childNodes.length;t ++ ) {
        var toolbar = toolbox.childNodes[t];
        var currentSet = toolbar.getAttribute("currentset");
        if(currentSet.indexOf(button.id) != -1) {
          var buttonList = currentSet.split(",");
          var passedButton = false;
          var nextButton = null;
          for(var b = 0;b < buttonList.length;b ++ ) {
            if(passedButton) {
              nextButton = document.getElementById(buttonList[b]);
              if(nextButton) {
                break}
            }
            if(buttonList[b] == button.id) {
              passedButton = true}
          }
          toolbar.insertItem(button.id, nextButton);
          inserted = true;
          break}
      }
      if(!inserted) {
        GTB_getToolbar()._addButton(button.id)}
    }
  }
}

, onCustomSearch:function(event, index) {
  var userText = GTB_GoogleToolbarOverlay.rememberSearchText();
  userText = userText == null ? "" : userText;
  var site = this.getCustomSearchURL(index, userText);
  GTB_GoogleToolbarOverlay._loadSearchURL(site);
  event.preventBubble()}

, getCustomSearchURL:function(index, userText) {
  var search = this._searches[index];
  var url = search.url == null ? "" : search.url;
  var site = search.site == null ? "" : search.site;
  if(userText != "" || site == "") {
    var home = GTB_GoogleToolbarOverlay.getGoogleHome();
    home = home.replace(/.*google\./, "");
    url = url.replace("{0}", home);
    url = url.replace("{domain}", home);
    var encodedSearch = encodeURIComponent(userText);
    url = url.replace("{1}", encodedSearch);
    url = url.replace("{query}", encodedSearch);
    site = url.replace(/[{][^}]*[}]/, "")}
  return site}

, searchToCheckboxId:function(search) {
  return"gtbCustomSearch_" + search.title}

, searchToButtonId:function(search) {
  return"gtbCustomButton" + search.title}

, addSearchesToDropDown:function() {
  var sep = document.getElementById("gtbCustomSearchSep");
  var nextSep = document.getElementById("gtbShowToolbarSep");
  var i;
  if(sep != null && nextSep != null) {
    if(sep.nextSibling == nextSep) {
      var menu = sep.parentNode;
      if(this._searches.length == 0) {
        menu.removeChild(sep)}
      else {
        for(i = 0;i < this._searches.length;i ++ ) {
          var customItem = document.createElement("menuitem");
          customItem.setAttribute("class", "menuitem-iconic");
          customItem.setAttribute("label", this._searches[i].title);
          if(this._searches[i].tip) {
            customItem.setAttribute("tooltiptext", this._searches[i].tip)}
          else {
            customItem.setAttribute("tooltiptext", this._searches[i].title)}
          customItem.setAttribute("image", this._searches[i].icon);
          customItem.setAttribute("oncommand", 'GTB_GTO_onGoogleSearchType(event, "GTB_Custom_Search_' + i + '", true)');
          customItem.setAttribute("onclick", "GTB_GTO_onClickMiddleMouse(event);");
          menu.insertBefore(customItem, nextSep)}
      }
    }
  }
}

};
function GTB_makeGoogleDefaultSearch(win) {
  if(win != null) {
    var dirSvc = Components.classes["@mozilla.org/file/directory_service;1"].getService(Components.interfaces.nsIProperties);
    var plugDir = dirSvc.get("SrchPlugns", Components.interfaces.nsILocalFile);
    var googleSrc = Components.classes["@mozilla.org/file/local;1"].createInstance(Components.interfaces.nsILocalFile);
    googleSrc.initWithPath(plugDir.path);
    googleSrc.appendRelativePath("google.src");
    var googleGif = Components.classes["@mozilla.org/file/local;1"].createInstance(Components.interfaces.nsILocalFile);
    googleGif.initWithPath(plugDir.path);
    googleGif.appendRelativePath("google.gif");
    if(win.document != null) {
      var searchbar = win.document.getElementById("searchbar");
      if(searchbar != null) {
        searchbar.setAttribute("searchengine", "engine://" + escape(googleSrc.path));
        searchbar.setAttribute("src", "file:///" + escape(googleGif.path))}
    }
  }
  var psvc = Components.classes["@mozilla.org/preferences;1"].getService(Components.interfaces.nsIPrefBranch);
  psvc.setCharPref("browser.search.defaultenginename", "Google");
  psvc.setCharPref("browser.search.defaulturl", "http://www.google.com/search?lr=&ie=UTF-8&oe=UTF-8&q=");
  psvc.setCharPref("browser.search.selectedEngine", "Google")}

function GTB_FirstRun_onAccept() {
  var enRadio = document.getElementById("gtbFirstRunEnablePageRank");
  var disRadio = document.getElementById("gtbFirstRunDisablePageRank");
  var en = enRadio.selected;
  var dis = disRadio.selected;
  if(!(en || dis)) {
    return false}
  var googleSearchDefault = document.getElementById("gtbFirstRunGoogleSearchDefault");
  if(googleSearchDefault.checked) {
    GTB_makeGoogleDefaultSearch(window.opener)}
  var allowGoogleCheckbox = document.getElementById("gtbFirstRunAllowGoogleExtensions");
  if(allowGoogleCheckbox.checked) {
    var ios = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
    var pm = Components.classes["@mozilla.org/permissionmanager;1"].getService(Components.interfaces.nsIPermissionManager);
    if(pm && ios) {
      var uri = ios.newURI("http://tools.google.com/", null, null);
      pm.add(uri, "install", Components.interfaces.nsIPermissionManager.ALLOW_ACTION)}
  }
  GTB_getPrefs().setBoolPref(GTB_PREF_OPT_IN, en);
  GTB_getPrefs().setStringPref(GTB_PREF_GOOGLE_HOME, GTB_FirstRun_googleHome());
  return true}

var GTB_TOOLBAR_FIRSTRUN_MOREINFO_OPTIONS = "chrome,width=800,height=600,resizable=yes,scrollbars=yes";
function GTB_FirstRun_onToolbarPrivacyPolicy() {
  var lang = window.arguments[0];
  GTB_FirstRun_showToolbarPrivacyPolicy(lang, GTB_TOOLBAR_FIRSTRUN_MOREINFO_OPTIONS)}

function GTB_FirstRun_onPageRankConfirmHelp() {
  var stringBundle = document.getElementById("gtb-localized_prefs");
  var lang = stringBundle.getString("lang");
  GTB_FirstRun_showToolbarPrivacyPolicy(lang)}

function GTB_FirstRun_showToolbarPrivacyPolicy(lang, opt_options) {
  var url = "http://www.google.com/support/toolbar/?quick=privacy";
  url += "&v=2.0f&hl=";
  url += lang;
  if(opt_options) {
    window.open(url, "gtbToolbarPrivacyPolicy", opt_options)}
  else {
    window.open(url, "gtbToolbarPrivacyPolicy")}
}

function GTB_FirstRun_onGooglePrivacyPolicy() {
  var stringBundle = document.getElementById("gtb-localized_prefs");
  var lang = stringBundle.getString("lang");
  GTB_FirstRun_showGooglePrivacyPolicy(lang)}

function GTB_FirstRun_showGooglePrivacyPolicy(lang) {
  var url = "http://www.google.com/privacy.html";
  window.open(url, "gtbGooglePrivacyPolicy", GTB_TOOLBAR_FIRSTRUN_MOREINFO_OPTIONS)}

function GTB_FirstRun_onToolbarLimitedInformation() {
  var stringBundle = document.getElementById("gtb-localized_prefs");
  var lang = stringBundle.getString("lang");
  GTB_FirstRun_showToolbarLimitedInformation(lang)}

function GTB_FirstRun_showToolbarLimitedInformation(lang) {
  var url = "http://www.google.com/support/toolbar/bin/answer.py?answer=34798&hl=";
  url += lang;
  window.open(url, "gtbToolbarLimitedInformation", GTB_TOOLBAR_FIRSTRUN_MOREINFO_OPTIONS)}

function GTB_FirstRun_onLoad(event) {
  var menulist = document.getElementById("gtbFirstRunWhichGoogleList");
  GTB_getPrefs().selectValueFromMenu(GTB_PREF_GOOGLE_HOME, menulist);
  var dialog = document.getElementById("gtbFirstRun");
  var button = dialog.getButton("accept");
  button.disabled = true;
  var handler = function() {
    button.disabled = false}

  ;
  var enable = document.getElementById("gtbFirstRunEnablePageRank");
  var disable = document.getElementById("gtbFirstRunDisablePageRank");
  enable.addEventListener("command", handler, true);
  disable.addEventListener("command", handler, true)}

function GTB_FirstRun_googleHome() {
  var menulist = document.getElementById("gtbFirstRunWhichGoogleList");
  var whichGoogle = menulist.selectedItem;
  var site = whichGoogle.label;
  return site}

function GTB_Highlighter() {
}

GTB_Highlighter.prototype = {_GOOGLE_TOOLBAR_ID:"google-toolbar-hilite-", _MAX_TERMS:10, _TERM_BUTTON_TOOLTIP:null, observe:GTB_MessageObserve, GTB_MESSAGES:{"GTB_OPTION.button_option.gtbHighlight":function(data) {
  if("false" == data) {
    GTB_getToolbar().highlighter.unhighlight()}
  else {
    GTB_getToolbar().highlighter.updateUiToHighlightFlag()}
}

, "GTB_OPTION.button_option.gtbFindTerms":function(data) {
  if("true" == data) {
    GTB_getToolbar().highlighter._currentWords = [];
    GTB_getToolbar().highlighter.onSearchTextChanged()}
}

}, init:function() {
  var stringBundle = document.getElementById("google-toolbar-strings");
  this._TERM_BUTTON_TOOLTIP = stringBundle.getString("prop.google-term.tooltip")}

, _highlightFlag:false, _currentWords:[], _HIGHLIGHT_COLORS:["Yellow", "Cyan", "Fuchsia", "Chartreuse", "Dodgerblue"], updateUiToHighlightFlag:function() {
  var button = this._getHighlightButton();
  if(button != null) {
    button.checked = this._highlightFlag;
    var highlightIcon = this._highlightFlag ? "highlight-on.png" : "highlight.png";
    button.setAttribute("image", "chrome://google-toolbar/skin/" + highlightIcon)}
}

, toggle:function() {
  this._highlightFlag = !this._highlightFlag;
  this.updateUiToHighlightFlag();
  if(document.getElementById("gtbFindTerms")) {
    for(var index = 0;index < this._MAX_TERMS;index ++ ) {
      var termButton = this._getHighlightTermButton(index);
      var wordFindIcon = "find.png";
      if(this._highlightFlag) {
        wordFindIcon = "find-" + this._HIGHLIGHT_COLORS[index % this._HIGHLIGHT_COLORS.length].toLowerCase() + ".png"}
      termButton.setAttribute("image", "chrome://google-toolbar/skin/" + wordFindIcon)}
  }
  if(this._highlightFlag) {
    this._highlight()}
  else {
    this._unhighlight()}
}

, onPageLoad:function() {
  if(this._highlightFlag) {
    this._highlight()}
}

, onTabSwitch:function() {
  if(this._highlightFlag) {
    this._highlight()}
  else {
    this._unhighlight()}
}

, _getSearchTextBox:function() {
  var searchTextBox = document.getElementById("gtbGoogleSearchBox");
  return searchTextBox}

, _getSearchTextValue:function() {
  var searchTextBox = this._getSearchTextBox();
  if(searchTextBox == null) {
    return""}
  return searchTextBox.value}

, _selectText:function(text) {
}

, _isWhitespace:function(ch) {
  return/^\s$/.test(ch)}

, _isPunctuation:function(ch) {
  return/[`~!@#$%^&\*()-+={}\[\]|\\:;\"<>,\.\?\/]/.test(ch)}

, _isWordCharacter:function(ch) {
  if(ch == null || typeof ch != "string" || ch.length != 1) {
    return false}
  var code = ch.charCodeAt(0);
  return code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 138 && code <= 142 || code >= 154 && code <= 159 || code >= 192 && code <= 255}

, _beginsWith:function(str, pref) {
  return str.substring(0, pref.length).toUpperCase() == pref.toUpperCase()}

, _extractCommandString:function(input, command) {
  var result = ["", input, false];
  var inQuotes = false;
  for(var i = 0;i < input.length; ++ i) {
    if(inQuotes) {
      if(input[i] == '"') {
        inQuotes = false}
    }
    else {
      if(input[i] == '"') {
        inQuotes = true}
      else if(i == 0 || this._isWhitespace(input[i - 1])) {
        if(this._beginsWith(input.substring(i), command)) {
          result[0] = input.substring(i + command.length);
          result[1] = input.substring(0, i);
          result[2] = true;
          break}
      }
    }
  }
  return result}

, _tokenizeSearchQuery:function(input) {
  var tokens = [];
  var state = 0;
  for(var i = 0;i < input.length; ++ i) {
    var ch = input[i];
    if(state == 0) {
      if(ch == '"') {
        tokens.push(["", true]);
        state = 2}
      else if(!this._isWhitespace(ch) && !this._isPunctuation(ch)) {
        tokens.push([ch, false]);
        state = 1}
    }
    else if(state == 1) {
      if(this._isWhitespace(ch) || this._isPunctuation(ch)) {
        state = 0}
      else {
        tokens[tokens.length - 1][0] += ch}
    }
    else if(state == 2) {
      if(ch == '"') {
        state = 0}
      else {
        tokens[tokens.length - 1][0] += ch}
    }
  }
  return tokens}

, _removeOperators:function(tokens) {
  var results = [];
  for(var i = 0;i < tokens.length; ++ i) {
    var token = tokens[i][0];
    if(tokens[i][1]) {
      if(token.length > 0) {
        results.push(token)}
      continue}
    if(token.toUpperCase() == "OR") {
      continue}
    if(token[0] == "-") {
      continue}
    if(token == "*" || token == "/" || token == "^" || token == "%") {
      continue}
    if(/\d+\.\.\.\d+/.test(token)) {
      continue}
    if(token[0] == "~") {
      token = token.substring(1)}
    results.push(token)}
  return results}

, _normalizeSpacing:function(tokens) {
  var results = [];
  for(var i = 0;i < tokens.length; ++ i) {
    var token = tokens[i];
    token = token.replace(/^\s+/, "");
    token = token.replace(/\s+$/, "");
    token = token.replace(/\s+/g, " ");
    if(token.length > 0) {
      results.push(token)}
  }
  return results}

, _removeDuplicates:function(list) {
  var member = function(array, item) {
    for(var index in array) {
      if(item == array[index]) {
        return true}
    }
    return false}

  ;
  var result = [];
  for(var i = 0;i < list.length; ++ i) {
    if(!member(result, list[i])) {
      result.push(list[i])}
  }
  return result}

, _splitUpSearchQuery:function(query) {
  var tokens = [];
  tokens = this._tokenizeSearchQuery(query);
  tokens = this._removeOperators(tokens);
  tokens = this._normalizeSpacing(tokens);
  return this._removeDuplicates(tokens)}

, _sameWordList:function(a, b) {
  var result = a.length == b.length;
  var index = 0;
  while(result && index < a.length) {
    result = a[index] == b[index];
    index ++ }
  return result}

, _getHighlightTermButton:function(index) {
  var button = document.getElementById("gtbFindTerm" + index);
  return button}

, _onCurrentWordsChanged:function(newWords, oldWords) {
  if(document.getElementById("gtbFindTerms") == null) {
    return}
  var tooltip = this._TERM_BUTTON_TOOLTIP;
  for(var index = 0;index < this._MAX_TERMS;index ++ ) {
    var button = this._getHighlightTermButton(index);
    var isHidden = index >= newWords.length;
    button.hidden = isHidden;
    if(!isHidden && newWords[index] != oldWords[index]) {
      button.label = newWords[index];
      button.tooltipText = tooltip.replace("$term;", newWords[index])}
  }
  GTB_GoogleToolbarOverlay.chevron.doResize()}

, _checkSearchWordList:function(opt_text) {
  var text = opt_text != null ? opt_text : this._getSearchTextValue();
  GTB_getToolbar().lastQuery = text;
  var newText = GTB_GoogleToolbarOverlay._removeQueryOperators(text);
  var words = this._splitUpSearchQuery(newText);
  if(!this._sameWordList(words, this._currentWords)) {
    this._onCurrentWordsChanged(words, this._currentWords);
    this._currentWords = words}
  return{hasTerms:words.length > 0, hasOps:text != newText}}

, _replaceSearchNewLines:function() {
  var textbox = this._getSearchTextBox();
  if(textbox) {
    var value = textbox.value;
    if(textbox && /[\n\r]/.test(value)) {
      value = value.replace(/[\n\r]/g, " ");
      textbox.value = value}
  }
}

, toggleWordFindEnabled:function() {
  this._onCurrentWordsChanged(this._currentWords, this._currentWords)}

, _isSearchTextBoxEmpty:function() {
  var text = this._getSearchTextValue();
  return text.length == 0}

, onSearchTextChanged:function(opt_text) {
  this._replaceSearchNewLines();
  return this._checkSearchWordList(opt_text)}

, findTerm:function(index, forward) {
  this.findTermText(this._currentWords[index], forward)}

, findTermText:function(text, forward) {
  if(getBrowser().findString == text) {
    if(forward) {
      findNext()}
    else {
      findPrevious()}
  }
  else {
    find(text);
    if(!forward) {
      findPrevious()}
  }
}

, _getHighlightButton:function() {
  var button = document.getElementById("gtbHighlight");
  return button}

, _highlightRange:function(range, color, id) {
  GTB_Dump(GTB_Dump.HI, "highlighting: " + id);
  var startContainer = range.startContainer;
  var spanNode = startContainer.ownerDocument.createElement("layer");
  spanNode.style.backgroundColor = color;
  spanNode.style.color = "black";
  spanNode.id = id;
  var docfrag = range.extractContents();
  spanNode.appendChild(docfrag);
  range.insertNode(spanNode);
  return spanNode}

, unhighlight:function() {
  if(this._highlightFlag) {
    this.toggle()}
}

, doPageHide:function(event) {
  if(event.persisted) {
    this._unhighlight()}
}

, _unhighlight:function() {
  var count = 0;
  var win = GTB_GoogleToolbarOverlay._getCurrentWindow();
  while(this._unhighlightWindow(win, count)) {
    count ++ }
  GTB_Dump(GTB_Dump.HI, "Last count unhighlighted: " + count)}

, _unhighlightWindow:function(win, count) {
  var result = false;
  if(win != null) {
    var doc = win.document;
    doc.normalize();
    if(win.frames != null) {
      for(var i = 0;i < win.frames.length;i ++ ) {
        if(this._unhighlightWindow(win.frames[i], count)) {
          result = true}
      }
    }
    if(!result) {
      var layer = doc.getElementById(this._GOOGLE_TOOLBAR_ID + count);
      while(layer != null) {
        var parent = layer.parentNode;
        var children = layer.childNodes;
        for(var index = children.length - 1;index >= 0;index -- ) {
          parent.insertBefore(children[0], layer)}
        parent.removeChild(layer);
        result = true;
        layer = doc.getElementById(this._GOOGLE_TOOLBAR_ID + count)}
    }
  }
  return result}

, _highlight:function() {
  this._unhighlight();
  var count = 0;
  for(var index = 0;index < this._currentWords.length;index ++ ) {
    var numHighlight = this._highlightWindow(GTB_GoogleToolbarOverlay._getCurrentWindow(), this._currentWords[index], this._HIGHLIGHT_COLORS[index % this._HIGHLIGHT_COLORS.length], count);
    count += numHighlight}
  GTB_Dump(GTB_Dump.HI, "Number of ranges highlighted: " + count)}

, _isNodeInputNodeOrChildOf:function(node) {
  if(node.nodeName.toUpperCase() == "INPUT") {
    return true}
  if(node.parentNode != null) {
    return this._isNodeInputNodeOrChildOf(node.parentNode)}
  return false}

, _highlightWindow:function(win, text, color, idIndex) {
  GTB_Dump(GTB_Dump.HI, "Highlighting: " + text);
  var count = 0;
  if(win.frames != null) {
    for(var i = 0;i < win.frames.length;i ++ ) {
      var numHighlight = this._highlightWindow(win.frames[i], text, color, idIndex + count);
      count += numHighlight}
  }
  var doc = win.document;
  if(doc != null) {
    var body = doc.body;
    if(body != null) {
      var docRange = doc.createRange();
      docRange.selectNode(body);
      var startRange = docRange.cloneRange();
      startRange.collapse(true);
      var stopRange = docRange.cloneRange();
      stopRange.collapse(false);
      var findRange = Components.classes["@mozilla.org/embedcomp/rangefind;1"].createInstance();
      if(findRange != null && findRange  instanceof Components.interfaces.nsIFind) {
        findRange.caseSensitive = false;
        findRange.findBackwards = false;
        var result = findRange.Find(text, docRange, startRange, stopRange);
        while(null != result) {
          if(result.endContainer != null && result.startContainer != null && result.endContainer.nodeType == Node.TEXT_NODE && result.startContainer.nodeType == Node.TEXT_NODE && !this._isNodeInputNodeOrChildOf(result.startContainer) && !this._isNodeInputNodeOrChildOf(result.endContainer)) {
            var startChar = null;
            if(result.startOffset > 0) {
              startChar = result.startContainer.nodeValue.charAt(result.startOffset - 1)}
            var endChar = result.endContainer.nodeValue.charAt(result.endOffset);
            if(!this._isWordCharacter(startChar) && !this._isWordCharacter(endChar)) {
              var spanNode = this._highlightRange(result, color, this._GOOGLE_TOOLBAR_ID + (idIndex + count));
              startRange.selectNode(spanNode);
              count ++ }
            else {
              startRange = result}
          }
          else {
            startRange = result}
          startRange.collapse(false);
          result = findRange.Find(text, docRange, startRange, stopRange)}
      }
    }
  }
  return count}

};
function GTB_InfoButton() {
  var stringBundle = document.getElementById("google-toolbar-strings");
  this._TOOLTIP_NO_INFO = stringBundle.getString("prop.google-info.noinfo");
  this._TOOLTIP_MORE_INFO = stringBundle.getString("prop.google-info.moreinfo");
  this._TOOLTIP_CACHE = stringBundle.getString("prop.info.cache.tooltip");
  this._TOOLTIP_SIMILAR = stringBundle.getString("prop.info.related.tooltip");
  this._TOOLTIP_BACKLINKS = stringBundle.getString("prop.info.backlinks.tooltip");
  this._TOOLTIP_TRANSLATE = stringBundle.getString("prop.info.translate.tooltip");
  try {
    var localeBundle = document.getElementById("gtb-localized_prefs");
    var available = localeBundle.getString("page_translate_available");
    if(available != "true") {
      var translateItem = document.getElementById("gtbInfoTranslate");
      if(translateItem && translateItem.parentNode) {
        translateItem.parentNode.removeChild(translateItem)}
    }
  }
  catch(e) {
  }
}

GTB_InfoButton.prototype = {observe:GTB_MessageObserve, GTB_MESSAGES:{"GTB_OPTION.button_option.gtbInfo":function(data) {
  if("true" == data) {
    try {
      var localeBundle = document.getElementById("gtb-localized_prefs");
      var available = localeBundle.getString("page_translate_available");
      if(available != "true") {
        var translateItem = document.getElementById("gtbInfoTranslate");
        if(translateItem && translateItem.parentNode) {
          translateItem.parentNode.removeChild(translateItem)}
      }
    }
    catch(e) {
    }
    GTB_getToolbar().infoButton.onPageChange(null)}
}

}, init:function() {
}

, onPageChange:function(event) {
  var infoButton = document.getElementById("gtbInfo");
  if(infoButton == null) {
    return}
  if(event && event.type != "load" && event.type != "pageshow" && event.type != "select") {
    return}
  if(event && (event.type == "load" || event.type == "pageshow")) {
    var contentWindow = GTB_GoogleToolbarOverlay._getCurrentWindow();
    if(contentWindow.document != event.originalTarget) {
      return}
  }
  var currentUrl = GTB_GoogleToolbarOverlay._getCurrentLocation().href;
  var infoAvailable = this._urlIndexable(currentUrl);
  if(!infoAvailable) {
    infoButton.disabled = true;
    infoButton.tooltipText = this._TOOLTIP_NO_INFO;
    infoButton.image = "chrome://google-toolbar/skin/info-disabled.png"}
  if(infoAvailable) {
    infoButton.disabled = false;
    var tooltip = this._TOOLTIP_MORE_INFO;
    tooltip = tooltip.replace("$url;", currentUrl);
    infoButton.tooltipText = tooltip;
    infoButton.image = "chrome://google-toolbar/skin/info.png"}
}

, doShowMenu:function(event) {
  var docLocation = GTB_GoogleToolbarOverlay._getCurrentLocation();
  var url = this._getInfoUrl(docLocation.href);
  var cacheItem = document.getElementById("gtbInfoCache");
  cacheItem.tooltipText = this._TOOLTIP_CACHE.replace("$infourl;", url);
  var similarItem = document.getElementById("gtbInfoSimilar");
  similarItem.tooltipText = this._TOOLTIP_SIMILAR.replace("$url;", url);
  var backlinksItem = document.getElementById("gtbInfoBacklinks");
  backlinksItem.tooltipText = this._TOOLTIP_BACKLINKS.replace("$infourl;", url);
  var translateItem = document.getElementById("gtbInfoTranslate");
  if(translateItem) {
    translateItem.tooltipText = this._TOOLTIP_TRANSLATE}
}

, _urlIndexable:function(url) {
  if(url.length == 0) {
    return false}
  if(url.indexOf(" ") != -1) {
    return false}
  var ios = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
  var xpcomUrl = ios.newURI(url, null, null);
  if(!(xpcomUrl  instanceof Components.interfaces.nsIURL)) {
    return false}
  if(xpcomUrl.scheme != "http") {
    return false}
  if(/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/.exec(xpcomUrl.host)) {
    return true}
  var tld = xpcomUrl.host.substring(xpcomUrl.host.lastIndexOf("."), xpcomUrl.host.length);
  return validTldList.indexOf(tld) != -1}

, _getInfoUrl:function(browserUrl) {
  if(browserUrl.length == 0 || browserUrl.indexOf(" ") != -1) {
    return browserUrl}
  var ios = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
  var xpcomUrl = ios.newURI(browserUrl, null, null);
  if(!(xpcomUrl  instanceof Components.interfaces.nsIURL)) {
    return browserUrl}
  if(!GTB_isGoogleUrl(xpcomUrl)) {
    return browserUrl}
  if(!xpcomUrl.query || xpcomUrl.query.length == 0) {
    return browserUrl}
  var args = GTB_parseQueryString(xpcomUrl.query);
  if(!args || args == {}) {
    return browserUrl}
  if(args.q && args.q.indexOf("related:") == 0) {
    return args.q.replace("related:", "")}
  if(args.q && args.q.indexOf("link:") == 0) {
    return args.q.replace("link:", "")}
  if(xpcomUrl.host == "translate.google.com" && args && args.u) {
    return decodeURIComponent(args.u)}
  return browserUrl}

, _gwsRequestInfo:function(event, infoOperation) {
  var home = GTB_GoogleToolbarOverlay.getGoogleHome();
  var docLocation = GTB_GoogleToolbarOverlay._getCurrentLocation();
  var url = this._getInfoUrl(docLocation.href);
  GTB_GoogleToolbarOverlay.loadUrlWithModifiers(GTB_InfoUrl(home, infoOperation, url), event);
  event.preventBubble()}

, doCachedSnapshot:function(event) {
  this._gwsRequestInfo(event, "cache:")}

, doSimilarPages:function(event) {
  this._gwsRequestInfo(event, "related:")}

, doBackwardLinks:function(event) {
  this._gwsRequestInfo(event, "link:")}

, doTranslatePage:function(event) {
  var docLocation = GTB_GoogleToolbarOverlay._getCurrentLocation();
  var url = this._getInfoUrl(docLocation.href);
  var lang = GTB_GoogleToolbarOverlay.languageCode;
  GTB_GoogleToolbarOverlay.loadUrlWithModifiers(GTB_TranslateUrl(lang, url), event);
  event.preventBubble()}

};
function GTB_IB_onShowMenu(event) {
  GTB_GoogleToolbarOverlay.infoButton.doShowMenu(event)}

function GTB_SC_onSelectLangPref(event, lang) {
  GTB_GoogleToolbarOverlay.spellCheck.setLangPref(event, lang)}

function GTB_IB_onCachedSnapshot(event) {
  GTB_GoogleToolbarOverlay.infoButton.doCachedSnapshot(event)}

function GTB_IB_onSimilarPages(event) {
  GTB_GoogleToolbarOverlay.infoButton.doSimilarPages(event)}

function GTB_IB_onBackwardLinks(event) {
  GTB_GoogleToolbarOverlay.infoButton.doBackwardLinks(event)}

function GTB_IB_onTranslatePage(event) {
  GTB_GoogleToolbarOverlay.infoButton.doTranslatePage(event)}

function GTB_setBoolPrefWithMessage(name, value, gto) {
  GTB_getPrefs().setBoolPref(name, value);
  var message = "GTB_OPTION." + name;
  gto.sendMessage(message, value)}

function GTB_setStringPrefWithMessage(name, value, gto) {
  GTB_getPrefs().setStringPref(name, value);
  var message = "GTB_OPTION." + name;
  gto.sendMessage(message, value)}

function OptionsDialog() {
  this._overlay = null;
  this._options = null}

OptionsDialog.MORE_URL_PAGERANK = "http://www.google.com/support/toolbar/bin/answer.py?answer=14293&hl={LANG}";
OptionsDialog.MORE_URL_SAFEBROWSING = "http://www.google.com/support/toolbar/bin/answer.py?answer=34798&hl={LANG}";
OptionsDialog.MORE_URL_SPELLCHECK = "http://google.com/tools/firefox/toolbar/FT2/intl/{LANG}/spellcheckintro";
OptionsDialog.MORE_URL_WORDTRANSLATOR = "http://google.com/tools/firefox/toolbar/FT2/intl/{LANG}/translationintro.html";
OptionsDialog.MORE_URL_AUTOFILL = "http://google.com/tools/firefox/toolbar/FT2/intl/{LANG}/afintro.html";
OptionsDialog.MORE_URL_AUTOLINK = "http://google.com/tools/firefox/toolbar/FT2/intl/{LANG}/autolinkintro.html";
OptionsDialog.MORE_URL_FEEDSUBSCRIBE = "http://google.com/tools/firefox/toolbar/FT2/intl/{LANG}/subscribeintro.html";
OptionsDialog.MORE_URL_MAILTO = "http://google.com/tools/firefox/toolbar/FT2/intl/{LANG}/gmailtointro.html";
OptionsDialog.MORE_URL_BUTTONLAYOUT = "http://www.google.com/support/toolbar/bin/answer.py?answer=24897&hl={LANG}";
OptionsDialog.PAGE_RANK_WINDOW_FLAGS = "dependent=no,width=800,height=600,scrollbars=yes,resizable=yes,location=no";
OptionsDialog.MORE_WINDOW_FLAGS = "dependent=no,width=600,height=420,scrollbars=yes,resizable=yes,personalbar=no,location=no";
OptionsDialog.MORE_WINDOW_FLAGS_MODAL = OptionsDialog.MORE_WINDOW_FLAGS + ",modal";
OptionsDialog.MORE_WINDOW_NAME = "gtbOptionsMore";
OptionsDialog.more = function(win, lang, urlTemplate, opt_flags) {
  if(!opt_flags) {
    opt_flags = OptionsDialog.MORE_WINDOW_FLAGS}
  win.open(this.localize(urlTemplate, lang), OptionsDialog.MORE_WINDOW_NAME, opt_flags)}

;
OptionsDialog.localize = function(template, lang) {
  return template.replace(/{LANG}/, lang)}

;
OptionsDialog.prototype.onTranslateOptions = function(event) {
  window.openDialog("chrome://google-toolbar/content/options-translation.xul", "gtbTranslationOptions", "modal,centerscreen,chrome,resizable=no");
  event.preventBubble()}

;
OptionsDialog.prototype.onRestoreDefaults = function(event) {
  window.openDialog("chrome://google-toolbar/content/restore-defaults.xul", "gtbRestoreDefaults", "modal,centerscreen,chrome,resizable=no");
  event.preventBubble()}

;
OptionsDialog.prototype.onMailOptions = function(event) {
  window.openDialog("chrome://google-toolbar/content/options-mail.xul", "gtbMailOptions", "modal,centerscreen,chrome,resizable=no");
  event.preventBubble()}

;
OptionsDialog.prototype.onLayoutOptions = function(event) {
  window.openDialog("chrome://google-toolbar/content/options-layouts.xul", "gtbLayoutOptions", "modal,centerscreen,chrome,resizable=no");
  event.preventBubble();
  window.focus()}

;
OptionsDialog.prototype.onSpellingOptions = function(event) {
  window.openDialog("chrome://google-toolbar/content/options-spelling.xul", "gtbSpellingOptions", "modal,centerscreen,chrome,resizable=no");
  event.preventBubble()}

;
OptionsDialog.prototype.onSafeBrowsingOptions = function(event) {
  window.openDialog("chrome://tb-amulet-of-protection/content/protection-preferences.xul", "gtbSafeBrowsingOptions", "modal,centerscreen,chrome,resizable=no");
  event.preventBubble()}

;
OptionsDialog.prototype.onAutoLinkOptions = function(event) {
  window.openDialog("chrome://google-toolbar/content/options-auto-link.xul", "gtbAutoLinkOptions", "modal,centerscreen,chrome,resizable=no");
  event.preventBubble()}

;
OptionsDialog.prototype.onFeedSubscribeOptions = function(event) {
  window.openDialog("chrome://google-toolbar/content/options-subscribe.xul", "gtbFeedSubscribeOptions", "modal,centerscreen,chrome,resizable=no");
  event.preventBubble()}

;
OptionsDialog.prototype.onAutoFillOptions = function(event) {
  window.openDialog("chrome://google-toolbar/content/options-auto-fill.xul", "gtbAutoFillOptions", "modal,centerscreen,chrome,resizable=no");
  event.preventBubble()}

;
OptionsDialog.prototype.persistAllToolbars = function() {
  var toolbox = null;
  var windows = GTB_getBrowserWindows();
  for(var b = 0, win = null;win = windows[b]; ++ b) {
    toolbox = win.document.getElementById("navigator-toolbox");
    if(toolbox) {
      this.persistToolbars(win, toolbox)}
    win.document.persist("gtbToolbar", "collapsed")}
}

;
OptionsDialog.prototype.persistToolbars = function(win, toolbox) {
  var oldGToolboxChanged = gToolboxChanged;
  gToolboxChanged = true;
  var oldGToolbox = gToolbox;
  gToolbox = toolbox;
  var oldGToolboxDocument = gToolboxDocument;
  gToolboxDocument = win.document;
  persistCurrentSets();
  gToolboxChanged = oldGToolboxChanged;
  gToolbox = oldGToolbox;
  gToolboxDocument = oldGToolboxDocument}

;
OptionsDialog.prototype.onDialogAccept = function(event) {
  for(var i = 0;i < this._options.length;i ++ ) {
    this._options[i].onApply(this._overlay)}
  if(window.name == "gtbOptions") {
    GTB_getToolbar().handleCustomize();
    this.persistAllToolbars()}
  event.preventBubble()}

;
OptionsDialog.prototype._getToolboxWindow = function() {
  var currentWindow = window.opener;
  var toolbox;
  while(currentWindow != null) {
    toolbox = currentWindow.document.getElementById("navigator-toolbox");
    if(toolbox != null) {
      break}
    currentWindow = currentWindow.opener}
  return currentWindow}

;
OptionsDialog.prototype.resetLayout = function() {
  var lastQuery = this._overlay.lastQuery;
  var currentWindow = this._getToolboxWindow();
  var doc = currentWindow.document;
  var toolbox = currentWindow.document.getElementById("navigator-toolbox");
  var googletoolbar = null;
  var i, j;
  for(i = 0;i < toolbox.childNodes.length;i ++ ) {
    var toolbar = toolbox.childNodes[i];
    for(j = toolbar.childNodes.length - 1;j >= 0;j -- ) {
      if(GTB_isGoogleToolbarItem(toolbar.childNodes[j])) {
        var prefName = "button_option." + toolbar.childNodes[j].id;
        GTB_getPrefs().setBoolPref(prefName, false)}
      if(toolbar.id == "gtbToolbar") {
        toolbar.removeChild(toolbar.childNodes[j])}
    }
    if(toolbar.id == "gtbToolbar") {
      googletoolbar = toolbar}
  }
  var defaultSet = googletoolbar.getAttribute("defaultset");
  var defaults = defaultSet.split(",");
  for(i = 0;i < defaults.length;i ++ ) {
    this._overlay._addButton(defaults[i]);
    GTB_getPrefs().setBoolPref("button_option." + defaults[i], true)}
  this._overlay.restoreDefaultsFixUi();
  this._overlay.lastQuery = lastQuery;
  var searchbox = doc.getElementById("gtbGoogleSearchBox");
  searchbox.value = this._overlay.lastQuery;
  var answer = this._overlay.highlighter.onSearchTextChanged(this._overlay.lastQuery);
  this._overlay._enableDisableQueryButtons(answer.hasTerms, answer.hasOps);
  this._overlay.propogateToolbarChanges(true);
  GTB_GTO_replaceSearchBox(false);
  GTB_GTO_setGoogleToolbarCollapsed(false);
  this.persistToolbars(currentWindow, toolbox);
  this._overlay.handleCustomize()}

;
OptionsDialog.prototype.onRestoreDefaultsAccept = function(event) {
  this.resetLayout();
  this._overlay.sendMessage("GTB_SpellCheck.resetButton", null);
  for(var i = 0;i < this._options.length;i ++ ) {
    this._options[i].restoreDefaults(this._overlay)}
  var advancedProtectionDefault = GTB_getPrefs().getBoolPrefWithDefault(GTB_PREF_ADVANCED_DEFAULT, false);
  GTB_getPrefs().setBoolPref("button_option.safebrowsing.advancedprotection", advancedProtectionDefault);
  event.preventBubble()}

;
OptionsDialog.prototype.getGoogleVar = function(varname) {
  if(window.opener[varname]) {
    return window.opener[varname]}
  if(window.opener.opener && window.opener.opener[varname]) {
    return window.opener.opener[varname]}
  try {
    var windowMediator = Components.classes["@mozilla.org/appshell/window-mediator;1"].getService(Components.interfaces.nsIWindowMediator)}
  catch(e) {
    return null}
  if(windowMediator) {
    var browser = windowMediator.getMostRecentWindow("navigator:browser");
    if(browser) {
      return browser[varname]}
  }
}

;
function MenulistOption(menulistId, property, opt_default) {
  this._property = property;
  this._default = opt_default;
  if(!this._default) {
    this._default = GTB_getPrefs().getLocaleDefault(property)}
  this._menulist = null;
  if(menulistId != null) {
    this._menulist = document.getElementById(menulistId);
    GTB_getPrefs().selectValueFromMenu(this._property, this._menulist)}
}

MenulistOption.prototype.onApply = function(gto) {
  if(this._menulist == null) {
    return}
  var oldValue = GTB_getPrefs().getStringPref(this._property);
  var newValue = GTB_getPrefs().getSelection(this._menulist);
  if(oldValue != newValue) {
    GTB_getPrefs().setStringPref(this._property, newValue);
    var message = "GTB_OPTION." + this._property;
    gto.sendMessage(message, newValue);
    if(typeof this.doApply == "function") {
      this.doApply(newValue, gto)}
  }
}

;
MenulistOption.prototype.restoreDefaults = function(gto) {
  var oldValue = GTB_getPrefs().getStringPref(this._property);
  if(this._default != null) {
    GTB_getPrefs().setStringPref(this._property, this._default)}
  else {
    GTB_getPrefs().resetToDefault(this._property)}
  var newValue = GTB_getPrefs().getStringPref(this._property);
  if(this._menulist != null) {
    GTB_getPrefs().selectValueFromMenu(this._property, this._menulist)}
  if(oldValue != newValue) {
    var message = "GTB_OPTION." + this._property;
    gto.sendMessage(message, newValue);
    if(typeof this.doApply == "function") {
      this.doApply(newValue, gto)}
  }
}

;
function BooleanOption() {
  BooleanOption.prototype._checkbox = null;
  BooleanOption.prototype._property = null;
  BooleanOption.prototype._default = null}

BooleanOption.prototype.onApply = function(gto) {
  if(this._checkbox == null) {
    return}
  var oldValue = GTB_getPrefs().getBoolPref(this._property);
  var newValue = this._checkbox.checked;
  if(oldValue != newValue) {
    GTB_getPrefs().setBoolPref(this._property, newValue);
    if(typeof this.doApply == "function") {
      this.doApply(newValue, gto)}
    gto.sendMessage("GTB_OPTION." + this._property, newValue)}
}

;
BooleanOption.prototype.restoreDefaults = function(gto) {
  var oldValue = GTB_getPrefs().getBoolPref(this._property);
  if(this._default != null) {
    GTB_getPrefs().setBoolPref(this._property, this._default)}
  else {
    GTB_getPrefs().resetToDefault(this._property)}
  var newValue = GTB_getPrefs().getBoolPref(this._property);
  if(this._checkbox != null) {
    this._checkbox.checked = newValue}
  if(oldValue != newValue) {
    var message = "GTB_OPTION." + this._property;
    gto.sendMessage(message, newValue);
    if(typeof this.doApply == "function") {
      this.doApply(newValue, gto)}
  }
}

;
BooleanOption.prototype._getCurrentValue = function() {
  return GTB_getPrefs().getBoolPref(this._property)}

;
BooleanOption.prototype.dependentWidget = function(widgetName) {
  var dw = document.getElementById(widgetName);
  var idw = this._checkbox;
  dw.disabled = !idw.checked;
  idw.addEventListener("CheckboxStateChange", function(event) {
    dw.disabled = !idw.checked;
    event.preventBubble()}

  , true)}

;
function ButtonOption(checkboxId, property, opt_default) {
  this._checkbox = document.getElementById(checkboxId);
  this._property = "button_option." + property;
  this._checkbox.checked = this._getCurrentValue();
  this._default = opt_default;
  if(!this._default) {
    var def_val = GTB_getPrefs().getLocaleDefault(this._property);
    if(def_val == "true") {
      this._default = true}
    if(def_val == "false") {
      this._default = false}
  }
}

ButtonOption.prototype = new BooleanOption;
ButtonOption.prototype.doApply = function(newValue, gto) {
  var button = [this._property.replace("button_option.", "")];
  if(newValue) {
    gto.addButtons(button)}
  else {
    gto.removeButtons(button)}
}

;
function CheckboxOption(checkboxId, property, opt_default) {
  this._property = property;
  this._default = opt_default;
  if(!this._default) {
    var def_val = GTB_getPrefs().getLocaleDefault(property);
    if(def_val == "true") {
      this._default = true}
    else if(def_val == "false") {
      this._default = false}
  }
  if(checkboxId != null) {
    this._checkbox = document.getElementById(checkboxId);
    this._checkbox.checked = this._getCurrentValue()}
}

CheckboxOption.prototype = new BooleanOption;
function GTB_Option_createMainOptionsDialog() {
  var optionsDialog = new OptionsDialog;
  optionsDialog._confirmedOptIn = false;
  optionsDialog.onLoad = function(event) {
    this._overlay = GTB_getToolbar();
    var searchNewTab = new CheckboxOption("gtbOptionsSearchResultsToNewTabCheckbox", "search_new_tab");
    var translatorButton = new CheckboxOption("gtbOptionsBrowsingWordTranslatorCheckbox", GTB_PREF_AUTO_TRANSLATE);
    translatorButton.dependentWidget("gtbOptionsBrowsingWordTranslatorButton");
    if(this._overlay.languageCode != "en") {
      var container = document.getElementById("gtbOptionsAutoLinkContainer");
      container.hidden = true;
      container = document.getElementById("gtbOptionsAutoFillContainer");
      container.hidden = true}
    if(!(this._overlay.languageCode == "en" || this._overlay.languageCode == "ja")) {
      var suggestBox = document.getElementById("gtbOptionsUseSuggestCheckbox");
      suggestBox.hidden = true}
    var optionalButtons = [["gtbSearchNews", "gtbOptionsMoreNewsCheckbox"], ["gtbSearchFroogle", "gtbOptionsSearchButtonsFroogleCheckbox"], ["gtbSearchLocal", "gtbOptionsSearchButtonsLocalCheckbox"]];
    var i, buttonIds;
    for(i = 0;buttonIds = optionalButtons[i]; ++ i) {
      if(!this._overlay.availableButtons[buttonIds[0]]) {
        var buttonElt = document.getElementById(buttonIds[1]);
        buttonElt.hidden = true}
    }
    if(!this._overlay.autoTransLibAvailable) {
      var container = document.getElementById("gtbOptionsWordTranslatorContainer");
      container.hidden = true}
    var translatorSuboption = new MenulistOption(null, "autotranslate_to_lang");
    translatorSuboption.doApply = function(newValue, gto) {
      gto.autoTranslate.downloadToLangDict(newValue)}

    ;
    this._options = [new CheckboxOption("gtbOptionsMailCheckbox", GTB_PREF_OPT_MAIL), new CheckboxOption("gtbOptionsSearchSaveHistoryCheckbox", GTB_PREF_SAVE_HISTORY), new CheckboxOption("gtbOptionsSearchOnSelectCheckbox", GTB_PREF_SEARCH_ON_SELECT), searchNewTab, translatorButton, new CheckboxOption("gtbOptionsUseSuggestCheckbox", GTB_PREF_USE_SUGGEST), new CheckboxOption("gtbOptionsSearchRememberTypeCheckbox", GTB_PREF_REMEMBER_SEARCH_TYPE), new MenulistOption("gtbOptionsSearchWhichGoogleList",
    "google_home"), new MenulistOption("gtbOptionsMoreButtonTextList", "button_text_level"), new CheckboxOption(null, GTB_PREF_SC_IGNORE_DUPS), new CheckboxOption(null, GTB_PREF_SC_IGNORE_ALL_CAPS), new CheckboxOption(null, GTB_PREF_SC_IGNORE_DIGITS), translatorSuboption, new CheckboxOption(null, GTB_PREF_AUTO_LINK_NEW_WINDOW), new MenulistOption(null, "autolink.map"), new MenulistOption(null, "autolink.isbn"), new MenulistOption(null, "autolink.vin"), new MenulistOption(null, GTB_FS_PREF_CURRENT)
    , new MenulistOption(null, "spell_check.lang")];
    for(i = 0;i < this._overlay.buttonOptions.length;i ++ ) {
      var info = this._overlay.buttonOptions[i];
      var buttonOption = new ButtonOption(info.checkboxId, info.property);
      if(info.dependentWidget) {
        buttonOption.dependentWidget(info.dependentWidget)}
      if(info.optIn) {
        buttonOption._default = GTB_getPrefs().getBoolPref(GTB_PREF_OPT_IN)}
      this._options.push(buttonOption)}
    var container = document.getElementById("gtbOptionsCustomSearchContainer");
    var GTB_cs = this._overlay.customSearch;
    var customSearches = GTB_cs._searches;
    if(customSearches.length == 0) {
      var label = document.getElementById("gtbOptionsCustomSearchListLabel");
      label.hidden = true}
    for(i = 0;i < customSearches.length;i ++ ) {
      var search = customSearches[i];
      var checkboxId = GTB_cs.searchToCheckboxId(search);
      var buttonId = GTB_cs.searchToButtonId(search);
      var checkbox = document.createElement("checkbox");
      checkbox.setAttribute("id", checkboxId);
      checkbox.setAttribute("label", search.title);
      container.appendChild(checkbox);
      this._options.push(new ButtonOption(checkboxId, buttonId, false))}
  }

  ;
  optionsDialog.onDialogHelp = function(event, lang) {
    var url = "http://www.google.com/support/toolbar?hl=";
    url += this._overlay.languageCode;
    window.opener.open(url, "gtbOptionsDialogHelpWindow", "width=800,height=600,resizable=yes,scrollbars=yes")}

  ;
  optionsDialog.onPageRankMore = function(event) {
    this.more(OptionsDialog.MORE_URL_PAGERANK, OptionsDialog.PAGE_RANK_WINDOW_FLAGS)}

  ;
  optionsDialog.onSafeBrowsingMore = function(event) {
    this.more(OptionsDialog.MORE_URL_SAFEBROWSING, OptionsDialog.PAGE_RANK_WINDOW_FLAGS)}

  ;
  optionsDialog.onSpellCheckMore = function(event) {
    this.more(OptionsDialog.MORE_URL_SPELLCHECK)}

  ;
  optionsDialog.onWordTranslatorMore = function(event) {
    this.more(OptionsDialog.MORE_URL_WORDTRANSLATOR)}

  ;
  optionsDialog.onAutoFillMore = function(event) {
    this.more(OptionsDialog.MORE_URL_AUTOFILL)}

  ;
  optionsDialog.onAutoLinkMore = function(event) {
    this.more(OptionsDialog.MORE_URL_AUTOLINK)}

  ;
  optionsDialog.onFeedSubscribeMore = function(event) {
    this.more(OptionsDialog.MORE_URL_FEEDSUBSCRIBE)}

  ;
  optionsDialog.onButtonLayoutMore = function(event) {
    this.more(OptionsDialog.MORE_URL_BUTTONLAYOUT)}

  ;
  optionsDialog.onMailtoCheckMore = function(event) {
    this.more(OptionsDialog.MORE_URL_MAILTO)}

  ;
  optionsDialog.more = function(urlTemplate, opt_flags) {
    OptionsDialog.more(window.opener, this._overlay.languageCode, urlTemplate, opt_flags)}

  ;
  return optionsDialog}

function GTB_Option_createSpellingOptionsDialog() {
  var optionsDialog = new OptionsDialog;
  optionsDialog.onLoad = function(event) {
    this._overlay = GTB_getToolbar();
    this._options = [new CheckboxOption("gtbOptionsSpellingIgnoreRepeatedCheckbox", GTB_PREF_SC_IGNORE_DUPS), new CheckboxOption("gtbOptionsSpellingIgnoreAllCapsCheckbox", GTB_PREF_SC_IGNORE_ALL_CAPS), new CheckboxOption("gtbOptionsSpellingIgnoreDigitsCheckbox", GTB_PREF_SC_IGNORE_DIGITS)]}

  ;
  return optionsDialog}

function GTB_Option_createLayoutOptionsDialog() {
  var optionsDialog = new OptionsDialog;
  optionsDialog.onLoad = function(event) {
    this._overlay = GTB_getToolbar();
    var radioGroup = document.getElementById("gtbOptionsLayoutRadio");
    if(radioGroup != null) {
      radioGroup.addEventListener("command", LayoutRadioCommand, false);
      var win = this._getToolboxWindow();
      var googleToolbar = win.document.getElementById("gtbToolbar");
      var isCollapsed = googleToolbar.collapsed;
      var searchBox = win.document.getElementById("gtbSearchBox");
      var isOnNavbar = false;
      if(searchBox && searchBox.parentNode) {
        isOnNavbar = searchBox.parentNode.id == "nav-bar"}
      var value = "classic";
      if(isOnNavbar && isCollapsed) {
        value = "spacesaver"}
      else if(isOnNavbar) {
        value = "combined"}
      radioGroup.value = value;
      UpdateImageFromRadioState();
      var radios = radioGroup.getElementsByTagName("radio");
      for(var r = 0, radio = null;radio = radios[r]; ++ r) {
        if(radio.value == radioGroup.value) {
          radioGroup.selectedIndex = r}
      }
    }
  }

  ;
  optionsDialog.onDialogAccept = function(event) {
    var radioGroup = document.getElementById("gtbOptionsLayoutRadio");
    if(radioGroup != null) {
      this.resetLayout();
      var layout = radioGroup.value;
      var collapsed = layout == "spacesaver";
      GTB_GTO_setGoogleToolbarCollapsed(collapsed);
      var replaceSearchBox = layout != "classic";
      GTB_GTO_replaceSearchBox(replaceSearchBox);
      this.persistAllToolbars()}
  }

  ;
  function UpdateImageFromRadioState() {
    var radioGroup = document.getElementById("gtbOptionsLayoutRadio");
    var image = document.getElementById("gtbOptionsLayoutImage");
    if(radioGroup != null && image != null) {
      switch(radioGroup.value) {
        case "classic":image.src = "chrome://google-toolbar/skin/layout-classic.png";
        break;
        case "combined":image.src = "chrome://google-toolbar/skin/layout-combined.png";
        break;
        case "spacesaver":image.src = "chrome://google-toolbar/skin/layout-space-saver.png";
        break;
        default:break}
    }
  }

  function LayoutRadioCommand(event) {
    UpdateImageFromRadioState()}

  return optionsDialog}

function GTB_Option_createTranslationOptionsDialog() {
  var optionsDialog = new OptionsDialog;
  optionsDialog.onLoad = function(event) {
    this._overlay = GTB_getToolbar();
    var gtbOptionsMenuPopup = document.getElementById("gtbOptionsTranslationLanguageMenuPopup");
    if(gtbOptionsMenuPopup != null) {
      GTB_sortMenuPopup(gtbOptionsMenuPopup)}
    var self = this;
    var option = new MenulistOption("gtbOptionsTranslationLanguageMenulist", "autotranslate_to_lang");
    option.doApply = function(newValue, gto) {
      gto.autoTranslate.downloadToLangDict(newValue)}

    ;
    setTimeout(function() {
      self._options = [option]}

    , 0)}

  ;
  return optionsDialog}

function GTB_Option_createAutoLinkOptionsDialog() {
  var optionsDialog = new OptionsDialog;
  optionsDialog.onLoad = function(event) {
    this._overlay = GTB_getToolbar();
    var self = this;
    setTimeout(function() {
      self._options = [new CheckboxOption("gtbOptionsAutoLinkNewWindow", GTB_PREF_AUTO_LINK_NEW_WINDOW), new MenulistOption("gtbOptionsAutoLinkMapsMenulist", "autolink.map"), new MenulistOption("gtbOptionsAutoLinkIsbnMenulist", "autolink.isbn"), new MenulistOption("gtbOptionsAutoLinkVinMenulist", "autolink.vin")]}

    , 0);
    this.baseDialogAccept = this.onDialogAccept;
    this.onDialogAccept = function(event) {
      this.baseDialogAccept(event);
      var autoLink = this._overlay.autoLink;
      if(autoLink) {
        autoLink.relink()}
    }

  }

  ;
  return optionsDialog}

function GTB_Option_createFeedSubscribeOptionsDialog() {
  var optionsDialog = new OptionsDialog;
  optionsDialog.addMenuElement = function(agg) {
    var newel = document.createElement("menuitem");
    newel.setAttribute("label", agg.title);
    newel.setAttribute("tooltiptext", agg.desc);
    newel.setAttribute("value", agg.id);
    var agglist = document.getElementById("gtbOptionsFeedSubscribeAggregatorsPopup");
    agglist.insertBefore(newel, null)}

  ;
  optionsDialog.onLoad = function(event) {
    this._overlay = GTB_getToolbar();
    var aggs = GTB_FS_getAggMgr().loadAggregatorsFromPrefs();
    for(var idx = 0;idx < aggs.length;idx ++ ) {
      this.addMenuElement(aggs[idx])}
    GTB_FS_getAggMgr().maybeInitCurrentAggregator();
    var self = this;
    setTimeout(function() {
      self._options = [new MenulistOption("gtbOptionsFeedSubscribeAggregatorsMenulist", GTB_FS_PREF_CURRENT)]}

    , 0);
    this.baseDialogAccept = this.onDialogAccept;
    this.onDialogAccept = function(event) {
      GTB_FS_Dump("Received onDialogAccept for Subscribe Settings");
      this.baseDialogAccept(event)}

  }

  ;
  return optionsDialog}

var _GPTD_PREFIX = "GPTD__data__";
var _GPTD_TAG_PROP = _GPTD_PREFIX + "tagged";
var _GPTD_DEBUG = false;
function GPTD_dump(s) {
}

function GTB_TabManager() {
  this._tabBrowser = document.getElementById("content");
  this._numOpenTabs = 0;
  this._keys = new Object;
  var browsers = this._tabBrowser.browsers;
  for(var i = 0;i < browsers.length;i ++ ) {
    this._initNewTab(browsers[i])}
}

GTB_TabManager.prototype = {makeContainers:function(key) {
  if(this._keys[key] != null) {
    throw new Error("containers already exist for key '" + key + "'");}
  this._keys[key] = true;
  var browsers = this._tabBrowser.browsers;
  for(var i = 0;i < browsers.length;i ++ ) {
    this._addContainerToBrowser(browsers[i], key)}
  return this.getContainers(key)}

, getContainers:function(key) {
  if(this._keys[key] == null) {
    throw new Error("containers do not exist for key '" + key + "'");}
  var containers = new Array;
  var browsers = this._tabBrowser.browsers;
  for(var i = 0;i < browsers.length;i ++ ) {
    var browser = browsers[i];
    if(browser[_GPTD_TAG_PROP] == null) {
      this._initNewTab(browser)}
    var tabData = browser[_GPTD_PREFIX + key];
    if(typeof tabData != "object" || tabData == null) {
      throw new Error("container does not exist for key '" + key + "' (tab index " + i + ")");}
    containers.push(tabData)}
  return containers}

, destroyContainers:function(key) {
  if(this._keys[key] == null) {
    throw new Error("containers do not exist for key '" + key + "'");}
  delete this._keys[key];
  var browsers = this._tabBrowser.browsers;
  for(var i = 0;i < browsers.length;i ++ ) {
    browsers[i].removeAttribute(_GPTD_PREFIX + key)}
}

, getSelectedTabIndex:function() {
  return this._tabBrowser.mTabBox.selectedIndex}

, getSelectedTabContainer:function(key) {
  var containers = this.getContainers(key);
  var idx = this.getSelectedTabIndex();
  return containers[idx]}

, onPageLoad:function(event) {
  var contentDocument = event.target;
  if(!contentDocument) {
    return}
  if(contentDocument.nodeName != "#document") {
    GTB_Dump(GTB_Dump.PT, "GPTD ignoring page load since it is not a document -- it is " + contentDocument.nodeName + "\n");
    return}
  var browser;
  var browsers = this._tabBrowser.browsers;
  var tabIndex = null;
  for(var i = 0;i < browsers.length;i ++ ) {
    if(browsers[i].contentDocument == contentDocument) {
      browser = browsers[i];
      tabIndex = i;
      break}
  }
  if(tabIndex == null) {
    return}
  if(browser[_GPTD_TAG_PROP] == null) {
    this._initNewTab(browser)}
  var message = "GPTD_PAGELOAD";
  var optData = tabIndex.toString();
  GTB_GoogleToolbarOverlay.sendMessage(message, optData)}

, onPageUnload:function(event) {
  var browser = event.currentTarget;
  var browser_str = browser.toString();
  if(this._tabBrowser.browsers.length < this._numOpenTabs) {
    this._numOpenTabs -- }
}

, _initNewTab:function(browser) {
  GPTD_dump("we've got a new browser tab " + browser.toString());
  this._numOpenTabs ++ ;
  this._addContainersToBrowser(browser);
  browser[_GPTD_TAG_PROP] = true;
  browser.addEventListener("unload", function(event) {
    GTB_perTabData().onPageUnload(event)}

  , true)}

, _addContainersToBrowser:function(browser) {
  for(var key in this._keys) {
    this._addContainerToBrowser(browser, key)}
}

, _addContainerToBrowser:function(browser, key) {
  var prefixed_key = _GPTD_PREFIX + key;
  if(browser[prefixed_key] != null) {
    throw new Error("container already exists for key '" + key + "' in browser " + browser.toString());}
  GPTD_dump("adding key '" + key + "' to tab " + browser.toString());
  browser[prefixed_key] = new Object}

};
function GTB_SearchUrl(prefix, host, restrict, query, opt_options) {
  var queryParts = [];
  queryParts.push("sourceid=navclient-ff");
  queryParts.push("ie=UTF-8");
  var installWeek = GTB_GetInstallWeek();
  var brand = GTB_getPrefs().getLocalMachineString("brand");
  if(brand == null)brand = "GGGL";
  queryParts.push("rls=" + brand + "," + brand + ":" + installWeek + "," + brand + ":" + GTB_GoogleToolbarOverlay.languageCode);
  if(opt_options && opt_options.lucky) {
    queryParts.push("btnI=I")}
  if(query && query != "") {
    var encoded = encodeURIComponent(query).replace(/\%20/g, "+");
    if(opt_options && opt_options.site != null) {
      encoded = "site:" + encodeURIComponent(opt_options.site) + "+" + encoded}
    queryParts.push("q=" + encoded)}
  return GTB_ComposeUrl(prefix, host, restrict, queryParts)}

function GTB_GetInstallWeek() {
  var installTime = GTB_getPrefs().getLocalMachineString("installtime");
  if(installTime == null) {
    var today = new Date;
    installTime = today.getTime().toString();
    GTB_getPrefs().setLocalMachineString("installtime", installTime)}
  var installDate = new Date;
  installDate.setTime(parseFloat(installTime));
  var newYearDate = new Date;
  newYearDate.setFullYear(parseInt(installDate.getFullYear()), 1, 1);
  var delta = installDate.getTime() - newYearDate.getTime();
  var week = Math.floor(delta / 604800000) + 1;
  return installDate.getFullYear() + "-" + week}

function GTB_ComposeUrl(prefix, host, restrict, searchStringTerms) {
  var parts = [];
  parts.push("http://");
  parts.push(prefix);
  parts.push(host.substr(3));
  parts.push("/");
  parts.push(restrict);
  parts.push("?");
  parts.push(searchStringTerms.join("&"));
  return parts.join("")}

function GTB_DictionaryUrl(host, text, lang, hl) {
  var queryParts = [];
  queryParts.push("sourceid=navclient-ff");
  queryParts.push("ie=UTF-8");
  queryParts.push("oe=UTF-8");
  queryParts.push("text=" + text);
  queryParts.push("langpair=" + lang);
  queryParts.push("hl=" + hl);
  queryParts.push("sig=8" + GTB_PageRank.GPR_awesomeHash(text));
  return GTB_ComposeUrl("www", host, "tbproxy/dictionary", queryParts)}

function GTB_InfoUrl(host, op, url) {
  var queryParts = [];
  queryParts.push("sourceid=navclient-ff");
  queryParts.push("ie=UTF-8");
  queryParts.push("q=" + op + encodeURIComponent(url));
  return GTB_ComposeUrl("www", host, "search", queryParts)}

function GTB_TranslateUrl(lang, url) {
  var queryParts = [];
  queryParts.push("sourceid=navclient-ff");
  queryParts.push("hl=" + lang);
  queryParts.push("u=" + encodeURIComponent(url));
  return GTB_ComposeUrl("translate", "www.google.com", "translate", queryParts)}

function GTB_SearchType(name, image, label, tip, url) {
  this.name = name;
  this.image = image;
  this.label = label;
  this.tip = tip;
  this.url = url}

GTB_SearchType.prototype.name = null;
GTB_SearchType.prototype.image = null;
GTB_SearchType.prototype.url = null;
function GTB_GoogleSearchType(name, image, bundle, opt_options) {
  var label = bundle.getString("prop.gtb." + name);
  var tip = bundle.getString("prop.gtb." + name + ".tip");
  return new GTB_SearchType(name, image, label, tip, function(query, home) {
    return GTB_SearchUrl("www", home, "search", query, opt_options)}

  )}

function GTB_StandardSearchType(name, image, bundle) {
  var label = bundle.getString("prop.gtb." + name);
  var tip = bundle.getString("prop.gtb." + name + ".tip");
  return new GTB_SearchType(name, image, label, tip, function(query, home) {
    return GTB_SearchUrl(name, home, name, query)}

  )}

function GTB_CustomSearchType(cs, index) {
  var customSearch = cs._searches[index];
  var lambda = function(query, home) {
    return cs.getCustomSearchURL(index, query)}

  ;
  var label = customSearch.title;
  var tip = customSearch.tip;
  if(!tip) {
    tip = label}
  return new GTB_SearchType("GTB_Custom_Search_" + index, customSearch.icon, label, tip, lambda)}

var validTldList = ".com.edu.net.org.gov.mil.jp.de.au.in.uk.fr.ca.dk.it.cn.kr.int.arpa.nato.biz.name.museum.pro.aero.coop.info.ac.ad.ae.af.ag.ai.al.am.an.ao.aq.ar.as.at.au.aw.az.ba.bb.bd.be.bf.bg.bh.bi.bj.bm.bn.bo.br.bs.bt.bv.bw.by.bz.ca.cc.cd.cf.cg.ch.ci.ck.cl.cm.cn.co.cr.cu.cv.cx.cy.cz.de.dj.dk.dm.do.dz.ec.ee.eg.eh.er.es.et.fi.fj.fk.fm.fo.fr.ga.gd.ge.gf.gg.gh.gi.gl.gm.gn.gp.gq.gr.gs.gt.gu.gw.gy.hk.hm.hn.hr.ht.hu.id.ie.il.im.in.io.iq.ir.is.it.je.jm.jo.jp.ke.kg.kh.ki.km.kn.kp.kr.kw.ky.kz.la.lb.lc.li.lk.lr.ls.lt.lu.lv.ly.ma.mc.md.mg.mh.mk.ml.mm.mn.mo.mp.mq.mr.ms.mt.mu.mv.mw.mx.my.mz.na.nc.ne.nf.ng.ni.nl.no.np.nr.nu.nz.om.pa.pe.pf.pg.ph.pk.pl.pm.pn.pr.ps.pt.pw.py.qa.re.ro.ru.rw.sa.sb.sc.sd.se.sg.sh.si.sj.sk.sl.sm.sn.so.sr.st.sv.sy.sz.tc.td.tf.tg.th.tj.tk.tm.tn.to.tp.tr.tt.tv.tw.tz.ua.ug.uk.um.us.uy.uz.va.vc.ve.vg.vi.vn.vu.wf.ws.ye.yt.yu.za.zm.zw."
;
function GTB_LooksLikeUrl(str) {
  if(str.search(/\s/) != -1) {
    return false}
  if(str.indexOf("http://") == 0 || str.indexOf("https://") == 0 || str.indexOf("ftp://") == 0) {
    return true}
  var hostnameEnd = str.indexOf("/");
  if(hostnameEnd == -1) {
    hostnameEnd = str.length}
  var hostname = str.substr(0, hostnameEnd);
  if(hostname.search(/[^_a-zA-Z0-9\*\-\.]/) != -1) {
    return false}
  var lastDot = hostname.lastIndexOf(".");
  if(lastDot == -1) {
    return false}
  var tld = hostname.substring(lastDot, hostname.length);
  if(validTldList.indexOf(tld + ".") == -1) {
    return false}
  return true}

function GTB_IsOnline() {
  var ioService = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
  if(ioService.offline) {
    return false}
  try {
    var connectClass = Components.classes["@google.com/connectutil;1"];
    if(!connectClass) {
      return true}
    var connectUtil = connectClass.createInstance(Components.interfaces.GTBIConnectUtil);
    if(!connectUtil) {
      return true}
    return connectUtil.isOnline()}
  catch(e) {
    return true}
}

function GTB_GenerateId() {
  var id = "";
  var values = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"];
  for(var index = 0;index < 44;index ++ ) {
    id += values[Math.floor(Math.random() * values.length)]}
  return id}

function GTB_GetId() {
  var id = null;
  var id = GTB_getPrefs().getLocalMachineString("id");
  if(id) {
    GTB_getPrefs().setStringPref(GTB_PREF_INSTALL_ID, id);
    return id}
  try {
    id = GTB_getPrefs().getStringPref(GTB_PREF_INSTALL_ID)}
  catch(exception) {
    id = null}
  if(id)return id;
  id = GTB_GenerateId();
  GTB_getPrefs().setStringPref(GTB_PREF_INSTALL_ID, id);
  GTB_getPrefs().setLocalMachineString("id", id);
  return id}

function GTB_ComposeDailyPingUrl() {
  var firstsearch = "";
  if(GTB_getPrefs().hasUserValue(GTB_PREF_FIRST_SEARCH)) {
    if(GTB_getPrefs().getBoolPref(GTB_PREF_FIRST_SEARCH)) {
      if(GTB_getPrefs().getLocalMachineString("sentfs")) {
        GTB_getPrefs().setBoolPref(GTB_PREF_FIRST_SEARCH, false)}
      else {
        var numTries = GTB_getPrefs().getIntPrefWithDefault(GTB_PREF_FIRST_SEARCH_PING_RETRIES, 0);
        if(numTries < 14) {
          firstsearch = "fs=1&";
          GTB_getPrefs().setIntPref(GTB_PREF_FIRST_SEARCH_PING_RETRIES, numTries + 1)}
      }
    }
  }
  var install = "";
  if(!GTB_getPrefs().getBoolPrefWithDefault(GTB_PREF_INSTALL_PING_ACKED, false)) {
    if(GTB_getPrefs().getLocalMachineString("sent")) {
      GTB_getPrefs().setBoolPref(GTB_PREF_INSTALL_PING_ACKED, true)}
    else {
      var numTries = GTB_getPrefs().getIntPrefWithDefault(GTB_PREF_INSTALL_PING_RETRIES, 0);
      if(numTries < 14) {
        install = "install=1&";
        GTB_getPrefs().setIntPref(GTB_PREF_INSTALL_PING_RETRIES, numTries + 1)}
    }
  }
  var home = GTB_getPrefs().getStringPref(GTB_PREF_GOOGLE_HOME);
  var homePrefix = "www.google.";
  var tld = home.slice(homePrefix.length, home.length);
  var guid = GTB_GetId();
  var brand = GTB_getPrefs().getLocalMachineString("brand");
  if(brand == null)brand = "GGGL";
  var url = "http://www.google.com/tools/toolbar/service/update?as=tbff&id=" + guid + "&" + install + firstsearch + "version=2.0.20060515&hl=" + GTB_GoogleToolbarOverlay.languageCode + "&tbbrand=" + brand + "&sd=" + tld + "&os=" + encodeURIComponent(window.navigator.platform) + "&browser=" + encodeURIComponent(window.navigator.productSub);
  return url}

function GTB_SendDailyPing() {
  try {
    var lastPing = parseFloat(GTB_getPrefs().getStringPref(GTB_LAST_PING_ATTEMPT));
    var now = new Date;
    if(now.valueOf() - lastPing < 86400000) {
      return}
  }
  catch(e) {
  }
  if(!GTB_IsOnline()) {
    return}
  try {
    var xmlhttp = new XMLHttpRequest;
    var dailyPingUrl = GTB_ComposeDailyPingUrl();
    xmlhttp.open("GET", dailyPingUrl, true);
    new PROT_CookieStripper(xmlhttp.channel)}
  catch(exception) {
    return}
  xmlhttp.onreadystatechange = function() {
    try {
      if(xmlhttp.readyState == 4) {
        if(xmlhttp.status == 200) {
          var response = xmlhttp.responseText;
          if(response != null) {
            var url = null;
            var version = null;
            var lines = response.split("\n");
            for(var index in lines) {
              var line = lines[index];
              var keyvalue = line.split(": ");
              if(keyvalue.length == 2) {
                switch(keyvalue[0]) {
                  case "Url":url = keyvalue[1];
                  break;
                  case "Version":version = keyvalue[1];
                  break;
                  case "Protocol":GTB_getPrefs().setBoolPref(GTB_PREF_INSTALL_PING_ACKED, true);
                  GTB_getPrefs().setLocalMachineString("sent", "1");
                  if(GTB_getPrefs().hasUserValue(GTB_PREF_FIRST_SEARCH) && GTB_getPrefs().getBoolPref(GTB_PREF_FIRST_SEARCH)) {
                    GTB_getPrefs().setBoolPref(GTB_PREF_FIRST_SEARCH, false);
                    GTB_getPrefs().setLocalMachineString("sentfs", "1")}
                }
              }
            }
            if(version != null && version != "2.0.20060515" && url != null && true) {
              GTB_DoXpiInstall(url)}
          }
        }
      }
    }
    catch(exception) {
    }
  }

  ;
  try {
    xmlhttp.setRequestHeader("Accept", "*/*");
    xmlhttp.send(null);
    var now = new Date;
    GTB_getPrefs().setStringPref(GTB_LAST_PING_ATTEMPT, now.valueOf().toString())}
  catch(exception) {
  }
  var cookieService = Components.classes["@mozilla.org/cookieService;1"].getService(Components.interfaces.nsICookieService);
  var ios = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
  var google = ios.newURI("http://www.google.com", null, null);
  var cookieString = cookieService.getCookieString(google, null);
  if(cookieString == null || cookieString.toUpperCase().indexOf("TB=2") == -1) {
    try {
      var cookieRequest = new XMLHttpRequest;
      cookieRequest.open("GET", "http://www.google.com/url?sa=p&pref=tb&pval=2&q=", true);
      cookieRequest.send(null);
      cookieRequest.onload = function() {
      }

    }
    catch(e) {
    }
  }
}

function GTB_DoXpiInstall(xpiUrl) {
  try {
    var dir = Components.classes["@mozilla.org/file/directory_service;1"].getService(Components.interfaces.nsIProperties).get("ProfD", Components.interfaces.nsIFile);
    dir.append("extensions");
    dir.append("staged-xpis");
    dir.append("{3112ca9c-de6d-4884-a869-9855de68056c}");
    if(dir.exists()) {
      dir.remove(true)}
  }
  catch(e) {
  }
  var manager = Components.classes["@mozilla.org/xpinstall/install-manager;1"].createInstance(Components.interfaces.nsIXPInstallManager);
  if(manager != null) {
    var items = [xpiUrl];
    var installProgress = {onStateChange:function(index, state, value) {
    }

    , onProgress:function(index, value, maxValue) {
    }

    };
    manager.initManagerFromChrome(items, items.length, installProgress)}
}

function PROT_CookieStripper(channel) {
  this.topic_ = "http-on-modify-request";
  this.channel_ = channel;
  var Cc = Components.classes;
  var Ci = Components.interfaces;
  this.observerService_ = Cc["@mozilla.org/observer-service;1"].getService(Ci.nsIObserverService);
  this.observerService_.addObserver(this, this.topic_, false);
  var twentySeconds = 20000;
  this.alarm_ = setTimeout(GTB_hitch(this, this.stopObserving), twentySeconds)}

PROT_CookieStripper.prototype.observe = function(subject, topic, data) {
  if(topic != this.topic_ || subject != this.channel_)return;
  this.channel_.QueryInterface(Components.interfaces.nsIHttpChannel);
  this.channel_.setRequestHeader("Cookie", "", false);
  clearTimeout(this.alarm_);
  this.stopObserving()}

;
PROT_CookieStripper.prototype.stopObserving = function() {
  this.observerService_.removeObserver(this, this.topic_);
  this.channel_ = (this.alarm_ = (this.observerService_ = null))}

;
PROT_CookieStripper.prototype.QueryInterface = function(iid) {
  var Ci = Components.interfaces;
  if(iid.equals(Ci.nsISupports) || iid.equals(Ci.nsIObserve))return this;
  throw Components.results.NS_ERROR_NO_INTERFACE;}

;
var GTBSC_MENU_PREFIX = "gtbspellmenu";
var GTBSC_POPUPMENU_ID = "gtbSpellcheckPopup";
var GTBSC_MISSPELL_SPAN_PREFIX = "gtbmisp";
var GTBSC_EDIT = "sc_edit";
var GTBSC_CHECK = "sc_check";
var GTBSC_PREF_PREFIX = "spell_check.";
var GTBSC_DICT_PREF_PREFIX = GTBSC_PREF_PREFIX + "dictionary.";
var GTBSC_CONTAINER_TAG = "spell_check";
function GTBSC_dump(s) {
}

function GetPageOffset(el) {
  var x = el.offsetLeft;
  var y = el.offsetTop;
  if(el.offsetParent != null) {
    var pos = GetPageOffset(el.offsetParent);
    x += pos.x;
    y += pos.y}
  return{x:x, y:y}}

function TrimLeft(str) {
  return str.replace(/^\s+/, "")}

function TrimRight(str) {
  return str.replace(/\s+$/, "")}

function Trim(str) {
  return TrimRight(TrimLeft(str))}

function getElementByIdAcrossFrames(win, id) {
  var el;
  if(win && win.document) {
    el = win.document.getElementById(id);
    if(el) {
      return el}
  }
  if(win && win.frames) {
    for(var i = 0;i < win.frames.length;i ++ ) {
      el = getElementByIdAcrossFrames(win.frames[i], id);
      if(el) {
        return el}
    }
  }
  return el}

function GTBSC_GetAnonymousDivFromTextbox(textbox) {
  var div = null;
  try {
    div = textbox.QueryInterface(Components.interfaces.nsIDOMNSEditableElement).editor.rootElement;
    if(div) {
      return div}
  }
  catch(e) {
  }
  var acs = Components.classes["@google.com/anonymous-content-service;1"].getService(Components.interfaces.GTBIAnonymousContentService);
  var nodes = null;
  try {
    nodes = acs.getAnonymousContent(textbox)}
  catch(e) {
  }
  if(nodes) {
    div = nodes.getNext()}
  return div}

function GTBSC_RemoveSpansFromTextbox(node) {
  var doc = node.ownerDocument;
  var textToAppend = "";
  for(var child = node.childNodes.length - 1;child >= 0;child -- ) {
    if(node.childNodes[child].nodeType == Node.TEXT_NODE) {
      textToAppend = node.childNodes[child].nodeValue + textToAppend;
      node.removeChild(node.childNodes[child])}
    else if(node.childNodes[child].nodeName.toLowerCase() == "span" && (GTBSC_startsWith(node.childNodes[child].id, GTBSC_MISSPELL_SPAN_PREFIX) || GTBSC_startsWith(node.childNodes[child].id, "gtbunch"))) {
      textToAppend = node.childNodes[child].firstChild.nodeValue + textToAppend;
      node.removeChild(node.childNodes[child])}
    else if(node.childNodes[child].nodeName.toLowerCase() == "input") {
      textToAppend = node.childNodes[child].value + textToAppend;
      node.removeChild(node.childNodes[child])}
    else if(node.childNodes[child].nodeName.toLowerCase() == "br" && textToAppend != "") {
      if(node.childNodes[child].nextSibling) {
        node.insertBefore(doc.createTextNode(textToAppend), node.childNodes[child].nextSibling)}
      else {
        node.appendChild(doc.createTextNode(textToAppend))}
      textToAppend = ""}
    else {
      if(textToAppend != "") {
        if(node.childNodes[child].nextSibling) {
          node.insertBefore(doc.createTextNode(textToAppend), node.childNodes[child].nextSibling)}
        else {
          node.appendChild(doc.createTextNode(textToAppend))}
        textToAppend = ""}
      GTBSC_RemoveSpansFromTextbox(node.childNodes[child])}
  }
  if(textToAppend != "") {
    if(node.childNodes.length > 0) {
      node.insertBefore(doc.createTextNode(textToAppend), node.childNodes[0])}
    else {
      node.appendChild(doc.createTextNode(textToAppend))}
  }
}

function GTBSC_startsWith(largerString, smallerString) {
  if(largerString.length < smallerString.length) {
    return false}
  if(largerString.substring(0, smallerString.length) == smallerString) {
    return true}
  return false}

function GTBSC_getMode() {
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  var mode = tabData.mode;
  if(!mode)mode = GTBSC_EDIT;
  return mode}

function GTBSC_setMode(mode) {
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  tabData.mode = mode;
  if(mode == GTBSC_CHECK) {
    GTB_SpellCheck._toggleSpellCheckButton(true)}
  else {
    GTB_SpellCheck._toggleSpellCheckButton(false)}
}

function GTBSC_getIsAutoFix() {
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  var isAutoFix = tabData.isAutoFix;
  if(isAutoFix == null)isAutoFix = false;
  return isAutoFix}

function GTBSC_setIsAutoFix(isAutoFix) {
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  tabData.isAutoFix = isAutoFix;
  if(isAutoFix) {
    GTB_SpellCheck._toggleAutoFixLabel(true)}
  else {
    GTB_SpellCheck._toggleAutoFixLabel(false)}
}

function GTBSC_getTextareasAcrossFrames(win, textareasByFrame) {
  if(win && win.document) {
    textareasByFrame[textareasByFrame.length] = win.document.getElementsByTagName("textarea")}
  if(win && win.frames) {
    for(var i = 0;i < win.frames.length;i ++ ) {
      textareasByFrame = GTBSC_getTextareasAcrossFrames(win.frames[i], textareasByFrame)}
  }
  return textareasByFrame}

function GTBSC_getTextinputsAcrossFrames(win, textinputsByFrame) {
  if(win && win.document) {
    textinputsByFrame[textinputsByFrame.length] = win.document.getElementsByTagName("input")}
  if(win && win.frames) {
    for(var i = 0;i < win.frames.length;i ++ ) {
      textinputsByFrame = GTBSC_getTextinputsAcrossFrames(win.frames[i], textinputsByFrame)}
  }
  return textinputsByFrame}

function GTBSC_getDesignModeDocs(win, designmode) {
  if(win && win.document && win.document.body) {
    var dm = win.document.designMode;
    if(dm == "on") {
      designmode[designmode.length] = win.document.body}
  }
  if(win && win.frames) {
    for(var i = 0;i < win.frames.length;i ++ ) {
      designmode = GTBSC_getDesignModeDocs(win.frames[i], designmode)}
  }
  return designmode}

function GTBSC_getSpellText(win, switchToCheckMode) {
  var blocks = new GTBSC_TextBlockifier;
  win.focus();
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  tabData.textareas = [];
  tabData.textinputs = [];
  tabData.designmode = [];
  var textareasByFrame = GTBSC_getTextareasAcrossFrames(win, []);
  var textinputsByFrame = GTBSC_getTextinputsAcrossFrames(win, []);
  var designModeDocs = GTBSC_getDesignModeDocs(win, []);
  var blockIndex, tabDataIndex;
  for(var frame = 0;frame < textareasByFrame.length;frame ++ ) {
    var textareas = textareasByFrame[frame];
    for(var i = 0;i < textareas.length;i ++ ) {
      if(textareas[i].disabled || textareas[i].readOnly) {
        continue}
      tabDataIndex = tabData.textareas.length;
      blockIndex = blocks.addBlock(textareas[i].value, tabDataIndex, 1);
      if(switchToCheckMode) {
        GTBSC_toggleBoxToCheckMode(textareas[i], blockIndex, 1)}
      tabData.textareas[tabDataIndex] = textareas[i]}
  }
  for(var frame = 0;frame < textinputsByFrame.length;frame ++ ) {
    var textinputs = textinputsByFrame[frame];
    for(i = 0;i < textinputs.length;i ++ ) {
      if(textinputs[i].type == "text") {
        if(textinputs[i].disabled || textinputs[i].readOnly) {
          continue}
        tabDataIndex = tabData.textinputs.length;
        blockIndex = blocks.addBlock(textinputs[i].value, tabDataIndex, 0);
        if(switchToCheckMode) {
          GTBSC_toggleBoxToCheckMode(textinputs[i], blockIndex, 0)}
        tabData.textinputs[tabDataIndex] = textinputs[i]}
    }
  }
  for(var i = 0;i < designModeDocs.length;i ++ ) {
    var allText = GTBSC_getNodeText(designModeDocs[i]);
    blockIndex = blocks.addBlock(allText, i, 2);
    if(switchToCheckMode) {
      GTBSC_toggleBoxToCheckMode(designModeDocs[i], blockIndex, 2)}
    tabData.designmode[tabData.designmode.length] = designModeDocs[i]}
  return blocks}

function GTBSC_toggleBoxToCheckMode(editBox, blockIndex, inputBoxType) {
  var doc = editBox.ownerDocument;
  var win = doc && doc.defaultView;
  if(!win) {
    GTB_Dump(GTB_Dump.SC, "unable to get editbox window");
    return}
  var computed_style = win.getComputedStyle(editBox, "");
  if(computed_style) {
    editBox.setAttribute("GTB_oldBackgroundColor", computed_style["backgroundColor"]);
    editBox.setAttribute("GTB_oldColor", computed_style["color"]);
    editBox.style["backgroundColor"] = "#e8f1ff";
    editBox.style["color"] = "black";
    if(2 == inputBoxType) {
      if(editBox.ownerDocument) {
        editBox.ownerDocument.designMode = "off"}
    }
    else {
      editBox.readOnly = true}
    editBox.addEventListener("click", GTBSC_showStopSpellCheckMenu, false)}
}

function GTBSC_toggleToEdit() {
  var win = GTB_getToolbar()._getCurrentWindow();
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  if(tabData.editWord) {
    tabData.editWord.removeEditBox()}
  var textareas = [];
  var input, i;
  for(i = 0;input = tabData.textareas[i]; ++ i) {
    textareas.push(input)}
  for(i = 0;input = tabData.textinputs[i]; ++ i) {
    if(input.type == "text") {
      textareas.push(input)}
  }
  var designmode = tabData.designmode;
  var div;
  for(var i = 0;i < textareas.length;i ++ ) {
    textareas[i].style.backgroundColor = textareas[i].getAttribute("GTB_oldBackgroundColor");
    textareas[i].style.color = textareas[i].getAttribute("GTB_oldColor");
    textareas[i].removeAttribute("GTB_oldBackgroundColor");
    textareas[i].removeAttribute("GTB_oldColor");
    textareas[i].readOnly = false;
    textareas[i].removeEventListener("click", GTBSC_showStopSpellCheckMenu, false);
    div = GTBSC_GetAnonymousDivFromTextbox(textareas[i]);
    if(div) {
      GTBSC_RemoveSpansFromTextbox(div)}
  }
  for(var k = 0;k < designmode.length;k ++ ) {
    designmode[k].style.backgroundColor = designmode[k].getAttribute("GTB_oldBackgroundColor");
    designmode[k].style.color = designmode[k].getAttribute("GTB_oldColor");
    designmode[k].removeAttribute("GTB_oldBackgroundColor");
    designmode[k].removeAttribute("GTB_oldColor");
    if(designmode[k].ownerDocument) {
      try {
        designmode[k].ownerDocument.designMode = "on"}
      catch(e) {
      }
    }
    designmode[k].removeEventListener("click", GTBSC_showStopSpellCheckMenu, false);
    GTBSC_RemoveSpansFromTextbox(designmode[k])}
  win.focus();
  GTBSC_setIsAutoFix(false);
  GTBSC_setMode(GTBSC_EDIT)}

function GTBSC_getNodeText(node) {
  var text = [];
  for(var c = 0;c < node.childNodes.length;c ++ ) {
    var child = node.childNodes[c];
    text[text.length] = GTBSC_getNodeText(child)}
  if(node.nodeType == 3) {
    text[text.length] = node.nodeValue}
  if(node.tagName) {
    if(node.tagName == "INPUT") {
      text[text.length] = Trim(node.value)}
    if(node.tagName == "BR") {
      text[text.length] = "\n"}
  }
  return text.join("")}

function GTBSC_appendText(node, text) {
  var doc = node.ownerDocument;
  node.appendChild(doc.createTextNode(text))}

function GTBSC_setDefaultStyle(node) {
  node.style.font = "normal normal normal 100% serif";
  node.style.border = "0";
  node.style.position = "static";
  node.style.background = "transparent none";
  node.style.margin = "0";
  node.style.padding = "0";
  node.style.whitespace = "normal";
  node.style.textAlign = "left";
  node.style.textIndent = 0;
  node.style.textTransform = "none";
  node.style.color = "#000";
  node.style.textDecoration = "none";
  node.style.cursor = "default"}

function GTBSC_spanAroundText(node, text, opt_beforeNode) {
  var doc = GTB_getToolbar()._getCurrentDocument();
  var span = doc.createElement("span");
  GTBSC_setDefaultStyle(span);
  GTBSC_appendText(span, text);
  if(opt_beforeNode) {
    node.insertBefore(span, opt_beforeNode)}
  else {
    node.appendChild(span)}
  return span}

function GTBSC_createMisspellSpan(node, endIndex, misspelled, id, indexes) {
  var doc = node.ownerDocument;
  for(var i = 0;i < node.childNodes.length;i ++ ) {
    if(node.childNodes[i].nodeType == Node.TEXT_NODE) {
      var textStart = indexes.currentIndex;
      indexes.currentIndex += node.childNodes[i].nodeValue.length;
      var textEnd = indexes.currentIndex;
      if(textEnd > indexes.startIndex) {
        var textNode1Val = node.childNodes[i].nodeValue.substring(0, indexes.startIndex - textStart);
        var textNode2Val = node.childNodes[i].nodeValue.substr(endIndex - textStart);
        var misspelledText = node.childNodes[i].nodeValue.substring(indexes.startIndex - textStart, endIndex - indexes.startIndex);
        if(endIndex - indexes.startIndex < misspelled.length) {
          node.childNodes[i].nodeValue = textNode2Val}
        else {
          node.childNodes[i].nodeValue = textNode1Val;
          var newTextNode = doc.createTextNode(textNode2Val);
          if(node.childNodes[i].nextSibling) {
            node.insertBefore(newTextNode, node.childNodes[i].nextSibling)}
          else {
            node.appendChild(newTextNode)}
          var misspellSpan = GTBSC_spanAroundText(node, misspelled, newTextNode);
          GTBSC_setMisspellStyle(misspellSpan);
          misspellSpan.id = GTBSC_MISSPELL_SPAN_PREFIX + "_" + id;
          misspellSpan.addEventListener("click", GTBSC_spellListSuggestions, false);
          i += 2}
        if(textEnd >= endIndex) {
          return true}
        else {
          indexes.startIndex += misspelledText.length}
      }
    }
    else if(node.childNodes[i].nodeName.toLowerCase() == "span" && GTBSC_startsWith(node.childNodes[i].id, GTBSC_MISSPELL_SPAN_PREFIX)) {
      indexes.currentIndex += node.childNodes[i].firstChild.nodeValue.length}
    else if(node.childNodes[i].nodeName.toLowerCase() == "br") {
      indexes.currentIndex ++ }
    else {
      if(GTBSC_createMisspellSpan(node.childNodes[i], endIndex, misspelled, id, indexes)) {
        return true}
    }
  }
  return false}

function GTBSC_editWordBox(misspellSpan) {
  this.misspellSpan = misspellSpan;
  var doc = misspellSpan.ownerDocument;
  this.editBox = doc.createElement("input");
  this.editBox.type = "text";
  this.editBox.size = parseInt(misspellSpan.firstChild.data.length) + 10;
  this.editBox.value = misspellSpan.firstChild.data;
  this.onKeydown = GTB_hitch(this, this.doKeydown);
  this.onKeypress = GTB_hitch(this, this.doKeypress);
  this.editBox.addEventListener("click", GTBSC_stopPropagation, false);
  this.editBox.addEventListener("keydown", this.onKeydown, false);
  this.editBox.addEventListener("keypress", this.onKeypress, false);
  misspellSpan.parentNode.insertBefore(this.editBox, misspellSpan);
  misspellSpan.style.display = "none";
  this.editBox.focus()}

GTBSC_editWordBox.prototype._removeEventListeners = function() {
  this.editBox.removeEventListener("click", GTBSC_stopPropagation, false);
  this.editBox.removeEventListener("keydown", this.onKeydown, false);
  this.editBox.removeEventListener("keypress", this.onKeypress, false)}

;
GTBSC_editWordBox.prototype.doKeydown = function(ev) {
  if(ev.keyCode == KeyEvent.DOM_VK_RETURN) {
    ev.preventDefault();
    this.removeEditBox()}
}

;
GTBSC_editWordBox.prototype.doKeypress = function(ev) {
  if(ev.keyCode == KeyEvent.DOM_VK_ESCAPE) {
    this.removeEditBox()}
}

;
GTBSC_editWordBox.prototype.removeEditBox = function() {
  this._removeEventListeners();
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  var idComponents = this.misspellSpan.id.split("_");
  var originalWord = tabData.originalWords[idComponents[1]];
  this.misspellSpan.firstChild.data = this.editBox.value;
  var color = "green";
  if(this.editBox.value == originalWord) {
    color = "red"}
  this.misspellSpan.style.color = color;
  this.misspellSpan.style.display = "";
  this.editBox.parentNode.removeChild(this.editBox);
  tabData.editWord = null}

;
function GTBSC_stopPropagation(event) {
  event.stopPropagation();
  event.target.focus()}

function GTBSC_showStopSpellCheckMenu(event) {
  var stringBundle = document.getElementById("google-toolbar-strings");
  var popup = GTBSC_createPopupMenu(GTBSC_POPUPMENU_ID);
  popup.addEventListener("command", GTBSC_toggleToEdit, false);
  var menuitem = document.createElement("menuitem");
  popup.appendChild(menuitem);
  var editingDisabledString = stringBundle.getString("prop.gtb.spelling.editingdisabled");
  menuitem.setAttribute("label", editingDisabledString);
  menuitem.setAttribute("disabled", true);
  popup.appendChild(document.createElement("menuseparator"));
  menuitem = document.createElement("menuitem");
  popup.appendChild(menuitem);
  var stopCheckingString = stringBundle.getString("prop.gtb.spelling.stopchecking");
  menuitem.setAttribute("label", stopCheckingString);
  var anchor = GTB_getToolbar()._getCurrentBrowser();
  document.popupNode = anchor;
  var xpos = event.screenX - anchor.boxObject.screenX + anchor.boxObject.x;
  var ypos = event.screenY - anchor.boxObject.screenY + anchor.boxObject.y;
  popup.showPopup(anchor, xpos, ypos, "popup")}

function GTBSC_createPopupMenu(id) {
  var popup = document.getElementById(id);
  if(!popup) {
    var popup = document.createElement("popup");
    var popupset = document.getElementById("mainPopupSet");
    popupset.appendChild(popup);
    popup.setAttribute("id", id)}
  else {
    while(popup.hasChildNodes()) {
      popup.removeChild(popup.firstChild)}
    popup.removeEventListener("command", GTBSC_toggleToEdit, false);
    popup.removeEventListener("command", GTBSC_onCommandSuggestion, false)}
  return popup}

function GTBSC_showAlertMessage(msg) {
  GTB_TT_XULTooltipAlert(GTB_SpellCheck._getSpellCheckButton(), msg, false)}

function GTBSC_setMisspellStyle(misspellSpan) {
  var parent = misspellSpan.parentNode;
  while(parent && parent.nodeName.toLowerCase() != "input" && parent.nodeName.toLowerCase() != "textarea") {
    parent = parent.parentNode}
  if(parent) {
    var doc = misspellSpan.ownerDocument;
    var computed_style = doc.defaultView.getComputedStyle(parent, "");
    misspellSpan.style.font = computed_style.font}
  misspellSpan.style.color = "red";
  misspellSpan.style.textDecoration = "underline";
  misspellSpan.style.fontWeight = "bold";
  misspellSpan.style.cursor = "pointer"}

function GTBSC_setDimmedSpanStyle(uncheckedSpan) {
  var parent = uncheckedSpan.parentNode;
  while(parent && parent.nodeName.toLowerCase() != "input" && parent.nodeName.toLowerCase() != "textarea") {
    parent = parent.parentNode}
  if(parent) {
    var doc = uncheckedSpan.ownerDocument;
    var computed_style = doc.defaultView.getComputedStyle(parent, "");
    uncheckedSpan.style.font = computed_style.font}
  uncheckedSpan.style.color = "#AAA"}

function GTBSC_correctAllInstances(tabData, correctWord) {
  var win = GTB_getToolbar()._getCurrentWindow();
  var positions = tabData.misspelledWords.getWordValues(correctWord);
  for(var i in positions) {
    var thisSpan = getElementByIdAcrossFrames(win, GTBSC_MISSPELL_SPAN_PREFIX + "_" + positions[i]);
    GTBSC_removeMisspellStyle(thisSpan);
    thisSpan.removeEventListener("click", GTBSC_spellListSuggestions, false)}
}

function GTBSC_removeMisspellStyle(misspellSpan) {
  misspellSpan.style.color = "black";
  misspellSpan.style.textDecoration = "";
  misspellSpan.style.fontWeight = "";
  misspellSpan.style.cursor = "default"}

function GTBSC_spellListSuggestions(event) {
  if(event.button == 0) {
    var win = GTB_getToolbar()._getCurrentWindow();
    var misspellSpan = event.target;
    var idComponents = misspellSpan.id.split("_");
    var id = idComponents[1];
    var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
    var suggestions = tabData.suggestions[parseInt(id)];
    var popup = GTBSC_createPopupMenu(GTBSC_POPUPMENU_ID);
    popup.setAttribute("spanId", id);
    popup.addEventListener("command", GTBSC_onCommandSuggestion, false);
    var stringBundle = document.getElementById("google-toolbar-strings");
    var menuitem;
    if(suggestions.length == 0) {
      menuitem = document.createElement("menuitem");
      popup.appendChild(menuitem);
      var noSuggestionString = stringBundle.getString("prop.gtb.spelling.nosuggestions");
      menuitem.setAttribute("label", noSuggestionString);
      menuitem.setAttribute("disabled", "true")}
    else {
      var suggestion;
      for(var i = 0;suggestion = suggestions[i]; ++ i) {
        menuitem = document.createElement("menuitem");
        popup.appendChild(menuitem);
        menuitem.setAttribute("label", suggestion)}
    }
    popup.appendChild(document.createElement("menuseparator"));
    menuitem = document.createElement("menuitem");
    popup.appendChild(menuitem);
    var editString = stringBundle.getString("prop.gtb.spelling.edit");
    menuitem.setAttribute("label", editString);
    menuitem.setAttribute("id", GTBSC_MENU_PREFIX + "_edit");
    if("red" == misspellSpan.style.color) {
      menuitem = document.createElement("menuitem");
      popup.appendChild(menuitem);
      var ignoreAllMsg = stringBundle.getString("prop.gtb.spelling.ignoreall");
      menuitem.setAttribute("label", ignoreAllMsg);
      menuitem.setAttribute("id", GTBSC_MENU_PREFIX + "_ignoreall");
      menuitem = document.createElement("menuitem");
      popup.appendChild(menuitem);
      var dictAddMsg = stringBundle.getString("prop.gtb.spelling.dictadd");
      menuitem.setAttribute("label", dictAddMsg);
      menuitem.setAttribute("id", GTBSC_MENU_PREFIX + "_dictadd")}
    else {
      menuitem = document.createElement("menuitem");
      popup.appendChild(menuitem);
      var revertMsg = stringBundle.getString("prop.gtb.spelling.revert");
      var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
      var originalWord = tabData.originalWords[id];
      menuitem.setAttribute("label", revertMsg.replace("%s", originalWord));
      menuitem.setAttribute("id", GTBSC_MENU_PREFIX + "_revert")}
    var misspellPos = GetPageOffset(misspellSpan);
    var parentPos = GetPageOffset(misspellSpan.parentNode);
    var nodeOffsetX = -event.layerX + misspellPos.x - parentPos.x;
    var nodeOffsetY = -event.layerY + misspellPos.y - parentPos.y + misspellSpan.offsetHeight + 2;
    var anchor = GTB_getToolbar()._getCurrentBrowser();
    document.popupNode = anchor;
    var xpos = event.screenX - anchor.boxObject.screenX + anchor.boxObject.x;
    var ypos = event.screenY - anchor.boxObject.screenY + anchor.boxObject.y;
    popup.showPopup(anchor, xpos + nodeOffsetX, ypos + nodeOffsetY, "popup");
    event.stopPropagation()}
}

function GTBSC_onCommandSuggestion(event) {
  var id = event.target.id;
  var popup = this;
  var win = GTB_getToolbar()._getCurrentWindow();
  var misspellSpanId = popup.getAttribute("spanId", id);
  var misspellSpan = getElementByIdAcrossFrames(win, GTBSC_MISSPELL_SPAN_PREFIX + "_" + misspellSpanId);
  if(id == GTBSC_MENU_PREFIX + "_edit") {
    GTBSC_editMisspelledWord(misspellSpan)}
  else if(id == GTBSC_MENU_PREFIX + "_ignoreall") {
    GTBSC_addWordToWhitelist(misspellSpan.firstChild.data)}
  else if(id == GTBSC_MENU_PREFIX + "_dictadd") {
    GTBSC_addWordToDictionary(misspellSpan.firstChild.data)}
  else if(id == GTBSC_MENU_PREFIX + "_revert") {
    GTBSC_revertToOriginal(misspellSpan, misspellSpanId)}
  else {
    GTBSC_spellAcceptCorrection(misspellSpan, event.target.label)}
}

function GTBSC_addWordToWhitelist(word) {
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  tabData.whitelist.addWord(word);
  GTBSC_correctAllInstances(tabData, word)}

function GTBSC_addWordToDictionary(word) {
  GTB_getToolbar().spellCheck.userDictionary.addWord(word);
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  GTBSC_correctAllInstances(tabData, word);
  GTB_getToolbar().spellCheck.userDictionary.save();
  GTB_getToolbar().sendMessage("GTB_SpellCheck.reload_dictionary", null)}

function GTBSC_editMisspelledWord(misspellSpan) {
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  if(tabData.editWord) {
    try {
      tabData.editWord.removeEditBox()}
    catch(e) {
    }
    tabData.editWord = null}
  tabData.editWord = new GTBSC_editWordBox(misspellSpan)}

function GTBSC_spellAcceptCorrection(misspellSpan, correctWord) {
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  tabData.whitelist.addWord(correctWord);
  tabData.whitelist.removeWord(misspellSpan.firstChild.data);
  misspellSpan.firstChild.data = correctWord;
  misspellSpan.style.color = "green"}

function GTBSC_revertToOriginal(misspellSpan, idIndex) {
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  var originalWord = tabData.originalWords[idIndex];
  GTB_Assert(tabData.misspelledWords.hasWord(originalWord), "word " + originalWord + " is not one of the misspelled words");
  misspellSpan.firstChild.data = originalWord;
  misspellSpan.style.color = "red"}

function GTBSC_TextBlockifier() {
  this.separator = "\n";
  this.allText = "";
  this.blockOffsets = [];
  this.blockLengths = [];
  this.blockType = [];
  this.blockTextboxIndex = []}

GTBSC_TextBlockifier.prototype.addBlock = function(text, index, inputType) {
  if(this.allText.length > 0) {
    this.allText += this.separator}
  var block_index = this.blockOffsets.length;
  this.blockOffsets[block_index] = this.allText.length;
  this.blockLengths[block_index] = String(text).length;
  this.blockTextboxIndex[block_index] = index;
  this.blockType[block_index] = inputType;
  this.allText += text;
  return block_index}

;
GTBSC_TextBlockifier.prototype.getText = function() {
  return this.allText}

;
GTBSC_TextBlockifier.prototype.getTextLength = function() {
  return this.allText.length}

;
GTBSC_TextBlockifier.prototype.globalToLocal = function(global) {
  GTB_Assert(global >= 0 && global < this.getTextLength(), "The requested global index " + global + " is invalid");
  var offset;
  var block;
  for(var i = 1;i < this.blockOffsets.length;i ++ ) {
    if(this.blockOffsets[i] > global) {
      block = i - 1;
      offset = global - this.blockOffsets[i - 1];
      return new GTBSC_BlockAndLocalOffset(block, offset)}
  }
  block = this.blockOffsets.length - 1;
  offset = global - this.blockOffsets[block];
  return new GTBSC_BlockAndLocalOffset(block, offset)}

;
GTBSC_TextBlockifier.prototype.localToGlobal = function(block, offset) {
  return parseInt(this.blockOffsets[block]) + parseInt(offset)}

;
GTBSC_TextBlockifier.prototype.divForBlock = function(blockNum, tabData) {
  var type = this.blockType[blockNum];
  var realBlockNum = this.blockTextboxIndex[blockNum];
  var textbox;
  var div;
  if(type == 1) {
    textbox = tabData.textareas[realBlockNum];
    div = GTBSC_GetAnonymousDivFromTextbox(textbox)}
  else if(type == 0) {
    textbox = tabData.textinputs[realBlockNum];
    div = GTBSC_GetAnonymousDivFromTextbox(textbox)}
  else if(type == 2) {
    textbox = tabData.designmode[realBlockNum];
    div = textbox}
  return new GTBSC_TextboxAndDiv(textbox, div)}

;
function GTBSC_BlockAndLocalOffset(block, offset) {
  this.block = block;
  this.offset = offset}

function GTBSC_TextboxAndDiv(textbox, div) {
  this.textbox = textbox;
  this.div = div}

function GTBSC_ParseStatus(blocks, text, currentBlock, currentIndex) {
  this.blocks = blocks;
  this.text = text;
  this.currentBlock = currentBlock;
  this.currentIndex = currentIndex}

function GTBSC_MisspellIndexes(startIndex, currentIndex) {
  this.startIndex = startIndex;
  this.currentIndex = currentIndex}

function GTBSC_Correction(offset, length, confidence, suggestions) {
  this.offset = offset;
  this.length = length;
  this.confidence = confidence;
  if(suggestions == "") {
    this.suggestions = []}
  else {
    this.suggestions = suggestions.split("\t")}
}

function GTBSC_SpellResponse(xmlDoc, rawText) {
  this._xmlDoc = xmlDoc;
  this._rawText = rawText;
  this.corrections = [];
  this._error = null;
  this._clipped = null;
  this._charsChecked = null;
  this._suggestedLang = null;
  this._parse()}

GTBSC_SpellResponse.prototype._parse = function() {
  var spellResultNode = this._xmlDoc.documentElement;
  this._error = parseInt(spellResultNode.getAttribute("error"));
  this._clipped = parseInt(spellResultNode.getAttribute("clipped"));
  this._charsChecked = parseInt(spellResultNode.getAttribute("charschecked"));
  this._suggestedLang = spellResultNode.getAttribute("suggestedlang");
  if(spellResultNode.hasChildNodes()) {
    var children = spellResultNode.childNodes;
    for(var i = 0;i < children.length;i ++ ) {
      var cNode = children[i];
      if(cNode.nodeName != "c")continue;
      var offset = parseInt(cNode.getAttribute("o"));
      var length = parseInt(cNode.getAttribute("l"));
      var confidence = parseInt(cNode.getAttribute("s"));
      var suggestions = "";
      if(cNode.hasChildNodes()) {
        suggestions = cNode.firstChild.nodeValue}
      this.corrections[this.corrections.length] = new GTBSC_Correction(offset, length, confidence, suggestions)}
  }
  var stringBundle = document.getElementById("google-toolbar-strings");
  if(this._error != 0) {
    var errorString = stringBundle.getString("prop.gtb.spelling.servererror");
    alert(errorString);
    GTB_Dump(GTB_Dump.SC, errorString + "\nServer error: " + this._error)}
  if(this._clipped == 1) {
    var clippedString = stringBundle.getString("prop.gtb.spelling.errorsclipped");
    clippedString = clippedString.replace("%d", this.corrections.length);
    alert(clippedString);
    GTB_Dump(GTB_Dump.SC, clippedString)}
  else if(this._clipped == 2) {
    var clippedString = stringBundle.getString("prop.gtb.spelling.textclipped");
    alert(clippedString);
    GTB_Dump(GTB_Dump.SC, clippedString)}
}

;
function GTBSC_SpellRequest(spellText) {
  this._spellText = spellText;
  this._textAlreadyClipped = false;
  this._ignoreDups = GTB_getPrefs().getBoolPref(GTB_PREF_SC_IGNORE_DUPS);
  this._ignoreDigits = GTB_getPrefs().getBoolPref(GTB_PREF_SC_IGNORE_DIGITS);
  this._ignoreAllCaps = GTB_getPrefs().getBoolPref(GTB_PREF_SC_IGNORE_ALL_CAPS)}

GTBSC_SpellRequest.prototype._buildXmlDoc = function() {
  var xmlDoc = document.implementation.createDocument("", "", null);
  var spellRequestElt = xmlDoc.createElement("spellrequest");
  var textElt = xmlDoc.createElement("text");
  var textNode = xmlDoc.createTextNode(this._spellText);
  textElt.appendChild(textNode);
  spellRequestElt.setAttribute("textalreadyclipped", self.textAlreadyClipped ? "1" : "0");
  spellRequestElt.setAttribute("ignoredups", this._ignoreDups ? "1" : "0");
  spellRequestElt.setAttribute("ignoredigits", this._ignoreDigits ? "1" : "0");
  spellRequestElt.setAttribute("ignoreallcaps", this._ignoreAllCaps ? "1" : "0");
  spellRequestElt.appendChild(textElt);
  xmlDoc.appendChild(spellRequestElt);
  return xmlDoc}

;
GTBSC_SpellRequest.prototype._buildUrl = function() {
  var spellcheckUrl = "https://www.google.com/tbproxy/spell";
  var language = GTB_getPrefs().getStringPref(GTBSC_PREF_PREFIX + "lang");
  if(language == "auto") {
    language = GTB_getPrefs().getStringPref(GTBSC_PREF_PREFIX + "last_lang")}
  var hl = GTB_getToolbar().languageCode;
  var args = [];
  args.push("lang=" + language);
  args.push("hl=" + hl);
  return spellcheckUrl + "?" + args.join("&")}

;
GTBSC_SpellRequest.prototype.send = function(allowSuggestLang) {
  var requestXmlDoc = this._buildXmlDoc();
  var serializer = new XMLSerializer;
  var requestBody = serializer.serializeToString(requestXmlDoc);
  var xmlhttp = new XMLHttpRequest;
  var asynchronous = true;
  var spellRequestUrl = this._buildUrl();
  xmlhttp.open("POST", spellRequestUrl, asynchronous);
  xmlhttp.onreadystatechange = function() {
    if(xmlhttp.readyState == 4) {
      if(xmlhttp.status != 200) {
        var stringBundle = document.getElementById("google-toolbar-strings");
        var errorString = stringBundle.getString("prop.gtb.spelling.noconnection");
        alert(errorString);
        GTB_Dump(GTB_Dump.SC, errorString);
        return}
      var responseXmlDoc = xmlhttp.responseXML;
      if(responseXmlDoc == null) {
        var parser = new DOMParser;
        responseXmlDoc = parser.parseFromString(xmlhttp.responseText, "text/xml")}
      else {
        GTB_Dump(GTB_Dump.SC, "spell server has been fixed!")}
      var response = new GTBSC_SpellResponse(responseXmlDoc, xmlhttp.responseText);
      GTBSC_handleResult(response, allowSuggestLang)}
  }

  ;
  xmlhttp.setRequestHeader("Accept", "text/html");
  xmlhttp.setRequestHeader("Accept", "text/xml");
  xmlhttp.setRequestHeader("Content-Type", "text/xml");
  xmlhttp.setRequestHeader("Content-Length", requestBody.length);
  xmlhttp.send(requestBody)}

;
function GTBSC_handleResult(response, allowSuggestLang) {
  var win = GTB_getToolbar()._getCurrentWindow();
  if(GTBSC_getMode() == GTBSC_EDIT) {
    return}
  var language = GTB_getPrefs().getStringPref(GTBSC_PREF_PREFIX + "lang");
  var autodetectLanguage = false;
  if(language == "auto") {
    language = GTB_getPrefs().getStringPref(GTBSC_PREF_PREFIX + "last_lang");
    autodetectLanguage = true}
  var suggestedLanguage = response._suggestedLang;
  if(allowSuggestLang && suggestedLanguage != null) {
    if(suggestedLanguage.length == 2 && suggestedLanguage != language && (autodetectLanguage || GTBSC_ShouldChangeSpellLang(language, suggestedLanguage))) {
      if(!autodetectLanguage) {
        GTB_getPrefs().setStringPref(GTBSC_PREF_PREFIX + "lang", suggestedLanguage);
        GTB_SpellCheck._setLangMenuSelection(suggestedLanguage);
        GTB_SpellCheck._setLanguageSpecificTooltip(suggestedLanguage)}
      GTB_getPrefs().setStringPref(GTBSC_PREF_PREFIX + "last_lang", suggestedLanguage);
      GTBSC_toggleToEdit();
      GTB_getToolbar().spellCheck.run(true);
      return}
  }
  GTB_getPrefs().setStringPref(GTBSC_PREF_PREFIX + "last_lang", language);
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  tabData.misspelledWords.clear();
  tabData.originalWords = [];
  tabData.autofixSuggestions.clear();
  tabData.suggestions = {};
  if(response.corrections.length == 0) {
    var stringBundle = document.getElementById("google-toolbar-strings");
    var spellingOkMsg = stringBundle.getString("prop.gtb.spelling.noerrors");
    GTBSC_showAlertMessage(spellingOkMsg);
    GTBSC_setMode(GTBSC_EDIT);
    GTBSC_setIsAutoFix(false);
    return}
  var textBlocks = GTBSC_getSpellText(win, true);
  var parseStatus = new GTBSC_ParseStatus(textBlocks, textBlocks.getText(), 0, 0);
  var total_misspelled = 0;
  for(var i = 0;i < response.corrections.length;i ++ ) {
    var c = response.corrections[i];
    GTBSC_updateParseStatus(parseStatus, c.offset - parseStatus.currentIndex);
    var blockInfo = parseStatus.blocks.globalToLocal(c.offset);
    var blockInfoEnd;
    var blockInfoEndIndex = parseInt(c.offset) + parseInt(c.length);
    if(blockInfoEndIndex == parseStatus.blocks.getTextLength()) {
      blockInfoEnd = blockInfo}
    else {
      blockInfoEnd = parseStatus.blocks.globalToLocal(blockInfoEndIndex)}
    var misspelled = parseStatus.text.substring(c.offset, c.offset + c.length);
    tabData.originalWords[tabData.originalWords.length] = misspelled;
    if(!GTB_getToolbar().spellCheck.userDictionary.hasWord(misspelled) && !tabData.whitelist.hasWord(misspelled)) {
      total_misspelled ++ ;
      if(c.confidence && c.suggestions.length > 0) {
        tabData.autofixSuggestions.addWordValue(c.suggestions[0], "" + i)}
      tabData.misspelledWords.addWordValue(misspelled, "" + i);
      var textboxInfo = parseStatus.blocks.divForBlock(parseStatus.currentBlock, tabData);
      var div = textboxInfo.div;
      if(div) {
        var offset = c.offset - parseStatus.blocks.blockOffsets[parseStatus.currentBlock];
        var indexes = new GTBSC_MisspellIndexes(offset, 0);
        GTBSC_createMisspellSpan(div, offset + c.length, misspelled, i, indexes);
        tabData.suggestions[i] = c.suggestions}
    }
    parseStatus.currentIndex = c.offset + c.length;
    if(parseStatus.currentIndex != parseStatus.blocks.getTextLength()) {
      if(parseStatus.blocks.globalToLocal(parseStatus.currentIndex).offset == parseStatus.blocks.blockLengths[parseStatus.currentBlock]) {
        parseStatus.currentBlock ++ ;
        parseStatus.currentIndex ++ }
    }
  }
  if(response._clipped != 0) {
    var lastCheckedBlockInfo = parseStatus.blocks.globalToLocal(response._charsChecked + 1);
    var div = parseStatus.blocks.divForBlock(lastCheckedBlockInfo.block, tabData).div;
    GTBSC_dimUncheckedText(div, lastCheckedBlockInfo.offset);
    for(var blockNum = lastCheckedBlockInfo.block + 1;blockNum < parseStatus.blocks.blockLengths.length;blockNum ++ ) {
      var div = parseStatus.blocks.divForBlock(blockNum, tabData).div;
      GTBSC_dimUncheckedText(div, 0)}
  }
  if(parseStatus.currentIndex < parseStatus.text.length - 1) {
    GTBSC_updateParseStatus(parseStatus, parseStatus.text.length - parseStatus.currentIndex)}
  if(total_misspelled == 0) {
    GTBSC_toggleToEdit();
    var stringBundle = document.getElementById("google-toolbar-strings");
    var spellingOkMsg = stringBundle.getString("prop.gtb.spelling.noerrors");
    GTBSC_showAlertMessage(spellingOkMsg);
    return}
  if(GTBSC_getIsAutoFix()) {
    GTBSC_autofixAllMisspellings()}
}

function GTBSC_dimUncheckedText(node, offset) {
  var currentOffset = 0;
  for(var i = 0;i < node.childNodes.length;i ++ ) {
    var childNode = node.childNodes[i];
    var offsetInChild = offset < currentOffset ? 0 : offset - currentOffset;
    if(childNode.nodeType == Node.TEXT_NODE) {
      if(offset < currentOffset + childNode.nodeValue.length) {
        var markedText = childNode.nodeValue.substring(offsetInChild);
        var unmarkedText = childNode.nodeValue.substring(0, offsetInChild);
        var newTextSpan = GTBSC_spanAroundText(node, markedText, childNode.nextSibling);
        childNode.nodeValue = unmarkedText;
        newTextSpan.id = "gtbunch_" + node.id + "_" + currentOffset;
        GTBSC_setDimmedSpanStyle(newTextSpan);
        if(offsetInChild == 0) {
          childNode.removeNode()}
        else {
          i ++ }
      }
      currentOffset += childNode.nodeValue.length}
    else if(node.nodeName.toLowerCase() == "br") {
      currentOffset ++ }
    else {
      currentOffset += GTBSC_dimUncheckedText(childNode, offsetInChild)}
  }
  return currentOffset}

function GTBSC_autofixAllMisspellings() {
  var win = GTB_getToolbar()._getCurrentWindow();
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  var autofixSuggestions = tabData.autofixSuggestions.getWordsAsArray();
  for(var i = 0;i < autofixSuggestions.length;i ++ ) {
    var suggestion = autofixSuggestions[i];
    var positions = tabData.autofixSuggestions.getWordValues(suggestion);
    for(var j = 0;j < positions.length;j ++ ) {
      var misspelled = tabData.originalWords[positions[j]];
      var misspellSpan = getElementByIdAcrossFrames(win, GTBSC_MISSPELL_SPAN_PREFIX + "_" + positions[j]);
      if(GTB_getToolbar().spellCheck.userDictionary.hasWord(misspelled) || tabData.whitelist.hasWord(misspelled) || misspelled != misspellSpan.firstChild.data) {
        continue}
      misspellSpan.firstChild.data = suggestion;
      misspellSpan.style.color = "green"}
  }
}

function GTBSC_revertAutofixChanges() {
  var win = GTB_getToolbar()._getCurrentWindow();
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  var originalWords = tabData.originalWords;
  for(var i = 0;i < originalWords.length;i ++ ) {
    var misspellSpan = getElementByIdAcrossFrames(win, GTBSC_MISSPELL_SPAN_PREFIX + "_" + i);
    if(misspellSpan) {
      GTBSC_revertToOriginal(misspellSpan, i)}
  }
}

function GTBSC_updateParseStatus(parseStatus, length) {
  var blocks = parseStatus.blocks;
  var endBlock;
  var endBlockIndex = parseInt(parseStatus.currentIndex) + parseInt(length);
  if(endBlockIndex == blocks.getTextLength()) {
    endBlock = blocks.blockLengths.length - 1}
  else {
    endBlock = blocks.globalToLocal(endBlockIndex).block}
  while(parseStatus.currentBlock < endBlock) {
    parseStatus.currentBlock ++ ;
    length = length - (blocks.blockOffsets[parseStatus.currentBlock] - parseStatus.currentIndex);
    parseStatus.currentIndex = blocks.blockOffsets[parseStatus.currentBlock]}
  parseStatus.currentIndex = parseStatus.currentIndex + length}

function GTBSC_getLocalizedLanuage(langCode) {
  var readableLangMap = {auto:"auto", da:"danish", de:"german", en:"english", es:"spanish", fr:"french", it:"italian", nl:"dutch", pl:"polish", pt:"portuguese", fi:"finnish", sv:"swedish"};
  var stringBundle = document.getElementById("google-toolbar-strings");
  var locLang = stringBundle.getString("prop.gtb.spelling.lang." + readableLangMap[langCode]);
  return locLang}

function GTBSC_getLocalizedTooltip(langCode) {
  var stringBundle = document.getElementById("google-toolbar-strings");
  var locLang = GTBSC_getLocalizedLanuage(langCode);
  var tooltipText = stringBundle.getString("prop.gtb.spelling.tooltip");
  tooltipText = tooltipText.replace("%s", locLang);
  return tooltipText}

function GTB_SpellCheck() {
}

GTB_SpellCheck.prototype.initUi = function() {
  var langPref = GTB_getPrefs().getStringPref(GTBSC_PREF_PREFIX + "lang");
  GTB_SpellCheck._setLangMenuSelection(langPref);
  GTB_SpellCheck._setLanguageSpecificTooltip(langPref)}

;
GTB_SpellCheck.prototype.init = function(gto) {
  this.overlay = gto;
  this.initUi();
  try {
    GTB_getPrefs().getStringPref(GTBSC_PREF_PREFIX + "last_lang")}
  catch(e) {
    var langPref = GTB_getPrefs().getStringPref(GTBSC_PREF_PREFIX + "lang");
    GTB_getPrefs().setStringPref(GTBSC_PREF_PREFIX + "last_lang", langPref)}
  this.userDictionary = new GTBSC_UserDictionary;
  this.userDictionary.init();
  this.onDocSubmit_ = GTB_hitch(this, this.doDocSubmit_);
  document.addEventListener("submit", this.onDocSubmit_, false);
  this.onUnload_ = GTB_hitch(this, this.doUnload_);
  window.addEventListener("unload", this.onUnload_, false);
  GTB_perTabData().makeContainers(GTBSC_CONTAINER_TAG);
  this.GTB_MESSAGES = {GTB_TABSWITCH:function(data) {
    var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
    if(tabData.mode == GTBSC_CHECK) {
      GTB_SpellCheck._toggleSpellCheckButton(true)}
    else {
      GTB_SpellCheck._toggleSpellCheckButton(false)}
  }

  , "GTB_OPTION.button_option.gtbSpellCheck":function(data) {
    if("true" == data) {
      GTB_getToolbar().spellCheck.initUi()}
  }

  };
  this.observe = GTB_MessageObserve;
  gto.registerMessages(this)}

;
GTB_SpellCheck.prototype.doUnload_ = function(event) {
  window.removeEventListener("unload", this.onUnload_, false);
  document.removeEventListener("submit", this.onDocSubmit_, false)}

;
GTB_SpellCheck.prototype.doDocSubmit_ = function(event) {
  var mode = GTBSC_getMode();
  if(mode == GTBSC_CHECK) {
    GTBSC_toggleToEdit()}
}

;
GTB_SpellCheck.prototype.run = function(opt_disallowSuggestLang) {
  GTB_getToolbar().maybeShowUsage("spellcheck_used", OptionsDialog.MORE_URL_SPELLCHECK);
  var spellText;
  var win = this.overlay._getCurrentWindow();
  var mode = GTBSC_getMode();
  if(mode == GTBSC_CHECK) {
    GTBSC_toggleToEdit();
    return}
  GTBSC_setMode(GTBSC_CHECK);
  var blocks = GTBSC_getSpellText(win, false);
  spellText = blocks.getText();
  if(spellText.length == 0) {
    var stringBundle = document.getElementById("google-toolbar-strings");
    var blankFormFieldsMsg = blocks.blockOffsets.length > 0 ? stringBundle.getString("prop.gtb.spelling.notext") : stringBundle.getString("prop.gtb.spelling.nofields");
    GTBSC_showAlertMessage(blankFormFieldsMsg);
    GTBSC_setMode(GTBSC_EDIT);
    return}
  var request = new GTBSC_SpellRequest(spellText);
  var allowSuggestLang = opt_disallowSuggestLang == null ? true : false;
  request.send(allowSuggestLang)}

;
GTB_SpellCheck.prototype.maybeRerun = function() {
  if(GTBSC_getMode() == GTBSC_CHECK) {
    GTBSC_toggleToEdit();
    GTB_getToolbar().spellCheck.run()}
}

;
GTB_SpellCheck.prototype.runAutoFix = function() {
  var isAutoFix = GTBSC_getIsAutoFix();
  if(isAutoFix) {
    GTBSC_revertAutofixChanges();
    GTBSC_setIsAutoFix(false)}
  else {
    GTBSC_setIsAutoFix(true);
    if(GTBSC_getMode() == GTBSC_CHECK) {
      GTBSC_autofixAllMisspellings()}
    else {
      GTB_getToolbar().spellCheck.run()}
  }
}

;
GTB_SpellCheck.prototype.doTabSwitch = function(event) {
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  if(tabData.whitelist) {
    return}
  else {
    this.doPageParse()}
}

;
GTB_SpellCheck.prototype.doPageLoad = function(event) {
  var content = document.getElementById("content");
  var browsers = content.browsers;
  var index = content.mTabBox.selectedIndex;
  var browser = browsers[index];
  var same = event.target == browser.contentDocument;
  if(!same)return;
  this.doPageParse()}

;
GTB_SpellCheck.prototype.doPageParse = function() {
  GTBSC_setMode(GTBSC_EDIT);
  var tabData = GTB_perTabData().getSelectedTabContainer(GTBSC_CONTAINER_TAG);
  if(tabData.whitelist == null) {
    tabData.whitelist = new GTBSC_WordList}
  else {
    tabData.whitelist.clear()}
  if(tabData.misspelledWords == null) {
    tabData.misspelledWords = new GTBSC_WordList}
  if(tabData.originalWords == null) {
    tabData.originalWords = []}
  if(tabData.autofixSuggestions == null) {
    tabData.autofixSuggestions = new GTBSC_WordList}
  tabData.textareas = [];
  tabData.textinputs = [];
  tabData.designmode = [];
  tabData.popupMenuId = null}

;
GTB_SpellCheck.prototype.doPageHide = function(event) {
  if(event.persisted) {
    var mode = GTBSC_getMode();
    if(mode == GTBSC_CHECK) {
      GTBSC_toggleToEdit()}
  }
}

;
GTB_SpellCheck.prototype.setLangPref = function(event, lang) {
  GTB_SpellCheck._setLangMenuSelection(lang);
  GTB_SpellCheck._setLanguageSpecificTooltip(lang);
  GTB_getPrefs().setStringPref(GTBSC_PREF_PREFIX + "lang", lang);
  event.preventBubble();
  if(GTBSC_getMode() == GTBSC_CHECK) {
    GTBSC_toggleToEdit()}
  this.run(false)}

;
GTB_SpellCheck._setLangMenuSelection = function(langCode) {
  var menupopup = document.getElementById("googleSpellCheckLangMenu");
  if(menupopup == null) {
    return}
  var menuitems = menupopup.getElementsByTagName("menuitem");
  var langCodeMap = {auto:"auto", danish:"da", german:"de", english:"en", spanish:"es", french:"fr", italian:"it", dutch:"nl", polish:"pl", portuguese:"pt", finnish:"fi", swedish:"sv"};
  for(var i = 0;i < menuitems.length;i ++ ) {
    var menuitem = menuitems[i];
    var language = menuitem.id.split(".").pop();
    var itemLang = langCodeMap[language];
    menuitem.setAttribute("tooltiptext", GTBSC_getLocalizedTooltip(itemLang));
    if(langCode == itemLang) {
      menuitem.setAttribute("checked", "true")}
    else {
      menuitem.setAttribute("checked", "false")}
  }
}

;
GTB_SpellCheck._setLanguageSpecificTooltip = function(langPref) {
  var button = GTB_SpellCheck._getSpellCheckButton();
  if(button) {
    button.setAttribute("tooltiptext", GTBSC_getLocalizedTooltip(langPref))}
}

;
GTB_SpellCheck._getSpellCheckButton = function() {
  var button = document.getElementById("gtbSpellCheck");
  return button}

;
GTB_SpellCheck._toggleSpellCheckButton = function(checked) {
  var button = GTB_SpellCheck._getSpellCheckButton();
  if(button == null) {
    return}
  button.setAttribute("checked", checked);
  var stringBundle = document.getElementById("google-toolbar-strings");
  if(checked) {
    var stopLabel = stringBundle.getString("prop.gtb.spelling.button.stop.label");
    button.setAttribute("label", stopLabel);
    button.setAttribute("tooltiptext", stopLabel)}
  else {
    button.setAttribute("label", stringBundle.getString("prop.gtb.spelling.button.check.label"));
    var langPref = GTB_getPrefs().getStringPref(GTBSC_PREF_PREFIX + "lang");
    GTB_SpellCheck._setLanguageSpecificTooltip(langPref)}
}

;
GTB_SpellCheck._toggleAutoFixLabel = function(autoFixOn) {
  var autoFixMenuItem = document.getElementById("googleSpellCheckAutoFix");
  if(autoFixMenuItem == null) {
    return}
  var stringBundle = document.getElementById("google-toolbar-strings");
  if(autoFixOn) {
    autoFixMenuItem.setAttribute("label", stringBundle.getString("prop.gtb.spelling.autofix.revert.label"))}
  else {
    autoFixMenuItem.setAttribute("label", stringBundle.getString("prop.gtb.spelling.autofix.start.label"))}
}

;
function GTBSC_WordList(opt_initWords) {
  this._words = {};
  this._length = 0;
  if(opt_initWords != null) {
    for(var i = 0;i < opt_initWords.length;i ++ ) {
      this.addWord(opt_initWords[i])}
  }
}

GTBSC_WordList.prototype.getWordsAsArray = function() {
  var words = [];
  for(var word in this._words) {
    words.push(word)}
  return words}

;
GTBSC_WordList.prototype.getLength = function() {
  return this._length}

;
GTBSC_WordList.prototype.addWord = function(word) {
  if(this.hasWord(word)) {
    return false}
  if(!this.isValidWord(word)) {
    return false}
  this._words[word] = "1";
  this._length ++ ;
  return true}

;
GTBSC_WordList.prototype.addWordValue = function(word, value) {
  if(!this.isValidValue(value)) {
    return false}
  if(this.hasWord(word)) {
    var valueToAdd = ":" + value;
    this._words[word] += valueToAdd}
  else {
    this._words[word] = value;
    this._length ++ }
  return true}

;
GTBSC_WordList.prototype.removeWord = function(word) {
  if(!this.hasWord(word)) {
    return false}
  if(!this.isValidWord(word)) {
    return false}
  delete this._words[word];
  this._length -- ;
  return true}

;
GTBSC_WordList.prototype.clear = function() {
  this._words = {};
  this._length = 0}

;
GTBSC_WordList.prototype.hasWord = function(word) {
  return this._words[word] != null}

;
GTBSC_WordList.prototype.getWordValues = function(word) {
  var values = this._words[word];
  return values.split(":")}

;
GTBSC_WordList.prototype.isValidWord = function(word) {
  if(typeof word != "string") {
    return false}
  if(word == "") {
    return false}
  return true}

;
GTBSC_WordList.prototype.isValidValue = function(value) {
  if(typeof value != "string") {
    return false}
  if(value.indexOf(":") != -1) {
    return false}
  return true}

;
GTBSC_WordList.prototype.toString = function() {
  var wordListString = "";
  for(var word in this._words) {
    wordListString += word + ","}
  wordListString = wordListString.substring(0, wordListString.length - 1);
  return wordListString}

;
function GTBSC_UserDictionary() {
}

GTBSC_UserDictionary.prototype = {init:function() {
  this._wordList = null;
  this._readFromPrefs()}

, addWord:function(word) {
  if(!this._isValidWord(word)) {
    return false}
  return this._wordList.addWord(word)}

, removeWord:function(word) {
  if(!this._isValidWord(word)) {
    return false}
  return this._wordList.removeWord(word)}

, hasWord:function(word) {
  return this._wordList.hasWord(word)}

, getLength:function() {
  return this._wordList.getLength()}

, getWordsAsArray:function() {
  return this._wordList.getWordsAsArray()}

, toString:function() {
  return this._wordList.toString()}

, save:function() {
  this._writeToPrefs()}

, reload:function() {
  this._readFromPrefs()}

, _isValidWord:function(word) {
  if(word.indexOf(",") != -1) {
    return false}
  return this._wordList.isValidWord(word)}

, _readFromPrefs:function() {
  var words;
  var prefName = GTBSC_DICT_PREF_PREFIX + "words";
  try {
    words = GTB_getPrefs().getStringPref(prefName)}
  catch(e) {
    this._wordList = new GTBSC_WordList;
    this._writeToPrefs();
    return}
  if(words == "") {
    this._wordList = new GTBSC_WordList;
    return}
  this._wordList = new GTBSC_WordList(words.split(","));
  GTB_Assert(typeof this._wordList == "object" && this._wordList.getLength() > 0, "GTBSC_UserDictionary: this._wordList is not an array with length > 0");
  GTBSC_dump("dumping " + this._wordList.getLength() + " words");
  var words = this._wordList.getWordsAsArray();
  for(var i = 0;i < words.length;i ++ ) {
  }
}

, _writeToPrefs:function() {
  var prefName = GTBSC_DICT_PREF_PREFIX + "words";
  GTBSC_dump("saving " + this._wordList.getLength() + " words to pref " + prefName + ":\n" + this.toString());
  GTB_getPrefs().setStringPref(prefName, this.toString())}

};
function GTBSC_ShouldChangeSpellLang(checkedLang, suggestedLang) {
  var params = {inz:{checkedLang:checkedLang, suggestedLang:suggestedLang}, out:null};
  window.openDialog("chrome://google-toolbar/content/spellcheck-language.xul", "gtbGoogleSpellingSuggLang", "modal,centerscreen,chrome,resizable=no", params);
  return params.out}

function GTB_SC_suggLangDialogInit(event) {
  var params = window.arguments[0];
  var checkedLangCode = params.inz.checkedLang;
  var suggestedLangCode = params.inz.suggestedLang;
  var checkedLang = GTBSC_getLocalizedLanuage(checkedLangCode);
  var suggestedLang = GTBSC_getLocalizedLanuage(suggestedLangCode);
  var stringBundle = document.getElementById("google-toolbar-strings");
  var differentMsg = stringBundle.getString("prop.gtb.spelling.different.msg");
  differentMsg = differentMsg.replace("%s", checkedLang);
  differentMsg = differentMsg.replace("%s", suggestedLang);
  differentMsg = differentMsg.replace("%s", suggestedLang);
  var dialogDesc0 = document.getElementById("gtbGoogleSpellingSuggLangDesc0");
  var dialogDesc1 = document.getElementById("gtbGoogleSpellingSuggLangDesc1");
  var msgParts = differentMsg.split("\n\n");
  dialogDesc0.value = msgParts[0];
  dialogDesc1.value = msgParts[1];
  var differentChange = stringBundle.getString("prop.gtb.spelling.different.change");
  differentChange = differentChange.replace("%s", suggestedLang);
  var buttonChange = document.getElementById("gtbGoogleSpellingSuggLangChange");
  buttonChange.label = differentChange;
  var differentKeep = stringBundle.getString("prop.gtb.spelling.different.keep");
  differentKeep = differentKeep.replace("%s", checkedLang);
  var buttonKeep = document.getElementById("gtbGoogleSpellingSuggLangKeep");
  buttonKeep.label = differentKeep}

function GTB_SC_suggLangDialogDoChange() {
  var params = window.arguments[0];
  params.out = true;
  return true}

function GTB_SC_suggLangDialogDoKeep() {
  var params = window.arguments[0];
  params.out = false;
  return true}

function GTB_PageRank() {
  this.GPR_fetcher = new GPR_XMLFetcher(this)}

GTB_PageRank.prototype.GPR_contentArea = null;
GTB_PageRank.GPR_INFO_COLON_URL = "toolbarqueries.google.";
GTB_PageRank.prototype.GPR_defaultTld = null;
GTB_PageRank.GPR_extraQueryParams = {sourceid:"navclient-ff", features:"Rank", client:"navclient-auto-ff"};
GTB_PageRank.GPR_HASH_SEED = "Mining PageRank is AGAINST GOOGLE'S TERMS OF SERVICE. Yes, I'm talking to you, scammer.";
GTB_PageRank.prototype.GPR_hasPr = null;
GTB_PageRank.prototype.GPR_noPr = null;
GTB_PageRank.prototype.GPR_resolvedIp = null;
GTB_PageRank.prototype.GPR_sendTime = null;
GTB_PageRank.prototype.GPR_queryTime = null;
GTB_PageRank.prototype.GPR_queryStatus = null;
function GPR_DNSLookUpHandler(pr) {
  this.pr = pr}

GPR_DNSLookUpHandler.prototype = {QueryInterface:function(iid) {
  if(iid.equals(Components.interfaces.nsISupports) || iid.equals(Components.interfaces.nsIDNSListener)) {
    return this}
  throw Components.results.NS_NOINTERFACE;}

, onLookupComplete:function(request, record, status) {
  this.pr.GPR_resolvedIp = record.getNextAddrAsString()}

};
function GPR_XMLFetcher(pr) {
  this.pr = pr;
  this._request = new XMLHttpRequest}

GPR_XMLFetcher.prototype = {_callback:null, get:function(page) {
  this._request.onreadystatechange = null;
  this._request.abort();
  this._request = new XMLHttpRequest;
  var asynchronous = true;
  this._request.open("GET", page, asynchronous);
  var self = this;
  this._request.onreadystatechange = function() {
    self.readyStateChange(self)}

  ;
  this.pr.GPR_sendTime = new Date;
  this._request.send(null)}

, readyStateChange:function(fetcher) {
  if(fetcher._request.readyState == 4) {
    fetcher.pr.GPR_handleResponse(fetcher._request.responseText)}
}

};
GTB_PageRank.prototype.GPR_fetcher = null;
GTB_PageRank.prototype.GPR_getDefaultTld = function() {
  var home = GTB_getPrefs().getStringPref(GTB_PREF_GOOGLE_HOME);
  var homePrefix = "www.google.";
  this.GPR_defaultTld = home.slice(homePrefix.length, home.length);
  GTB_Dump(GTB_Dump.PR, "### PAGERANK trace: Found TLD: " + this.GPR_defaultTld + "\n")}

;
GTB_PageRank.prototype.GPR_startup = function() {
  GTB_Dump(GTB_Dump.PR, "### PAGERANK trace: Initialization\n");
  this.GPR_contentArea = document.getElementById("content");
  var strings = document.getElementById("google-toolbar-strings");
  this.GPR_hasPr = strings.getString("prop.google-pr.havepr");
  this.GPR_noPr = strings.getString("prop.google-pr.nopr");
  this.GPR_getDefaultTld();
  this.GPR_resolveDns();
  GTB_perTabData().makeContainers("page_rank");
  GPR_TEST("!GTB_PageRank.GPR_canFetchPRFor('https://www.example.com')");
  GPR_TEST("!GTB_PageRank.GPR_canFetchPRFor('http://www')");
  GPR_TEST("!GTB_PageRank.GPR_canFetchPRFor('http://10.0.0.10')");
  GPR_TEST("!GTB_PageRank.GPR_canFetchPRFor('http://192.168.0.1')");
  GPR_TEST("!GTB_PageRank.GPR_canFetchPRFor('http://127.0.0.1')");
  GPR_TEST("GTB_PageRank.GPR_canFetchPRFor('http://google.com')");
  GPR_TEST("GTB_PageRank.GPR_canFetchPRFor('http://google.info')");
  GPR_TEST("GTB_PageRank.GPR_canFetchPRFor('http://172.24.0.7')");
  GPR_TEST('GTB_PageRank.GPR_extractResponse("blah\t\t Rank_1:1:7\tblah")==7');
  GPR_TEST("GTB_PageRank.GPR_extractResponse('blah\t\t\tblah')==null")}

;
function GPR_onTabSwitch(event) {
  GTB_GoogleToolbarOverlay.pageRank.doTabSwitch(event)}

GTB_PageRank.prototype.doTabSwitch = function(event) {
  if(!GTB_PageRank.GPR_pageRankEnabled()) {
    return}
  var tabData = GTB_perTabData().getSelectedTabContainer("page_rank");
  var undefined;
  if(tabData.pageRank == undefined) {
    GTB_Dump(GTB_Dump.PR, "### PAGERANK trace: undefined in tab switch, fetching\n");
    this.GPR_getPageRank();
    return}
  this.GPR_displayPageRank(tabData.pageRank);
  GTB_Dump(GTB_Dump.PR, "### PAGERANK trace: switching tabs, rank: " + tabData.pageRank + "\n")}

;
GTB_PageRank.prototype.GPR_resolveDns = function() {
  var dnsListener = new GPR_DNSLookUpHandler(this);
  var dns = Components.classes["@mozilla.org/network/dns-service;1"].getService(Components.interfaces.nsIDNSService);
  var toolbarName = GTB_PageRank.GPR_INFO_COLON_URL + this.GPR_defaultTld;
  var eventQ = null;
  try {
    var nsIEventQueueService = Components.interfaces.nsIEventQueueService;
    var eqService = Components.classes["@mozilla.org/event-queue-service;1"].getService(nsIEventQueueService);
    eventQ = eqService.getSpecialEventQueue(nsIEventQueueService.UI_THREAD_EVENT_QUEUE)}
  catch(e) {
  }
  dns.asyncResolve(toolbarName, 0, dnsListener, eventQ);
  if(this.GPR_resolvedIp != null) {
    GTB_Dump(GTB_Dump.PR, "Resolved: " + this.GPR_resolvedIp + "\n")}
}

;
GTB_PageRank.prototype.GPR_latencyInfo = function() {
  if(this.GPR_queryStatus == null) {
    return""}
  var googleIp = "googleip=" + this.GPR_queryStatus + ";" + this.GPR_resolvedIp + ";" + this.GPR_queryTime + "&";
  return googleIp}

;
GTB_PageRank.prototype.GPR_getPageRank = function() {
  var page = this.GPR_contentArea.contentWindow.location.href;
  if(!GTB_PageRank.GPR_canFetchPRFor(page)) {
    this.GPR_displayPageRank(null);
    var tabData = GTB_perTabData().getSelectedTabContainer("page_rank");
    tabData.pageRank = null;
    return}
  var hash = "8" + GTB_PageRank.GPR_awesomeHash(page);
  var url = "http://" + GTB_PageRank.GPR_INFO_COLON_URL + this.GPR_defaultTld + "/search?";
  for(var param in GTB_PageRank.GPR_extraQueryParams) {
    url += param + "=" + GTB_PageRank.GPR_extraQueryParams[param] + "&"}
  url += this.GPR_latencyInfo();
  url += "ch=" + hash + "&q=info:" + encodeURIComponent(page);
  GTB_Dump(GTB_Dump.PR, "### PAGERANK trace: URL: " + url + "\n");
  this.GPR_queryStatus = "P";
  this.GPR_fetcher.get(url)}

;
GTB_PageRank.prototype.doPageLoad = function(event) {
  if(event.originalTarget != this.GPR_contentArea.contentDocument) {
    return}
  if(!GTB_PageRank.GPR_pageRankEnabled()) {
    return}
  this.GPR_getPageRank();
  this.GPR_resolveDns()}

;
GTB_PageRank.GPR_pageRankEnabled = function() {
  var button = document.getElementById("gtbPageRank");
  return button != null}

;
GTB_PageRank.GPR_awesomeHash = function(value) {
  var kindOfThingAnIdiotWouldHaveOnHisLuggage = 16909125;
  for(var i = 0;i < value.length;i ++ ) {
    kindOfThingAnIdiotWouldHaveOnHisLuggage ^= GTB_PageRank.GPR_HASH_SEED.charCodeAt(i % GTB_PageRank.GPR_HASH_SEED.length) ^ value.charCodeAt(i);
    kindOfThingAnIdiotWouldHaveOnHisLuggage = kindOfThingAnIdiotWouldHaveOnHisLuggage >>> 23 | kindOfThingAnIdiotWouldHaveOnHisLuggage << 9}
  return GTB_PageRank.GPR_hexEncodeU32(kindOfThingAnIdiotWouldHaveOnHisLuggage)}

;
GTB_PageRank.GPR_hexEncodeU32 = function(num) {
  var result = GTB_PageRank.GPR_toHex8(num >>> 24);
  result += GTB_PageRank.GPR_toHex8(num >>> 16 & 255);
  result += GTB_PageRank.GPR_toHex8(num >>> 8 & 255);
  return result + GTB_PageRank.GPR_toHex8(num & 255)}

;
GTB_PageRank.GPR_toHex8 = function(num) {
  return(num < 16 ? "0" : "") + num.toString(16)}

;
GTB_PageRank.GPR_newURI = function(spec) {
  var ios = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
  return ios.newURI(spec, null, null)}

;
GTB_PageRank.GPR_canFetchPRFor = function(page) {
  var uri = GTB_PageRank.GPR_newURI(page);
  var host = uri.asciiHost;
  if(uri.scheme != "http" || uri.username || uri.password) {
    return false}
  if(/\.[a-zA-Z]{2,4}$/.test(host)) {
    return true}
  if(/^(\d{1,3}\.){3}\d{1,3}$/.test(host) && host.indexOf("10.0.0.") != 0 && host.indexOf("172.16.") != 0 && host.indexOf("192.168.") != 0 && host.indexOf("127.0.0.") != 0 && host.indexOf("0.0.0.") != 0 && host.indexOf("192.0.") != 0 && host.indexOf("1.") != 0)return true;
  return false}

;
GTB_PageRank.prototype.GPR_handleResponse = function(responseText) {
  var arrivalTime = new Date;
  this.GPR_queryTime = arrivalTime.getTime() - this.GPR_sendTime.getTime();
  var tabData = GTB_perTabData().getSelectedTabContainer("page_rank");
  var pr = GTB_PageRank.GPR_extractResponse(responseText);
  if(pr < 0 || pr > 10) {
    this.GPR_queryStatus = "U"}
  else {
    this.GPR_queryStatus = "O"}
  tabData.pageRank = pr;
  this.GPR_displayPageRank(pr);
  GTB_Dump(GTB_Dump.PR, "\n### PAGERANK trace: Response text: " + responseText);
  GTB_Dump(GTB_Dump.PR, "\n### PAGERANK trace: Retrieval time: " + this.GPR_queryTime + " ms, rank: " + pr + "\n")}

;
GTB_PageRank.GPR_extractResponse = function(responseText) {
  if(responseText && responseText.match(/Rank_1:\d+:(\d+)/))return RegExp.$1;
  return null}

;
GTB_PageRank.prototype.GPR_displayPageRank = function(pr) {
  var button = document.getElementById("gtbPageRank");
  if(button != null) {
    var tooltip = pr == null ? this.GPR_noPr : this.GPR_hasPr.replace(/\$pagerank;/, pr);
    button.setAttribute("tooltiptext", tooltip);
    var image = document.getElementById("gtbPageRankImage");
    if(image != null) {
      var imageUrl = "chrome://google-toolbar/skin/page-rank-";
      imageUrl += pr == null ? "unknown" : pr;
      imageUrl += ".png";
      image.setAttribute("src", imageUrl);
      image.setAttribute("tooltiptext", tooltip)}
  }
}

;
function GPR_TEST(str) {
  GTB_Assert(eval(str), "TEST FAILED: " + str + "\n")}

function GTB_Uninstall_onLoad(event) {
  var frame = document.getElementById("gtbFormFrame");
  var src = "http://google.com/tools/firefox/toolbar/FT2/intl/" + window.arguments[0] + "/uninstall.html";
  frame.setAttribute("src", src)}

function GTB_UninstallExtension(guid) {
  var manager = Components.classes["@mozilla.org/extensions/manager;1"].getService(Components.interfaces.nsIExtensionManager);
  var dummy = manager.datasource;
  if("uninstallExtension"  in  manager) {
    manager.uninstallExtension("{" + guid + "}")}
  else if("uninstallItem"  in  manager) {
    manager.uninstallItem("{" + guid + "}")}
  else {
    return false}
  dummy = null;
  return true}

function GTB_Uninstall_showDialog() {
  var stringBundle = document.getElementById("google-toolbar-strings");
  var mesg = stringBundle.getString("google-uninstall.finalMessage");
  window.alert(mesg)}

function GTB_Uninstall_onAccept() {
  var frame = document.getElementById("gtbFormFrame");
  var doc = frame.contentDocument;
  var form = doc.FeedbackForm;
  if(form != null) {
    form.submit()}
  GTB_getPrefs().setBoolPref("uninstall_pending", true);
  var uninstalled = false;
  try {
    var uninstall = Components.classes["@google.com/uninstallutil;1"].createInstance(Components.interfaces.GTBIUninstallUtil);
    if(uninstall.msiUninstall()) {
      uninstalled = true;
      GTB_Uninstall_showDialog()}
  }
  catch(e) {
    uninstalled = false}
  if(!uninstalled) {
    if(GTB_UninstallExtension("3112ca9c-de6d-4884-a869-9855de68056c")) {
      GTB_Uninstall_showDialog()}
  }
}

function GTB_UpButton() {
  this.observe = GTB_MessageObserve;
  var stringBundle = document.getElementById("google-toolbar-strings");
  this._UP_BUTTON_ENABLED_TOOLTIP = stringBundle.getString("prop.google-up.enabledtooltip");
  this._UP_BUTTON_DISABLED_TOOLTIP = stringBundle.getString("prop.google-up.disabledtooltip");
  this._UP_MENU_MAX_SIZE = 10}

GTB_UpButton._fixSlash = function(url, removeTrailingSlash) {
  if(removeTrailingSlash && url.charAt(url.length - 1) == "/") {
    url = url.substring(0, url.length - 1)}
  else if(!removeTrailingSlash && url.charAt(url.length - 1) != "/") {
    url = url + "/"}
  return url}

;
GTB_UpButton.prototype.GTB_MESSAGES = {"GTB_OPTION.button_option.gtbGoUp":function(data) {
  if("true" == data) {
    GTB_getToolbar().upButton._setUpButton(null)}
}

};
GTB_UpButton.prototype._urlTruncateFilename = function(xpcomUrl) {
  xpcomUrl.query = "";
  xpcomUrl.ref = "";
  if(xpcomUrl.fileName != "") {
    xpcomUrl.fileName = "";
    return xpcomUrl.spec}
  return null}

;
GTB_UpButton.prototype._urlTruncateDirectory = function(xpcomUrl) {
  var dir = xpcomUrl.directory;
  if(dir[dir.length - 1] == "/") {
    dir = dir.substring(0, dir.length - 1)}
  var lastSlash = dir.lastIndexOf("/");
  if(lastSlash != -1) {
    dir = dir.substring(0, lastSlash);
    xpcomUrl.filePath = dir;
    return xpcomUrl.spec}
  else if(dir != "") {
    xpcomUrl.directory = "";
    return xpcomUrl.spec}
  return null}

;
GTB_UpButton.prototype._urlTruncateHostname = function(xpcomUrl) {
  if(xpcomUrl.scheme == "http" || xpcomUrl.scheme == "https") {
    var host = xpcomUrl.host;
    var hostList = host.split(".");
    if(hostList.length <= 2 || hostList.length == 3 && hostList[0] == "www") {
      return null}
    if(!isNaN(parseInt(hostList[hostList.length - 1]))) {
      return null}
    if(hostList[hostList.length - 1].length == 2 && hostList[hostList.length - 2].length <= 3) {
      if(hostList.length == 4 && hostList[0] == "www") {
        return null}
      hostList[hostList.length - 2] += "." + hostList[hostList.length - 1];
      hostList.pop()}
    host = "www." + hostList[hostList.length - 2] + "." + hostList[hostList.length - 1];
    xpcomUrl.host = host;
    return xpcomUrl.spec}
}

;
GTB_UpButton.prototype._urlAbove = function(url, removeTrailingSlash) {
  if(url.length == 0) {
    return null}
  var xpcomUrl = GTB_convertToUrl(url);
  if(!(xpcomUrl  instanceof Components.interfaces.nsIURL))return null;
  switch(xpcomUrl.scheme) {
    case "ftp":case "gopher":case "http":case "https":case "file":break;
    default:return null}
  var aboveUrl = this._urlTruncateFilename(xpcomUrl);
  if(aboveUrl != null) {
    return GTB_UpButton._fixSlash(aboveUrl, removeTrailingSlash)}
  aboveUrl = this._urlTruncateDirectory(xpcomUrl);
  if(aboveUrl != null) {
    return GTB_UpButton._fixSlash(aboveUrl, removeTrailingSlash)}
  aboveUrl = this._urlTruncateHostname(xpcomUrl);
  if(aboveUrl != null) {
    return GTB_UpButton._fixSlash(aboveUrl, removeTrailingSlash)}
  return null}

;
GTB_UpButton.prototype._eventAffectsUpButton = function(event) {
  var upButton = document.getElementById("gtbGoUp");
  if(upButton == null) {
    return false}
  if(event.type == "load" || event.type == "pageshow") {
    var contentWindow = GTB_GoogleToolbarOverlay._getCurrentWindow();
    if(contentWindow.document == event.originalTarget) {
      return true}
  }
  if(event.type == "select") {
    return true}
  return false}

;
GTB_UpButton.prototype._setUpButton = function(event) {
  if(event && !this._eventAffectsUpButton(event)) {
    return}
  var upButton = document.getElementById("gtbGoUp");
  if(upButton == null) {
    return}
  var docLocation = GTB_GoogleToolbarOverlay._getCurrentLocation();
  var urlAbove = null;
  if(docLocation != null) {
    urlAbove = this._urlAbove(docLocation.href, true)}
  if(urlAbove != null) {
    upButton.disabled = false;
    upButton.image = "chrome://google-toolbar/skin/up.png";
    var tooltip = this._UP_BUTTON_ENABLED_TOOLTIP;
    tooltip = tooltip.replace("$up;", urlAbove);
    upButton.tooltipText = tooltip;
    if(upButton.collapsed) {
      var menu = document.getElementById("gtbChevronMenu" + upButton.id);
      if(menu) {
        menu.setAttribute("disabled", false);
        menu.setAttribute("image", upButton.image);
        menu.setAttribute("onclick", upButton.attributes["oncommand"].value)}
    }
  }
  else {
    upButton.disabled = true;
    upButton.image = "chrome://google-toolbar/skin/up-disabled.png";
    upButton.tooltipText = this._UP_BUTTON_DISABLED_TOOLTIP;
    if(upButton.collapsed) {
      var menu = document.getElementById("gtbChevronMenu" + upButton.id);
      if(menu) {
        menu.setAttribute("disabled", true);
        menu.setAttribute("image", upButton.image);
        menu.setAttribute("onclick", null)}
    }
  }
}

;
GTB_UpButton.prototype.onUpMenuClick = function(event) {
  var url = event.target.getAttribute("label");
  GTB_UpButton._fixSlash(url, false);
  GTB_GoogleToolbarOverlay.loadUrlWithModifiers(url, event);
  event.preventBubble()}

;
GTB_UpButton.prototype.onUpdateUpMenu = function(event) {
  var menu = event.target;
  var children = menu.childNodes;
  var index = 0;
  for(var i = children.length - 1;i >= 0; -- i) {
    index = children[i].getAttribute("index");
    if(index) {
      menu.removeChild(children[i])}
  }
  var docLocation = GTB_GoogleToolbarOverlay._getCurrentLocation();
  var nextUrl = this._urlAbove(docLocation.href, true);
  index = 0;
  while(index < this._UP_MENU_MAX_SIZE && nextUrl != null) {
    var menuItem = document.createElement("menuitem");
    menuItem.setAttribute("label", nextUrl);
    menuItem.setAttribute("index", index);
    menu.appendChild(menuItem);
    var favUrl = this._getFaviconUrl(nextUrl);
    if(favUrl) {
      dump(favUrl + "\n");
      menuItem.setAttribute("class", "menuitem-iconic");
      menuItem.setAttribute("image", favUrl)}
    nextUrl = this._urlAbove(nextUrl, true);
    index ++ }
}

;
GTB_UpButton.prototype._getFaviconUrl = function(url) {
  var xpcomUrl = GTB_convertToUrl(url);
  if(!(xpcomUrl  instanceof Components.interfaces.nsIURL))return null;
  if(xpcomUrl.scheme.substring(0, 4) != "http") {
    return}
  return xpcomUrl.scheme + "://" + xpcomUrl.hostPort + "/favicon.ico"}

;
GTB_UpButton.prototype.onGoUp = function(event) {
  if(event.type == "click" && event.target.nodeName == "menuitem") {
    return}
  var docLocation = GTB_GoogleToolbarOverlay._getCurrentLocation();
  if(docLocation != null && docLocation.href != null && docLocation.href.length > 0) {
    var above = this._urlAbove(docLocation.href, false);
    GTB_GoogleToolbarOverlay.loadUrlWithModifiers(above, event)}
}

;
function GTB_UB_onPopupShowing(event) {
  return GTB_GoogleToolbarOverlay.upButton.onUpdateUpMenu(event)}

function GTB_UB_onPopupCommand(event) {
  GTB_GoogleToolbarOverlay.upButton.onUpMenuClick(event)}

function GTB_UB_onButtonCommand(event) {
  GTB_GoogleToolbarOverlay.upButton.onGoUp(event)}

function UserStats() {
  this.reset();
  this.deserialize()}

UserStats.prototype.reset = function() {
  this._map = {}}

;
UserStats.prototype.readUserStatsString = function() {
  var value = GTB_getPrefs().getStringPref(GTB_getPrefs().USER_STATS_PREF);
  if(null == value) {
    value = ""}
  return value}

;
UserStats.prototype.readUserStats = function() {
  this.reset();
  var temp = this.readUserStatsString();
  var tempMap = temp.split(",");
  for(var index in tempMap) {
    var keyValueMap = value.split("=");
    var key = keyValueMap[0];
    try {
      var value = parseInt(keyValueMap[1]);
      this._map[key] = value}
    catch(ex) {
    }
  }
}

;
UserStats.prototype.writeUserStats = function() {
  var temp = "";
  var first = true;
  for(var index in this._map) {
    if(!first) {
      temp += ","}
    temp += temp + index + "=" + this._map[index]}
  this.writeUserStatsString(temp)}

;
UserStats.prototype.writeUserStatsString = function(value) {
  GTB_getPrefs().setStringPref(GTB_getPrefs().USER_STATS_PREF, value)}

;
UserStats.prototype.onClickButton = function(item) {
  if(null != this._map[item]) {
    this._map[item] += 1}
  else {
    this._map[item] = 1}
}

;
function GTB_SearchHistory() {
  this.observe = GTB_MessageObserve;
  var self = this;
  this.GTB_MESSAGES = {"GTB_OPTION.search_box_save_history":function(data) {
    self.doToggleSave(data)}

  , GTB_CLEAR_HISTORY:function(data) {
    self.clearHistory()}

  , GTB_UPDATED_CURRENTSET:function(data) {
    self.init()}

  }}

GTB_SearchHistory._HISTORY_PREF = "search_box_history";
GTB_SearchHistory._HISTORY_MAX_ELEMENTS = 20;
GTB_SearchHistory._restoreMenuListFromGoogleProperty = function(menulist, name) {
  menulist.selectedIndex = -1;
  menulist.removeAllItems();
  var pref = GTB_getPrefs().getUnicodePref(name);
  if(pref === "") {
    return}
  var items = pref.split("\n");
  for(var i = 0;i < items.length;i ++ ) {
    menulist.appendItem(items[i])}
}

;
GTB_SearchHistory._canonicalize = function(text) {
  if(text == null) {
    return text}
  return Trim(text).toLowerCase()}

;
GTB_SearchHistory._isSameQuery = function(query1, query2) {
  return GTB_SearchHistory._canonicalize(query1) == GTB_SearchHistory._canonicalize(query2)}

;
GTB_SearchHistory._getSearchMenuList = function() {
  var menulist = document.getElementById("gtbGoogleSearchBox");
  return menulist}

;
GTB_SearchHistory.prototype._history = "";
GTB_SearchHistory.prototype.GTB_MESSAGES = null;
GTB_SearchHistory.prototype.init = function() {
  var menulist = GTB_SearchHistory._getSearchMenuList();
  this._history = GTB_getPrefs().getUnicodePrefWithDefault(GTB_SearchHistory._HISTORY_PREF, "");
  if(menulist) {
    GTB_SearchHistory._restoreMenuListFromGoogleProperty(menulist, GTB_SearchHistory._HISTORY_PREF)}
}

;
GTB_SearchHistory.prototype._historyCache = function(text) {
  if(text !== "") {
    if(this._history != "") {
      var items = this._history.split("\n");
      var dup = false;
      var newHistory = [text];
      var max = GTB_SearchHistory._HISTORY_MAX_ELEMENTS;
      for(var i = 0;i < items.length && newHistory.length < max;i ++ ) {
        if(!GTB_SearchHistory._isSameQuery(items[i], text)) {
          newHistory.push(items[i])}
        else {
          dup = true}
      }
      this._history = newHistory.join("\n")}
    else {
      this._history = text}
    if(GTB_getPrefs().getBoolPref(GTB_PREF_SAVE_HISTORY)) {
      GTB_getPrefs().setUnicodePref(GTB_SearchHistory._HISTORY_PREF, this._history)}
  }
}

;
GTB_SearchHistory.addHistoryMenuItem = function(menulist, text) {
  var items = menulist.getElementsByTagName("menuitem");
  var count = items.length;
  for(var i = 0;i < count;i ++ ) {
    if(GTB_SearchHistory._isSameQuery(items[i].getAttribute("label"), text)) {
      return false}
  }
  var item = menulist.insertItemAt(0, text);
  item.label = text;
  return true}

;
GTB_SearchHistory.prototype.addToHistory = function(text) {
  if(text === "") {
    return}
  this._historyCache(text);
  var menulist = GTB_SearchHistory._getSearchMenuList();
  if(menulist == null) {
    return}
  if(GTB_SearchHistory.addHistoryMenuItem(menulist, text)) {
    var popup = menulist.menupopup;
    if(popup) {
      popup.setAttribute("maxheight", "200")}
  }
}

;
GTB_SearchHistory.prototype.doToggleSave = function(newValue) {
  if(!newValue || newValue == "false") {
    GTB_getPrefs().setUnicodePref(GTB_SearchHistory._HISTORY_PREF, "")}
  else {
    GTB_getPrefs().setUnicodePref(GTB_SearchHistory._HISTORY_PREF, this._history)}
}

;
GTB_SearchHistory.prototype.clearHistory = function() {
  var menulist = GTB_SearchHistory._getSearchMenuList();
  if(menulist) {
    menulist.selectedIndex = -1;
    menulist.removeAllItems()}
  this._history = "";
  GTB_getPrefs().setUnicodePref(GTB_SearchHistory._HISTORY_PREF, "");
  var overlay = GTB_getToolbar();
  var answer = overlay.highlighter.onSearchTextChanged();
  overlay._enableDisableQueryButtons(answer.hasTerms, answer.hasOps)}

;
function GTB_Suggest() {
  this.observe = GTB_MessageObserve;
  var self = this;
  this.GTB_MESSAGES = {"GTB_OPTION.search_box_use_suggest":function(data) {
    self.doToggleSuggest(data)}

  };
  this.doToggleSuggest(GTB_getPrefs().getBoolPref(GTB_PREF_USE_SUGGEST))}

GTB_Suggest.prototype.doToggleSuggest = function(newValue) {
  var googleSearchBox = document.getElementById("gtbGoogleSearchBox");
  if(googleSearchBox) {
    var searchBox = googleSearchBox.textBox;
    if(!newValue || newValue == "false") {
      searchBox.setAttribute("disableautocomplete", true);
      searchBox.removeEventListener("keypress", GTB_GoogleToolbar._eventHack_onFieldKeyPress, false)}
    else {
      searchBox.setAttribute("disableautocomplete", false);
      searchBox.addEventListener("keypress", GTB_GoogleToolbar._eventHack_onFieldKeyPress, false)}
  }
}

;
function GTB_Tooltip(tippers) {
  this._toolTippers = [];
  for(var i = 0;i < tippers.length;i ++ ) {
    this._toolTippers.push(tippers[i])}
  this._rangeParent = null;
  this._rangeOffset = 0}

GTB_Tooltip.GTB_TOOLTIP_ID = "aHTMLTooltip";
GTB_Tooltip.prototype.maybeShowTooltip = function(tipElement) {
  var menu = document.getElementById("contentAreaContextMenu");
  if(0 != menu.boxObject.screenX || 0 != menu.boxObject.screenY) {
    return false}
  var parent = this._rangeParent;
  var offset = this._rangeOffset;
  if(parent == null) {
    return false}
  var match = null;
  var tts = this._toolTippers;
  for(var ttNum = 0;ttNum < tts.length; ++ ttNum) {
    match = tts[ttNum].getTooltipBody(parent, offset, tipElement);
    if(match != null) {
      break}
  }
  if(match == null) {
    return false}
  if(match.length > 0) {
    GTB_Tooltip._updateTooltip(match)}
  return true}

;
GTB_Tooltip._updateTooltip = function(match) {
  var tooltip = document.getElementById(GTB_Tooltip.GTB_TOOLTIP_ID);
  tooltip.removeAttribute("label");
  while(tooltip.hasChildNodes()) {
    tooltip.removeChild(tooltip.firstChild)}
  for(var c in match) {
    tooltip.appendChild(match[c])}
  tooltip.width = "";
  tooltip.height = "";
  tooltip.sizeTo(tooltip.boxObject.width, tooltip.boxObject.height);
  tooltip.isGoogleTooltip = true}

;
GTB_Tooltip.prototype.doMouseMove = function(event) {
  this.updateCursorPosition(event);
  GTB_Tooltip.maybeHideTooltip(event)}

;
GTB_Tooltip.prototype.updateCursorPosition = function(event) {
  this._rangeParent = event.rangeParent;
  this._rangeOffset = event.rangeOffset}

;
GTB_Tooltip.maybeHideTooltip = function() {
  var tooltip = document.getElementById(GTB_Tooltip.GTB_TOOLTIP_ID);
  if(tooltip.isGoogleTooltip) {
    tooltip.hidePopup()}
}

;
function GTB_TooltipDefault() {
}

GTB_TooltipDefault.prototype.getTooltipBody = function(parent, offset, tipElement) {
  if(FillInHTMLTooltip(tipElement)) {
    var tooltip = document.getElementById(GTB_Tooltip.GTB_TOOLTIP_ID);
    while(tooltip.hasChildNodes()) {
      tooltip.removeChild(tooltip.firstChild)}
    tooltip.width = "";
    tooltip.height = "";
    tooltip.sizeTo(tooltip.boxObject.width, tooltip.boxObject.height);
    tooltip.isGoogleTooltip = false;
    return[]}
  return null}

;
function GTB_TT_XULTooltipAlert(node, msg, setWindowStatus) {
  if(!node) {
    return}
  var tooltip = document.getElementById("gtbBtnTooltip");
  if(tooltip.timeout) {
    window.clearTimeout(tooltip.timeout);
    if(tooltip.statusMsg) {
      window.status = tooltip.statusMsg;
      tooltip.statusMsg = null}
  }
  var descs = tooltip.getElementsByTagName("description");
  if(descs && descs.length == 1) {
    descs[0].setAttribute("value", msg)}
  document.popupNode = node;
  tooltip.showPopup(node, node.boxObject.screenX + 10, node.boxObject.screenY + node.boxObject.height, "tooltip");
  if(setWindowStatus) {
    var toolbar = document.getElementById("gtbToolbar");
    var name = toolbar.getAttribute("toolbarname");
    var statusbar = document.getElementById("statusbar-display");
    if(statusbar && statusbar.label) {
      tooltip.statusMsg = statusbar.label}
    window.status = name + ": " + msg}
  tooltip.timeout = window.setTimeout(GTB_TT_hideTooltip, 2000, tooltip)}

function GTB_TT_hideTooltip(tooltip) {
  tooltip.hidePopup();
  if(tooltip.statusMsg) {
    window.status = tooltip.statusMsg;
    tooltip.statusMsg = null}
  tooltip.timeout = null}

function GTB_TT_maybeSurpressTooltip(event) {
  var tt = document.tooltipNode;
  if(tt) {
    var parentId = tt.parentNode && tt.parentNode.id;
    if(parentId && parentId.substr(0, 3) == "gtb" && "menuitem" == tt.nodeName && tt.getAttribute("tooltiptext") == "") {
      event.preventDefault()}
    var btnTooltip = document.getElementById("gtbBtnTooltip");
    if(btnTooltip) {
      btnTooltip.hidePopup()}
  }
}

var GTB_FS_PREF_AGGREGATORS = "subscribe.aggregators";
var GTB_FS_PREF_AGGREGATORS_PREFIX = "subscribe.aggregators.";
var GTB_FS_PREF_CURRENT = "subscribe.aggregatorid";
var GTB_FS_PREF_DEFAULT = "subscribe.defaultid";
var GTB_FS_PREF_LAST_REFRESHED = "subscribe.lastrefreshed";
function GTB_FS_getFS() {
  return GTB_getToolbar().feedSubscribe}

function GTB_FS_getAggMgr() {
  return GTB_FS_getFS().aggregatorsManager}

function GTB_FS_Dump(text) {
  GTB_Dump(GTB_Dump.FS, "[GTB_FS]>>> " + text + "\n")}

function GTB_FeedSubscribe() {
  GTB_FS_Dump("Initialization");
  this.strings = new GTB_FS_Strings;
  this.aggregatorsManager = new GTB_FS_AggregatorsManager;
  this.aggregatorsManager.refreshAggregatorsFromWeb();
  this.observe = GTB_MessageObserve;
  var browser = GTB_GoogleToolbarOverlay._getTabBrowser();
  browser.addEventListener("DOMLinkAdded", GTB_FS_onDomLinkAdded, false);
  this.updateButtonState()}

GTB_FeedSubscribe.prototype.doPageHideOrUnload = function(event) {
  var button = document.getElementById("gtbFeedSubscribe");
  if(!button) {
    return}
  GTB_FS_Dump("received doPageHideOrUnload");
  var doc = event.target;
  if(doc && doc.location) {
    GTB_FS_Dump("Target = " + doc.location.href)}
  var browser = GTB_GoogleToolbarOverlay._getBrowserFromDoc(doc);
  if(browser) {
    GTB_FS_Dump("Browser.contentDocument = " + browser.contentDocument.location.href);
    if(event.target == browser.contentDocument && browser.GTB_feedLocator) {
      GTB_FS_Dump("Found feed locator for the browser, setting to null");
      browser.GTB_feedLocator = null;
      this.updateButtonState()}
  }
  else {
    GTB_FS_Dump("Browser not available, can't clean up feed information")}
}

;
GTB_FeedSubscribe.prototype.doTabSwitch = function() {
  GTB_FS_Dump("Received doTabSwitch");
  this.updateButtonState()}

;
GTB_FeedSubscribe.prototype.doDomLinkAdded = function(event) {
  var button = document.getElementById("gtbFeedSubscribe");
  if(!button) {
    return}
  GTB_FS_Dump("Received doDomLinkAdded");
  var safeGetProperty = function(obj, propname) {
    return Components.lookupMethod(obj, propname).call(obj)}

  ;
  var targetDoc = safeGetProperty(event.target, "ownerDocument");
  var browser = GTB_GoogleToolbarOverlay._getBrowserFromDoc(targetDoc);
  if(browser.GTB_feedLocator == null) {
    GTB_FS_Dump("Allocating feed locator for current browser (onDomLinkAdded)");
    browser.GTB_feedLocator = new GTB_FS_FeedLocator}
  var feedFound = browser.GTB_feedLocator.addLinkIfFeed(event.target, targetDoc, true);
  if(feedFound && browser == GTB_GoogleToolbarOverlay._getCurrentBrowser()) {
    this.updateButtonState()}
}

;
GTB_FeedSubscribe.prototype.doPageShowOrLoad = function(event) {
  var button = document.getElementById("gtbFeedSubscribe");
  if(!button) {
    return}
  GTB_FS_Dump("received doPageShowOrLoad");
  var doc = event.target;
  var browser = GTB_GoogleToolbarOverlay._getBrowserFromDoc(doc);
  if(browser.GTB_feedLocator == null) {
    GTB_FS_Dump("Allocating feed locator for current browser (doPageLoad)");
    browser.GTB_feedLocator = new GTB_FS_FeedLocator}
  var feedsFound = browser.GTB_feedLocator.locateFeeds(doc, false);
  if(feedsFound) {
    this.updateButtonState()}
}

;
GTB_FeedSubscribe.prototype.numberOfFeedsFound = function() {
  var result = 0;
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  if(browser.GTB_feedLocator && browser.GTB_feedLocator.feedsList) {
    result = browser.GTB_feedLocator.feedsList.length}
  return result}

;
GTB_FeedSubscribe.prototype.updateButtonState = function() {
  GTB_FS_Dump("Updating subscribe button state");
  var subscribeButton = document.getElementById("gtbFeedSubscribe");
  if(subscribeButton) {
    if(this.numberOfFeedsFound() > 0) {
      GTB_FS_Dump("enabling button");
      subscribeButton.disabled = false;
      subscribeButton.image = "chrome://google-toolbar/skin/subscribe.png";
      if(this.numberOfFeedsFound() > 1) {
        subscribeButton.type = "menu";
        subscribeButton.label = this.strings.SUBSCRIBE_LABEL + "  "}
      else {
        subscribeButton.type = "menu-button";
        subscribeButton.label = this.strings.SUBSCRIBE_LABEL}
    }
    else {
      window.setTimeout(GTB_hitch(this, this._updateButtonStateDelayed), 50)}
  }
}

;
GTB_FeedSubscribe.prototype._updateButtonStateDelayed = function() {
  if(this.numberOfFeedsFound() == 0) {
    var subscribeButton = document.getElementById("gtbFeedSubscribe");
    GTB_FS_Dump("disabling button");
    subscribeButton.disabled = true;
    subscribeButton.image = "chrome://google-toolbar/skin/subscribe-off.png"}
}

;
GTB_FeedSubscribe.prototype.doUpdatePopupMenu = function(menu) {
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  var fl = browser.GTB_feedLocator;
  GTB_FS_Dump("doUpdatePopupMenu: adding " + fl.feedsList.length + " feeds to pup-up menu");
  var items = menu.getElementsByTagName("menuitem");
  while(items.length > 1) {
    menu.removeChild(items[0])}
  fl.processForDisplay();
  var separator = menu.getElementsByTagName("menuseparator")[0];
  for(var i = 0;i < fl.feedsList.length;i ++ ) {
    var feed = fl.feedsList[i];
    var mi = document.createElement("menuitem");
    var labelText = this.strings.SUBSCRIBE_TO;
    labelText = labelText.replace("&feedTitle;", feed.displayTitle);
    mi.setAttribute("label", labelText);
    mi.GTB_FS_index = i;
    menu.insertBefore(mi, separator)}
  GTB_FS_Dump("Added " + fl.feedsList.length + " feeds to menu")}

;
GTB_FeedSubscribe.prototype.doOpenPrefs = function() {
  window.openDialog("chrome://google-toolbar/content/options-subscribe.xul", "gtbFeedSubscribeOptions", "modal,centerscreen,chrome,resizable=no")}

;
GTB_FeedSubscribe.prototype.performSubscribe = function(feed) {
  var aggUrl = GTB_FS_getAggMgr().loadCurrentAggregator().url;
  if(aggUrl == "LiveBookmarksUrl") {
    BookmarksUtils.addLivemark("", feed.url, feed.contentTitle)}
  else {
    var targetUrl = aggUrl.replace(/%feed%/, feed.url);
    var browserAccess = new nsBrowserAccess;
    var ios = Components.classes["@mozilla.org/network/io-service;1"].getService(Components.interfaces.nsIIOService);
    var xpcomUrl = ios.newURI(targetUrl, null, null);
    browserAccess.openURI(xpcomUrl, null, nsCI.nsIBrowserDOMWindow.OPEN_DEFAULTWINDOW, null)}
}

;
GTB_FeedSubscribe.prototype.doSubscribeButtonClicked = function() {
  GTB_GoogleToolbarOverlay.maybeShowUsage("subscribe_used", OptionsDialog.MORE_URL_FEEDSUBSCRIBE);
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  var fl = browser.GTB_feedLocator;
  fl.processForDisplay();
  this.performSubscribe(fl.feedsList[0])}

;
GTB_FeedSubscribe.prototype.doFeedClicked = function(menuitem) {
  GTB_GoogleToolbarOverlay.maybeShowUsage("subscribe_used", OptionsDialog.MORE_URL_FEEDSUBSCRIBE, OptionsDialog.MORE_WINDOW_FLAGS_MODAL);
  var browser = GTB_GoogleToolbarOverlay._getCurrentBrowser();
  if(menuitem.GTB_FS_index != null) {
    var feed = browser.GTB_feedLocator.feedsList[menuitem.GTB_FS_index];
    this.performSubscribe(feed)}
}

;
GTB_FeedSubscribe.prototype.doToggleSubscribeButton = function(data) {
  var toolbar = GTB_getToolbar();
  var browsers = toolbar._getTabBrowser().browsers;
  for(var i = 0;i < browsers.length;i ++ ) {
    var browser = browsers[i];
    browser.GTB_feedLocator = null;
    if(data == "true" && browser.contentDocument) {
      GTB_FS_Dump("Allocating feed locator for tab " + i);
      browser.GTB_feedLocator = new GTB_FS_FeedLocator;
      window.setTimeout(GTB_hitch(this, this._locateFeedsTimeout), 0, browser)}
  }
}

;
GTB_FeedSubscribe.prototype._locateFeedsTimeout = function(browser) {
  browser.GTB_feedLocator.locateFeeds(browser.contentDocument, true);
  if(browser == GTB_GoogleToolbarOverlay._getCurrentBrowser()) {
    this.updateButtonState()}
}

;
GTB_FeedSubscribe.prototype.GTB_MESSAGES = {"GTB_OPTION.button_option.gtbFeedSubscribe":function(data) {
  GTB_FS_Dump("Received message GTB_OPTION.button_option.gtbFeedSubscribe, data = " + data);
  GTB_FS_getFS().doToggleSubscribeButton(data)}

};
function GTB_FS_Strings() {
  var strings = document.getElementById("google-toolbar-strings");
  var propPrefix = "google-feedsubscribe.";
  this.SUBSCRIBE_TO = strings.getString(propPrefix + "subscribeTo");
  this.LIVEBOOKMARKS_TITLE = strings.getString(propPrefix + "liveBookmarksTitle");
  this.LIVEBOOKMARKS_DESC = strings.getString(propPrefix + "liveBookmarksDesc");
  this.SUBSCRIBE_LABEL = strings.getString(propPrefix + "subscribeLabel")}

function GTB_FS_onDomLinkAdded(event) {
  GTB_GoogleToolbarOverlay.feedSubscribe.doDomLinkAdded(event)}

function GTB_FS_onFeedSubscribe(event) {
  GTB_FS_Dump("Received GTB_FS_onFeedSubscribe");
  if(event.type == "click" && event.target.nodeName == "menuitem") {
    return}
  GTB_GoogleToolbarOverlay.feedSubscribe.doSubscribeButtonClicked()}

function GTB_FS_onOpenPrefs(event) {
  GTB_FS_Dump("Received GTB_FS_onOpenPrefs");
  GTB_GoogleToolbarOverlay.feedSubscribe.doOpenPrefs(event);
  event.preventBubble()}

function GTB_FS_onButtonMenuPopupShowing(event) {
  GTB_GoogleToolbarOverlay.feedSubscribe.doUpdatePopupMenu(event.target)}

function GTB_FS_onButtonMenuCommand(event) {
  GTB_FS_Dump("Received GTB_FS_onButtonMenuCommand");
  GTB_GoogleToolbarOverlay.feedSubscribe.doFeedClicked(event.target);
  event.preventBubble()}

function GTB_FS_Aggregator() {
  this.id = "";
  this.title = "";
  this.desc = "";
  this.url = "";
  this.order = -1}

GTB_FS_Aggregator.prototype.saveToPref = function() {
  var prefs = GTB_getPrefs();
  if(this.id !== "") {
    prefs.setStringPref(GTB_FS_PREF_AGGREGATORS_PREFIX + this.id + ".id", this.id);
    prefs.setUnicodePref(GTB_FS_PREF_AGGREGATORS_PREFIX + this.id + ".title", this.title);
    prefs.setUnicodePref(GTB_FS_PREF_AGGREGATORS_PREFIX + this.id + ".desc", this.desc);
    prefs.setUnicodePref(GTB_FS_PREF_AGGREGATORS_PREFIX + this.id + ".url", this.url);
    prefs.setStringPref(GTB_FS_PREF_AGGREGATORS_PREFIX + this.id + ".order", this.order.toString())}
}

;
GTB_FS_Aggregator.prototype.fromXML = function(xmlNode) {
  var attrs = xmlNode.attributes;
  if(attrs.getNamedItem("id") && attrs.getNamedItem("id").value !== "") {
    this.id = attrs.getNamedItem("id").value;
    if(attrs.getNamedItem("title")) {
      this.title = attrs.getNamedItem("title").value}
    if(attrs.getNamedItem("desc")) {
      this.desc = attrs.getNamedItem("desc").value}
    if(attrs.getNamedItem("url")) {
      this.url = attrs.getNamedItem("url").value}
    return true}
  return false}

;
GTB_FS_Aggregator.prototype.fromPref = function(id) {
  var prefs = GTB_getPrefs();
  this.id = id;
  this.title = prefs.getUnicodePref(GTB_FS_PREF_AGGREGATORS_PREFIX + id + ".title");
  this.url = prefs.getUnicodePref(GTB_FS_PREF_AGGREGATORS_PREFIX + id + ".url");
  this.desc = prefs.getUnicodePref(GTB_FS_PREF_AGGREGATORS_PREFIX + id + ".desc");
  this.order = parseInt(prefs.getStringPref(GTB_FS_PREF_AGGREGATORS_PREFIX + id + ".order"))}

;
GTB_FS_Aggregator.prototype.toString = function() {
  return"Aggregator (id=" + this.id + ", url=" + this.url + ")"}

;
function GTB_FS_Feed(url) {
  this.title = "";
  this.contentTitle = "";
  this.displayTitle = "";
  this.url = url;
  this.content = "";
  this.type = ""}

GTB_FS_Feed.prototype.toString = function() {
  return"feed [url=" + this.url + ", title=" + this.title + "]"}

;
GTB_FS_Feed.prototype.setContent = function(content) {
  this.content = content;
  var titleElements = content.getElementsByTagName("title");
  if(titleElements.length > 0) {
    this.contentTitle = titleElements[0].textContent}
}

;
function GTB_FS_FeedLocator() {
  this.feedsList = [];
  this.feedsProcessed = false}

GTB_FS_FeedLocator.prototype.toString = function() {
  return"GTB_FS_FeedLocator: feeds=" + this.feedsList.length}

;
GTB_FS_FeedLocator.prototype.getAbsoluteUri = function(uri, doc) {
  var link = doc.createElement("a");
  link.href = uri;
  return link.href}

;
GTB_FS_FeedLocator.prototype.numberOfFeedsPending = function() {
  var result = 0;
  for(var i = 0;i < this.feedsList.length;i ++ ) {
    if(this.feedsList[i].content == "") {
      result ++ }
  }
  return result}

;
GTB_FS_FeedLocator.prototype.processForDisplay = function() {
  if(this.feedsProcessed == true) {
    return}
  var allContentTitlesAvailable = true;
  var allContentTitlesUnique = true;
  var contentTitles = {};
  var resultFeeds = [];
  for(var i = 0;i < this.feedsList.length;i ++ ) {
    var feed = this.feedsList[i];
    if(feed.contentTitle === "") {
      allContentTitlesAvailable = false;
      break}
    if(!(feed.contentTitle  in  contentTitles)) {
      contentTitles[feed.contentTitle] = feed.type;
      resultFeeds.push(feed)}
    else if(contentTitles[feed.contentTitle] == feed.type) {
      allContentTitlesUnique = false;
      resultFeeds.push(feed)}
    else {
      GTB_FS_Dump(feed + " was determined to be a different format of another feed, dropping")}
  }
  if(allContentTitlesAvailable) {
    this.feedsList = resultFeeds;
    this.feedsProcessed = true}
  for(i = 0;i < this.feedsList.length;i ++ ) {
    if(allContentTitlesAvailable) {
      if(allContentTitlesUnique) {
        this.feedsList[i].displayTitle = this.feedsList[i].contentTitle}
      else {
        this.feedsList[i].displayTitle = this.feedsList[i].contentTitle + " - " + this.feedsList[i].title}
    }
    else {
      if(this.feedsList[i].title == "") {
        this.feedsList[i].displayTitle = this.feedsList[i].url}
      else {
        this.feedsList[i].displayTitle = this.feedsList[i].title}
    }
  }
}

;
GTB_FS_FeedLocator.prototype.locateFeeds = function(doc, checkAlternates) {
  this.processContent(doc);
  this.processAnchors(doc);
  if(checkAlternates == true) {
    this.processAlternates(doc)}
  return this.feedsList.length > 0}

;
GTB_FS_FeedLocator.prototype.processContent = function(doc) {
  if(this.isFeedDescription(doc)) {
    var href = doc.location.href;
    if(href.toLowerCase().indexOf("http://") != 0) {
      GTB_FS_Dump("Skipping current doc since it's not http, href=" + href);
      return}
    var feed = new GTB_FS_Feed(href);
    feed.setContent(doc);
    this.addFeed(feed)}
}

;
GTB_FS_FeedLocator.prototype.processAlternates = function(doc) {
  var links = doc.getElementsByTagName("link");
  for(var i = 0;i < links.length;i ++ ) {
    this.addLinkIfFeed(links[i], doc, true)}
}

;
GTB_FS_FeedLocator.prototype.processAnchors = function(doc) {
  var anchors = doc.getElementsByTagName("a");
  for(var i = 0;i < anchors.length;i ++ ) {
    this.addLinkIfFeed(anchors[i], doc, false)}
}

;
GTB_FS_FeedLocator.prototype.addLinkIfFeed = function(link, doc, requireAlternate) {
  var FEED_MIME_TYPES = {"application/rss+xml":"rss", "text/xml":"???", "application/atom+xml":"atom", "application/x.atom+xml":"atom", "application/x-atom+xml":"atom"};
  var rel = link.getAttribute("rel");
  var type = link.getAttribute("type");
  var href = link.getAttribute("href");
  var title = link.getAttribute("title");
  if(!href || !type) {
    return false}
  if(requireAlternate) {
    var isAlternate = false;
    if(rel) {
      var rels = rel.split(/\s+/);
      for(var j = 0;j < rels.length;j ++ ) {
        if(rels[j].toLowerCase() == "alternate") {
          isAlternate = true}
      }
    }
    if(!isAlternate) {
      GTB_FS_Dump("rel attribute does not contain 'alternate' for href=" + href + ", skipping");
      return false}
  }
  if(href.toLowerCase().indexOf("javascript:") != -1) {
    GTB_FS_Dump("Skipping link since it's javascript, href=" + href);
    return false}
  type = type.toLowerCase();
  if(!FEED_MIME_TYPES[type]) {
    GTB_FS_Dump("Skipping link since its type is not indicating feed, href=" + href + ", type=" + type);
    return false}
  var absoluteUri = this.getAbsoluteUri(href, doc);
  if(absoluteUri.toLowerCase().indexOf("http://") != 0) {
    GTB_FS_Dump("Skipping link since it's not http, href=" + absoluteUri);
    return false}
  var feed = new GTB_FS_Feed(absoluteUri);
  if(title) {
    feed.title = title}
  if(type) {
    feed.type = type}
  this.addFeed(feed);
  return true}

;
GTB_FS_FeedLocator.prototype.isFeedDescription = function(doc) {
  if(doc.getElementsByTagName("html").length > 0) {
    return false}
  return(doc.getElementsByTagName("rss").length || doc.getElementsByTagName("channel").length || doc.getElementsByTagName("feed").length) > 0}

;
GTB_FS_FeedLocator.prototype.addFeed = function(feed) {
  for(var i = 0;i < this.feedsList.length;i ++ ) {
    if(this.feedsList[i].url == feed.url) {
      GTB_FS_Dump(feed + " already exists, skipping");
      return}
  }
  this.feedsProcessed = false;
  this.feedsList.push(feed);
  GTB_FS_Dump("Added " + feed);
  if(feed.content === "") {
    var feedLocator = this;
    var request = new XMLHttpRequest;
    request.feed = feed;
    request.open("GET", feed.url, true);
    request.setRequestHeader("X-moz", "prefetch");
    function handleReadyStateChange() {
      if(request.readyState == 4 && request.status == 200 && request.responseXML) {
        if(feedLocator.isFeedDescription(request.responseXML)) {
          feed.setContent(request.responseXML);
          if(feedLocator.numberOfFeedsPending() == 0) {
            feedLocator.processForDisplay();
            GTB_FS_getFS().updateButtonState()}
        }
      }
    }

    ;
    request.onreadystatechange = handleReadyStateChange;
    try {
      request.send(null)}
    catch(err) {
      GTB_FS_Dump("XMLHttpRequest failed for " + feed + ", ignoring")}
  }
}

;
function GTB_FS_AggregatorsManager() {
}

GTB_FS_AggregatorsManager.prototype.loadCurrentAggregator = function() {
  var prefs = GTB_getPrefs();
  var result = null;
  try {
    this.maybeInitCurrentAggregator();
    var currentId = prefs.getStringPref(GTB_FS_PREF_CURRENT);
    var agg = new GTB_FS_Aggregator;
    agg.fromPref(currentId);
    result = agg}
  catch(exc) {
  }
  if(result == null) {
    GTB_FS_Dump("Current setting isn't available, reporting first aggregator");
    var aggs = this.loadAggregatorsFromPrefs();
    result = aggs[0]}
  return result}

;
GTB_FS_AggregatorsManager.prototype.loadAggregatorsFromPrefs = function() {
  var aggs = [];
  var prefs = GTB_getPrefs();
  var children = prefs.getNamesOfChildren(GTB_FS_PREF_AGGREGATORS, {});
  if(children.length > 0) {
    for(var i = 0;i < children.length;i ++ ) {
      var current = children[i];
      if(current.indexOf(".id") == current.length - ".id".length) {
        var id = prefs.getStringPref(GTB_FS_PREF_AGGREGATORS_PREFIX + current);
        var agg = new GTB_FS_Aggregator;
        agg.fromPref(id);
        aggs.push(agg)}
    }
    aggs.sort(function(a, b) {
      if(a.order > b.order)return 1;
      if(a.order < b.order)return-1;
      return 0}

    );
    GTB_FS_Dump("Loaded " + aggs.length + " aggregators from preferences")}
  else {
    GTB_FS_Dump("No aggregators in preferences, reporting default aggregator");
    var agg = new GTB_FS_Aggregator;
    agg.id = "LiveBookmarks";
    agg.url = "LiveBookmarksUrl";
    agg.desc = GTB_FS_getFS().strings.LIVEBOOKMARKS_DESC;
    agg.title = GTB_FS_getFS().strings.LIVEBOOKMARKS_TITLE;
    agg.order = 0;
    aggs.push(agg)}
  return aggs}

;
GTB_FS_AggregatorsManager.prototype.isRefreshNeeded = function() {
  var prefs = GTB_getPrefs();
  var lastRefreshed = null;
  try {
    lastRefreshed = new Date(prefs.getStringPref(GTB_FS_PREF_LAST_REFRESHED))}
  catch(exc) {
    lastRefreshed = new Date(1990, 1, 1)}
  var currentDate = new Date;
  var diffMilliseconds = currentDate.valueOf() - lastRefreshed.valueOf();
  if(diffMilliseconds >= 86400000) {
    return true}
  GTB_FS_Dump("Last aggregators list refresh was done just " + diffMilliseconds + " milliseconds ago, will not refresh now");
  return false}

;
GTB_FS_AggregatorsManager.prototype.refreshAggregatorsFromWeb = function() {
  if(this.isRefreshNeeded()) {
    GTB_FS_Dump("Requesting aggregators list from server");
    var prefs = GTB_getPrefs();
    var url;
    try {
      url = prefs.getStringPref("subscribe.aggregatorURL")}
    catch(e) {
      url = "http://google.com/tools/firefox/toolbar/FT2/intl/{LANG}/aggregators.xml"}
    prefs = null;
    url = url.replace(/{LANG}/, GTB_getToolbar().languageCode);
    var request = new XMLHttpRequest;
    request.open("GET", url, true);
    request.setRequestHeader("Cache-Control", "no-cache");
    request.onreadystatechange = function(aEvt) {
      if(request.readyState == 4 && request.status == 200 && request.responseXML) {
        var aggNodes = request.responseXML.getElementsByTagName("aggregator");
        if(aggNodes && aggNodes.length >= 1) {
          var prefs = GTB_getPrefs();
          prefs.deleteBranch(GTB_FS_PREF_AGGREGATORS);
          for(var i = 0;i < aggNodes.length;i ++ ) {
            var agg = new GTB_FS_Aggregator;
            if(agg.fromXML(aggNodes[i])) {
              agg.order = i;
              agg.saveToPref()}
          }
          var defaultNodes = request.responseXML.getElementsByTagName("default");
          if(defaultNodes.length > 0) {
            var defaultId = defaultNodes[0].textContent;
            prefs.setStringPref(GTB_FS_PREF_DEFAULT, defaultId);
            GTB_FS_Dump("Received default aggregator, id=" + defaultId)}
          var currentDate = new Date;
          prefs.setStringPref(GTB_FS_PREF_LAST_REFRESHED, currentDate.toString());
          GTB_FS_Dump("Successfully refreshed aggregators list, total " + aggNodes.length + " aggregators")}
      }
    }

    ;
    request.send(null)}
}

;
GTB_FS_AggregatorsManager.prototype.isValidAggregator = function(id) {
  var prefs = GTB_getPrefs();
  try {
    prefs.getUnicodePref(GTB_FS_PREF_AGGREGATORS_PREFIX + id + ".url")}
  catch(err) {
    return false}
  return true}

;
GTB_FS_AggregatorsManager.prototype.maybeInitCurrentAggregator = function() {
  var prefs = GTB_getPrefs();
  var currentId = prefs.getStringPref(GTB_FS_PREF_CURRENT);
  if(this.isValidAggregator(currentId) == false) {
    currentId = prefs.getStringPref(GTB_FS_PREF_DEFAULT);
    if(this.isValidAggregator(currentId) == false) {
      currentId = "LiveBookmarks"}
    prefs.setStringPref(GTB_FS_PREF_CURRENT, currentId);
    GTB_FS_Dump("Initialized current aggregator pref, id=" + currentId)}
}

;
function PROTTB_thisFirefoxIsSafeBrowsingCompatible() {
  var compatible = false;
  try {
    var Cc = Components.classes;
    var appContext = Cc["@google.com/tbsafebrowsing/application;1"].getService();
    appContext = appContext.wrappedJSObject.appContext;
    if(appContext.PROT_Application.isCompatibleWithThisFirefox())compatible = true}
  catch(e) {
  }
  return compatible}

;