home *** CD-ROM | disk | FTP | other *** search
/ Chip 2002 January / 01_02.iso / software / netscape62win / mail.xpi / bin / chrome / messenger.jar / content / messenger / msgHdrViewOverlay.js < prev    next >
Text File  |  2001-08-09  |  42KB  |  1,070 lines
  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
  2.  * The contents of this file are subject to the Netscape Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/NPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is Mozilla Communicator client code, released
  13.  * March 31, 1998.
  14.  * 
  15.  * The Initial Developer of the Original Code is Netscape
  16.  * Communications Corporation. Portions created by Netscape are
  17.  * Copyright (C) 1998-1999 Netscape Communications Corporation. All
  18.  * Rights Reserved.
  19.  */
  20.  
  21. /* This is where functions related to displaying the headers for a selected message in the
  22.    message pane live. */
  23.  
  24. ////////////////////////////////////////////////////////////////////////////////////
  25. // Warning: if you go to modify any of these JS routines please get a code review from either
  26. // hangas@netscape.com or mscott@netscape.com. It's critical that the code in here for displaying
  27. // the message headers for a selected message remain as fast as possible. In particular, 
  28. // right now, we only introduce one reflow per message. i.e. if you click on a message in the thread
  29. // pane, we batch up all the changes for displaying the header pane (to, cc, attachements button, etc.) 
  30. // and we make a single pass to display them. It's critical that we maintain this one reflow per message
  31. // view in the message header pane. 
  32. //
  33. ////////////////////////////////////////////////////////////////////////////////////
  34.  
  35. var msgHeaderParserContractID           = "@mozilla.org/messenger/headerparser;1";
  36. var abAddressCollectorContractID     = "@mozilla.org/addressbook/services/addressCollecter;1";
  37.  
  38. // gGeneratedViewAllHeaderInfo --> we clear this every time we start to display a new message.
  39. // the view all header popup will set it when we first generate a view of all the headers. this is 
  40. // just so it won't try to regenerate all the information every time the user clicks on the popup.
  41. var gGeneratedViewAllHeaderInfo = false; 
  42. var gViewAllHeaders = false;
  43. var gNumAddressesToShow = 3;
  44. var gShowUserAgent = false;
  45. var gCollectIncoming = false;
  46. var gCollectNewsgroup = false;
  47. var gCollapsedHeaderViewMode = false;
  48. var gBuildAttachmentsForCurrentMsg = false;
  49. var gBuildAttachmentPopupForCurrentMsg = true;
  50. var gOpenLabel;
  51. var gSaveLabel;
  52.  
  53. var msgHeaderParser = Components.classes[msgHeaderParserContractID].getService(Components.interfaces.nsIMsgHeaderParser);
  54. var abAddressCollector = Components.classes[abAddressCollectorContractID].getService(Components.interfaces.nsIAbAddressCollecter);
  55.  
  56. // All these variables are introduced to keep track of insertion and deletion of the toggle button either
  57. // as the first node in the list of emails or the last node.
  58. var numOfEmailsInEnumerator;
  59.  
  60. // var used to determine whether to show the toggle button at the
  61. // beginning or at the end of a list of emails in to/cc fields.
  62. var gNumOfEmailsToShowToggleButtonInFront = 15;
  63.  
  64. // For every possible "view" in the message pane, you need to define the header names you want to
  65. // see in that view. In addition, include information describing how you want that header field to be
  66. // presented. i.e. if it's an email address field, if you want a toggle inserted on the node in case
  67. // of multiple email addresses, etc. We'll then use this static table to dynamically generate header view entries
  68. // which manipulate the UI. 
  69. // When you add a header to one of these view lists you can specify the following properties:
  70. // name: the name of the header. i.e. "to", "subject". This must be in lower case and the name of the
  71. //       header is used to help dynamically generate ids for objects in the document. (REQUIRED)
  72. // useToggle:      true if the values for this header are multiple email addresses and you want a 
  73. //                 a toggle icon to show a short vs. long list (DEFAULT: false)
  74. // useShortView:   (only works on some fields like From). If the field has a long presentation and a
  75. //                 short presentation we'll use the short one. i.e. if you are showing the From field and you
  76. //                 set this to true, we can show just "John Doe" instead of "John Doe <jdoe@netscape.net>".
  77. //                 (DEFAULT: false)
  78. // 
  79. // outputFunction: this is a method which takes a headerEntry (see the definition below) and a header value
  80. //                 This allows you to provide your own methods for actually determining how the header value
  81. //                 is displayed. (DEFAULT: updateHeaderValue which just sets the header value on the text node)
  82.  
  83. // Our first view is the collapsed view. This is very light weight view of the data. We only show a couple
  84. // fields.
  85. var gCollapsedHeaderList = [ {name:"subject", outputFunction:updateHeaderValueInTextNode},
  86.                              {name:"from", useShortView:true, outputFunction:OutputEmailAddresses},
  87.                              {name:"date", outputFunction:updateHeaderValueInTextNode}];
  88.  
  89. // We also have an expanded header view. This shows many of your more common (and useful) headers.
  90. var gExpandedHeaderList = [ {name:"subject"}, 
  91.                             {name:"from", outputFunction:OutputEmailAddresses},
  92.                             {name:"reply-to", isEmailAddress:true, outputFunction:OutputEmailAddresses},
  93.                             {name:"date"},
  94.                             {name:"to", useToggle:true, outputFunction:OutputEmailAddresses},
  95.                             {name:"cc", useToggle:true, outputFunction:OutputEmailAddresses},
  96.                             {name:"bcc", useToggle:true, outputFunction:OutputEmailAddresses},
  97.                             {name:"newsgroups", outputFunction:OutputNewsgroups},
  98.                             {name:"followup-to", outputFunction:OutputNewsgroups} ];
  99.  
  100. // Now, for each view the message pane can generate, we need a global table of headerEntries. These
  101. // header entry objects are generated dynamically based on the static date in the header lists (see above)
  102. // and elements we find in the DOM based on properties in the header lists. 
  103. var gCollapsedHeaderView = {};
  104. var gExpandedHeaderView = {};
  105.  
  106. // currentHeaderData --> this is an array of header name and value pairs for the currently displayed message.
  107. //                       it's purely a data object and has no view information. View information is contained in the view objects.
  108. //                       for a given entry in this array you can ask for:
  109. // .headerName ---> name of the header (i.e. 'to'). Always stored in lower case
  110. // .headerValue --> value of the header "johndoe@netscape.net"
  111. var currentHeaderData = {};
  112.  
  113. // For the currently displayed message, we store all the attachment data. When displaying a particular
  114. // view, it's up to the view layer to extract this attachment data and turn it into something useful.
  115. // For a given entry in the attachments list, you can ask for the following properties:
  116. // .contentType --> the content type of the attachment
  117. // url --> an imap, or mailbox url which can be used to fetch the message
  118. // uri --> an RDF URI which refers to the message containig the attachment
  119. // notDownloaded --> boolean flag stating whether the attachment is downloaded or not.
  120. var currentAttachments = new Array();
  121.  
  122. // createHeaderEntry --> our constructor method which creates a header Entry 
  123. // based on an entry in one of the header lists. A header entry is different from a header list.
  124. // a header list just describes how you want a particular header to be presented. The header entry
  125. // actually has knowledge about the DOM and the actual DOM elements associated with the header.
  126. // prefix --> the name of the view (i.e. "collapsed", "expanded")
  127. // headerListInfo --> entry from a header list.
  128. function createHeaderEntry(prefix, headerListInfo)
  129. {
  130.   var partialIDName = prefix + headerListInfo.name;
  131.   //dump('enclosingBox id = ' + partialIDName + 'Box' + '\n');
  132.   this.enclosingBox = document.getElementById(partialIDName + 'Box');
  133.   //dump(this.enclosingBox + \'n');
  134.   this.textNode = document.getElementById(partialIDName + 'Value');
  135.   this.isValid = false;
  136.  
  137.   if ("useToggle" in headerListInfo)
  138.   {
  139.     this.useToggle = headerListInfo.useToggle;
  140.     if (this.useToggle) // find the toggle icon in the document
  141.     {
  142.       this.toggleIcon = document.getElementById(partialIDName + 'ToggleIcon');
  143.       this.longTextNode = document.getElementById(partialIDName + 'Value' + 'Long');
  144.     }
  145.   }
  146.   else
  147.    this.useToggle = false;
  148.  
  149.   if ("useShortView" in headerListInfo)
  150.     this.useShortView = headerListInfo.useShortView;
  151.   else
  152.     this.useShortView = false;
  153.  
  154.   if ("outputFunction" in headerListInfo)
  155.     this.outputFunction = headerListInfo.outputFunction;
  156.   else
  157.     this.outputFunction = updateHeaderValue;
  158. }
  159.  
  160. function initializeHeaderViewTables()
  161. {
  162.   // iterate over each header in our header list arrays and create header entries 
  163.   // for each one. These header entries are then stored in the appropriate header table
  164.   for (var index = 0; index < gCollapsedHeaderList.length; index++)
  165.   {
  166.     gCollapsedHeaderView[gCollapsedHeaderList[index].name] = 
  167.       new createHeaderEntry('collapsed', gCollapsedHeaderList[index]);
  168.   }
  169.  
  170.   for (index = 0; index < gExpandedHeaderList.length; index++)
  171.   {
  172.     var headerName = gExpandedHeaderList[index].name;
  173.     gExpandedHeaderView[headerName] = new createHeaderEntry('expanded', gExpandedHeaderList[index]);
  174.   }
  175.  
  176.   if (gShowUserAgent)
  177.   {
  178.     var userAgentEntry = {name:"user-agent", outputFunction:updateHeaderValueInTextNode};
  179.     gExpandedHeaderView[userAgentEntry.name] = new createHeaderEntry('expanded', userAgentEntry);
  180.   }
  181.  
  182. }
  183.  
  184. function OnLoadMsgHeaderPane()
  185. {
  186.   // HACK...force our XBL bindings file to be load before we try to create our first xbl widget....
  187.   // otherwise we have problems.
  188.  
  189.   document.loadBindingDocument('chrome://messenger/content/mailWidgets.xml');
  190.   
  191.   // load any preferences that at are global with regards to 
  192.   // displaying a message...
  193.   gNumAddressesToShow = pref.GetIntPref("mailnews.max_header_display_length");
  194.   gCollectIncoming = pref.GetBoolPref("mail.collect_email_address_incoming");
  195.   gCollectNewsgroup = pref.GetBoolPref("mail.collect_email_address_newsgroup");
  196.   gShowUserAgent = pref.GetBoolPref("mailnews.headers.showUserAgent");
  197.   initializeHeaderViewTables();
  198.  
  199.   var toggleHeaderView = document.getElementById("msgHeaderView");
  200.   var initialCollapsedSetting = toggleHeaderView.getAttribute("state");
  201.   if (initialCollapsedSetting == "true")
  202.     gCollapsedHeaderViewMode = true;   
  203. }
  204.  
  205. // The messageHeaderSink is the class that gets notified of a message's headers as we display the message
  206. // through our mime converter. 
  207.  
  208. var messageHeaderSink = {
  209.     onStartHeaders: function()
  210.     {
  211.       // every time we start to redisplay a message, check the view all headers pref....
  212.       var showAllHeadersPref = pref.GetIntPref("mail.show_headers");
  213.       if (showAllHeadersPref == 2)
  214.         gViewAllHeaders = true;
  215.       else
  216.         gViewAllHeaders = false;
  217.  
  218.       ClearCurrentHeaders();
  219.       gGeneratedViewAllHeaderInfo = false;
  220.       gBuildAttachmentsForCurrentMsg = false;
  221.       gBuildAttachmentPopupForCurrentMsg = true;
  222.       ClearAttachmentTreeList();
  223.       ClearEditMessageButton();
  224.     },
  225.  
  226.     onEndHeaders: function() 
  227.     {
  228.       // WARNING: This is the ONLY routine inside of the message Header Sink that should 
  229.       // trigger a reflow!
  230.       CheckNotify();
  231.       
  232.       ClearHeaderView(gCollapsedHeaderView);
  233.       ClearHeaderView(gExpandedHeaderView);
  234.  
  235.       EnsureSubjectValue(); // make sure there is a subject even if it's empty so we'll show the subject and the twisty
  236.       
  237.       ShowMessageHeaderPane();
  238.       UpdateMessageHeaders();
  239.       if (gIsEditableMsgFolder)
  240.         ShowEditMessageButton();
  241.     },
  242.  
  243.     handleHeader: function(headerName, headerValue, dontCollectAddress) 
  244.     {
  245.       // WARNING: if you are modifying this function, make sure you do not do *ANY*
  246.       // dom manipulations which would trigger a reflow. This method gets called 
  247.       // for every rfc822 header in the message being displayed. If you introduce a reflow
  248.       // you'll be introducing a reflow for every time we are told about a header. And msgs have
  249.       // a lot of headers. Don't do it =)....Move your code into OnEndHeaders which is only called
  250.       // once per message view.
  251.  
  252.       // for consistancy sake, let's force all header names to be lower case so
  253.       // we don't have to worry about looking for: Cc and CC, etc.
  254.       var lowerCaseHeaderName = headerName.toLowerCase();
  255.       var foo = new Object;
  256.       foo.headerValue = headerValue;
  257.       foo.headerName = headerName;
  258.  
  259.       // some times, you can have multiple To or cc lines....in this case, we want to APPEND 
  260.       // these headers into one. 
  261.       if ( (lowerCaseHeaderName == 'to' || lowerCaseHeaderName == 'cc') && ( lowerCaseHeaderName in currentHeaderData))
  262.       {
  263.         currentHeaderData[lowerCaseHeaderName].headerValue = currentHeaderData[lowerCaseHeaderName].headerValue + ',' + foo.headerValue;
  264.       }
  265.       else
  266.        currentHeaderData[lowerCaseHeaderName] = foo;
  267.  
  268.       if (lowerCaseHeaderName == "from")
  269.       {
  270.         if (headerValue && abAddressCollector && 
  271.             ((gCollectIncoming && !dontCollectAddress) || (gCollectNewsgroup && dontCollectAddress)))
  272.           abAddressCollector.collectUnicodeAddress(headerValue);  
  273.       }
  274.  
  275.     },
  276.  
  277.     handleAttachment: function(contentType, url, displayName, uri, notDownloaded) 
  278.     {
  279.       currentAttachments.push (new createNewAttachmentInfo(contentType, url, displayName, uri, notDownloaded));
  280.       // if we have an attachment, set the MSG_FLAG_ATTACH flag on the hdr
  281.       // this will cause the "message with attachment" icon to show up
  282.       // in the thread pane
  283.       // we only need to do this on the first attachment
  284.       var numAttachments = currentAttachments.length;
  285.       if (numAttachments == 1) {
  286.         try {
  287.           // convert the uri into a hdr
  288.           var hdr = messenger.messageServiceFromURI(uri).messageURIToMsgHdr(uri);
  289.           hdr.markHasAttachments(true);
  290.         }
  291.         catch (ex) {
  292.           dump("ex = " + ex + "\n");
  293.         }
  294.       }
  295.     },
  296.     
  297.     onEndAllAttachments: function()
  298.     {
  299.       // AddSaveAllAttachmentsMenu();
  300.       if (gCollapsedHeaderViewMode)
  301.         displayAttachmentsForCollapsedView();
  302.       else
  303.         displayAttachmentsForExpandedView();
  304.     }
  305. };
  306.  
  307. function EnsureSubjectValue()
  308. {
  309.   if (!('subject' in currentHeaderData))
  310.   {
  311.     var foo = new Object;
  312.     foo.headerValue = "";
  313.     foo.headerName = 'subject';
  314.     currentHeaderData[foo.headerName] = foo;
  315.   } 
  316. }
  317.  
  318. function CheckNotify()
  319. {
  320.   if (this.NotifyClearAddresses != undefined)
  321.     NotifyClearAddresses();
  322. }
  323.  
  324.  
  325. // flush out any local state being held by a header entry for a given
  326. // table
  327. function ClearHeaderView(headerTable)
  328. {
  329.   for (index in headerTable)
  330.   {
  331.      var headerEntry = headerTable[index];
  332.      if (headerEntry.useToggle)
  333.      {
  334.        ClearEmailField(headerEntry.textNode);
  335.        if (headerEntry.longTextNode)
  336.         ClearEmailField(headerEntry.longTextNode);        
  337.      }
  338.  
  339.      headerEntry.valid = false;
  340.   }
  341. }
  342.  
  343. // make sure that any valid header entry in the table is collapsed
  344. function hideHeaderView(headerTable)
  345. {
  346.   for (index in headerTable)
  347.   {
  348.     headerTable[index].enclosingBox.setAttribute('collapsed', true);
  349.   }
  350. }
  351.  
  352. // make sure that any valid header entry in the table specified is 
  353. // visible
  354. function showHeaderView(headerTable)
  355. {
  356.   var headerEntry;
  357.   for (index in headerTable)
  358.   {
  359.     headerEntry = headerTable[index];
  360.     if (headerEntry.valid)
  361.       headerEntry.enclosingBox.removeAttribute('collapsed');
  362.     else // if the entry is invalid, always make sure it's collapsed
  363.       headerEntry.enclosingBox.setAttribute('collapsed', true);
  364.   }
  365. }
  366.  
  367. // make sure the appropriate fields within the currently displayed view header mode
  368. // are collapsed or visible...
  369. function updateHeaderViews()
  370. {
  371.   if (gCollapsedHeaderViewMode)
  372.   {
  373.     showHeaderView(gCollapsedHeaderView);
  374.     displayAttachmentsForCollapsedView();
  375.   }
  376.   else
  377.   {
  378.     showHeaderView(gExpandedHeaderView);
  379.     displayAttachmentsForExpandedView();
  380.   }
  381. }
  382.  
  383. function ToggleHeaderView ()
  384. {
  385.   var expandedNode = document.getElementById("expandedHeaderView");
  386.   var collapsedNode = document.getElementById("collapsedHeaderView");
  387.   var toggleHeaderView = document.getElementById("msgHeaderView");
  388.  
  389.   if (gCollapsedHeaderViewMode)
  390.   {          
  391.     gCollapsedHeaderViewMode = false;
  392.     // hide the current view
  393.     hideHeaderView(gCollapsedHeaderView);
  394.     // update the current view
  395.     updateHeaderViews();
  396.     
  397.     // now uncollapse / collapse the right views
  398.     expandedNode.removeAttribute("collapsed");
  399.     collapsedNode.setAttribute("collapsed", "true");
  400.   }
  401.   else
  402.   {
  403.     gCollapsedHeaderViewMode = true;
  404.     // hide the current view
  405.     hideHeaderView(gExpandedHeaderView);
  406.     // update the current view
  407.     updateHeaderViews();
  408.     
  409.     // now uncollapse / collapse the right views
  410.     collapsedNode.removeAttribute("collapsed");
  411.     expandedNode.setAttribute("collapsed", "true");
  412.   }  
  413.  
  414.   if (gCollapsedHeaderViewMode)
  415.     toggleHeaderView.setAttribute("state", "true");
  416.   else
  417.     toggleHeaderView.setAttribute("state", "false");
  418. }
  419.  
  420. // Clear Email Field takes the passed in div and removes all the child nodes!
  421. function ClearEmailField(parentDiv)
  422. {
  423.   if (parentDiv)
  424.   {
  425.     while (parentDiv.childNodes.length > 0)
  426.       parentDiv.removeChild(parentDiv.childNodes[0]);
  427.   }
  428. }
  429.  
  430. // default method for updating a header value into a header entry
  431. function updateHeaderValue(headerEntry, headerValue)
  432. {
  433.     headerEntry.textNode.childNodes[0].nodeValue = headerValue;
  434. }
  435.  
  436. function updateHeaderValueInTextNode(headerEntry, headerValue)
  437. {
  438.   headerEntry.textNode.setAttribute("value", headerValue);
  439. }
  440.  
  441. // UpdateMessageHeaders: Iterate through all the current header data we received from mime for this message
  442. // for each header entry table, see if we have a corresponding entry for that header. i.e. does the particular
  443. // view care about this header value. if it does then call updateHeaderEntry
  444. function UpdateMessageHeaders()
  445. {
  446.   // iterate over each header we received and see if we have a matching entry in each
  447.   // header view table...
  448.  
  449.   for (headerName in currentHeaderData)
  450.   {
  451.     var headerField = currentHeaderData[headerName];
  452.     var headerEntry = gExpandedHeaderView[headerName];
  453.     if (headerEntry != undefined && headerEntry)
  454.     {
  455.       headerEntry.outputFunction(headerEntry, headerField.headerValue);
  456.       headerEntry.valid = true;
  457.     }
  458.     headerEntry = gCollapsedHeaderView[headerName];
  459.     if (headerEntry != undefined && headerEntry)
  460.     {
  461.       headerEntry.outputFunction(headerEntry, headerField.headerValue);
  462.       headerEntry.valid = true;    
  463.     }
  464.   }
  465.  
  466.   // now update the view to make sure the right elements are visible
  467.   updateHeaderViews();
  468.   
  469.   if (this.FinishEmailProcessing != undefined)
  470.     FinishEmailProcessing();
  471. }
  472.  
  473. function ClearCurrentHeaders()
  474. {
  475.   currentHeaderData = {};
  476.   currentAttachments = new Array();
  477. }
  478.  
  479. function ShowMessageHeaderPane()
  480. { 
  481.   var node;
  482.   if (gCollapsedHeaderViewMode)
  483.   {          
  484.     node = document.getElementById("collapsedHeaderView");
  485.     if (node)
  486.       node.removeAttribute("collapsed");
  487.   }
  488.   else
  489.   {
  490.     node = document.getElementById("expandedHeaderView");
  491.     if (node)
  492.       node.removeAttribute("collapsed");
  493.   }
  494.  
  495.     /* workaround for 39655 */
  496.   if (gFolderJustSwitched) 
  497.   {
  498.     var el = document.getElementById("msgHeaderView");
  499.     el.setAttribute("style", el.getAttribute("style"));
  500.     gFolderJustSwitched = false;    
  501.   }
  502. }
  503.  
  504. function HideMessageHeaderPane()
  505. {
  506.   var node = document.getElementById("collapsedHeaderView");
  507.   if (node)
  508.     node.setAttribute("collapsed", "true");
  509.  
  510.   node = document.getElementById("expandedHeaderView");
  511.   if (node)
  512.     node.setAttribute("collapsed", "true");
  513. }
  514.  
  515. function OutputNewsgroups(headerEntry, headerValue)
  516. { 
  517.   headerValue = headerValue.replace(/,/g,", ");
  518.   updateHeaderValue(headerEntry, headerValue);
  519. }
  520.  
  521. // OutputEmailAddresses --> knows how to take a comma separated list of email addresses,
  522. // extracts them one by one, linkifying each email address into a mailto url. 
  523. // Then we add the link'ified email address to the parentDiv passed in.
  524. // 
  525. // defaultParentDiv --> the div to add the link-ified email addresses into. 
  526. // emailAddresses --> comma separated list of the addresses for this header field
  527. // includeShortLongToggle --> true if you want to include the ability to toggle between short/long
  528. // address views for this header field. If true, then pass in a another div which is the div the long
  529. // view will be added too...
  530. // useShortView --> if true, we'll only generate the Name of the email address field instead of
  531. //                        showing the name + the email address.
  532.  
  533. function OutputEmailAddresses(headerEntry, emailAddresses)
  534. {
  535.     if ( !emailAddresses ) return;
  536.  
  537.   if (msgHeaderParser)
  538.   {
  539.     // Count the number of email addresses being inserted into each header
  540.     // The headers could be "to", "cc", "from"
  541.     var myEnum = msgHeaderParser.ParseHeadersWithEnumerator(emailAddresses);
  542.     myEnum = myEnum.QueryInterface(Components.interfaces.nsISimpleEnumerator);
  543.  
  544.     numOfEmailsInEnumerator = 0;
  545.     while (myEnum.hasMoreElements())
  546.     {
  547.         myEnum.getNext();
  548.         numOfEmailsInEnumerator++;
  549.     }
  550.  
  551.     var enumerator = msgHeaderParser.ParseHeadersWithEnumerator(emailAddresses);
  552.     enumerator = enumerator.QueryInterface(Components.interfaces.nsISimpleEnumerator);
  553.     var numAddressesParsed = 0;
  554.     if (enumerator)
  555.     {
  556.       var emailAddress = {};
  557.       var name = {};
  558.  
  559.       while (enumerator.hasMoreElements())
  560.       {
  561.         var headerResult = enumerator.getNext();
  562.         headerResult = enumerator.QueryInterface(Components.interfaces.nsIMsgHeaderParserResult);
  563.         
  564.         // get the email and name fields
  565.         var addrValue = {};
  566.         var nameValue = {};
  567.         var fullAddress = headerResult.getAddressAndName(addrValue, nameValue);
  568.         emailAddress = addrValue.value;
  569.         name = nameValue.value;
  570.  
  571.         // if we want to include short/long toggle views and we have a long view, always add it.
  572.         // if we aren't including a short/long view OR if we are and we haven't parsed enough
  573.         // addresses to reach the cutoff valve yet then add it to the default (short) div.
  574.         if (headerEntry.useToggle && headerEntry.longTextNode)
  575.         {
  576.           InsertEmailAddressUnderEnclosingBox(headerEntry, headerEntry.longTextNode, emailAddress, fullAddress, name);
  577.         }
  578.         if (!headerEntry.useToggle || (numAddressesParsed < gNumAddressesToShow))
  579.         {
  580.           InsertEmailAddressUnderEnclosingBox(headerEntry, headerEntry.textNode, emailAddress, fullAddress, name);
  581.         }
  582.         
  583.         numAddressesParsed++;
  584.       } 
  585.     } // if enumerator
  586.  
  587.     if (headerEntry.useToggle && headerEntry.toggleIcon)
  588.     {
  589.       if (numAddressesParsed > gNumAddressesToShow) // make sure the icon is always visible if we have more than the # of addresses to show
  590.         headerEntry.toggleIcon.removeAttribute('collapsed');
  591.       else
  592.        headerEntry.toggleIcon.setAttribute('collapsed', true);
  593.     }
  594.   } // if msgheader parser
  595. }
  596.  
  597. function updateEmailAddressNode(emailAddressNode, emailAddress, fullAddress, displayName, useShortView)
  598. {
  599.   if (useShortView && displayName)
  600.     emailAddressNode.setAttribute("label", displayName);  
  601.   else
  602.     emailAddressNode.setAttribute("label", fullAddress);    
  603.   emailAddressNode.setTextAttribute("emailAddress", emailAddress);
  604.   emailAddressNode.setTextAttribute("fullAddress", fullAddress);  
  605.   emailAddressNode.setTextAttribute("displayName", displayName);  
  606.   
  607.   if (this.AddExtraAddressProcessing != undefined)
  608.     AddExtraAddressProcessing(emailAddress, emailAddressNode);
  609. }
  610.  
  611. /* InsertEmailAddressUnderEnclosingBox --> right now all email addresses are borderless titled buttons
  612.    with formatting to make them look like html anchors. When you click on the button,
  613.    you are prompted with a popup asking you what you want to do with the email address
  614.    useShortView --> only show the name (if present) instead of the name + email address
  615. */
  616.    
  617. function InsertEmailAddressUnderEnclosingBox(headerEntry, parentNode,
  618.                                              emailAddress, fullAddress, displayName) 
  619. {
  620.   var itemInDocument = parentNode;
  621.   // if this header uses a toggle then it can contain multiple email addresses. In this case,
  622.   // parentNode is really an HTML div. we need to create a mail-emailaddress element and insert it into
  623.   // the html div.
  624.   if ( headerEntry.useToggle)
  625.   {
  626.     var item = document.createElement("mail-emailaddress");
  627.     if (item && parentNode) 
  628.     { 
  629.       if (parentNode.childNodes.length >= 1)
  630.       {
  631.         var textNode = document.createElement("text");
  632.         textNode.setAttribute("value", ", ");
  633.         textNode.setAttribute("class", "emailSeparator");
  634.         parentNode.appendChild(textNode);
  635.       }
  636.   
  637.       itemInDocument = parentNode.appendChild(item);
  638.     }
  639.   } 
  640.  
  641.   updateEmailAddressNode(itemInDocument, emailAddress, fullAddress, displayName, headerEntry.useShortView);
  642. }
  643.  
  644. // ToggleLongShortAddresses is used to toggle between showing
  645. // all of the addresses on a given header line vs. only the first 'n'
  646. // where 'n' is a user controlled preference. By toggling on the more/less
  647. // images in the header window, we'll hide / show the appropriate div for that header.
  648.  
  649. function ToggleLongShortAddresses(imageID, shortDivID, longDivID)
  650. {
  651.   var shortNode = document.getElementById(shortDivID);
  652.   var longNode = document.getElementById(longDivID);
  653.   var imageNode = document.getElementById(imageID);
  654.  
  655.   var nodeToReset;
  656.  
  657.   // test to see which if short is already hidden...
  658.   if (shortNode.getAttribute("collapsed") == "true")
  659.   {        
  660.     longNode.setAttribute("collapsed", true);
  661.     shortNode.removeAttribute("collapsed"); 
  662.     imageNode.setAttribute("class", 'showMoreAddressesButton');
  663.     nodeToReset = shortNode;
  664.   }
  665.   else
  666.   {
  667.     shortNode.setAttribute("collapsed", true);
  668.     longNode.removeAttribute("collapsed"); 
  669.     imageNode.setAttribute("class", 'showFewerAddressesButton');
  670.     nodeToReset = longNode;
  671.   }
  672. }
  673.  
  674. function AddNodeToAddressBook (emailAddressNode)
  675. {
  676.   if (emailAddressNode)
  677.   {
  678.     var primaryEmail = emailAddressNode.getAttribute("emailAddress");
  679.     var displayName = emailAddressNode.getAttribute("displayName");
  680.       window.openDialog("chrome://messenger/content/addressbook/abNewCardDialog.xul",
  681.                       "",
  682.                       "chrome,titlebar,resizeable=no", 
  683.             {primaryEmail:primaryEmail, displayName:displayName });
  684.   }
  685. }
  686.  
  687. // SendMailToNode takes the email address title button, extracts
  688. // the email address we stored in there and opens a compose window
  689. // with that address
  690. function SendMailToNode(emailAddressNode)
  691. {
  692.   if (emailAddressNode)
  693.   {
  694.      var emailAddress = emailAddressNode.getAttribute("emailAddress");
  695.      if (emailAddress)
  696.         messenger.OpenURL("mailto:" + emailAddress );
  697.   }
  698. }
  699.  
  700. // CopyEmailAddress takes the email address title button, extracts
  701. // the email address we stored in there and copies it to the clipboard
  702. function CopyEmailAddress(emailAddressNode)
  703. {
  704.   if (emailAddressNode)
  705.   {
  706.     var emailAddress = emailAddressNode.getAttribute("emailAddress");
  707.  
  708.     var contractid = "@mozilla.org/widget/clipboardhelper;1";
  709.     var iid = Components.interfaces.nsIClipboardHelper;
  710.     var clipboard = Components.classes[contractid].getService(iid);
  711.     clipboard.copyString(emailAddress);
  712.   }
  713. }
  714.  
  715. // createnewAttachmentInfo --> constructor method for creating new attachment object which goes into the
  716. // data attachment array.
  717. function createNewAttachmentInfo(contentType, url, displayName, uri, notDownloaded)
  718. {
  719.   this.contentType = contentType;
  720.   this.url = url;
  721.   this.displayName = displayName;
  722.   this.uri = uri;
  723.   this.notDownloaded = notDownloaded;
  724. }
  725.  
  726. function saveAttachment(contentType, url, displayName, messageUri)
  727. {
  728.   messenger.saveAttachment(contentType, url, displayName, messageUri);
  729. }
  730.  
  731. function openAttachment(contentType, url, displayName, messageUri)
  732. {
  733.   messenger.openAttachment(contentType, url, displayName, messageUri);
  734. }
  735.  
  736. function printAttachmentAttachment(contentType, url, displayName, messageUri)
  737. {
  738.   // we haven't implemented the ability to print attachments yet...
  739.   // messenger.printAttachment(contentType, url, displayName, messageUri);
  740. }
  741.  
  742. // this is our onclick handler for the attachment tree. 
  743. // A double click in a tree cell simulates "opening" the attachment....
  744. function attachmentTreeClick(event)
  745. { 
  746.     // we only care about button 0 (left click) events
  747.     if (event.button != 0) return;
  748.  
  749.     if (event.detail == 2) // double click
  750.     {
  751.         var target = event.originalTarget;
  752.         var item = target.parentNode.parentNode;
  753.         if (item.localName == "treeitem")
  754.     {
  755.             var commandStringSuffix = item.getAttribute("commandSuffix");
  756.       var openString = 'openAttachment' + commandStringSuffix;
  757.       eval(openString);
  758.     }
  759.     }
  760. }
  761.  
  762. // on command handlers for the attachment tree context menu...
  763. // commandPrefix matches one of our existing functions (openAttachment, saveAttachment, etc.) which we'll add to the command suffix
  764. // found on the tree item....
  765. function handleAttachmentSelection(commandPrefix)
  766. {
  767.   // get the selected attachment...and call openAttachment on it...
  768.   var attachmentTree = document.getElementById('attachmentTree');
  769.   var selectedAttachments = attachmentTree.selectedItems;
  770.   var treeItem = selectedAttachments[0];
  771.   var commandStringSuffix = treeItem.getAttribute("commandSuffix");
  772.   var openString = commandPrefix + commandStringSuffix;
  773.   eval(openString);
  774. }
  775.  
  776. function generateCommandSuffixForAttachment(attachment)
  777. {
  778.   return "('" + attachment.contentType + "', '" + attachment.url + "', '" + escape(attachment.displayName) + "', '" + attachment.uri + "')";
  779. }
  780.  
  781. function displayAttachmentsForExpandedView()
  782. {
  783.   var numAttachments = currentAttachments.length;
  784.   if (numAttachments > 0 && !gBuildAttachmentsForCurrentMsg)
  785.   {
  786.     var attachmentList = document.getElementById('attachmentsBody');
  787.     var row, cell, item;
  788.     for (index in currentAttachments)
  789.     {
  790.       var attachment = currentAttachments[index];
  791.       // we need to create a tree item, a tree row and a tree cell to insert the attachment
  792.       // into the attachment tree..
  793.  
  794.       item = document.createElement("treeitem");
  795.       row = document.createElement("treerow");
  796.       cell = document.createElement("treecell");
  797.  
  798.       cell.setAttribute('class', "treecell-iconic"); 
  799.       cell.setAttribute("label", attachment.displayName);
  800.       cell.setAttribute("tooltip", "attachmentTreeTooltip");
  801.       item.setAttribute("commandSuffix", generateCommandSuffixForAttachment(attachment)); // set the command suffix on the tree item...
  802.       setApplicationIconForAttachment(attachment, cell);
  803.       row.appendChild(cell);
  804.       item.appendChild(row);
  805.       attachmentList.appendChild(item);
  806.     } // for each attachment
  807.     gBuildAttachmentsForCurrentMsg = true;
  808.   }
  809.  
  810.   var attachmentNode = document.getElementById('expandedAttachmentBox');
  811.   if (numAttachments > 0)  // make sure the attachment button is visible
  812.     attachmentNode.removeAttribute('collapsed');
  813.   else
  814.     attachmentNode.setAttribute('collapsed', true);
  815. }
  816.  
  817. // attachment --> the attachment struct containing all the information on the attachment
  818. // treeCell --> the tree cell currently showing the attachment.
  819. function setApplicationIconForAttachment(attachment, treeCell)
  820. {
  821.    // generate a moz-icon url for the attachment so we'll show a nice icon next to it.
  822.    treeCell.setAttribute('src', "moz-icon:" + "//" + attachment.displayName + "?size=16&contentType=" + attachment.contentType);
  823. }
  824.  
  825. function displayAttachmentsForCollapsedView()
  826. {
  827.   var numAttachments = currentAttachments.length;
  828.   var attachmentNode = document.getElementById('collapsedAttachmentBox');
  829.   if (numAttachments > 0)  // make sure the attachment button is visible
  830.   {
  831.     attachmentNode.removeAttribute('hide');
  832.   }
  833.   else
  834.   {
  835.     attachmentNode.setAttribute('hide', true);
  836.   }
  837. }
  838.  
  839. // Public method called to generate a tooltip over an attachment
  840. function FillInAttachmentTooltip(cellNode)
  841. {
  842.   var attachmentName = cellNode.getAttribute("label");
  843.   var textNode = document.getElementById("attachmentTreeTooltipText");
  844.   textNode.setAttribute('value', attachmentName);
  845.   return true;
  846. }
  847.  
  848. // Public method called when we create the attachments file menu
  849. function FillAttachmentListPopup(popup)
  850. {
  851.   // the FE sometimes call this routie TWICE...I haven't been able to figure out why yet...
  852.   // protect against it...
  853.  
  854.   if (!gBuildAttachmentPopupForCurrentMsg) return; 
  855.  
  856.   // otherwise we need to build the attachment view...
  857.   // First clear out the old view...
  858.   ClearAttachmentMenu(popup);
  859.  
  860.  
  861.   for (index in currentAttachments)
  862.   {
  863.     addAttachmentToPopup(popup, currentAttachments[index]);
  864.   }
  865.  
  866.   gBuildAttachmentPopupForCurrentMsg = false;
  867.  
  868. }
  869.  
  870. // Public method used to clear the file attachment menu
  871. function ClearAttachmentMenu(popup) 
  872. { 
  873.   if ( popup ) 
  874.   { 
  875.      while ( popup.childNodes.length > 2 ) 
  876.        popup.removeChild(popup.childNodes[0]); 
  877.   } 
  878. }
  879.  
  880. // Public method used to determine the number of attachments for the currently displayed message...
  881. function GetNumberOfAttachmentsForDisplayedMessage()
  882. {
  883.   return currentAttachments.length;
  884. }
  885.  
  886. // private method used to build up a menu list of attachments
  887. function addAttachmentToPopup(popup, attachment) 
  888. { 
  889.   if (popup)
  890.   { 
  891.     var item = document.createElement('menu');
  892.     if ( item ) 
  893.     {     
  894.       // insert the item just before the separator...the separator is the 2nd to last element in the popup.
  895.       item.setAttribute('class', 'menu-iconic');
  896.       setApplicationIconForAttachment(attachment,item);
  897.       var numItemsInPopup = popup.childNodes.length;
  898.       item = popup.insertBefore(item, popup.childNodes[numItemsInPopup-2]);
  899.       item.setAttribute('label', attachment.displayName); 
  900.       var oncommandPrefix = generateCommandSuffixForAttachment(attachment);
  901.  
  902.       var openpopup = document.createElement('menupopup');
  903.       openpopup = item.appendChild(openpopup);
  904.  
  905.       var menuitementry = document.createElement('menuitem');     
  906.       menuitementry.setAttribute('oncommand', 'openAttachment' + oncommandPrefix); 
  907.  
  908.       if (!gSaveLabel || !gOpenLabel) {
  909.         var messengerBundle = document.getElementById("bundle_messenger");
  910.         gSaveLabel = messengerBundle.getString("saveLabel");
  911.         gOpenLabel = messengerBundle.getString("openLabel");
  912.       }
  913.  
  914.       menuitementry.setAttribute('label', gOpenLabel); 
  915.       menuitementry = openpopup.appendChild(menuitementry);
  916.  
  917.       var menuseparator = document.createElement('menuseparator');
  918.       openpopup.appendChild(menuseparator);
  919.       
  920.       menuitementry = document.createElement('menuitem');
  921.       menuitementry.setAttribute('oncommand', 'saveAttachment' + oncommandPrefix); 
  922.       menuitementry.setAttribute('label', gSaveLabel); 
  923.       menuitementry = openpopup.appendChild(menuitementry);
  924.     }  // if we created a menu item for this attachment...
  925.   } // if we have a popup
  926. } 
  927.  
  928. function SaveAllAttachments()
  929. {
  930.  try 
  931.  {
  932.    // convert our attachment data into some c++ friendly structs
  933.    var attachmentContentTypeArray = new Array();
  934.    var attachmentUrlArray = new Array();
  935.    var attachmentDisplayNameArray = new Array();
  936.    var attachmentMessageUriArray = new Array();
  937.  
  938.    // populate these arrays..
  939.    for (index in currentAttachments)
  940.    {
  941.      var attachment = currentAttachments[index];
  942.      attachmentContentTypeArray[index] = attachment.contentType;
  943.      attachmentUrlArray[index] = attachment.url;
  944.      attachmentDisplayNameArray[index] = escape(attachment.displayName);
  945.      attachmentMessageUriArray[index] = attachment.uri;
  946.    }
  947.  
  948.    // okay the list has been built...now call our save all attachments code...
  949.    messenger.saveAllAttachments(attachmentContentTypeArray.length,
  950.                                 attachmentContentTypeArray, attachmentUrlArray,
  951.                                 attachmentDisplayNameArray, attachmentMessageUriArray);
  952.  }
  953.  catch (ex)
  954.  {
  955.    dump ("** failed to save all attachments **\n");
  956.  }
  957. }
  958.  
  959. function ClearAttachmentTreeList() 
  960. { 
  961.   var attachmentTreebody = document.getElementById("attachmentsBody"); 
  962.   if ( attachmentTreebody ) 
  963.   { 
  964.      while ( attachmentTreebody.childNodes.length ) 
  965.        attachmentTreebody.removeChild(attachmentTreebody.childNodes[0]); 
  966.   } 
  967. }
  968.  
  969. function ShowEditMessageButton() 
  970. {
  971.   var editBox = document.getElementById("editMessageBox");
  972.   if (editBox)
  973.     editBox.removeAttribute("collapsed");
  974. } 
  975.  
  976. function ClearEditMessageButton() 
  977. { 
  978.   var editBox = document.getElementById("editMessageBox");
  979.   if (editBox)
  980.     editBox.setAttribute("collapsed", "true");
  981. }
  982.  
  983. // given a box, iterate through all of the headers and add them to 
  984. // the enclosing box. 
  985. function fillBoxWithAllHeaders(containerBox, boxPartOfPopup)
  986. {
  987.   // clear out the old popup date if there is any...
  988.   while ( containerBox.childNodes.length ) 
  989.     containerBox.removeChild(containerBox.childNodes[0]); 
  990.  
  991.   for (header in currentHeaderData)
  992.   {
  993.     var innerBox = document.createElement('box');
  994.     innerBox.setAttribute("class", "headerBox");
  995.     innerBox.setAttribute("orient", "horizontal");
  996.     if (boxPartOfPopup)
  997.         innerBox.setAttribute("autostretch", "never");
  998.  
  999.     // for each header, create a header value and header name then assign those values...
  1000.     var headerValueBox = document.createElement('hbox');
  1001.     headerValueBox.setAttribute("class", "headerValueBox");
  1002.  
  1003.       var newHeaderTitle  = document.createElement('text');
  1004.     newHeaderTitle.setAttribute("class", "headerdisplayname");
  1005.       newHeaderTitle.setAttribute("value", currentHeaderData[header].headerName + ':');
  1006.     headerValueBox.appendChild(newHeaderTitle);
  1007.  
  1008.       innerBox.appendChild(headerValueBox);
  1009.  
  1010.     var newHeaderValue = document.createElement('html');
  1011.     // make sure we are properly resized...
  1012. //    if (boxPartOfPopup)
  1013. //        newHeaderValue.setAttribute("width", window.innerWidth*.65);
  1014.     newHeaderValue.setAttribute("class", "headerValue");
  1015.     if (!boxPartOfPopup)
  1016.       newHeaderValue.setAttribute("flex", "1");
  1017.     innerBox.appendChild(newHeaderValue);
  1018.     containerBox.appendChild(innerBox);
  1019.     ProcessHeaderValue(innerBox, newHeaderValue, currentHeaderData[header], boxPartOfPopup);
  1020.   }
  1021. }
  1022.  
  1023. // the on create handler for the view all headers popup...
  1024. function fillAllHeadersPopup(node)
  1025. {
  1026.   // don't bother re-filling the popup if we've already done it for the
  1027.   // currently displayed message....
  1028.   if (gGeneratedViewAllHeaderInfo == true)
  1029.     return true; 
  1030.  
  1031.   var containerBox = document.getElementById('allHeadersPopupContainer');
  1032.  
  1033.   containerBox.setAttribute("class", "header-part1");
  1034.   containerBox.setAttribute("align", "vertical");
  1035.   containerBox.setAttribute("flex", "1");
  1036.  
  1037.   fillBoxWithAllHeaders(containerBox, true);
  1038.   gGeneratedViewAllHeaderInfo = true; // don't try to regenerate this information for the currently displayed message
  1039.   return true;
  1040. }
  1041.  
  1042. // containingBox --> the box containing the header
  1043. // containerNode --> the div or box that we want to insert this specific header into
  1044. // header --> an entry from currentHeaderData contains .headerName and .headerValue
  1045. // boxPartOfPopup --> true if the box is part of a popup (certain functions are disabled in this scenario)
  1046. function ProcessHeaderValue(containingBox, containerNode, header, boxPartOfPopup)
  1047. {
  1048.   // in the simplest case, we'll just create a text node for the header
  1049.   // and append it to the container Node. for certain headers, we might want to do 
  1050.   // extra processing....
  1051.   
  1052.   var headerName = header.headerName;
  1053.   headerName = headerName.toLowerCase();
  1054.   if (!boxPartOfPopup && (headerName == "cc" || headerName == "from" || headerName == "to" || headerName == "reply-to"))
  1055.   {
  1056.     OutputEmailAddresses(containingBox, containerNode, header.headerValue, false, "", "", headerName)
  1057.     return;
  1058.   }
  1059.   
  1060.   var headerValue = header.headerValue;
  1061.   headerValue = headerValue.replace(/\n|\r/g,"");
  1062.   var textNode = document.createTextNode(headerValue);
  1063.   if (headerName == "subject")
  1064.   {
  1065.       containerNode.setAttribute("class", "subjectvalue headerValue");
  1066.   }
  1067.  
  1068.   containerNode.appendChild(textNode);
  1069. }
  1070.