g1 d lK6
ox[Ae|,Y--ϭ 55oep_
_Oɝ벜_h**Qks@n 6ecdv^\] S/t/ { Md/@~6
ېZ4&*C;lqo)ɇv YI~ 7_Ymn${/eC-{I!ǓM.iʞ;^IZ|j?-@wN$wh' rT<2jpSm~ qu#U#m'%-~ΚoNXm6V&١/ SALA9x, \zwGW`D_&؟'UQZ6 D﨟3VNQRkRԸ\8&
AIJ9(/osi.Th*}: \%Տ.;qUT傟JfDT]qedOúVN||
@c,Jcy}t}jU*6sǚ?Hx7F暇
_L
o^k74B
ǍTø4܂E,6v`LDz>[dݹp N>YP1İJ3e)8y29`Yuq̘ ROZiUl;kZF~dQa͎h{=^M)薤)Ax"`]$ vH.?] ]|,Lc=յGG3; 5$3p=|GI6kB2,&(@й=4GmunM/>パ'P+a7;;| I5G[qGV^sN
|>t7 xp4>^Fu]suxGQTjXj |L[/ M D
Ԅ͌\+\!eIf({ŀjpx/c-o^w x?`A1V {ŹXR_ fTm D1u"J> A$սA@%;Pn@fMQ f?H<:S^X
wJ[^%k (T
z%]L0 eC||}Dfw ,kgmhC /._ U@e MP5u:SX6eʭ[{s/NEIt(rM3ePcDoYբ:sbZG9Сl0}?_6rOzLN
ԯ+E$L-_ w&=ۣʘ,p
ָ!Zb7V3-
ΞIAIYzgqJ y Nˀ.t (S@T].gkP<q]KUb[6Ez272 89}%̧e(TGwF By Oy' T#4F֓a? Nۚ· ެ ͞{̇Wrg7 UOuG7&hu7X#,Y$ؾ6L\]5Y=ϗڱ:~} S;omuKU8'nql! ,+#rF]oi
aK`a$A"*NO/BWK jon0 }iȓ:2gYUpb
p M6IXMSPMwe4;
$3wD bQ(;
.?'RB{U֦B %5ȑ/?i,gp^Vs+@:5H7PK
[&4\Y4
content/browser/spuiDialog.xulUT 1žCCUx
PK
[&4[w w content/browser/spuiOverlay.xulUT 0žCCUx
PK
[&4Gu!H| H| content/browser/passcardUtils.jsUT 0žCCUx /*
PasscardUtils
Initial refactoring of code from browser.js: JMckenty
*/
var kDefaultPasscard = "DefaultPasscard";
var kScreenNameService = "ScreenNameService";
var gPasscardMgr = null;
function passcardUtilsInit()
{
gPasscardMgr = Components.classes["@mozilla.org/passwordmanager;1"]
.getService(Components.interfaces.nsIPasswordManager);
}
function passcardDebug(aStr)
{
if (gPrefService.getPrefType("passcard.debug") &&
gPrefService.getBoolPref("passcard.debug"))
{
dump('PASSCARD: '+aStr+'\n');
}
}
function PasscardBlacklistSite()
{
gPasscardMgr.addReject(gBrowser.currentURI.host);
}
function PasscardIsSiteBlacklisted(aURI)
{
if (!aURI) return false;
if (!(aURI.scheme == 'http' || aURI.scheme == 'https'))
return false;
var dotTestHost = '.'+aURI.host.toLowerCase();
var enumerator = gPasscardMgr.rejectEnumerator;
while (enumerator.hasMoreElements()) {
var nextReject = enumerator.getNext();
nextReject.QueryInterface(Components.interfaces.nsIPassword);
var dotRejectHost = '.'+nextReject.host.toLowerCase();
var idx = dotTestHost.indexOf(dotRejectHost);
if (idx == -1) continue;
var tmp = dotTestHost.substring(idx);
if (tmp == dotRejectHost) return true;
}
return false;
}
function SetAsPasscardDefault(menulist)
{
passcardDebug('passcard uniqueID: ' + menulist.selectedItem.value);
var realm = new Object();
gPasscardMgr.getDomain(gBrowser.currentURI, realm);
passcardDebug('SetAsPasscardDefault(): realm: ' + realm.value);
gPasscardMgr.setAsLastUsedSignon(realm.value, menulist.selectedItem.value);
// update the passcard button label on the toolbar
SetPasscard();
/* used for testing
dump('***Passcard URI: ' + gBrowser.currentURI.host + '\n');
var enumerator = passwordManager.enumerator;
while (enumerator.hasMoreElements()) {
var nextPassword = enumerator.getNext();
nextPassword = nextPassword.QueryInterface(Components.interfaces.nsIPassword);
dump("***Passcard -- passcard: " + nextPassword.passcard +
" uniqueID: " + nextPassword.uniqueID + " lastUsed: " + nextPassword.lastUsed + "\n");
}
*/
}
// MERC - JCH: Fix for BLT#161274. If notification bar "Don't Show Again" checkbox
// is checked, hide the notification bar whenever passcard detects the site.
function SetDoNotShowPasscardMessageBar(list,checkbox)
{
if (gPasscardMgr == null)
return;
const DONT_SHOW_NOTIFICATION_BAR = 3;
const SHOW_NOTIFICATION_BAR = 0;
var currentURI = getWebNavigation().currentURI;
// realm is the base domain
var realm = new Object();
gPasscardMgr.getDomain(currentURI, realm);
var passcard = GetPasscard(realm.value, list.label);
var newval;
if (checkbox.checked) {
newval = DONT_SHOW_NOTIFICATION_BAR;
} else {
newval = SHOW_NOTIFICATION_BAR;
}
// Update passcard data.
gPasscardMgr.updateSignon(passcard.host, passcard.passcard, passcard.user, passcard.password,
newval, passcard.protect, passcard.lastUsed, passcard.uniqueID,
passcard.advancedFields, passcard.fraudProtected, passcard.snsEnabled);
}
function isPasscardHighlight()
{
if (passcardPreferences('Highlight') != "0")
return true;
return false;
}
function openSelectedPasscard(menulist) {
//var menulist = document.getElementById('messagePasscardList');
var passcardName = menulist.selectedItem.getAttribute('label');
gPrefService.setCharPref('browser.passcard.selectedcard', passcardName);
openPasscardPrefs();
}
// MERC - JCH : need to select the proper tab when pref dialog opens
function openPasscardPrefs() {
gPrefService.setCharPref('browser.preferences.formfillORpasscard', 'passcardtab');
openPrefs(PREF_AUTOFILL);
}
// MERC JVL
// Save the current fields on the form as a passcard
function savePasscard() {
var hpDoc = getTridentDocument();
if (hpDoc) {
// fire Trident side
passcardDebug('********* SavePasscard via Trident **********');
hpDoc.savePasscard();
}
else
{
// fire Gecko side
passcardDebug('********* SavePasscard via Gecko **********');
gPasscardMgr.savePasscard(gBrowser.contentDocument);
}
}
// delete the old passcard menu items
function clearPasscardMenu() {
var menu = document.getElementById('combinedFormFillPopup');
if (!menu) return;
var pcSep = document.getElementById('combinedFormFillPasscardSep');
pcSep.setAttribute('hidden', 'true');
var child = menu.lastChild;
while (child) {
nextChild = child.previousSibling;
if (child.hasAttribute('passcard')) {
menu.removeChild(child);
}
child = nextChild;
}
}
function GetWebmailPasscard(domain, key)
{
if (!domain || domain == '') return null;
passcardDebug('GetWebmailPasscard('+domain+', '+key+')');
var enumerator = gPasscardMgr.enumerator;
while (enumerator.hasMoreElements()) {
var nextPasscard = enumerator.getNext();
nextPasscard = nextPasscard.QueryInterface(Components.interfaces.nsIPassword);
if ((domain == nextPasscard.host) && (nextPasscard.passcard == key)) {
return nextPasscard;
}
}
return null;
}
function GetDefaultPasscard()
{
return GetPasscard('DefaultPasscard', 'DefaultPasscard');
}
function GetPasscard(domain, key)
{
if (!domain || domain == '') return null;
passcardDebug('GetPasscard('+domain+', '+key+')');
var enumerator = gPasscardMgr.enumerator;
while (enumerator.hasMoreElements()) {
var nextPasscard = enumerator.getNext();
nextPasscard = nextPasscard.QueryInterface(Components.interfaces.nsIPassword);
if ((domain == nextPasscard.host) && (nextPasscard.passcard == key)) {
return nextPasscard;
}
}
return null;
}
function GetFirstPasscardForSite(domain)
{
if (!domain || domain == '') return null;
passcardDebug('GetPasscard('+domain+')');
var enumerator = gPasscardMgr.enumerator;
while (enumerator.hasMoreElements()) {
var nextPasscard = enumerator.getNext();
nextPasscard = nextPasscard.QueryInterface(Components.interfaces.nsIPassword);
if ((domain == nextPasscard.host)) {
return nextPasscard;
}
}
return null;
}
// MERC (DP): get a list of passcards for URL
// MERC - JCH: Changing menu ids for new combined datacard-passcard button.
function updatePasscardMenu(menu) {
// keep track of number of passcards found for the specific realm
var passcardCount = 0;
var foundSitePasscards = false;
var addDefaultPasscard = false;
var defaultName = "";
var defaultUniqueID = -1;
var currentURI = getWebNavigation().currentURI;
try {
// realm is the base domain
var realm = new Object();
gPasscardMgr.getDomain(currentURI, realm);
passcardDebug('***Passcard -- realm: ' + realm.value);
var enumerator = gPasscardMgr.enumerator;
while (enumerator.hasMoreElements()) {
var nextPasscard = enumerator.getNext();
nextPasscard = nextPasscard.QueryInterface(Components.interfaces.nsIPassword);
var host = nextPasscard.host;
passcardDebug("***Passcard -- host: " + host);
if (realm.value && realm.value == host) {
var uniqueID = nextPasscard.uniqueID;
var passcard = nextPasscard.passcard;
var lastUsed = nextPasscard.lastUsed;
passcardDebug("***Passcard -- passcard: " + passcard +
" uniqueID: " + uniqueID + " lastUsed: " + lastUsed);
/* // if this is the first passcard menu item, put a menu separator before
var menuitem;
if (passcardCount == 0) {
menuitem = document.createElement("menuseparator");
menu.appendChild(menuitem);
} */
// create a new menuitem to add to the dropdown list
menuitem = document.createElement("menuitem");
menuitem.setAttribute('label', passcard);
menuitem.setAttribute('host', host);
menuitem.setAttribute('uniqueID', uniqueID);
menuitem.setAttribute('lastUsed', lastUsed);
menuitem.setAttribute('type', 'checkbox');
menuitem.setAttribute('passcard', 'true');
//menuitem.setAttribute('tooltiptext', 'UserID: ' + user);
menuitem.setAttribute('oncommand', 'setPasscardDefault(this);');
// find the default passcard for site
if (eval(lastUsed)) {
menuitem.setAttribute('checked', 'true');
} else {
menuitem.setAttribute('checked', 'false');
}
menu.appendChild(menuitem);
passcardCount++;
foundSitePasscards = true;
}
else if (kDefaultPasscard == host) {
defaultName = nextPasscard.passcard;
defaultUniqueID = nextPasscard.uniqueID;
// if it is protected, we will assume that the user has a valid Default Passcard
addDefaultPasscard = IsProtectedAndPopulatedPasscard(nextPasscard);
}
} // while
} catch(e) {}
// Toggle visibility of menu separator, depending on whether
// passcards were listed
var pcSep = document.getElementById('combinedFormFillPasscardSep');
if (pcSep && foundSitePasscards) {
pcSep.removeAttribute('hidden');
} else {
pcSep.setAttribute('hidden', 'true');
}
if (addDefaultPasscard && !foundSitePasscards &&
defaultName.length > 0 && defaultUniqueID != -1)
{
dump("***Default Passcard -- passcard: " + defaultName + " uniqueID: " + defaultUniqueID + "\n");
// add a menu separator before
//menu.appendChild(document.createElement("menuseparator"));
pcSep.removeAttribute('hidden');
// create a new menuitem to add to the dropdown list
var menuitem = document.createElement("menuitem");
menuitem.setAttribute('label', defaultName);
menuitem.setAttribute('host', kDefaultPasscard);
menuitem.setAttribute('uniqueID', defaultUniqueID);
menuitem.setAttribute('lastUsed', '1');
menuitem.setAttribute('type', 'checkbox');
//menuitem.setAttribute('tooltiptext', 'UserID: ' + user);
menuitem.setAttribute('oncommand', 'setPasscardDefault(this);');
menuitem.setAttribute('checked', 'true');
menuitem.setAttribute('passcard', 'true');
menu.appendChild(menuitem);
passcardCount++;
}
// if there are no passcards found, disable fill menu item
var fillItem = document.getElementById('combinedFillFormMenuItem');
var fillSubmitItem = document.getElementById('combinedFillAndSubmitMenuItem');
if (passcardCount > 0) {
fillItem.removeAttribute('disabled');
fillSubmitItem.removeAttribute('disabled');
} else {
fillItem.setAttribute('disabled', 'true');
fillSubmitItem.setAttribute('disabled', 'true');
}
// MERC JVL
// if there are no password fields (HTML INPUT type fields)
// on the form, disable the Save Passcard menu item
// var savePasscardMenuItem = document.getElementById('savePasscardMenuItem');
var savePasscardMenuItem = document.getElementById('combinedSaveMenuItem');
if (CheckIsPasscardable(false) && !PasscardIsSiteBlacklisted(currentURI))
{
passcardDebug(' - enabling save');
savePasscardMenuItem.removeAttribute('disabled');
}
else
{
passcardDebug(' - disabling save');
savePasscardMenuItem.setAttribute('disabled', 'true');
}
}
// MERC JVL
// helper function to check of a passcard is protected and has a username/password
function IsProtectedAndPopulatedPasscard(passcard)
{
// if it is protected, we will assume that the user has a populated Passcard
if (passcard.protect == 0 &&
(passcard.user.length < 1 || passcard.password.length < 1))
{
return false;
}
return true;
}
// MERC JVL
// helper function to check if a passcard can be
// applied to the form, regardless of engine
function CheckIsPasscardable(bIgnoreValue)
{
var bIsPasscardable = false;
var hpDoc = getTridentDocument();
if (hpDoc)
{
// fire Trident side
bIsPasscardable = hpDoc.isPasscardable(bIgnoreValue);
}
else
{
// fire Gecko side
bIsPasscardable = IsPasscardable(gBrowser.contentDocument, bIgnoreValue);
}
return bIsPasscardable;
}
// TODO JVL : Would be useful in XPCom - move functionality to XPCom when there's a chance to do so
// MERC JVL
// Checks current document and its 'frame' ('iframe' and 'object' as well) for a
// potential Passcard (looks for documents with only one password field and not two)
// RECURSIVE!!!
const NO_PASSWORD_FIELD = 0;
const FOUND_A_PASSCARD = 1;
const NOT_A_PASSCARD = 2;
function IsPasscardable(doc, bIgnoreValue)
{
if (!doc)
return false;
var inputTextElement = null;
var isPasscard = NO_PASSWORD_FIELD;
var idx = 0;
var inputElements = doc.getElementsByTagName('input');
while (isPasscard != NOT_A_PASSCARD && idx < inputElements.length)
{
var inputElement = inputElements.item(idx);
if (inputElement != null)
{
var elementType = inputElement.getAttribute('type');
if (elementType == 'text' || elementType == null)
{
// found a text field, may be the username field,
// store reference to object for later use
inputTextElement = inputElement;
}
else if (elementType == 'password')
{
// if we encountered a second password field,
// this form is probably not passcardable, bail
if (isPasscard == FOUND_A_PASSCARD)
{
// MERC CCOTE bug fix blt 202309
var previousIdx= idx-1;
var previousInputElement = inputElements.item(previousIdx);
var previousElementType = previousInputElement.getAttribute('type');
if(previousElementType == 'password') isPasscard = NOT_A_PASSCARD;
}
else if (isPasscard == NO_PASSWORD_FIELD)
{
// look for a set of username/password fields
if (inputElement.value != "" || bIgnoreValue)
{
if (inputTextElement != null)
{
if (inputTextElement.value != "" || bIgnoreValue)
{
// found a set of username/password fields
isPasscard = FOUND_A_PASSCARD;
}
}
// TODO JVL - Added to handle static username input text field case
else
{
isPasscard = FOUND_A_PASSCARD;
}
}
}
}
}
idx++;
}
// haven't found a password field in this frame, check child frames
if (isPasscard == NO_PASSWORD_FIELD)
{
isPasscard = IsPasscardInFrames(doc, 'iframe', bIgnoreValue);
if (isPasscard == NO_PASSWORD_FIELD)
isPasscard = IsPasscardInFrames(doc, 'frame', bIgnoreValue);
if (isPasscard == NO_PASSWORD_FIELD)
isPasscard = IsPasscardInFrames(doc, 'object', bIgnoreValue);
}
return isPasscard == FOUND_A_PASSCARD;
}
// MERC JVL
// Checks for a passcard in a 'frame' document ('iframe' and 'object' as well)
// RECURSIVE!!!
function IsPasscardInFrames(doc, elementName, bIgnoreValue)
{
var isPasscard = NO_PASSWORD_FIELD;
var iframeElements = doc.getElementsByTagName(elementName);
var idx = 0; // JMC: Bad strict, should not redeclare
while (isPasscard == NO_PASSWORD_FIELD && idx < iframeElements.length)
{
var iframeElement = iframeElements.item(idx);
if (iframeElement)
{
if (IsPasscardable(iframeElement.contentDocument, bIgnoreValue))
isPasscard = FOUND_A_PASSCARD;
}
idx++;
}
return isPasscard;
}
function passcardAllowHost(aHost)
{
// showStack();
passcardDebug(" is " + aHost + " an allowed passcard host?");
var enumerator = gPasscardMgr.rejectEnumerator;
while (enumerator.hasMoreElements())
{
var nextReject = enumerator.getNext();
nextReject = nextReject.QueryInterface(Components.interfaces.nsIPassword);
if (nextReject.host == aHost)
{
passcardDebug("It's a reject");
return false;
}
}
if (gOptout.isInList(aHost))
{
passcardDebug("It's an Optout");
return false;
}
return true;
}
// MERC - JCH: Check if the page has a password field.
// If so, alert the user with notification bar.
function CheckForPasscardField()
{
// realm is the base domain
var realm = new Object();
if (gBrowser.currentURI && (gBrowser.currentURI.schemeIs("http") ||
gBrowser.currentURI.schemeIs("https")) )
{
var passcardMgrInternal = Components.classes["@mozilla.org/passwordmanager;1"]
.getService(Components.interfaces.nsIPasswordManagerInternal);
if (!passcardMgrInternal)
return false;
passcardDebug('uri (as a spec): ' + gBrowser.currentURI.spec);
passcardMgrInternal.ParseRealm(gBrowser.currentURI, realm, true, false);
passcardDebug('realm: ' + realm.value);
if (realm.value == null)
return false;
} else {
return false;
}
if (!passcardAllowHost(realm.value))
{
return false;
}
var bFoundPasscard = false;
var bShowNotification = false;
try {
// now check if the passcard is set to prompt
enumerator = gPasscardMgr.enumerator;
while (!bFoundPasscard && enumerator.hasMoreElements())
{
var nextPasscard = enumerator.getNext();
nextPasscard = nextPasscard.QueryInterface(Components.interfaces.nsIPassword);
if (isValidPasscardHost(nextPasscard.host,nextPasscard.lastUsed, realm.value)||
isValidSnsPasscardHost(nextPasscard.host, realm.value))
{
bFoundPasscard = true;
bShowNotification = nextPasscard.autologin == 0 && // display prompt
IsProtectedAndPopulatedPasscard(nextPasscard);
}
}
} catch (ex) { }
if (!bFoundPasscard)
{
bShowNotification = IsDisplayBrowserBarForDefaultPasscard();
passcardDebug('Checking if DefaultPasscard exists: ' + bShowNotification);
}
var bPasswordFieldExists = CheckIsPasscardable(true);
passcardDebug('Is Passcardable?: ' + bPasswordFieldExists);
passcardDebug('***** Notification bar state: '+gCurrentNotificationBar);
// If password field exists and passcard is set to show a prompt,
// then show the notification bar.
if (bShowNotification && bPasswordFieldExists)
{
ShowPasscardBar();
}
else
{
HidePasscardBar();
}
// if there is a password field, we don't want to display the datacard notification bar even if
// the passcard notification bar is not displayed
return bPasswordFieldExists;
}
function ShowPasscardBar()
{
displayNotificationBar("passcard");
/* var message;
var bundle_browser = document.getElementById("bundle_browser");
message = bundle_browser.getString("passcardMsg");
gBrowser.showMessage(gBrowser.selectedBrowser, "chrome://browser/skin/icons/passwordsm_h.png",
message, "", null, null, null, "top", true, 1); */
}
function HidePasscardBar()
{
if (gCurrentNotificationBar == 'passcard') {
var tabbrowser = getBrowser();
tabbrowser.hideMessage(tabbrowser.selectedBrowser, "top");
}
}
function IsDisplayBrowserBarForDefaultPasscard()
{
// search for default passcard
var enumerator = gPasscardMgr.enumerator;
while (enumerator.hasMoreElements())
{
try
{
var nextPasscard = enumerator.getNext();
// get all info for the passcard
nextPasscard = nextPasscard.QueryInterface(Components.interfaces.nsIPassword);
if (nextPasscard.host == kDefaultPasscard)
{
return nextPasscard.autologin == 0 && IsProtectedAndPopulatedPasscard(nextPasscard);
}
}
catch (ex) {}
}
return false;
}
function setPasscardDefault(menuitem) {
if(eval(menuitem.getAttribute('lastUsed')))
return;
// if the menuitem is NOT the default passcard...
var enumerator = gPasscardMgr.enumerator;
// realm is the base domain
var realm = new Object();
gPasscardMgr.getDomain(getWebNavigation().currentURI, realm);
if (realm.value == null)
return; // currentURI was probably null
// set select passcard as lastUsed
// NOTE: This operation does not reset the checked state for the selected menuitem
gPasscardMgr.setAsLastUsedSignon(menuitem.getAttribute('host'),
menuitem.getAttribute('uniqueID'));
// update the browser message bar if it is shown
UpdatePasscardMessageBar(menuitem.getAttribute('label'));
// update the passcard button label on the toolbar
SetPasscard();
passcardDebug('***default -- passcard: ' + menuitem.getAttribute('label'));
fillUsernamePassword(menuitem, false);
}
// update the browser message bar (if it is shown) with the current passcard
function UpdatePasscardMessageBar(menuLabel)
{
if (gCurrentNotificationBar != "passcard")
return;
if (menuLabel == null || menuLabel.length < 1)
return;
var theMenulist = document.getAnonymousElementByAttribute(gBrowser.mCurrentBrowser.previousSibling, 'anonid', 'messagePasscardList');
if (theMenulist == null)
return;
var theMenupopup = theMenulist.childNodes[0];
if (!theMenupopup || theMenupopup.localName != 'menupopup')
return;
var i;
for (i = 0; i < theMenupopup.childNodes.length; i++)
{
var child = theMenupopup.childNodes[i];
//passcardDebug('*** menuitem: child: ' + child.getAttribute('label') + ', menuitem: ' + menuLabel);
if (child.getAttribute('label') == menuLabel)
{
theMenulist.selectedIndex = i;
break;
}
}
}
//MERC: Durga
//Display default passcard on toolbar in text mode
function SetPasscard()
{
passcardDebug('SetPasscard()');
var enumerator = gPasscardMgr.enumerator;
var realm = new Object();
var host;
var password;
var passcard;
var nextPassword;
var numFound = 0;
var lastUsed;
var lastUsedName;
/* var filler1 = new Object();
var filler2 = new Object();
var filler3 = new Object();
var filler4 = new Object();
var filler5 = new Object();
var filler6 = new Object();
*/
// If passcard button is not present, no need to update it
// MERC - JCH: Use the combined datacard/passcard button ID
var button = document.getElementById("combined-autofill-button");
if (!button) return;
// Update button to generic setting
// MERC - JCH: Changing button name from 'passcard' to 'autofill'.
button.setAttribute("label", "Autofill");
button.removeAttribute("match");
// Check for realm
gPasscardMgr.getDomain(getWebNavigation().currentURI, realm);
if (realm.value == null)
return; // currentURI was probably null
passcardDebug("***Passcard -- realm: " + realm.value);
// search for default passcard
while (enumerator.hasMoreElements()) {
try {
nextPassword = enumerator.getNext();
// get all info for the passcard
nextPassword = nextPassword.QueryInterface(Components.interfaces.nsIPassword);
host = nextPassword.host;
lastUsed = nextPassword.lastUsed;
passcard = nextPassword.passcard;
if (realm.value == host) {
// This passcard matches the site
passcardDebug("***Passcard -- lastUsed: " + lastUsed);
passcardDebug("***Passcard -- passcard: " + passcard);
numFound++;
if (lastUsed == 1) {
// Set button label
dump("\n**Setting label to passcard: " + passcard + "**\n");
// BC: BLT #176383:
/* Expected Result:
* The Autofill button shouldn't be renamed, Clear History button and Netscape
* logo should visible on the screen.
* BC: Not sure why someone tried to add this, but the autofill label
* should NOT be changed.
*/
//button.setAttribute("label", passcard);
button.setAttribute("match", "true");
}
if (lastUsed == 1 || !lastUsedName) {
lastUsedName = passcard;
}
}
}
catch(e)
{
passcardDebug ("caught exception: " + e);
}
}
if (numFound > 1) {
button.setAttribute("label", lastUsedName + '+'+numFound);
button.setAttribute("match", "true");
}
} // end function
// MERC - JCH: This function is called from browser.xml: "browsermessage" binding.
// When submitFlag is false we don't submit the passcard info, when it's true we do.
function ParameterizedDoPasscard(submitFlag)
{
var theMenulist = document.getAnonymousElementByAttribute(gBrowser.mCurrentBrowser.previousSibling, 'anonid', 'messagePasscardList');
if (theMenulist)
{
passcardDebug("Currently selected Passcard in Browser Message Bar: " + theMenulist.label);
if (theMenulist.label.length > 0)
gPasscardMgr.useSpecialPasscard = theMenulist.label;
}
var hpDoc = getTridentDocument();
if (hpDoc)
{
// fire Trident side
if (submitFlag)
{
passcardDebug('********* DoFillFormAndSubmit via Trident **********');
hpDoc.doPasscardFillFormAndSubmit();
}
else
{
passcardDebug('********* DoFillForm via Trident **********');
hpDoc.doPasscardFillForm();
}
}
else
{
// fire Gecko side
passcardDebug('********* DoPasscardOneTime via Gecko **********');
var enumerator = gPasscardMgr.enumerator;
var realm = new Object();
var host;
var password;
var uniqueID;
var nextPassword;
var lastUsed;
var passcardFound = false;
var filler1 = new Object();
var filler2 = new Object();
var filler3 = new Object();
var filler4 = new Object();
var filler5 = new Object();
var filler6 = new Object();
var filler7 = new Object();
var filler8 = new Object();
var filler9 = new Object();
var filler10 = new Object();
var bUseSpecialPasscard = false;
var specialPasscard = gPasscardMgr.useSpecialPasscard;
if (specialPasscard.length > 0)
{
if (specialPasscard == kDefaultPasscard ||
specialPasscard == kScreenNameService)
bUseSpecialPasscard = true;
}
if (!bUseSpecialPasscard && enumerator.hasMoreElements())
{
gPasscardMgr.getDomain(getWebNavigation().currentURI, realm);
//passcardDebug('REALM: ' + realm + ' VALUE: ' + realm.value);
if (realm.value != null)
{
passcardDebug("***Passcard -- realm: " + realm.value);
// search for default passcard
while (enumerator.hasMoreElements() && !passcardFound) {
try {
nextPassword = enumerator.getNext();
// get all info for the passcard
nextPassword = nextPassword.QueryInterface(Components.interfaces.nsIPassword);
host = nextPassword.host;
lastUsed = nextPassword.lastUsed;
uniqueID = nextPassword.uniqueID;
if (realm.value == host && lastUsed==1)
{
passcardDebug("***Passcard -- lastUsed: " + lastUsed);
passcardFound = true;
passcardDebug('********* DoPasscardOneTime via Gecko, found passcard! **********');
gPasscardMgr.passcardFillRootDoc(gBrowser.contentDocument, host, uniqueID, submitFlag, false);
}
} catch(e) {}
}
}
}
if (!passcardFound) {
// use default user/password
passcardDebug('********* ParameterizedDoPasscard via Gecko, use default! **********');
gPasscardMgr.passcardDefaultRootDoc(gBrowser.contentDocument, submitFlag, true);
}
}
if (theMenulist)
gPasscardMgr.useSpecialPasscard = "";
} // end function
function passcardPreferences(prefName) {
var prefAutologin = new Object();
var prefAutologinPrompt = new Object();
var prefAutosave = new Object();
var prefAutosavePrompt = new Object();
var prefHighlight = new Object();
var prefFillAndSubmit = new Object();
var prefDefaultPrompt = new Object();
var prefDefaultUser = new Object();
var prefDefaultPassword = new Object();
var prefProtect = new Object();
var prefPrompt = new Object();
var prefExpire = new Object();
var prefVersion = new Object();
gPasscardMgr.getPreferences(prefAutologin, prefAutologinPrompt, prefAutosave,
prefAutosavePrompt, prefHighlight, prefFillAndSubmit,
prefDefaultPrompt, prefDefaultUser, prefDefaultPassword,
prefProtect, prefPrompt, prefExpire, prefVersion);
return eval('pref' + prefName + '.value'); //JMC: Cheap Hack
}
//MERC: Durga
//Retrieve passcard for specific url when toolbar button is clicked
function DoPasscardOneTime()
{
var hpDoc = getTridentDocument();
if (hpDoc)
{
// fire Trident side
passcardDebug('********* DoPasscardOneTime via Trident **********');
hpDoc.doPasscardOneTime(); // if Fill & Submit preference set, doPasscardOneTime() will call submit (see Trident CPasscards::OnToolbarButton())
}
else
{
// fire Gecko side
passcardDebug('********* DoPasscardOneTime via Gecko **********');
var enumerator = gPasscardMgr.enumerator;
var realm = new Object();
var host;
var password;
var uniqueID;
var nextPassword;
var lastUsed;
var passcardFound = false;
var filler1 = new Object();
var filler2 = new Object();
var filler3 = new Object();
var filler4 = new Object();
var filler5 = new Object();
var filler6 = new Object();
var filler7 = new Object();
var filler8 = new Object();
var filler9 = new Object();
var filler10 = new Object();
var bSubmitForm = isPasscardFillAndSubmit();
if (enumerator.hasMoreElements())
{
gPasscardMgr.getDomain(getWebNavigation().currentURI, realm);
//passcardDebug('REALM: ' + realm + ' VALUE: ' + realm.value);
if (realm.value != null)
{
passcardDebug("***Passcard -- realm: " + realm.value);
// search for default passcard
while (enumerator.hasMoreElements() && !passcardFound) {
try {
nextPassword = enumerator.getNext();
// get all info for the passcard
nextPassword = nextPassword.QueryInterface(Components.interfaces.nsIPassword);
host = nextPassword.host;
lastUsed = nextPassword.lastUsed;
uniqueID = nextPassword.uniqueID;
if(realm.value == host && lastUsed==1)
{
passcardDebug("***Passcard -- lastUsed: " + lastUsed);
passcardFound = true;
passcardDebug('********* DoPasscardOneTime via Gecko, found passcard! **********');
gPasscardMgr.passcardFillRootDoc(gBrowser.contentDocument, host, uniqueID, bSubmitForm, false);
}
} catch(e) {}
}
}
}
if (!passcardFound) {
// use default user/password
passcardDebug('********* DoPasscardOneTime via Gecko, use default! **********');
gPasscardMgr.passcardDefaultRootDoc(gBrowser.contentDocument, bSubmitForm, false);
}
}
} // end function
function isPasscardFillAndSubmit()
{
// TODO JVL : Need to revisit when passcard preferences are stored in browser prefs, but for now, this will do
if (gPasscardMgr == null)
return false;
var prefAutologin = new Object();
var prefAutologinPrompt = new Object();
var prefAutosave = new Object();
var prefAutosavePrompt = new Object();
var prefHighlight = new Object();
var prefFillAndSubmit = new Object();
var prefDefaultPrompt = new Object();
var prefUserID = new Object();
var prefPassword = new Object();
var prefProtect = new Object();
var prefPrompt = new Object();
var prefExpire = new Object();
var prefVersion = new Object();
gPasscardMgr.getPreferences(prefAutologin, prefAutologinPrompt, prefAutosave,
prefAutosavePrompt, prefHighlight, prefFillAndSubmit,
prefDefaultPrompt, prefUserID, prefPassword,
prefProtect, prefPrompt, prefExpire, prefVersion);
if (prefFillAndSubmit.value != "0")
return true;
return false;
}
function fillUsernamePassword(menuitem, bSubmitForm) {
var hpDoc = getTridentDocument();
if (hpDoc)
{
// fire Trident side
if (bSubmitForm)
{
passcardDebug('********* DoFillFormAndSubmit via Trident **********');
hpDoc.doPasscardFillFormAndSubmit();
}
else
{
passcardDebug('********* DoFillForm via Trident **********');
hpDoc.doPasscardFillForm();
}
}
else
{
var bFound = false;
var myHost = menuitem.getAttribute('host');
var myUniqueID = menuitem.getAttribute('uniqueID');
if (myHost.length > 0 && myUniqueID.length > 0)
{
bFound = true;
}
else
{
var nextItem = menuitem.nextSibling;
while (!bFound && nextItem != null)
{
if (nextItem.getAttribute('lastUsed') == "1")
{
myHost = nextItem.getAttribute('host');
myUniqueID = nextItem.getAttribute('uniqueID');
bFound = true;
}
else
{
nextItem = nextItem.nextSibling;
}
}
}
if (bFound)
{
passcardDebug('*********** fillUsernamePassword() ********************');
passcardDebug('host: ' + myHost + ' ID: ' + myUniqueID + ' submitForm: ' + bSubmitForm);
gPasscardMgr.passcardFillRootDoc(gBrowser.contentDocument, myHost, myUniqueID, bSubmitForm, false);
}
}
}
//MERC CCOTE BLT fix 196092
// Return true or false if the current host is a match for this passcard
function isValidPasscardHost(aPasscardHost,aPasscardLastUsed, aHost){
if(aPasscardHost == aHost && aPasscardLastUsed == 1) return true;
return false
}
//MERC CCOTE BLT fix 196092
// Return true or false if the current host is a match for the SNS passcard
function isValidSnsPasscardHost(aPasscardHost, aHost){
if(aPasscardHost == 'ScreenNameService' && isSNSSite(aHost)) return true;
return false
}
PK
[&4.& # content/browser/contentAreaUtils.jsUT 0žCCUx /**
* Determine whether or not a given focused DOMWindow is in the content
* area.
**/
function openNewTabWith(href, linkNode, event, securityCheck, postData)
{
if (securityCheck)
urlSecurityCheck(href, document);
var prefSvc = Components.classes["@mozilla.org/preferences-service;1"]
.getService(Components.interfaces.nsIPrefService);
prefSvc = prefSvc.getBranch(null);
// should we open it in a new tab?
var loadInBackground = true;
try {
loadInBackground = prefSvc.getBoolPref("browser.tabs.loadInBackground");
}
catch(ex) {
}
if (event && event.shiftKey)
loadInBackground = !loadInBackground;
// As in openNewWindowWith(), we want to pass the charset of the
// current document over to a new tab.
var wintype = document.firstChild.getAttribute('windowtype');
var originCharset;
if (wintype == "navigator:browser") {
originCharset = window._content.document.characterSet;
}
// open link in new tab
var browser = top.document.getElementById("content");
var theTab = browser.addTabAt(href, undefined, getReferrer(document), originCharset, postData); // MERC (DP): changed to addTabAt
if (!loadInBackground)
browser.selectedTab = theTab;
else{
//CCOTE bug # 119809
//When loading tab in the background, this add the close button
// on the current selected tab (if needed).
//(Note this middle-click and ctrl-right-click
browser.updateChromeWhenLastTab();
}
if (linkNode)
markLinkVisited(href, linkNode);
}
// Stevo
function askUserAboutJar(href)
{
var xpinstallObj = {};
var args = new Object( );
args.handled = 2;
args.jarUrl = href;
var uri = Components.classes["@mozilla.org/network/standard-url;1"]
.createInstance(Components.interfaces.nsIURI);
uri.spec = href;
var url = uri.QueryInterface(Components.interfaces.nsIURL);
if (url.fileExtension == "xpi") {
xpinstallObj[url.fileName] = uri.spec;
InstallTrigger.install(xpinstallObj);
args.handled = 0;
}
else if (url.fileExtension == "jar") {
window.openDialog("chrome://browser/content/askUserAboutJar.xul",
"Descision", "modal,centerscreen,chrome,resizable=no",args);
// InstallTrigger.installChrome(InstallTrigger.SKIN, href, url.fileName);
// args.handled = 0;
}
return args.handled;
}
//JA
function openPopupInTab(href,bUserInitiated)
{
// As in openNewWindowWith(), we want to pass the charset of the
// current document over to a new tab.
dump("\n\n****openPopupInTab("+href+", "+bUserInitiated+")\n\n");
var wintype = document.firstChild.getAttribute('windowtype');
var originCharset;
if (wintype == "navigator:browser")
{
//sliu, it crash when close tab cause a unload event,
// , the event is open a new window and pref set to open popup in tab
//originCharset = window._content.document.characterSet;
originCharset = gCurrentDocCharset;
}
// open link in new tab
var browser = top.document.getElementById("content");
var theTab = browser.addTabAt(href, undefined, getReferrer(document), originCharset, null);
var b = browser.getBrowserForTab(theTab);
if(b)
{
// whether or not to set focus to the new popup tab
var bgLoad = browser.mPrefs.getBoolPref("browser.tabs.loadInBackground");
if(bUserInitiated && !bgLoad)
browser.selectedTab = theTab;
return b.contentWindow;
}
else
return null;//error
}
function openNewWindowWith(href, linkNode, securityCheck, postData)
{
if (securityCheck)
urlSecurityCheck(href, document);
// if and only if the current window is a browser window and it has a document with a character
// set, then extract the current charset menu setting from the current document and use it to
// initialize the new browser window...
var charsetArg = null;
var wintype = document.firstChild.getAttribute('windowtype');
if (wintype == "navigator:browser")
charsetArg = "charset=" + window._content.document.characterSet;
var referrer = getReferrer(document);
window.openDialog(getBrowserURL(), "_blank", "chrome,all,dialog=no", href, charsetArg, referrer, postData);
if (linkNode)
markLinkVisited(href, linkNode);
}
function markLinkVisited(href, linkNode)
{
var globalHistory = Components.classes["@mozilla.org/browser/global-history;2"]
.getService(Components.interfaces.nsIGlobalHistory2);
var uri = makeURL(href);
if (!globalHistory.isVisited(uri)) {
globalHistory.addURI(uri, false, true);
var oldHref = linkNode.getAttribute("href");
if (typeof oldHref == "string") {
// Use setAttribute instead of direct assignment.
// (bug 217195, bug 187195)
linkNode.setAttribute("href", "");
linkNode.setAttribute("href", oldHref);
}
else {
// Converting to string implicitly would be a
// minor security hole (similar to bug 202994).
}
}
}
function urlSecurityCheck(url, doc)
{
// URL Loading Security Check
var focusedWindow = doc.commandDispatcher.focusedWindow;
var sourceURL = getContentFrameURI(focusedWindow);
var sourceURI = Components.classes["@mozilla.org/network/standard-url;1"]
.createInstance(Components.interfaces.nsIURI);
sourceURI.spec = sourceURL;
var destURI = Components.classes["@mozilla.org/network/standard-url;1"]
.createInstance(Components.interfaces.nsIURI);
destURI.spec = url;
const nsIScriptSecurityManager = Components.interfaces.nsIScriptSecurityManager;
var secMan = Components.classes["@mozilla.org/scriptsecuritymanager;1"]
.getService(nsIScriptSecurityManager);
try {
secMan.checkLoadURI(sourceURI, destURI, nsIScriptSecurityManager.STANDARD);
} catch (e) {
throw "Load of " + url + " denied.";
}
}
function webPanelSecurityCheck(aSourceURL, aDestURL) {
var sourceURI = makeURL(aSourceURL);
var destURI = makeURL(aDestURL);
const nsIScriptSecurityManager = Components.interfaces.nsIScriptSecurityManager;
var secMan = Components.classes["@mozilla.org/scriptsecuritymanager;1"]
.getService(nsIScriptSecurityManager);
try {
secMan.checkLoadURI(sourceURI, destURI, nsIScriptSecurityManager.STANDARD);
} catch (e) {
return false;
}
return true;
}
function isContentFrame(aFocusedWindow)
{
if (!aFocusedWindow)
return false;
var focusedTop = Components.lookupMethod(aFocusedWindow, 'top')
.call(aFocusedWindow);
return (focusedTop == window.content);
}
function getContentFrameURI(aFocusedWindow)
{
var contentFrame = isContentFrame(aFocusedWindow) ? aFocusedWindow : window.content;
if (contentFrame)
return Components.lookupMethod(contentFrame, 'location').call(contentFrame).href;
else
return null;
}
function getReferrer(doc)
{
var focusedWindow = doc.commandDispatcher.focusedWindow;
var sourceURL = getContentFrameURI(focusedWindow);
if (sourceURL) {
try {
return makeURL(sourceURL);
}
catch (e) { }
}
return null;
}
const kSaveAsType_Complete = 0; // Save document with attached objects
const kSaveAsType_URL = 1; // Save document or URL by itself
const kSaveAsType_Text = 2; // Save document, converting to plain text.
// Clientelle: (Make sure you don't break any of these)
// - File -> Save Page/Frame As...
// - Context -> Save Page/Frame As...
// - Context -> Save Link As...
// - Context -> Save Image As...
// - Alt-Click links in web pages
// - Alt-Click links in the UI
//
// Try saving each of these types:
// - A complete webpage using File->Save Page As, and Context->Save Page As
// - A webpage as HTML only using the above methods
// - A webpage as Text only using the above methods
// - An image with an extension (e.g. .jpg) in its file name, using
// Context->Save Image As...
// - An image without an extension (e.g. a banner ad on cnn.com) using
// the above method.
// - A linked document using Save Link As...
// - A linked document using Alt-click Save Link As...
//
function saveURL(aURL, aFileName, aFilePickerTitleKey, aShouldBypassCache, aSkipPrompt, aReferrer)
{
saveInternal(aURL, null, aFileName, aFilePickerTitleKey, aShouldBypassCache, aSkipPrompt, aReferrer);
}
function saveDocument(aDocument, aSkipPrompt)
{
// In both cases here, we want to use cached data because the
// document is currently visible.
//Mercurial start
var hpDoc;
try
{
hpDoc=gBrowser.contentDocument.QueryInterface(Components.interfaces.nsIHTMLPluginDocument);
}
catch(ex){}
try
{
if(hpDoc)
{
hpDoc.doOLECmd(3);
}
else
{
if (aDocument)
saveInternal(aDocument.location.href, aDocument, false, aSkipPrompt);
else
saveInternal(_content.location.href, null, false, aSkipPrompt);
}
}
catch(e)
{}
}
function saveInternal(aURL, aDocument,
aFileName, aFilePickerTitleKey,
aShouldBypassCache, aSkipPrompt,
aReferrer)
{
if (aSkipPrompt == undefined)
aSkipPrompt = false;
var data = {
url: aURL,
fileName: aFileName,
filePickerTitle: aFilePickerTitleKey,
document: aDocument,
bypassCache: aShouldBypassCache,
window: window,
referrer: aReferrer
};
var sniffer = new nsHeaderSniffer(aURL, foundHeaderInfo, data, aSkipPrompt);
}
function foundHeaderInfo(aSniffer, aData, aSkipPrompt)
{
var contentType = aSniffer.contentType;
var contentEncodingType = aSniffer.contentEncodingType;
var shouldDecode = false;
// Are we allowed to decode?
try {
const helperAppService =
Components.classes["@mozilla.org/uriloader/external-helper-app-service;1"].
getService(Components.interfaces.nsIExternalHelperAppService);
var url = aSniffer.uri.QueryInterface(Components.interfaces.nsIURL);
var urlExt = url.fileExtension;
if (helperAppService.applyDecodingForExtension(urlExt,
contentEncodingType)) {
shouldDecode = true;
}
}
catch (e) {
}
var isDocument = aData.document != null && isDocumentType(contentType);
if (!isDocument && !shouldDecode && contentEncodingType) {
// The data is encoded, we are not going to decode it, and this is not a
// document save so we won't be doing a "save as, complete" (which would
// break if we reset the type here). So just set our content type to
// correspond to the outermost encoding so we get extensions and the like
// right.
contentType = contentEncodingType;
}
var file = null;
var saveAsType = kSaveAsType_URL;
try {
file = aData.fileName.QueryInterface(Components.interfaces.nsILocalFile);
}
catch (e) {
var saveAsTypeResult = { rv: 0 };
file = getTargetFile(aData, aSniffer, contentType, isDocument, aSkipPrompt, saveAsTypeResult);
if (!file)
return;
saveAsType = saveAsTypeResult.rv;
}
// If we're saving a document, and are saving either in complete mode or
// as converted text, pass the document to the web browser persist component.
// If we're just saving the HTML (second option in the list), send only the URI.
var source = (isDocument && saveAsType != kSaveAsType_URL) ? aData.document : aSniffer.uri;
var persistArgs = {
source : source,
contentType : (isDocument && saveAsType == kSaveAsType_Text) ? "text/plain" : contentType,
target : makeFileURL(file),
postData : aData.document ? getPostData() : null,
bypassCache : aData.bypassCache
};
var persist = makeWebBrowserPersist();
// Calculate persist flags.
const nsIWBP = Components.interfaces.nsIWebBrowserPersist;
const flags = nsIWBP.PERSIST_FLAGS_NO_CONVERSION | nsIWBP.PERSIST_FLAGS_REPLACE_EXISTING_FILES;
if (aData.bypassCache)
persist.persistFlags = flags | nsIWBP.PERSIST_FLAGS_BYPASS_CACHE;
else
persist.persistFlags = flags | nsIWBP.PERSIST_FLAGS_FROM_CACHE;
if (shouldDecode)
persist.persistFlags &= ~nsIWBP.PERSIST_FLAGS_NO_CONVERSION;
// Create download and initiate it (below)
var dl = Components.classes["@mozilla.org/download;1"].createInstance(Components.interfaces.nsIDownload);
if (isDocument && saveAsType != kSaveAsType_URL) {
// Saving a Document, not a URI:
var filesFolder = null;
if (persistArgs.contentType != "text/plain") {
// Create the local directory into which to save associated files.
filesFolder = file.clone();
var nameWithoutExtension = filesFolder.leafName;
nameWithoutExtension = nameWithoutExtension.substring(0, nameWithoutExtension.lastIndexOf("."));
var filesFolderLeafName = getStringBundle().formatStringFromName("filesFolder",
[nameWithoutExtension],
1);
filesFolder.leafName = filesFolderLeafName;
}
var encodingFlags = 0;
if (persistArgs.contentType == "text/plain") {
encodingFlags |= nsIWBP.ENCODE_FLAGS_FORMATTED;
encodingFlags |= nsIWBP.ENCODE_FLAGS_ABSOLUTE_LINKS;
encodingFlags |= nsIWBP.ENCODE_FLAGS_NOFRAMES_CONTENT;
}
else {
encodingFlags |= nsIWBP.ENCODE_FLAGS_ENCODE_BASIC_ENTITIES;
}
const kWrapColumn = 80;
dl.init(aSniffer.uri, persistArgs.target, null, null, null, persist);
persist.saveDocument(persistArgs.source, persistArgs.target, filesFolder,
persistArgs.contentType, encodingFlags, kWrapColumn);
} else {
dl.init(source, persistArgs.target, null, null, null, persist);
var referrer = aData.referrer || getReferrer(document)
persist.saveURI(source, null, referrer, persistArgs.postData, null, persistArgs.target);
}
}
function getTargetFile(aData, aSniffer, aContentType, aIsDocument, aSkipPrompt, aSaveAsTypeResult)
{
aSaveAsTypeResult.rv = kSaveAsType_Complete;
// Determine what the 'default' string to display in the File Picker dialog
// should be.
var defaultFileName = getDefaultFileName(aData.fileName,
aSniffer.suggestedFileName,
aSniffer.uri,
aData.document);
var defaultExtension = getDefaultExtension(defaultFileName, aSniffer.uri, aContentType);
var defaultString = getNormalizedLeafName(defaultFileName, defaultExtension);
const prefSvcContractID = "@mozilla.org/preferences-service;1";
const prefSvcIID = Components.interfaces.nsIPrefService;
var prefs = Components.classes[prefSvcContractID].getService(prefSvcIID).getBranch("browser.download.");
const nsILocalFile = Components.interfaces.nsILocalFile;
// ben 07/31/2003:
// |browser.download.defaultFolder| holds the default download folder for
// all files when the user has elected to have all files automatically
// download to a folder. The values of |defaultFolder| can be either their
// desktop, their downloads folder (My Documents\My Downloads) or some other
// location of their choosing (which is mapped to |browser.download.dir|
// This pref is _unset_ when the user has elected to be asked about where
// to place every download - this will force the prompt to ask the user
// where to put saved files.
var dir = null;
try {
dir = prefs.getComplexValue("defaultFolder", nsILocalFile);
}
catch (e) { }
var file;
if (!aSkipPrompt || !dir) {
// If we're asking the user where to save the file, root the Save As...
// dialog on they place they last picked.
try {
dir = prefs.getComplexValue("lastDir", nsILocalFile);
}
catch (e) {
// No default download location. Default to desktop.
var fileLocator = Components.classes["@mozilla.org/file/directory_service;1"].getService(Components.interfaces.nsIProperties);
function getDesktopKey()
{
return "DeskP";
return "Home";
}
dir = fileLocator.get(getDesktopKey(), Components.interfaces.nsILocalFile);
}
var fp = makeFilePicker();
var titleKey = aData.filePickerTitle || "SaveLinkTitle";
var bundle = getStringBundle();
fp.init(window, bundle.GetStringFromName(titleKey),
Components.interfaces.nsIFilePicker.modeSave);
appendFiltersForContentType(fp, aContentType, defaultExtension,
aIsDocument ? MODE_COMPLETE : MODE_FILEONLY);
if (dir)
fp.displayDirectory = dir;
if (aIsDocument) {
try {
fp.filterIndex = prefs.getIntPref("save_converter_index");
}
catch (e) {
}
}
fp.defaultExtension = defaultExtension;
fp.defaultString = defaultString;
if (fp.show() == Components.interfaces.nsIFilePicker.returnCancel || !fp.file)
return null;
var useDownloadDir = false;
try {
useDownloadDir = prefs.getBoolPref("useDownloadDir");
}
catch(ex) {
}
var directory = fp.file.parent.QueryInterface(nsILocalFile);
prefs.setComplexValue("lastDir", nsILocalFile, directory);
fp.file.leafName = validateFileName(fp.file.leafName);
aSaveAsTypeResult.rv = fp.filterIndex;
file = fp.file;
if (aIsDocument)
prefs.setIntPref("save_converter_index", aSaveAsTypeResult.rv);
}
else {
// ben 07/31/2003:
// We don't nullcheck dir here because dir should never be null if we get here
// unless something is badly wrong, and if it is, I want to know about it in
// bugs.
dir.append(defaultString);
file = dir;
// Since we're automatically downloading, we don't get the file picker's
// logic to check for existing files, so we need to do that here.
//
// Note - this code is identical to that in
// browser/components/downloads/content/nsHelperAppDlg.js.
// If you are updating this code, update that code too! We can't share code
// here since that code is called in a js component.
while (file.exists()) {
var parts = /.+-(\d+)(\..*)?$/.exec(file.leafName);
if (parts) {
file.leafName = file.leafName.replace(/((\d+)\.)|((\d+)$)/,
function (str, dot, dotNum, noDot, noDotNum, pos, s) {
return (parseInt(str) + 1) + (dot ? "." : "");
});
}
else {
file.leafName = file.leafName.replace(/\.|$/, "-1$&");
}
}
}
return file;
}
function nsHeaderSniffer(aURL, aCallback, aData, aSkipPrompt)
{
this.mCallback = aCallback;
this.mData = aData;
this.mSkipPrompt = aSkipPrompt;
this.uri = makeURL(aURL);
this.linkChecker = Components.classes["@mozilla.org/network/urichecker;1"]
.createInstance(Components.interfaces.nsIURIChecker);
this.linkChecker.init(this.uri);
var flags;
if (aData.bypassCache) {
flags = Components.interfaces.nsIRequest.LOAD_BYPASS_CACHE;
} else {
flags = Components.interfaces.nsIRequest.LOAD_FROM_CACHE;
}
this.linkChecker.loadFlags = flags;
this.linkChecker.asyncCheck(this, null);
}
nsHeaderSniffer.prototype = {
// ---------- nsISupports methods ----------
QueryInterface: function (iid) {
if (!iid.equals(Components.interfaces.nsIRequestObserver) &&
!iid.equals(Components.interfaces.nsISupports) &&
!iid.equals(Components.interfaces.nsIInterfaceRequestor)) {
throw Components.results.NS_ERROR_NO_INTERFACE;
}
return this;
},
// ---------- nsIInterfaceRequestor methods ----------
getInterface : function(iid) {
if (iid.equals(Components.interfaces.nsIAuthPrompt)) {
// use the window watcher service to get a nsIAuthPrompt impl
var ww = Components.classes["@mozilla.org/embedcomp/window-watcher;1"]
.getService(Components.interfaces.nsIWindowWatcher);
return ww.getNewAuthPrompter(window);
}
Components.returnCode = Components.results.NS_ERROR_NO_INTERFACE;
return null;
},
// ---------- nsIRequestObserver methods ----------
onStartRequest: function (aRequest, aContext) { },
onStopRequest: function (aRequest, aContext, aStatus) {
try {
if (aStatus == 0) { // NS_BINDING_SUCCEEDED, so there's something there
var linkChecker = aRequest.QueryInterface(Components.interfaces.nsIURIChecker);
var channel = linkChecker.baseChannel;
this.contentType = channel.contentType;
try {
var httpChannel = channel.QueryInterface(Components.interfaces.nsIHttpChannel);
var encodedChannel = channel.QueryInterface(Components.interfaces.nsIEncodedChannel);
this.contentEncodingType = null;
// There may be content-encodings on the channel. Multiple content
// encodings are allowed, eg "Content-Encoding: gzip, uuencode". This
// header would mean that the content was first gzipped and then
// uuencoded. The encoding enumerator returns MIME types
// corresponding to each encoding starting from the end, so the first
// thing it returns corresponds to the outermost encoding.
var encodingEnumerator = encodedChannel.contentEncodings;
if (encodingEnumerator && encodingEnumerator.hasMore()) {
try {
this.contentEncodingType = encodingEnumerator.getNext();
} catch (e) {
}
}
this.mContentDisposition = httpChannel.getResponseHeader("content-disposition");
}
catch (e) {
}
if (!this.contentType || this.contentType == "application/x-unknown-content-type") {
// We didn't get a type from the server. Fall back on other type detection mechanisms
throw "Unknown Type";
}
}
else {
dump("Error saving link aStatus = 0x" + aStatus.toString(16) + "\n");
var bundle = getStringBundle();
var errorTitle = bundle.GetStringFromName("saveLinkErrorTitle");
var errorMsg = bundle.GetStringFromName("saveLinkErrorMsg");
const promptService = Components.classes["@mozilla.org/embedcomp/prompt-service;1"].getService(Components.interfaces.nsIPromptService);
promptService.alert(this.mData.window, errorTitle, errorMsg);
return;
}
}
catch (e) {
if (this.mData.document) {
this.contentType = this.mData.document.contentType;
} else {
var type = getMIMETypeForURI(this.uri);
if (type)
this.contentType = type;
}
}
this.mCallback(this, this.mData, this.mSkipPrompt);
},
// ------------------------------------------------
get promptService()
{
var promptSvc;
try {
promptSvc = Components.classes["@mozilla.org/embedcomp/prompt-service;1"].getService();
promptSvc = promptSvc.QueryInterface(Components.interfaces.nsIPromptService);
}
catch (e) {}
return promptSvc;
},
get suggestedFileName()
{
var fileName = "";
if (this.mContentDisposition) {
const mhpContractID = "@mozilla.org/network/mime-hdrparam;1"
const mhpIID = Components.interfaces.nsIMIMEHeaderParam;
const mhp = Components.classes[mhpContractID].getService(mhpIID);
var dummy = { value: null }; // To make JS engine happy.
var charset = getCharsetforSave(null);
try {
fileName = mhp.getParameter(this.mContentDisposition, "filename", charset, true, dummy);
}
catch (e) {
try {
fileName = mhp.getParameter(this.mContentDisposition, "name", charset, true, dummy);
}
catch (e) {
}
}
}
fileName = fileName.replace(/^"|"$/g, "");
return fileName;
}
};
const MODE_COMPLETE = 0;
const MODE_FILEONLY = 1;
function appendFiltersForContentType(aFilePicker, aContentType, aFileExtension, aSaveMode)
{
var bundle = getStringBundle();
switch (aContentType) {
case "text/html":
if (aSaveMode == MODE_COMPLETE)
aFilePicker.appendFilter(bundle.GetStringFromName("WebPageCompleteFilter"), "*.htm; *.html");
aFilePicker.appendFilter(bundle.GetStringFromName("WebPageHTMLOnlyFilter"), "*.htm; *.html");
if (aSaveMode == MODE_COMPLETE)
aFilePicker.appendFilters(Components.interfaces.nsIFilePicker.filterText);
break;
default:
var mimeInfo = getMIMEInfoForType(aContentType, aFileExtension);
if (mimeInfo) {
var extEnumerator = mimeInfo.getFileExtensions();
var extString = "";
var defaultDesc = "";
var plural = false;
while (extEnumerator.hasMore()) {
if (defaultDesc) {
defaultDesc += ", ";
plural = true;
}
var extension = extEnumerator.getNext();
if (extString)
extString += "; "; // If adding more than one extension,
// separate by semi-colon
extString += "*." + extension;
defaultDesc += extension.toUpperCase();
}
if (extString) {
var desc = mimeInfo.Description;
if (!desc) {
var key = plural ? "unknownDescriptionFilesPluralFilter" :
"unknownDescriptionFilesFilter";
desc = getStringBundle().formatStringFromName(key, [defaultDesc], 1);
}
aFilePicker.appendFilter(desc, extString);
} else {
aFilePicker.appendFilters(Components.interfaces.nsIFilePicker.filterAll);
}
}
else
aFilePicker.appendFilters(Components.interfaces.nsIFilePicker.filterAll);
break;
}
}
function getPostData()
{
try {
var sessionHistory = getWebNavigation().sessionHistory;
entry = sessionHistory.getEntryAtIndex(sessionHistory.index, false);
entry = entry.QueryInterface(Components.interfaces.nsISHEntry);
return entry.postData;
}
catch (e) {
}
return null;
}
//XXXPch: that that be removed.
function getStringBundle()
{
const bundleURL = "chrome://browser/locale/contentAreaCommands.properties";
const sbsContractID = "@mozilla.org/intl/stringbundle;1";
const sbsIID = Components.interfaces.nsIStringBundleService;
const sbs = Components.classes[sbsContractID].getService(sbsIID);
const lsContractID = "@mozilla.org/intl/nslocaleservice;1";
const lsIID = Components.interfaces.nsILocaleService;
const ls = Components.classes[lsContractID].getService(lsIID);
var appLocale = ls.getApplicationLocale();
return sbs.createBundle(bundleURL, appLocale);
}
function makeWebBrowserPersist()
{
const persistContractID = "@mozilla.org/embedding/browser/nsWebBrowserPersist;1";
const persistIID = Components.interfaces.nsIWebBrowserPersist;
return Components.classes[persistContractID].createInstance(persistIID);
}
function makeURL(aURL)
{
var ioService = Components.classes["@mozilla.org/network/io-service;1"]
.getService(Components.interfaces.nsIIOService);
return ioService.newURI(aURL, null, null);
}
function makeFileURL(aFile)
{
var ioService = Components.classes["@mozilla.org/network/io-service;1"]
.getService(Components.interfaces.nsIIOService);
return ioService.newFileURI(aFile);
}
function makeFilePicker()
{
const fpContractID = "@mozilla.org/filepicker;1";
const fpIID = Components.interfaces.nsIFilePicker;
return Components.classes[fpContractID].createInstance(fpIID);
}
function getMIMEService()
{
const mimeSvcContractID = "@mozilla.org/mime;1";
const mimeSvcIID = Components.interfaces.nsIMIMEService;
const mimeSvc = Components.classes[mimeSvcContractID].getService(mimeSvcIID);
return mimeSvc;
}
function getMIMETypeForURI(aURI)
{
try {
return getMIMEService().getTypeFromURI(aURI);
}
catch (e) {
}
return null;
}
function getMIMEInfoForType(aMIMEType, aExtension)
{
try {
return getMIMEService().getFromTypeAndExtension(aMIMEType, aExtension);
}
catch (e) {
}
return null;
}
function getDefaultFileName(aDefaultFileName, aNameFromHeaders, aDocumentURI, aDocument)
{
if (aNameFromHeaders)
// 1) Use the name suggested by the HTTP headers
return validateFileName(aNameFromHeaders);
try {
var url = aDocumentURI.QueryInterface(Components.interfaces.nsIURL);
if (url.fileName != "") {
// 2) Use the actual file name, if present
return validateFileName(decodeURIComponent(url.fileName));
}
} catch (e) {
try {
// the file name might be non ASCII
// try unescape again with a characterSet
var textToSubURI = Components.classes["@mozilla.org/intl/texttosuburi;1"]
.getService(Components.interfaces.nsITextToSubURI);
var charset = getCharsetforSave(aDocument);
return validateFileName(textToSubURI.unEscapeURIForUI(charset, url.fileName));
} catch (e) {
// This is something like a wyciwyg:, data:, and so forth
// URI... no usable filename here.
}
}
if (aDocument) {
var docTitle = validateFileName(aDocument.title).replace(/^\s+|\s+$/g, "");
if (docTitle != "") {
// 3) Use the document title
return docTitle;
}
}
if (aDefaultFileName)
// 4) Use the caller-provided name, if any
return validateFileName(aDefaultFileName);
// 5) If this is a directory, use the last directory name
var re = /\/([^\/]+)\/$/;
var path = aDocumentURI.path.match(re);
if (path && path.length > 1) {
return validateFileName(path[1]);
}
try {
if (aDocumentURI.host)
// 6) Use the host.
return aDocumentURI.host;
} catch (e) {
// Some files have no information at all, like Javascript generated pages
}
try {
// 7) Use the default file name
return getStringBundle().GetStringFromName("DefaultSaveFileName");
} catch (e) {
//in case localized string cannot be found
}
// 8) If all else fails, use "index"
return "index";
}
function validateFileName(aFileName)
{
var re = /[\/]+/g;
if (navigator.appVersion.indexOf("Windows") != -1) {
re = /[\\\/\|]+/g;
aFileName = aFileName.replace(/[\"]+/g, "'");
aFileName = aFileName.replace(/[\*\:\?]+/g, " ");
aFileName = aFileName.replace(/[\<]+/g, "(");
aFileName = aFileName.replace(/[\>]+/g, ")");
}
else if (navigator.appVersion.indexOf("Macintosh") != -1)
re = /[\:\/]+/g;
return aFileName.replace(re, "_");
}
function getNormalizedLeafName(aFile, aDefaultExtension)
{
if (!aDefaultExtension)
return aFile;
// Fix up the file name we're saving to to include the default extension
const stdURLContractID = "@mozilla.org/network/standard-url;1";
const stdURLIID = Components.interfaces.nsIURL;
var url = Components.classes[stdURLContractID].createInstance(stdURLIID);
url.filePath = aFile;
if (url.fileExtension != aDefaultExtension) {
return aFile + "." + aDefaultExtension;
}
return aFile;
}
function getDefaultExtension(aFilename, aURI, aContentType)
{
if (aContentType == "text/plain" || aContentType == "application/octet-stream" || aURI.scheme == "ftp")
return ""; // temporary fix for bug 120327
// First try the extension from the filename
const stdURLContractID = "@mozilla.org/network/standard-url;1";
const stdURLIID = Components.interfaces.nsIURL;
var url = Components.classes[stdURLContractID].createInstance(stdURLIID);
url.filePath = aFilename;
var ext = url.fileExtension;
// This mirrors some code in nsExternalHelperAppService::DoContent
// Use the filename first and then the URI if that fails
var mimeInfo = getMIMEInfoForType(aContentType, ext);
if (ext && mimeInfo && mimeInfo.ExtensionExists(ext)) {
return ext;
}
// Well, that failed. Now try the extension from the URI
var urlext;
try {
url = aURI.QueryInterface(Components.interfaces.nsIURL);
urlext = url.fileExtension;
} catch (e) {
}
if (urlext && mimeInfo && mimeInfo.ExtensionExists(urlext)) {
return urlext;
}
else {
try {
return mimeInfo.primaryExtension;
}
catch (e) {
// Fall back on the extensions in the filename and URI for lack
// of anything better.
return ext || urlext;
}
}
}
function isDocumentType(aContentType)
{
switch (aContentType) {
case "text/html":
return true;
case "text/xml":
case "application/xhtml+xml":
case "application/xml":
return false; // XXX Disables Save As Complete until it works for XML
}
return false;
}
function getCharsetforSave(aDocument)
{
if (aDocument)
return aDocument.characterSet;
if (document.commandDispatcher.focusedWindow)
return document.commandDispatcher.focusedWindow.document.characterSet;
return window._content.document.characterSet;
return false;
}
function SwitchTextEntryDirection(aElement) {
if (window.getComputedStyle(aElement, "").direction == "ltr")
aElement.style.direction = "rtl";
else
aElement.style.direction = "ltr";
}
PK
h*4 , , content/browser/credits.xhtmlUT !CCUx
%brandDTD;
%creditsDTD;
%licenseDTD;
]
>
&brandFullName; Credits
PK
[&41! content/browser/hiddenWindow.xulUT 1žCCUx
PK
[&41! % content/browser/macBrowserOverlay.xulUT 0žCCUx
PK
[&4$ content/browser/addHeadlines.jsUT 1žCCUx // addHeadlines.js
var m_URI;
var m_Title;
function init(aEvent)
{
if (window.arguments && window.arguments.length >= 2) {
m_URI = window.arguments[0];
m_Title = window.arguments[1];
} else if (window.arguments.length == 1){
m_URI = m_Title = window.arguments[0];
} else {
window.close();
return false;
}
document.getElementById("tbTitle").setAttribute("value",m_Title);
buildTree();
}
function uninit(aEvent)
{
if (aEvent.target != document)
return;
}
function doOK()
{
var myIndex = document.getElementById('toolbarPicker').currentIndex;
if (myIndex == -1) return false;
var myID = tbView.visibleData[myIndex][1];
if (myID.indexOf("|") > -1 ) {
var mytbIndex = myID.substr(myID.indexOf("|") +1);
var mytb = myID.substr(0,myID.indexOf("|"));
// dump("attempting addLivemark("+m_URI+","+m_URI+","+m_Title+","+mytb+","+mytbIndex+")\n");
window.opener.spui.addLivemark(m_URI,m_URI,m_Title,mytb,mytbIndex);
} else {
// dump("attempting addLivemark("+m_URI+","+m_URI+","+m_Title+","+myID+")\n");
window.opener.spui.addLivemark(m_URI,m_URI,m_Title,myID);
}
return true;
}
function doCancel()
{
return true;
}
function buildTree()
{
var toolbox = window.opener.document.getElementById('navigator-toolbox');
if (!toolbox) return;
var mySelect = -1;
for (var i = toolbox.firstChild; i; i = i.nextSibling) {
if (i.localName == 'toolbar') {
// dump('toolbar found, name = '+ i.getAttribute("toolbarname") + " id = " + i.id + "\n");
tbView.visibleData[tbView.visibleData.length] = [ i.getAttribute("toolbarname"), i.id, false, false, 0 ];
} else if (i.localName == 'multibar') {
// dump('multibar found, name = '+ i.getAttribute("toolbarname") + " id = " + i.id + "\n");
tbView.visibleData[tbView.visibleData.length] = [ i.getAttribute("toolbarname"), i.id, true, true, 0 ];
tbView.childData[i.id] = [ ];
var mcount = 0;
var mSelect = i.getAttribute("multibarselected");
// dump("mSelect = "+mSelect+"\n");
var curSet = i.getAttribute("currentset");
// dump("curSet = "+curSet+"\n");
var curBar = curSet.split(/;/);
// dump("curBar = "+curBar+"\n");
if (curBar.length > mSelect) {
var curBarName = curBar[mSelect].split(/:/)[0]
} else {
var curBarName = null;
}
// dump("curBarName = "+curBarName+"\n");
for (var j=i.firstChild;j;mcount++,j=j.nextSibling) {
if (j.localName == "multibartray") {
// dump("multibartray found, name = " + j.getAttribute("toolbarname") + " id = " + j.id + "\n");
tbView.childData[i.id][tbView.childData[i.id].length] = [j.getAttribute("toolbarname"), i.id + "|" + mcount];
tbView.visibleData[tbView.visibleData.length] = [ j.getAttribute("toolbarname"), i.id + "|" + mcount, false, false, 1 ];
if (curBarName == j.getAttribute("toolbarname")) mySelect = tbView.visibleData.length - 1;
}
}
}
}
document.getElementById("toolbarPicker").view = tbView;
if (mySelect > -1) document.getElementById("toolbarPicker").view.selection.select(mySelect);
}
var tbView = {
// childData[] = [ , ];
childData : { },
// visibleData[] = [ , , , , ]
visibleData : [ ],
treeBox: null,
selection: null,
get rowCount() { return this.visibleData.length; },
setTree: function(treeBox) { this.treeBox = treeBox; },
getCellText: function(idx, column) { return this.visibleData[idx][0]; },
isContainer: function(idx) { return this.visibleData[idx][2]; },
isContainerOpen: function(idx) { return this.visibleData[idx][3]; },
getLevel: function(idx) { return this.visibleData[idx][4]; },
isContainerEmpty: function(idx) { return false; },
isSeparator: function(idx) { return false; },
isSorted: function() { return false; },
isEditable: function(idx, column) { return false; },
getParentIndex: function(idx) {
if (this.isContainer(idx)) return -1;
for (var t = idx - 1; t >= 0 ; t--) {
if (this.isContainer(t)) return t;
}
return -1;
},
hasNextSibling: function(idx, after) {
var thisLevel = this.getLevel(idx);
for (var t = idx + 1; t < this.visibleData.length; t++) {
var nextLevel = this.getLevel(t)
if (nextLevel == thisLevel) return true;
else if (nextLevel < thisLevel) return false;
}
return false;
},
toggleOpenState: function(idx) {
var item = this.visibleData[idx];
if (!item[2]) return;
if (item[3]) {
item[3] = false;
var thisLevel = this.getLevel(idx);
var deletecount = 0;
for (var t = idx + 1; t < this.visibleData.length; t++) {
if (this.getLevel(t) > thisLevel) deletecount++;
else break;
}
if (deletecount) {
this.visibleData.splice(idx + 1, deletecount);
this.treeBox.rowCountChanged(idx + 1, -deletecount);
}
}
else {
item[3] = true;
var label = this.visibleData[idx][1];
var toinsert = this.childData[label];
for (var i = 0; i < toinsert.length; i++) {
this.visibleData.splice(idx + i + 1, 0, [toinsert[i][0],toinsert[i][1], false, false, 1]);
}
this.treeBox.rowCountChanged(idx + 1, toinsert.length);
}
},
getImageSrc: function(idx, column) {
if (this.isContainer(idx)) return "chrome://browser/skin/tbtree_multibar.png";
else if (this.getLevel(idx) == 1) {
var diff = idx - this.getParentIndex(idx);
return "chrome://browser/skin/tbtree_multibartray"+diff+".png";
} else return "chrome://browser/skin/tbtree_toolbar.png";
},
getProgressMode : function(idx,column) {},
getCellValue: function(idx, column) {},
cycleHeader: function(col, elem) {},
selectionChanged: function() {},
cycleCell: function(idx, column) {},
performAction: function(action) {},
performActionOnCell: function(action, index, column) {},
getRowProperties: function(idx, column, prop) {},
getCellProperties: function(idx, column, prop) {},
getColumnProperties: function(column, element, prop) {},
};PK
[&4I content/browser/addHeadlines.cssUT 0žCCUx treecols
{
max-height:0px;
}
PK
[&4=X\6 6 content/browser/addHeadlines.xulUT 0žCCUx
%brandDTD;
]>
Button Title:
Create in Toolbar:
PK
[&45 % content/browser/manageEmailDialog.xulUT 1žCCUx
%brandDTD;
%aboutDialogDTD;
]>
Your User Name and Password for this account will be stored, encrypted, locally on your computer.
PK
[&4֤oS S $ content/browser/manageEmailDialog.jsUT 0žCCUx var PreSelectItem;
var webmail=window.opener.webmail;
var gUpdatingNow = false;
function init(aEvent)
{
// if (aEvent.target != document)
// return;
fixElements();
EnableRemove();
}
function uninit(aEvent)
{
if (aEvent.target != document)
return;
}
function doCancel() {
// window.close();
//dump("\n**\nmanageEmailDialog.js, doCancel()\n**\n");
removeInconsistentPrefs();
try {
webmail.fixMenus();
webmail.fixCustomAccountMenus();
} catch (ex) {
webmail.debug("Problem with fixMenus():\n"+ex);
}
return true;
}
function doOK() {
//dump("\n**\nmanageEmailDialog.js, doOk()\n**\n");
var listbox=document.getElementById("accountsListbox");
var myproviders=document.getElementById("webemailproviders");
// Set values for current item
var curItem = listbox.selectedItem;
curItem.setAttribute("provider",myproviders.selectedItem.id);
curItem.setAttribute("userid",document.getElementById("userid").value);
curItem.setAttribute("password",document.getElementById("password").value);
curItem.setAttribute("dispSep",document.getElementById("dispSep").checked);
curItem.setAttribute("autolog",document.getElementById("autolog").checked);
curItem.setAttribute("checkUpdates",document.getElementById("checkUpdates").checked);
curItem.setAttribute("emailfreq",document.getElementById("emailfreq").selectedItem.value);
curItem.setAttribute("notification",document.getElementById("notification").selectedItem.value);
curItem.setAttribute("otherDeck",document.getElementById("otherDeck").selectedIndex);
curItem.setAttribute("InboxURL",document.getElementById("InboxURL").value);
curItem.setAttribute("WriteURL",document.getElementById("WriteURL").value);
curItem.setAttribute("AddressURL",document.getElementById("AddressURL").value);
// Verify that there are no duplicate provider entries
var item = null;
var haveProv = new Array();
for (item = listbox.getItemAtIndex(0);item;item = listbox.getNextItem(item,1))
{
var tempP = item.getAttribute("provider");
if (tempP && tempP != "webmail:other")
{
if (haveProv[tempP])
{
alert("Unable to save two accounts for a single provider ("+tempP+")");
return false;
}
haveProv[tempP] = true;
}
}
// Save all preferences
for (item = listbox.getItemAtIndex(0);item;item = listbox.getNextItem(item,1))
{
// only save valid webmail accounts
if (isWebmailDataValid(item)) {
saveWebmailValues(item);
}
}
// MERC - JCH: Remove any webmail prefs inconsistent with listbox values.
// And do it before menus are changed.
removeInconsistentPrefs();
try {
webmail.fixMenus();
webmail.fixCustomAccountMenus();
} catch (ex) {
webmail.debug("Problem with fixMenus():\n"+ex);
}
// window.close();
return true;
}
function setFromPrefs(aItem, aAccountName, aPref) {
//dump("\n**\nmanageEmailDialog.js, setFromPrefs(aItem, aAccountName, aPref)\n**\n");
try {
aItem.setAttribute(aPref,webmail.Prefs.getCharPref(aPref+"."+aAccountName));
} catch(ex) {}
}
function setWebmailValues(aItem,aAccountName) {
//dump("\n**\nmanageEmailDialog.js, setWebmailValues(aItem,aAccountName)\n**\n");
webmail.debug('setWebmailValues(..., '+aAccountName+')');
setFromPrefs(aItem,aAccountName,"provider");
var myProvider=aItem.getAttribute("provider");
if (!myProvider || myProvider == "") {
webmail.debug("provider is null, removing "+aAccountName);
var listbox=document.getElementById("accountsListbox");
listbox.removeItemAt(listbox.getIndexOfItem(aItem));
return;
}
//MERC CCOTE bug 203312
// set temp variable
aItem.setAttribute("origAccountName", aAccountName);
if (myProvider && myProvider == "webmail:other") {
aItem.setAttribute("otherDeck",1);
} else {
aItem.setAttribute("otherDeck",0);
}
//var fHost={ value: "" }
//var fUser={ value: "" }
//var fPassword={ value: "" }
var mKey="webmail:"+aAccountName;
var service = webmail.getServiceById(myProvider);
// MERC - JCH: Make sure service is defined. Defined services are found in webmail.rdf
if (service) {
var domain = service.passcarddomain;
var pc = window.opener.GetWebmailPasscard(domain, mKey);
// If a master password is set on a mail account and user tries to open the dialog,
// a prompt is displayed to enter master password. Cancelling the prompt used to
// allow the dialog to open with no values for user and password, and some corresponding
// exceptions thrown for bad list values. Now if user cancels prompt, dialog should not
// open.
try
{
webmail.debug('Found a passcard for this account, un/pw = '+pc.user+'/'+pc.password);
var pcUser = pc.user;
var pcPwd = pc.password;
aItem.setAttribute("userid", pcUser);
aItem.setAttribute("password", pcPwd);
}
catch (ex)
{
webmail.debug('\n\nWEBMAIL ERROR: Did not find passcard for mKey = '+mKey+'\n');
}
}
setFromPrefs(aItem,aAccountName,"dispSep");
setFromPrefs(aItem,aAccountName,"autolog");
setFromPrefs(aItem,aAccountName,"checkUpdates");
setFromPrefs(aItem,aAccountName,"emailfreq");
setFromPrefs(aItem,aAccountName,"notification");
setFromPrefs(aItem,aAccountName,"InboxURL");
setFromPrefs(aItem,aAccountName,"WriteURL");
setFromPrefs(aItem,aAccountName,"AddressURL");
}
function setPrefFromItem(aItem,aAccountName,aPref) {
//dump("\n**\nmanageEmailDialog.js, setPrefFromItem(aItem,aAccountName,aPref)\n**\n");
webmail.Prefs.setCharPref(aPref+"."+aAccountName,aItem.getAttribute(aPref));
}
function saveWebmailValues(aItem) {
//dump("\n**\nmanageEmailDialog.js, saveWebmailValues(aItem)\n**\n");
////MERC CCOTE bug 203312
// Check if the original account name match curent account Name
// If not clear the pref
var accountName = aItem.getAttribute("origAccountName");
if(accountName!= aItem.label){
clearPref(accountName,"provider");
clearPref(accountName,"dispSep");
clearPref(accountName,"autolog");
clearPref(accountName,"checkUpdates");
clearPref(accountName,"emailfreq");
clearPref(accountName,"notification");
clearPref(accountName,"InboxURL");
clearPref(accountName,"WriteURL");
clearPref(accountName,"AddressURL");
webmail.removeMenus(accountName);
}
accountName = aItem.label;
webmail.debug("saveWebmailValues() saving " + accountName);
webmail.debug("\tstyle: " + aItem.getAttribute("style"));
if (aItem.getAttribute("style") == "font-weight: bold;") {
webmail.debug("attempting to set default to: "+accountName);
try {
webmail.Prefs.setCharPref("default",accountName);
} catch (ex) {
webmail.debug("set default failed:\n"+ex);
}
}
// MERC - JCH: Remove both built-in accounts and custom accounts
// if 'dispSep' unchecked.
if (aItem.getAttribute("dispSep") == "false") {
webmail.debug("attempting to remove menus");
webmail.removeMenus(aItem.getAttribute("origName"));
}
var myProvider=aItem.getAttribute("provider");
if (myProvider && myProvider != "webmail:other") {
//MERC CCOTE bug fix 204414
// Move the if code here to unable ok button when
// Other is selected as a provider
var mUserId=aItem.getAttribute("userid");
var mPassword=aItem.getAttribute("password");
if (mUserId.length > 0 && mPassword.length > 0) {
var mKey="webmail:"+accountName;
var fHost={ value: "" }
var fUser={ value: "" }
var fPassword={ value: "" }
var passwordManagerInternal = Components.classes["@mozilla.org/passwordmanager;1"].getService(Components.interfaces.nsIPasswordManagerInternal);
var passwordManager = Components.classes["@mozilla.org/passwordmanager;1"].getService(Components.interfaces.nsIPasswordManager);
var provider = aItem.getAttribute('provider');
webmail.debug('using provider: '+provider);
var service = webmail.getServiceById(provider);
var domain = service.passcarddomain;
var pc = window.opener.GetWebmailPasscard(domain, mKey);
if (pc) {
// There is an existing passcard, so toast it!!
try {
webmail.debug(' - removing old passcard with mKey=['+mKey+'] and username='+pc.user);
var pcUser = pc.user;
passwordManager.removeUser(domain, pcUser);
} catch (ex) {
}
}
var username = (service.passcardusername) ? service.passcardusername : 'userid';
var password = (service.passcardpassword) ? service.passcardpassword : 'password';
dump('\n\n\nAbout to save webmail passcard.\n');
dump(' - domain: '+domain+'\n');
dump(' - username: '+username+'\n');
dump(' - password: '+password+'\n');
dump("++++ JMC: addUserFull with domain: " + domain + ", mUserId : " + mUserId + ", mPassword: " + mPassword + ", mKey : " + mKey + "\t\t");
passwordManagerInternal.addUserFull(domain, mUserId, mPassword, username, password, mKey);
}
setPrefFromItem(aItem,accountName,"provider");
setPrefFromItem(aItem,accountName,"dispSep");
setPrefFromItem(aItem,accountName,"autolog");
if (aItem.getAttribute("autolog") == 'true') {
webmail.setAutoLoginPref(accountName, service, true);
} else if (service) {
webmail.setAutoLoginPref(accountName, service, false);
}
setPrefFromItem(aItem,accountName,"checkUpdates");
setPrefFromItem(aItem,accountName,"emailfreq");
setPrefFromItem(aItem,accountName,"notification");
} else {
if (myProvider) {
setPrefFromItem(aItem,accountName,"provider");
setPrefFromItem(aItem,accountName,"InboxURL");
if (aItem.getAttribute("WriteURL") != "")
{
setPrefFromItem(aItem,accountName,"WriteURL");
}
else
{ webmail.removeMenus(accountName);
if (webmail.Prefs.prefHasUserValue("WriteURL."+accountName))
webmail.Prefs.clearUserPref("WriteURL."+accountName);
}
if (aItem.getAttribute("AddressURL") != "")
{
setPrefFromItem(aItem,accountName,"AddressURL");
}
else
{
webmail.removeMenus(accountName);
if (webmail.Prefs.prefHasUserValue("AddressURL."+accountName))
webmail.Prefs.clearUserPref("AddressURL."+accountName);
}
setPrefFromItem(aItem,accountName,"dispSep");
}
}
}
// BLT #: 176412 BC (10/31/2005):
// Modification. Script was incorrectly comparing accountName with listbox label.
// The error was due to a substr(9) being applied to prefAccounts[i], thus making the two not equal for large names
// MERC - JCH: Removes all webmail accounts in the prefs that are not in the listbox.
// This is to make sure the two are properly synced.
function removeInconsistentPrefs()
{
//dump("\n**\nmanageEmailDialog.js, removeInconsistentPrefs()\n**\n");
// Get all webmail accounts stored as prefs
// BC: Getting the pref, and then comparing to listbox is not working.
// If the user changes the webmail description, the listbox label changes as well, in realtime.(this could be wrong)
// The problem is that the pref that stores the accountname is from the last-save, and doesn't have
// our current changes (in realtime), so the comparison is never true.
// Note: Still unsure why we lose the button if the match is false.
var count = {value:0};
var prefAccounts = webmail.Prefs.getChildList("provider.", count);
// Define listbox vars
var listbox = document.getElementById("accountsListbox");
var item;
// For each webmail account in the prefs, check if it is among the listbox accounts.
// If it is not, delete it, otherwise do nothing.
var accountName;
var foundMatch;
for (var i=0; i 0) {
webmail.debug("manageEmailDialog has arguments");
for (var i =0;i 0) {
webmail.debug("("+myItem.getAttribute("provider")+") is a valid provider");
webmail.debug("Attempting to select provider # "+tempitem[0].id);
myproviders.selectedItem = tempitem[0];
changeprovider(tempitem[0]);
} else {
// provider is not valid -- Select first item on list
webmail.debug("Invalid Provider: attempting to select netscape");
tempitem=myproviders.getElementsByAttribute("id","webmail:feed:netscape");
myproviders.selectedItem = tempitem[0];
changeprovider(tempitem[0]);
}
webmail.debug("myItem.label (post)="+myItem.label);
webmail.debug("un/pw: "+myItem.getAttribute("userid")+'/'+myItem.getAttribute("password"));
document.getElementById("userid").value = myItem.getAttribute("userid");
document.getElementById("password").value = myItem.getAttribute("password");
document.getElementById("autolog").checked = myItem.getAttribute("autolog")=="true";
if (myItem.getAttribute("userid") && myItem.getAttribute("password")) {
document.getElementById("autolog").disabled=false;
}
document.getElementById("checkUpdates").checked = myItem.getAttribute("checkUpdates")=="true";
document.getElementById("dispSep").checked = myItem.getAttribute("dispSep")=="true";
document.getElementById("dispSep2").checked = myItem.getAttribute("dispSep")=="true";
tempitem = document.getElementById("emailfreq").getElementsByAttribute("value",myItem.getAttribute("emailfreq"));
if (tempitem && tempitem.length > 0) {
document.getElementById("emailfreq").selectedItem = tempitem[0];
} else {
document.getElementById("emailfreq").selectedIndex = 2;
}
tempitem = document.getElementById("notification").getElementsByAttribute("value",myItem.getAttribute("notification"));
if (tempitem && tempitem.length > 0) {
document.getElementById("notification").selectedItem = tempitem[0];
}
document.getElementById("otherDeck").selectedIndex = myItem.getAttribute("otherDeck");
document.getElementById("InboxURL").value = myItem.getAttribute("InboxURL");
document.getElementById("WriteURL").value = myItem.getAttribute("WriteURL");
document.getElementById("AddressURL").value = myItem.getAttribute("AddressURL");
} else {
// Put in the defaults if there is no data
myproviders.selectedIndex=0;
changeprovider(myproviders.firstChild.childNodes[0]);
document.getElementById("userid").value="";
document.getElementById("password").value="";
document.getElementById("autolog").disabled=true;
document.getElementById("autolog").checked=false;
document.getElementById("checkUpdates").checked=false;
document.getElementById("dispSep").checked=false;
document.getElementById("dispSep2").checked=false;
document.getElementById("emailfreq").selectedIndex=2;
document.getElementById("notification").selectedIndex=0;
document.getElementById("InboxURL").value="";
document.getElementById("WriteURL").value="";
document.getElementById("AddressURL").value="";
}
gUpdatingNow=false;
changeDescription();
PreSelectItem=myItem;
}
function setDispSep() {
//dump("\n**\nmanageEmailDialog.js, setDispSep()\n**\n");
document.getElementById("dispSep").checked = document.getElementById("dispSep2").checked;
}
function setDispSep2() {
//dump("\n**\nmanageEmailDialog.js, setDispSep2()\n**\n");
document.getElementById("dispSep2").checked = document.getElementById("dispSep").checked;
}
function changeDescription() {
//dump("\n**\nmanageEmailDialog.js, changeDescription()\n**\n");
var listbox=document.getElementById("accountsListbox");
var firstitem=listbox.getItemAtIndex(0);
if (firstitem) webmail.debug("in changeDescription: firstitem.provider = "+firstitem.getAttribute("provider"));
var newtext=document.getElementById("txtDescription").value;
document.getElementById("accountsListbox").selectedItem.label=newtext;
document.getElementById("acctDesc").value=newtext+":";
if (newtext == document.getElementById("webemailproviders").selectedItem.getAttribute("label")) {
document.getElementById("txtDescription").setAttribute("isNew","true");
} else {
document.getElementById("txtDescription").setAttribute("isNew","false");
}
if (firstitem) webmail.debug("out changeDescription: firstitem.provider = "+firstitem.getAttribute("provider"));
//removeInvalidAccountsFromList();
}
function changeUser() {
//dump("\n**\nmanageEmailDialog.js, changeUser()\n**\n");
webmail.debug("changeUser() Called");
if (document.getElementById("userid").textLength > 0 &&
document.getElementById("password").textLength > 0)
{
document.getElementById("autolog").disabled=false;
} else {
document.getElementById("autolog").disabled=true;
document.getElementById("autolog").checked=false;
}
}
function updateOkButton() {
webmail.debug("updateOkButton() Called");
//dump("\n**\nmanageEmailDialog.js, updateOkButton()\n**\n");
if (gUpdatingNow) return;
// MERC (rpaul) if no data is provided, disable ok button to prevent the userfrom storing an
// an account
var listbox=document.getElementById("accountsListbox");
// Gets rid of exception when removing an account
if (listbox.selectedIndex < 0 || listbox.getRowCount() < 1)
return;
var firstitem=listbox.getItemAtIndex(0);
if (firstitem) webmail.debug("in updateOKButton: firstitem.provider = "+firstitem.getAttribute("provider"));
var myproviders=document.getElementById("webemailproviders");
// Set values for current item
var curItem = listbox.selectedItem;
curItem.setAttribute("provider",myproviders.selectedItem.id);
curItem.setAttribute("userid",document.getElementById("userid").value);
curItem.setAttribute("password",document.getElementById("password").value);
if (myproviders.selectedItem.id == "webmail:other") {
curItem.setAttribute("InboxURL", document.getElementById("InboxURL").value);
curItem.setAttribute("WriteURL", document.getElementById("WriteURL").value);
curItem.setAttribute("AddressURL", document.getElementById("AddressURL").value);
}
var enableOk = true;
// CCote bug #141453
// Before it used the selected item to enable or disable the OK button
// The new behavior ask to check for all item in the list.
// If one or more items are missing require fields the button is disable
// until field is filled or user remove email acount
var listbox=document.getElementById("accountsListbox");
var item=listbox.getItemAtIndex(0);
while (item) {
if (!isWebmailDataValid(item)) {
enableOk = false;
}
item = listbox.getNextItem(item,1);
}
document.getElementById('manageEmailDialog').getButton("accept").disabled=!enableOk;
if (firstitem) webmail.debug("out updateOKButton: firstitem.provider = "+firstitem.getAttribute("provider"));
return enableOk;
}
function changeprovider(aProvider) {
//dump("\n**\nmanageEmailDialog.js, changeprovider(aProvider)\n**\n");
webmail.debug("Changeprovider called with me.id=" + aProvider.id + ",me.label=" + aProvider.getAttribute("label"));
if (PreSelectItem)
webmail.debug("PreSelectItem.provider = "+PreSelectItem.getAttribute("provider"));
document.getElementById("uname").value = aProvider.getAttribute("username");
var notify = aProvider.getAttribute("notify");
var allnotify;
var i;
webmail.debug("notify="+notify);
document.getElementById("otherDeck").selectedIndex=0;
allnotify=document.getElementsByAttribute("notifyonly","true");
if (notify == "_none"){
for (i=0;i list.getRowCount() - 1) {
list.selectedIndex = list.getRowCount() - 1;
} else {
list.selectedIndex=index;
}
updateOkButton();
}
// If the default account was removed, create a new one.
if (removedDefault)
{
setDefault();
}
}
list.focus();
EnableRemove();
}
/*****
* AddAccount
* var aAccountName - the name of the account to add
* var setAsDefault - boolean that determines whether the new account is set to default
*/
function AddAccount(aAccountName, setAsDefault) {
//dump("\n**\nmanageEmailDialog.js, AddAccount(aAccountName, setAsDefault)\n**\n");
webmail.debug("AddAccount() Called");
// Add an entry to the listbox
var listbox=document.getElementById("accountsListbox");
var newItem=listbox.appendItem(aAccountName,"");
// Select the new entry
// MERC (rpaul) for BLT bug # 128289 before adding new account make sure the list item is visible
// so it is selectable
listbox.focus();
listbox.ensureIndexIsVisible(listbox.getRowCount()-1);
listbox.selectedIndex = listbox.getRowCount()-1;
if (setAsDefault == true) {
newItem.setAttribute("style","font-weight:bold");
var firstItem = listbox. getItemAtIndex(0);
firstItem.removeAttribute("style");
}
webmail.debug("txtDescription="+document.getElementById("txtDescription").value);
document.getElementById("txtDescription").setAttribute("isNew","true");
EnableRemove();
//document.getElementById('manageEmailDialog').getButton("accept").disabled=true;
}
function isWebmailDataValid(aItem) {
//dump("\n**\nmanageEmailDialog.js, isWebmailDataValid(aItem)\n**\n");
var isValid = false;
webmail.debug("isWebmailDataValid() Called on "+aItem.label+" \n");
// must enter a description
if (aItem.label == "") return false;
// validation of custom accounts have differnet rules
// check if the user has entered a valid inbox, write email url and addressbook
if (aItem.getAttribute("provider")=="webmail:other") {
// MERC - JCH: Insist on only the inbox url rather
// than inbox url, address box url and write url.
if (aItem.getAttribute("InboxURL") == "")
{
isValid = false;
} else {
isValid = true;
}
} else {
// check if the user entered a username and password
var mUserId=aItem.getAttribute("userid");
var mPassword=aItem.getAttribute("password");
if (mUserId == "" || mPassword == "")
{
isValid = false;
}
else {
isValid = true;
}
}
return isValid;
}
/**
* Enable the Remove button if there is an item in the list
**/
function EnableRemove()
{
//dump("\n**\nmanageEmailDialog.js, EnableRemove()\n**\n");
webmail.debug("EnableRemove() Called");
var removeBtn = document.getElementById("removeBtn");
if (document.getElementById("accountsListbox").getRowCount() > 1)
removeBtn.removeAttribute('disabled');
else
removeBtn.setAttribute('disabled', 'true');
}
/****
* On opening the webmail dialog, make sure no useless/confusing default accounts are created.
**/
function removeInvalidAccountsFromList()
{
//dump("\n**\nmanageEmailDialog.js, removeInvalidAccountsFromList()\n**\n");
var list = document.getElementById("accountsListbox");
var item;
var nRows = list.getRowCount();
// If there is only one item, it doesn't matter if it is undefined.
if (nRows < 2)
return;
for (var index=0; index 
