<HTML XMLNS:IE>
<HEAD>
<?import namespace="ie" implementation="#default">
<META HTTP-EQUIV="MSThemeCompatible" CONTENT="Yes">
<TITLE>Print Preview</TITLE>
#include "preview.h"
<STYLE>
.divPage
{
position: absolute;
top: -20000px;
border-left: 1 solid black;
border-top: 1 solid black;
border-right: 4 solid black;
border-bottom: 4 solid black;
}
.page
{
background: white; // pages are rendered over a white background
width: 8.5in;
height: 11in;
margin: 0px;
overflow: hidden;
}
.mRect
{
position: absolute;
margin: 1in;
width: 6.5in;
height: 9in;
border: none;
overflow : hidden;
}
.divHead
{
position: absolute;
overflow: hidden;
top: 0in;
left: 0in;
width: 8.5in;
}
.divFoot
{
position: absolute;
overflow: hidden;
bottom: 0in;
left: 0in;
width: 8.5in;
}
BODY { overflow: hidden; padding: 0; margin: 0; background: threedface; }
TABLE { margin: 0px; padding: 0px; background: threedface; }
.THeader { border: none; background: white; color: black; } // white to match .page
.TFooter { border: none; background: white; color: black; } // white to match .page
TD { padding: 0; margin: 0; border: none; }
TD.UIPane { width: 20px; border: none; font-family: 'ms sans serif'; font-size: 8pt; }
TD.UISeparator { width: 1px; border-left: 2px threedhighlight ridge; }
BUTTON { border: 1px solid threedface; background: threedface; font-family: 'ms sans serif'; font-size: 8pt; color: buttontext;}
</STYLE>
<SCRIPT DEFER>
#define NUM_ABSTRACT_ZOOMS 3
#define ZOOM_PAGE_WIDTH -1
#define ZOOM_WHOLE_PAGE -2
#define ZOOM_TWO_PAGES -3
#define FRAMESET_LAID_OUT 0
#define FRAMESET_SELECTED 1
#define FRAMESET_SEPARATE 2
#define STR_ZOOM_PAGE_WIDTH "-1"
#define STR_ZOOM_WHOLE_PAGE "-2"
#define STR_ZOOM_TWO_PAGES "-3"
#define STR_FRAMESET_LAID_OUT "0"
#define STR_FRAMESET_SELECTED "1"
#define STR_FRAMESET_SEPARATE "2"
#define HEADFOOTHEIGHT 27
var g_aDocTree = new Object(); // Array of CPrintDoc's... using IDispatch expandos
var g_nDispPage = -1; // 0...n Which of the pages is currently being previewed?
var g_nZoomFactor = 0; // What level of zoom is currently applying to the page?
var g_cLeftToPrint = 0; // How many documents are left to print? (Used in printing).
var g_fRTL;
var g_fPreview;
// HACKHACK (greglett) (IE6#17478)
// When printing WebOC apps from a nonbrowse thread (hyperlink "Print Target", PrintHTML API, File->Print + AllLinkedDocuments)
// we instantiate the WebOC on the background thread and call in IPrint::Print (via CTemplatePrinter::printNonNative).
// When that (asynchronously) returns, we close the printing thread... and the WebOC that is trying to print.
// This produces a vareity of interesting effects, all bad, and some dire.
// Note that we don't do this for Print Preview, Print All Linked Documents, because it would look very bad to the user.
var g_fDelayClose = false; // Delay window.close()
// Global value caches - mainly used to make sure we don't need to do any extra work:
// Require FULL REPAGINATION:
var g_nMarginTop = 0;
var g_nMarginBottom = 0;
var g_nMarginLeft = 0;
var g_nMarginRight = 0;
var g_nPageWidth = 0;
var g_nPageHeight = 0;
// Require only HEADER/FOOTER REAPPLICATION
var g_nUnprintTop = 0;
var g_nUnprintBottom = 0;
var g_strHeader = "";
var g_strFooter = "";
var g_fTableOfLinks = false;
// keep track of page layout space
var g_cPagesDisplayed = 0;
var g_cxDisplaySlots = 1;
var g_cyDisplaySlots = 1;
// keep track of whether the mouse is over any buttons
var g_imgUnderMouse = null;
// keep track of frameset layout-related stuff
var g_nFramesetLayout = FRAMESET_LAID_OUT; // Which of the frameset layouts is currently active?
var g_strActiveFrame = null; // Which frame "C_x_x," or null, is the active frame?
var g_nTotalPages = 0; // How many total pages will be printed if the user
var g_nDocsToCalc = 0;
var g_nFramesLeft = 0; // # of frames currently being processed
// selects FRAMESET_SEPARATE?
#ifdef DEBUG
g_fReallyClose = true; // Close template when Close() is called?
#endif
//----------------------------------------------------------------------
// Functions GetRuleFromSelector()
//
// Synopsis: Gets the first rule in the first stylesheet on the document
// that applies to the given selector.
// This will do the job for us so long as we have only one
// stylesheet and only one rule per selector.
//
// Returns: the rule or null if no match was found.
//----------------------------------------------------------------------
function GetRuleFromSelector(strSelector)
{
var i;
var oRule;
var oSS = document.styleSheets[0]; // Assume one style sheet
// Linear search.
for (i=0;;i++)
{
oRule = oSS.rules[i];
if (oRule == null)
break;
if (oRule.selectorText == strSelector)
break;
}
// Either null (no match found) or a rule.
return oRule;
}
function UnprintableURL(strLink)
{
var fUnprintable = false;
var cIndex;
// Sniff the URL scheme prefix to make sure we can print it.
cIndex = strLink.indexOf(":");
switch (cIndex)
{
case 4:
if (strLink.substr(0, cIndex) == "news")
fUnprintable = true;
break;
case 5:
if (strLink.substr(0, cIndex) == "snews")
fUnprintable = true;
break;
case 6:
if ( strLink.substr(0, cIndex) == "telnet"
|| strLink.substr(0, cIndex) == "mailto")
fUnprintable = true;
break;
case 8:
if (strLink.substr(0,cIndex) == "vbscript")
fUnprintable = true;
break;
case 10:
if (strLink.substr(0,cIndex) == "javascript")
fUnprintable = true;
break;
}
// (greglett) If we ever choose to check MIME type from script (unlikely),
// this is the place to do it.
return fUnprintable;
}
#ifdef DEBUG
function StatusToString(nStatus)
{
var strStatus;
switch (nStatus)
{
case 0:
strStatus="LOADING_OEHEADER";
break;
case 1:
strStatus="LOADING_CONTENT";
break;
case 2:
strStatus="LOADING_TABLEOFLINKS";
break;
case 3:
strStatus="PAGING_COMPLETE";
break;
case 4:
strStatus="READY_TO_PRINT";
break;
default:
strStatus="??? (" + nStatus + ")";
break;
}
return strStatus;
}
function Log(strEntry)
{
var oDate = new Date();
LogContainer.insertAdjacentHTML("beforeEnd", "[" + oDate.getTime() + "] " + strEntry + "<BR>");
}
#endif
function OnKeyPress()
{
if (event.keyCode == 27) // esc
{
Close();
}
#ifdef DEBUG
else if (event.keyCode == 126) // '~'
{
LogContainer.style.display = (LogContainer.currentStyle.display == "none") ? "block" : "none";
}
else if (event.keyCode == 33) // '!'
{
var strDocNew = prompt("(DEBUG only!) Command to execute?", "");
eval(strDocNew);
}
else if (event.keyCode == 64) // '@'
{
g_fReallyClose = !g_fReallyClose;
butClose.style.color = (g_fReallyClose) ? "" : "red";
}
#endif
}
function OnKeyDown()
{
if (event.altKey)
{
switch (event.keyCode)
{
case 37: // left arrow
ChangeDispPage(g_nDispPage-1);
break;
case 39: // right arrow
ChangeDispPage(g_nDispPage+1);
break;
case 107: // number pad +
case 187: // keyboard +
HandleZoom(-1);
break;
case 109: // number pad -
case 189: // keyboard -
HandleZoom(1);
break;
case 35: // end
HandleLastPage();
break;
case 36: //home
HandleFirstPage();
break;
}
}
}
function ShowHelp()
{
window.showHelp("iexplore.chm::/print_preview.htm");
}
function AttachDialogEvents()
{
// Attach events. This is done here to:
// 1. Prevent UI before we're able to handle it
// 2. Load the dialog faster.
// Attach button events
butPrint.onclick = HandlePrintClick;
butPageSetup.onclick = HandlePageSetup;
butFirstPage.onclick = HandleFirstPage;
butBackPage.onclick = HandleBackPage;
butNextPage.onclick = HandleForwardPage;
butLastPage.onclick = HandleLastPage;
butZoomIn.onclick = HandleZoomInButton;
butZoomOut.onclick = HandleZoomOutButton;
butClose.onclick = Close;
butHelp.onclick = ShowHelp;
document.onhelp = ShowHelp;
butPrint.onmousedown = buttonDown;
butPageSetup.onmousedown = buttonDown;
butFirstPage.onmousedown = buttonDown;
butBackPage.onmousedown = buttonDown;
butNextPage.onmousedown = buttonDown;
butLastPage.onmousedown = buttonDown;
butZoomIn.onmousedown = buttonDown;
butZoomOut.onmousedown = buttonDown;
butClose.onmousedown = buttonDown;
butHelp.onmousedown = buttonDown;
// Attach image UI events
printCtl.onmouseover = buttonOver;
printCtl.onmouseout = buttonOut;
begin.onmouseover = buttonOver;
begin.onmouseout = buttonOut;
prev.onmouseover = buttonOver;
prev.onmouseout = buttonOut;
next.onmouseover = buttonOver;
next.onmouseout = buttonOut;
end.onmouseover = buttonOver;
end.onmouseout = buttonOut;
zoomIn.onmouseover = buttonOver;
zoomIn.onmouseout = buttonOut;
zoomOut.onmouseover = buttonOver;
zoomOut.onmouseout = buttonOut;
butPrint.onmouseover = new Function("buttonRaise(this);");
butPrint.onmouseout = new Function("buttonLower(this);");
butClose.onmouseover = new Function("buttonRaise(this);");
butClose.onmouseout = new Function("buttonLower(this);");
butHelp.onmouseover = new Function("buttonRaise(this);");
butHelp.onmouseout = new Function("buttonLower(this);");
// Attach input events
inputPageNum.onkeypress = HandleInputKeyPress;
inputPageNum.onchange = HandlePageSelect;
selectZoom.onchange = HandleZoomSelect;
selectFrameset.onchange = HandleFramesetSelect;
// Attach document events
window.onresize = OnResizeBody;
window.onerror = HandleError;
// Focus maintenance: anytime we return from another dialog (page setup, help, etc.),
// push the focus back onto the document body (for scrolling and accessibility).
window.onfocus = new Function("MasterContainer.focus()");
document.body.onkeypress = OnKeyPress;
document.body.onkeydown = OnKeyDown;
}
//----------------------------------------------------------------------
// Body event handlers.
//----------------------------------------------------------------------
function OnLoadBody()
{
g_fRTL = (document.body.currentStyle.direction.toLowerCase() == "rtl");
g_fPreview = dialogArguments.__IE_PrintType == "Preview";
// For "printTarget" on an unprintable link URL on the body, we can have a bad URL.
// Sniff it for printability, and bail if not so good. (greglett) (103361)
if (UnprintableURL(dialogArguments.__IE_ContentDocumentUrl))
{
// JurgenE , variables for localization must be in the form L_someIDtext_Text_
var L_Invalid_Text = "Unable to print URL. Please navigate directly to this page and select Print.";
alert(L_Invalid_Text);
window.close();
}
// Set up "base" values for each of the arrow images - the image source will be different for LTR vs. RTL sy1stems.
// This assumes all images will be initialized to *_inactive.gif
// We could avoid doing all this string mangling by adding an inline "base" property on the IMG and localizing it.
var str;
str = begin.src;
begin.base = str.slice(str.lastIndexOf("/")+1,str.indexOf("_"));
str = end.src;
end.base = str.slice(str.lastIndexOf("/")+1,str.indexOf("_"));
str = next.src;
next.base = str.slice(str.lastIndexOf("/")+1,str.indexOf("_"));
str = prev.src;
prev.base = str.slice(str.lastIndexOf("/")+1,str.indexOf("_"));
ChangeZoom(75);
// Do this H/F switch before EnsureDocuments
if (dialogArguments.__IE_HeaderString)
Printer.header = dialogArguments.__IE_HeaderString
if (dialogArguments.__IE_FooterString)
Printer.footer = dialogArguments.__IE_FooterString
EnsureDocuments(); // Get defaults (no documents means little work)
// Make the cursor look like an hourglass while we wait for the frames to build
window.document.body.style.cursor="wait";
CreateDocument("document", "C", true);
ChangeDispPage(1);
// Set up the counter of remaning frames to load, and begin the iterative process
g_nFramesLeft = 1;
// Build those frames
// (greglett) We may want to revise how and when we do this for the printing only,
// i.e. non-preview situations. This may have a significant perf hit on how long
// it takes the print to happen, and most of the time, we don't really need to
// generate all those frames for a printout. We only do it this way so that we're
// prepared if a user decides to try the FRAMESET_SEPARATE option in preview.
OnBuildAllFrames("C");
if (g_fPreview)
{
AttachDialogEvents();
// make sure the display region is sized properly
OverflowContainer.style.top = idDivToolbar.offsetHeight;
OverflowContainer.style.height = document.body.clientHeight - idDivToolbar.offsetHeight;
}
else
{
PrintNow(dialogArguments.__IE_PrintType == "Prompt");
}
}
function BuildAllFramesComplete()
{
AssertSz(g_nFramesLeft == 0, "BuildAllFramesComplete when not complete?");
// Restore the cursor to its normal operation
window.document.body.style.cursor="auto";
// (t-svoida) Not sure this is the best or final place for this step to happen.
// (greglett) It almost certainly isn't: we wait for all frames to be built to allow someone to
// do the frameset selection thing.
UpdateFramesetSelect();
}
function CalcDocsComplete()
{
AssertSz(g_nDocsToCalc == 0, "CalcDocsComplete when not complete?");
// If we're currently laid out as FRAMESET_SEPARATE, we need to recompute our frame/page table
if (g_nFramesetLayout == FRAMESET_SEPARATE)
{
ChangeFramesetLayout(g_nFramesetLayout, true) // FORCE update
}
}
function OnResizeBody()
{
// make sure the display region is sized properly
OverflowContainer.style.height = Math.max(0, document.body.clientHeight - idDivToolbar.offsetHeight);
// make sure zoom gets updated if we're in an abstract zoom mode
HandleDynamicZoom();
// make sure a relayout happens, because the layout space changed
PositionPages(g_nDispPage);
}
//+-------------------------------------------------------------------
//
// Synopsis: Turns off error messages in dialogs
//
// Arguments: none
//
// returns: true (tells browser not to handle message)
//
//--------------------------------------------------------------------
function HandleError(message, url, line)
{
#ifdef DEBUG
var str = "";
if (url == document.URL)
str += "Template ";
// Debug only, no need to localize
str += "Error (" + url + ":" + line + "): " + message;
alert(str);
#else
var L_Internal_ErrorMessage = "There was an internal error, and Internet Explorer is unable to print this document.";
alert(L_Internal_ErrorMessage);
window.close();
#endif
return true;
}
// TODO (greglett) (TASK 5182)
// Q: So, why two RectComplete handlers, one called with a setTimeout from the other?
// A: Because otherwise we spend *all* of our time processing RectCompletes, and never give Trident a chance
// to do any redrawing, &c... In order to provide a somewhat interactive UI, we need this delay.
// Work to fix this should accompany incremental pagination.
function OnRectComplete( strDoc )
{
if (!g_aDocTree[strDoc])
{
// No need to localize the string - it is only displayed in debug mode.
HandleError("Document " + strDoc + " does not exist.", document.URL, "OnRectComplete");
return;
}
#ifdef DEBUG
Log("OnRectComplete " + event.srcElement.id + " " + event.contentOverflow);
#endif
window.setTimeout("OnRectCompleteNext('" + strDoc + "', " + event.contentOverflow + ",'" + event.srcElement.id + "');", 25);
}
function OnRectCompleteNext( strDoc, fOverflow, strElement)
{
#ifdef DEBUG
Log("OnRectCompleteNext " + strElement + " " + fOverflow);
#endif
g_aDocTree[strDoc].RectComplete(fOverflow, strElement);
}
//----------------------------------------------------------------------
// utilities for managing widget state
//----------------------------------------------------------------------
function enableButton(btn, img)
{
btn.disabled = false;
if (g_imgUnderMouse == img)
{
img.src = img.base + "_hilite.gif";
buttonRaise(btn);
}
else
{
img.src = img.base + ".gif";
buttonLower(btn);
}
}
function disableButton(btn, img)
{
btn.disabled = true;
buttonLower(btn);
// accept null because some buttons share
// a common inactive image and this
// generic naming scheme is broken
if (img != null)
{
img.src = img.base + "_inactive.gif";
}
}
function updateNavButtons()
{
//
// disable any nav buttons that need to be
//
if (g_nDispPage == 1)
{
disableButton(butFirstPage, begin);
disableButton(butBackPage, prev);
}
else
{
enableButton(butFirstPage, begin);
enableButton(butBackPage, prev);
}
if (TotalDisplayPages() - g_nDispPage < g_cxDisplaySlots * g_cyDisplaySlots)
{
disableButton(butNextPage, next);
disableButton(butLastPage, end);
}
else
{
enableButton(butNextPage, next);
enableButton(butLastPage, end);
}
}
function updateZoomButtons()
{
var fZoomOutDisabled = false;
var fZoomInDisabled = false;
//
// disable any zoom buttons necessary
//
var oOptions = selectZoom.options;
if (g_nZoomFactor >= parseInt(oOptions[0].value))
{
// we're on the largest zoom or larger, so disable zoom in
disableButton(butZoomIn, null);
zoomIn.src = "zoom_inactive.gif";
fZoomInDisabled = true;
}
else if (g_nZoomFactor <= parseInt(oOptions[oOptions.length-1-NUM_ABSTRACT_ZOOMS].value))
{
// we're on the smallest zoom or smaller, so disable zoon out
disableButton(butZoomOut, null);
zoomOut.src = "zoom_inactive.gif";
fZoomOutDisabled = true;
}
//
// and enable any zoom buttons that are left
//
if (!fZoomOutDisabled)
{
enableButton(butZoomOut, zoomOut);
}
if (!fZoomInDisabled)
{
enableButton(butZoomIn, zoomIn);
}
}
//----------------------------------------------------------------------
// Function Synopsis
// UpdateFramesetSelect()
// Preps frameset layout select for user interaction, by
// pruning off the SELECTED option if there's no selection
// and hiding the control altogether if it's not a frameset
// page.
//----------------------------------------------------------------------
function UpdateFramesetSelect()
{
// Check main document's frameset status first
if ( g_aDocTree["C"]._fFrameset )
{
// Pare the "Only the selected frame" option if there's no selected frame
// (and the list is still at its original length)
if (!g_strActiveFrame)
{
selectFrameset.options.remove(1);
}
// Show both the control and the preceding separator
separatorFrameset.style.display = "inline";
cellFrameset.style.display = "inline";
}
#ifdef DEBUG
else
{
// Hide both the control and the preceding separator
// separatorFrameset.style.display = "none";
// cellFrameset.style.display = "none";
// (greglett) They should already be hidden. Let's make this an assert.
AssertSz( separatorFrameset.currentStyle.display == "none"
&& cellFrameset.currentStyle.display == "none", "UI Visible when it shouldn't be?");
}
#endif
}
//----------------------------------------------------------------------
// Function Synopses
// getPageWidth, getPageHeight
// Returns the global size of each page - assumes constant sized pages.
// Return value is in screen CSS pixels.
//----------------------------------------------------------------------
function getPageWidth()
{
return g_aDocTree["C"].Page(1).offsetWidth;
}
function getPageHeight()
{
return g_aDocTree["C"].Page(1).offsetHeight;
}
//----------------------------------------------------------------------
// UndisplayPages()
// Undisplays all visible pages
//----------------------------------------------------------------------
function UndisplayPages()
{
while (g_cPagesDisplayed > 0)
{
var oPage = DisplayPage(g_nDispPage + g_cPagesDisplayed - 1);
if (oPage != null)
{
oPage.style.top = "-20000px";
if (g_fRTL)
oPage.style.right = "10px";
else
oPage.style.left = "10px";
}
g_cPagesDisplayed--;
}
}
//----------------------------------------------------------------------
// PositionPages(nDispPage)
// Sets the x and y positioning for the pages currently being
// displayed. If the given # is outside valid bounds, the
// nearest valid boundary is selected instead.
// PERF (greglett) We may want to make redisplay smarter - right now, all
// pages are redisplayed every time the window is resized. We really should
// have the funtion check if pages need to be redisplayed, with a force flag option.
//----------------------------------------------------------------------
function PositionPages(nDispPage)
{
// Cache the current display doc
var strDispDoc = DisplayDocument(nDispPage);
if ( g_aDocTree != null
&& g_aDocTree[strDispDoc] != null
&& g_aDocTree[strDispDoc].Pages() > 0)
{
// first clear the old pages
UndisplayPages();
//
// now draw the new pages with the new settings
//
// figure out how many pages we can show this time
var xPageWidth = getPageWidth();
var yPageHeight = getPageHeight();
var nMaxPage = TotalDisplayPages();
g_cxDisplaySlots = Math.max(1, Math.floor((OverflowContainer.offsetWidth*100)/(g_nZoomFactor*(xPageWidth+10))));
g_cyDisplaySlots = Math.max(1, Math.floor((OverflowContainer.offsetHeight*100)/(g_nZoomFactor*(yPageHeight+10))));
// Trim nDispPage to be inside a valid page range.
var nMaxPageRequest = Math.max(nMaxPage - g_cxDisplaySlots * g_cyDisplaySlots + 1, 1);
if ( nDispPage < 1 )
nDispPage = 1;
else if (nDispPage > nMaxPageRequest)
nDispPage = nMaxPageRequest;
// now start using the new (bounded) page index
g_nDispPage = nDispPage;
// Update the page display to show the right numbers
document.all.spanPageTotal.innerText = nMaxPage;
document.all.inputPageNum.value = g_nDispPage;
// fix the begin, prev, next, end arrows
updateNavButtons();
//
// set up pages until we run out of pages
// or run out of rows of slots to fill
//
var xDisplaySlot = 1;
var yDisplaySlot = 1;
var iPage = g_nDispPage;
g_cPagesDisplayed = 0;
// PERF We really don't need to do a DisplayPage each time
// We could loop through the DisplayDocuments, and loop through
// each of their pages to many multiple lookups inherent in calling
// DisplayPage each iteration of the loop (greglett)
while (iPage <= nMaxPage && yDisplaySlot <= g_cyDisplaySlots)
{
var xPos = xDisplaySlot*10 + (xDisplaySlot-1)*xPageWidth;
var yPos = yDisplaySlot*10 + (yDisplaySlot-1)*yPageHeight;
var oPage = DisplayPage(iPage);
if (g_fRTL)
oPage.style.right = xPos;
else
oPage.style.left = xPos;
oPage.style.top = yPos;
iPage++;
if (++xDisplaySlot > g_cxDisplaySlots)
{
xDisplaySlot = 1;
yDisplaySlot++;
}
g_cPagesDisplayed++;
}
}
}
function ChangeDispPage(nDispPageNew)
{
if (isNaN(nDispPageNew))
{
// make sure the UI shows a valid number
inputPageNum.value = g_nDispPage;
}
else
{
// Range check
if (nDispPageNew < 1)
nDispPageNew = 1;
else if (nDispPageNew > TotalDisplayPages())
nDispPageNew = TotalDisplayPages();
// make sure the top of the page is showing
OverflowContainer.scrollTop = 0;
PositionPages(nDispPageNew);
}
return g_nDispPage;
}
//----------------------------------------------------------------------
// Function Synopsis
// DisplayDocument()
// As below. Only valid when not FRAMESET_SELECT.
// DisplayDocument(nWhichPage)
// Returns either the current display document (indicated by
// g_nDispPage) in the format "C_x_x", or, when passed a page
// number from 1...total pages (includes all frames in SEPARATE
// frameset layout), returns the display document shown on that
// page. Will return null if the page number passed is out
// of range.
//----------------------------------------------------------------------
function DisplayDocument(nWhichPage)
{
switch (g_nFramesetLayout)
{
case FRAMESET_LAID_OUT:
// In LAID_OUT case, display doc is always the master, "C"
return "C";
break;
case FRAMESET_SELECTED:
// In SELECTED casem display doc is always the active frame
return g_strActiveFrame;
break;
case FRAMESET_SEPARATE:
var i;
if (!nWhichPage)
return null;
AssertSz(nWhichPage > 0 && nWhichPage <= g_nTotalPages, "DisplayDocument called with invalid page: " + nWhichPage);
// Otherwise, count to find correct document
for (i in g_aDocTree)
{
if ( nWhichPage >= g_aDocTree[i]._nStartingPage
&& nWhichPage < (g_aDocTree[i]._nStartingPage + g_aDocTree[i].Pages()))
return i;
}
default:
// Should never happen!
// Don't localize this string, debug code only
HandleError("Display document cannot be found!", document.URL, "DisplayDocument");
}
}
//----------------------------------------------------------------------
// Member TotalDisplayPages
//
// Synopsis: With multiple page arrays per CPrintDoc, these functions
// are to provide the illusion of one array. Unlike Pages(),
// this returns the number of pages in this CPrintDoc if the
// frameset layout is LAID_OUT or SELECTED, or the total
// number of pages in all individual frames if the frameset
// layout is SEPARATE. To make this closer to user UI, this
// virtual array is 1 based, not 0 based.
//----------------------------------------------------------------------
function TotalDisplayPages()
{
if (g_nFramesetLayout == FRAMESET_SEPARATE)
return g_nTotalPages;
AssertSz(DisplayDocument(), "TotalDisplayPages: No DisplayDocument!") // DEBUG only: don't localize.
return g_aDocTree[DisplayDocument()].Pages();
}
//----------------------------------------------------------------------
// DisplayPage(nWhichPage)
// Returns the specified page of the displayed set
//
// The only situation this is different than the DisplayDocument
// is for "all frames individually." Imagine two two page frames.
// Then, the function would return:
// nWhichPage Return
// 1-2 Frame1.Page(nWhichPage)
// 3-4 Frame2.Page(nWhichPage - 2)
//----------------------------------------------------------------------
function DisplayPage(nWhichPage)
{
AssertSz(nWhichPage >= 0, "Negative or null display page requested: " + nWhichPage);
// Local page numbers are always the same as total page
// numbers unless the layout is SEPARATE
if (g_nFramesetLayout != FRAMESET_SEPARATE)
return g_aDocTree[DisplayDocument(nWhichPage)].Page(nWhichPage);
// Compute the page offset into the current document, and ask for that page.
return g_aDocTree[DisplayDocument(nWhichPage)].Page(nWhichPage - g_aDocTree[DisplayDocument(nWhichPage)]._nStartingPage + 1);
}
//----------------------------------------------------------------------
// Function ChangeZoom
// Checks the bounds and changes the document zoom level to the new value.
//----------------------------------------------------------------------
function ChangeZoom(nNewVal)
{
if (nNewVal < 10)
nNewVal = 10;
else if (nNewVal > 1000)
nNewVal = 1000;
else if (isNaN(nNewVal))
nNewVal = g_nZoomFactor;
if (nNewVal != g_nZoomFactor)
{
MasterContainer.style.zoom = nNewVal + "%";
g_nZoomFactor = nNewVal;
updateZoomButtons();
PositionPages(g_nDispPage);
}
return g_nZoomFactor;
}
//----------------------------------------------------------------------
// Function BuildTableOfLinks
//
// Synopsis: These function takes a document, and uses its links collection
// to create another document with a table of links.
// Returns the document, or null if no links were encountered.
//----------------------------------------------------------------------
function BuildTableOfLinks( docSource )
{
var aLinks = docSource.links;
var nLinks = aLinks.length;
if (nLinks > 0)
{
var fDuplicate;
var i;
var j;
var newHTM;
var docLinkTable = document.createElement("BODY");
var L_LINKSHEADER1_Text = "Shortcut Text";
var L_LINKSHEADER2_Text = "Internet Address";
newHTM = "<CENTER><TABLE BORDER=1>";
newHTM += "<THEAD style=\"display:table-header-group\"><TR><TH>"
+ L_LINKSHEADER1_Text
+ "</TH><TH>" + L_LINKSHEADER2_Text + "</TH></TR></THEAD><TBODY>";
// Old behvaior: Print each linked URL only once. Do include a self link.
// Ack! Yes, this is a dreaded N-squared algorithm. This is what we used to do, though, so we're no worse.
// If we deem it important enough, we can pare it down to NlogN via a more efficient sorting algorithm. (greglett)
for (i = 0; i < nLinks; i++)
{
fDuplicate = false;
for (j = 0; (!fDuplicate) && (j < i); j++)
{
if (aLinks[i].href == aLinks[j].href)
fDuplicate = true;
}
if (!fDuplicate)
newHTM += ("<TR><TD>" + aLinks[i].innerText + "</TD><TD>" + aLinks[i].href + "</TD></TR>");
}
newHTM += "</TBODY></TABLE></CENTER>";
docLinkTable.innerHTML = newHTM;
return docLinkTable.document;
}
return null;
}
//----------------------------------------------------------------------
// Function CreateDocument
//
// Synopsis: Allocates and initializes a new CPrintDoc with the
// given contentURL and documentID. Also passed: Should
// we pay attention to any existing stream header.
//----------------------------------------------------------------------
function CreateDocument( docURL, strDocID, fUseStreamHeader )
{
if (g_aDocTree[strDocID])
return;
g_aDocTree[strDocID] = new CPrintDoc( strDocID, docURL );
g_aDocTree[strDocID].InitDocument( fUseStreamHeader );
}
function ChangeFramesetLayout( nNewLayout, fForce )
{
// Don't do any work if none is needed
if ( g_nFramesetLayout == nNewLayout
&& !fForce)
return;
// Hide the currently displayed page view
UndisplayPages();
// Grab the new frameset layout setting
g_nFramesetLayout = nNewLayout;
switch ( nNewLayout )
{
case FRAMESET_LAID_OUT:
case FRAMESET_SELECTED:
break;
case FRAMESET_SEPARATE:
// Recount all individual pages and assign starting page
// numbers to each. If a page has no starting page number,
// i.e. _nStartingPage = 0, then it's either a frameset page
// or the selection bit, and we don't want to include it in
// the SEPARATE-type frameset previews. We have to do this
// computation each time, or else we can get errors after
// repaginations.
g_nTotalPages = 0;
for (i in g_aDocTree)
{
if ( g_aDocTree[i]._fFrameset
|| i == "S")
g_aDocTree[i]._nStartingPage = 0;
else
{
g_aDocTree[i]._nStartingPage = g_nTotalPages + 1;
g_nTotalPages += g_aDocTree[i].Pages();
}
}
break;
default:
// Should never happen!
//Don't localize this string, debug code only
HandleError("Impossible frameset layout type: " + nNewLayout, document.URL, "ChangeFramesetLayout");
}
// Allow the logic in ChangeDispPage to select the correct page
// and page number, and then display it.
ChangeDispPage(1);
}
//----------------------------------------------------------------------
// Function EnsureDocuments()
//
// Synopsis: This function picks up and applies style changes, resetting all
// the documents states so they do enough work to reflow.
//
// Returns: nothing
//----------------------------------------------------------------------
function EnsureDocuments()
{
var i;
var tmp;
// Units received are 1/100"; convert to 1"
// Changes in these require repagination:
var top = Printer.marginTop / 100;
var bottom = Printer.marginBottom / 100;
var left = Printer.marginLeft / 100;
var right = Printer.marginRight / 100;
var pageWidth = Printer.pageWidth / 100;
var pageHeight = Printer.pageHeight / 100;
// Changes in these require repagination of the table of links:
var linktable = Printer.tableOfLinks;
// Changes in these require reapplication of headers/footers:
var upTop = Printer.unprintableTop / 100;
var upBottom = Printer.unprintableBottom / 100;
var header = Printer.header;
var footer = Printer.footer;
// Handle case where (unprintable) + (header/footer size) > (specified margin)
// Just autoincrease the margin...
// TODO (greglett) For now, use a guesstimation for the H/F size, as it is always one
// line of the same font. Frontload work to prevent reflow, and use a constant.
// Fixing this is REQUIRED for HTML headers/footers.
// TODO (greglett) (99287)
// On top of that, we are sizing the page slightly wrong - our "page size"
// should not include the 1px/4px borders on the page for UI. This could be amended by surrounding
// the page in a DIV contiainer (the UI page), and printing/sizing the inner page, while positioning
// the outer page. This has some difficulties due to interaction of absolutely positioning stuff.
if (header)
{
tmp = upTop + (HEADFOOTHEIGHT / 100);
if (tmp > top)
top = tmp;
}
if (footer)
{
tmp = upBottom + (HEADFOOTHEIGHT / 100);
if (tmp > bottom)
bottom = tmp;
}
if (upTop != g_nUnprintTop)
{
g_nUnprintTop = upTop;
// Set styles on Header
oRule = GetRuleFromSelector(".divHead");
if (oRule == null)
{
// Should never happen!
//Don't localize this string, debug code only
HandleError("'.divHead' rule does not exist!", document.URL, "CPrintDoc::EnsureDocuments");
}
oRule.style.top = upTop + "in";
}
if (upBottom != g_nUnprintBottom)
{
g_nUnprintBottom= upBottom;
// Set styles on Footer
oRule = GetRuleFromSelector(".divFoot");
if (oRule == null)
{
// Should never happen!
//Don't localize this string, debug code only
HandleError("'.divFoot' rule does not exist!", document.URL, "CPrintDoc::EnsureDocuments");
}
oRule.style.bottom = upBottom + "in";
}
// Check if something has changed that will force work on the document.
if ( top != g_nMarginTop
|| bottom != g_nMarginBottom
|| left != g_nMarginLeft
|| right != g_nMarginRight
|| pageWidth != g_nPageWidth
|| pageHeight != g_nPageHeight
|| header != g_strHeader
|| footer != g_strFooter )
{
var conWidth = pageWidth - left - right;
var conHeight = pageHeight - top - bottom;
var oStyleSheet = document.styleSheets[0];
var oRule;
if (conWidth < 0)
conWidth = 0;
if (conHeight < 0)
conHeight = 0;
// Hide currently displayed pages - they're about to become invalid.
UndisplayPages();
// Clear page numbering for FRAMESET_SEPARATE layout
g_nTotalPages = 0;
g_nDocsToCalc = 0;
// All documents are about to be repaginated!
for (i in g_aDocTree)
{
g_nDocsToCalc++;
g_aDocTree[i].ResetDocument();
}
// Cache new values.
g_nMarginTop = top;
g_nMarginBottom = bottom;
g_nMarginLeft = left;
g_nMarginRight = right;
g_nPageWidth = pageWidth;
g_nPageHeight = pageHeight;
g_fTableofLinks = linktable;
g_strHeader = header;
g_strFooter = footer;
HeadFoot.textHead = g_strHeader;
HeadFoot.textFoot = g_strFooter;
// Set styles on pages.
oRule = GetRuleFromSelector(".page");
if (oRule == null)
{
// Should never happen!
//Don't localize this string, debug code only
HandleError("'.page' rule does not exist!", document.URL, "CPrintDoc::EnsureDocuments");
}
oRule.style.width = pageWidth + "in";
oRule.style.height = pageHeight + "in";
// Set styles on layout rects.
oRule = GetRuleFromSelector(".mRect");
if (oRule == null)
{
// Should never happen!
//Don't localize this string, debug code only
HandleError("'.mRect' rule does not exist!", document.URL, "CPrintDoc::EnsureDocuments");
}
oRule.style.marginLeft = left + "in";
oRule.style.marginRight = right + "in";
oRule.style.marginTop = top + "in";
oRule.style.marginBottom = bottom + "in";
oRule.style.width = conWidth + "in";
oRule.style.height = conHeight + "in";
// Set styles on Header
oRule = GetRuleFromSelector(".divHead");
if (oRule == null)
{
// Should never happen!
//Don't localize this string, debug code only
HandleError("'.divHead' rule does not exist!", document.URL, "CPrintDoc::EnsureDocuments");
}
oRule.style.left = left + "in";
oRule.style.width = conWidth + "in";
// Set styles on Header
oRule = GetRuleFromSelector(".divFoot");
if (oRule == null)
{
// Should never happen!
//Don't localize this string, debug code only
HandleError("'.divHead' rule does not exist!", document.URL, "CPrintDoc::EnsureDocuments");
}
oRule.style.left = left + "in";
oRule.style.width = conWidth + "in";
// HACKHACK (greglett) 94479
// The viewchain is not capable of recalcing if the layout rect properties are changed right now.
// So, we unhook the LR, change the properties (ABOVE) and then reload/reparse the entire document (HERE)
for (i in g_aDocTree)
{
// Reinit document - and pass whether or not we're using an OE header.
g_aDocTree[i].InitDocument((g_aDocTree[i]._anMerge[LOADING_CONTENT] == 1));
}
// Repagination screws up the delicate frame page table used to figure out how
// many pages are in which documents. Force update.
if (g_nFramesetLayout == FRAMESET_SEPARATE)
ChangeFramesetLayout(g_nFramesetLayout, true);
// Repaint the current page(s) that we hid above with UndisplayPages()
PositionPages(g_nDispPage);
}
else if (linktable != g_fTableOfLinks)
{
// Cache new values.
g_fTableOfLinks = linktable;
// All documents are about to be table of linked! (?)
for (i in g_aDocTree)
{
g_aDocTree[i].ResetTableOfLinks();
}
}
}
//----------------------------------------------------------------------
// Functions: Button utilities.
//
// Synopsis: These various & sundry functions are button UI utilities
// and provide basic toolbar UI
//----------------------------------------------------------------------
function buttonRaise( elem )
{
elem.style.borderStyle = "outset";
elem.style.borderColor = "threedhighlight";
}
function buttonLower( elem )
{
elem.style.borderStyle = "solid";
elem.style.borderColor = "threedface";
}
function buttonDepress(elem)
{
elem.style.borderStyle = "inset";
elem.style.borderColor = "threedshadow";
}
// PERF (greglett)
// We don't need to do a whole updateXXXButtons!
function buttonOver()
{
var imgSrc = event.srcElement;
g_imgUnderMouse = imgSrc;
if (imgSrc == begin ||
imgSrc == prev ||
imgSrc == next ||
imgSrc == end)
{
updateNavButtons();
}
else if (imgSrc == zoomIn ||
imgSrc == zoomOut)
{
updateZoomButtons();
}
else
{
imgSrc.src= "" + imgSrc.id + "_hilite.gif";
buttonRaise( imgSrc.parentNode );
}
}
// PERF (greglett)
// We don't need to do a whole updateXXXButtons!
function buttonOut()
{
var imgSrc = event.srcElement;
g_imgUnderMouse = null;
if (imgSrc == begin ||
imgSrc == prev ||
imgSrc == next ||
imgSrc == end)
{
updateNavButtons();
}
else if (imgSrc == zoomIn ||
imgSrc == zoomOut)
{
updateZoomButtons();
}
else
{
imgSrc.src= "" + imgSrc.id + ".gif";
buttonLower( imgSrc.parentNode );
}
}
function buttonDown()
{
buttonDepress(event.srcElement);
}
// --------------------------------------------------------
function HandlePageSelect()
{
event.srcElement.value = ChangeDispPage(parseInt(inputPageNum.value));
// Force focus back to the preview document so keyboard
// accelerators work as expected
MasterContainer.focus();
}
function HandlePageSetup()
{
if (Printer.showPageSetupDialog())
EnsureDocuments();
}
function HandleForwardPage()
{
ChangeDispPage(g_nDispPage + 1);
// Force focus back to the preview document so keyboard
// accelerators work as expected
MasterContainer.focus();
}
function HandleBackPage()
{
ChangeDispPage(g_nDispPage - 1);
// Force focus back to the preview document so keyboard
// accelerators work as expected
MasterContainer.focus();
}
function HandleFirstPage()
{
ChangeDispPage(1);
// Force focus back to the preview document so keyboard
// accelerators work as expected
MasterContainer.focus();
}
function HandleLastPage()
{
ChangeDispPage(TotalDisplayPages());
// Force focus back to the preview document so keyboard
// accelerators work as expected
MasterContainer.focus();
}
function NumericFromSpecialZoom(fnBounder)
{
var iMaxNumericZoom = selectZoom.options.length-1-NUM_ABSTRACT_ZOOMS; // specials zooms follow numeric zooms
var iBelow = -1;
var nBelow = 0;
var iAbove = iMaxNumericZoom + 1;
var i;
// establish iBelow and iAbove so that they are the selection indices just
// below and above the current value of g_nZoomFactor. if there's an
// exact match, then iBelow and iAbove have to both be the index whose
// value matches
// get iBelow
for (i = 0; i <= iMaxNumericZoom; i++)
{
var nThisIndex = parseInt(selectZoom.options[i].value);
if (nThisIndex >= g_nZoomFactor)
{
iBelow = i;
nBelow = nThisIndex;
}
else
{
break;
}
}
// get iAbove
if (nBelow > g_nZoomFactor)
{
iAbove = iBelow + 1;
}
else
{
iAbove = iBelow;
}
return fnBounder(iBelow, iAbove);
}
function HandleZoom(nZoomIndexDelta)
{
var iCurrZoom = selectZoom.selectedIndex;
var iMaxNumericZoom = selectZoom.options.length-1-NUM_ABSTRACT_ZOOMS; // specials zooms follow numeric zooms
if (iCurrZoom > iMaxNumericZoom)
{
var fnRemapBounder = null;
// we're on a special zoom setting and now need to
// remap back into numeric zoom mode
if (nZoomIndexDelta == 1)
{
// we're going to be moving down the list
// so the index returned by NFSZ needs
// to be the vertically highest index
// which is the min index
fnRemapBounder = Math.min;
}
else
{
// moving up the list, need vertically lowest index
fnRemapBounder = Math.max;
}
iCurrZoom = NumericFromSpecialZoom(fnRemapBounder);
}
// move up or down the selection list as indicated by nZoomIndexDelta
selectZoom.selectedIndex = Math.min(Math.max(0, iCurrZoom + nZoomIndexDelta), iMaxNumericZoom);
ChangeZoom(parseInt(selectZoom.options[selectZoom.selectedIndex].value));
}
function HandleDynamicZoom()
{
var nZoomType = parseInt(selectZoom.options[selectZoom.selectedIndex].value);
if (nZoomType < 0)
{
var nZoomFactor = 100;
var xPageWidth = getPageWidth();
switch (nZoomType)
{
// page width
case ZOOM_PAGE_WIDTH:
nZoomFactor = Math.floor(((OverflowContainer.offsetWidth - 20) * 100) / xPageWidth);
break;
// whole page
case ZOOM_WHOLE_PAGE:
var xZoom = Math.floor(((OverflowContainer.offsetWidth - 20) * 100) / xPageWidth);
var yZoom = Math.floor(((OverflowContainer.offsetHeight - 20) * 100) / getPageHeight());
nZoomFactor = Math.min(xZoom, yZoom);
break;
// two pages
case ZOOM_TWO_PAGES:
nZoomFactor = Math.floor(((OverflowContainer.offsetWidth - 30) * 100) / (2 * xPageWidth));
break;
// eh?
default:
nZoomFactor = 100;
break;
}
ChangeZoom(nZoomFactor);
}
}
function HandleZoomSelect()
{
var nZoomFactor = parseInt(selectZoom.options[selectZoom.selectedIndex].value);
if (nZoomFactor < 0)
{
HandleDynamicZoom();
}
else
{
ChangeZoom(nZoomFactor);
}
// The selects require a user to be able to arrow between values, selecting each in succession.
// As such, we cannot refocus the master container here.
}
function HandleFramesetSelect()
{
ChangeFramesetLayout(parseInt(selectFrameset.options[selectFrameset.selectedIndex].value), false);
// The selects require a user to be able to arrow between values, selecting each in succession.
// As such, we cannot refocus the master container here.
}
function HandleZoomInButton()
{
HandleZoom(-1);
// Force focus back to the preview document so keyboard
// accelerators work as expected
MasterContainer.focus();
}
function HandleZoomOutButton()
{
HandleZoom(1);
// Force focus back to the preview document so keyboard
// accelerators work as expected
MasterContainer.focus();
}
function HandleInputKeyPress()
{
var keyStroke = event.keyCode;
if (keyStroke == 13) // Enter
{
event.srcElement.onchange();
}
else if (keyStroke < 48 || keyStroke > 57)
{
// only allow numeric input
event.returnValue = false;
}
}
function Close()
{
// (greglett) The point of this is to give the host an update on the page# we're
// printing. Since it's slow, and noone uses it now anyway except as a boolean,
// we just use it as an on/off for the printer status icon.
Printer.updatePageStatus(-1); // Display the printing icon in the browser
// HACKHACK (greglett) See defnition of this variable above for details.
if (g_fDelayClose)
{
g_fDelayClose = false;
window.setTimeout("Close()", 120000); // Allow 2 minutes
return;
}
#ifdef DEBUG
if (!g_fReallyClose)
return;
#endif
window.close();
}
//----------------------------------------------------------------------
// Function PrintAll()
//
// Synopsis: This function ensures that all settings are current,
// creates all linked documents (if the user has specified that
// print option), and asks each CPrintDoc to print itself.
//----------------------------------------------------------------------
function PrintAll()
{
var i;
var nFirstDoc;
// (greglett) If we're printing frames in any way other than as shown, we should
// wait on all the little frameset documents to load. Consider a better way?
if ( g_nFramesLeft > 0
&& Printer.framesetDocument
&& !Printer.frameAsShown )
{
// The OnBuildFrames timeout should be smaller than this one's - since this is gating on a variable that
// only changes when OnBuildFrames has had a chance to spin.
window.setTimeout("PrintAll()", 100); // Poll every tenth of a second.
return;
}
EnsureDocuments();
// Nothing to do if we have no copies
if (Printer.copies <= 0)
{
Close();
}
// Some OS's don't force this restriction in the Print dialog. We do it posthumously.
else if ( Printer.selectedPages
&& Printer.pageFrom > Printer.pageTo )
{
var L_PAGERANGE_ErrorMessage = "The 'From' value cannot be greater than the 'To' value.";
alert(L_PAGERANGE_ErrorMessage);
// A "Preview" print should just exit the function. The user can click print again.
// A "NoPrompt" print should never be here.
AssertSz(dialogArguments.__IE_PrintType != "NoPrompt", "From > To with no possible UI?");
// A "Prompt" print will leak the template if we just let it leave the function!
// Throw the dialog again.
if (!g_fPreview)
PrintNow(true);
}
else
{
// How do we know when to close the window (all docs done printing)?
// Right now, we have each doc decrement the g_cLeftToPrint until
// it hits zero; the last one then closes the window.
g_cLeftToPrint = 1;
// (greglett) The point of this is to give the host an update on the page# we're
// printing. Since it's slow, and noone uses it now anyway except as a boolean,
// we just use it as an on/off for the printer status icon.
Printer.updatePageStatus(1); // Display the printing icon in the browser
PrintSentinel(((Printer.selection)
? "S"
: (Printer.frameActive && !!g_strActiveFrame)
? g_strActiveFrame
: "C"),
true);
}
}
// No syncrohization mechanism exists in JScript except for brute force. Instead of pure busy waiting,
// let's at least sleep for fixed time periods.
function PrintSentinel( strDoc, fRecursionOK )
{
// Gate on the document being ready to print.
if ( !g_aDocTree[strDoc]
|| !g_aDocTree[strDoc].ReadyToPrint() )
{
window.setTimeout("PrintSentinel('" + strDoc + "'," + fRecursionOK + ");", 500);
return;
}
g_aDocTree[strDoc].Print(fRecursionOK);
}
function PrintDocumentComplete()
{
g_cLeftToPrint--;
if (g_cLeftToPrint <= 0)
{
Close();
}
}
//----------------------------------------------------------------------
// PrintNow()
// We've either been called without preview or from the preview
// helper function, HandlePrintClick(). In either case, just do
// that printing thing now. In preview situations, the user should
// always get a print dialog and the template should NOT close
// if the user clicks 'Cancel' in the dialog. In straight-print
// situations with a print dialog, a 'Cancel' selection will close
// the template.
//----------------------------------------------------------------------
function PrintNow( fWithPrompt)
{
// We have to gate on the loading of the original document right now for
// frameset information.
if ( !g_aDocTree["C"]
|| !g_aDocTree["C"]._aaRect[LOADING_CONTENT][0]
|| !g_aDocTree["C"]._aaRect[LOADING_CONTENT][0].contentDocument.body) // 89002 - may not exist yet.
{
window.setTimeout("PrintNow('" + fWithPrompt + "');", 100); // Poll every tenth of a second.
return;
}
var oDoc = g_aDocTree["C"]._aaRect[LOADING_CONTENT][0].contentDocument;
var fConfirmed;
var fFramesetDocument = (oDoc.body.tagName.toUpperCase() == "FRAMESET");
// fActiveFrame includes:
// FRAMESET documents (which will have a g_strActiveFrame)
// IFRAME documents (which will not!)
var fActiveFrame = (oDoc.all.tags("HTML").item(0).__IE_ActiveFrame != null);
Printer.framesetDocument = fFramesetDocument;
Printer.frameActiveEnabled = fActiveFrame;
if (g_fPreview)
{
Printer.frameActive = (g_nFramesetLayout == FRAMESET_SELECTED);
Printer.frameAsShown = (g_nFramesetLayout == FRAMESET_LAID_OUT);
Printer.currentPageAvail = true;
}
else
{
Printer.frameActive = fActiveFrame;
Printer.frameAsShown = false;
Printer.currentPageAvail = false;
}
// The selection document may not be created yet. Directly check the dialogArguments.
Printer.selectionEnabled = !!(dialogArguments.__IE_ContentSelectionUrl);
Printer.selection = false; // Never default to selection.
#ifdef DEBUG
Log("ShowingPrintDialog " + eval(fWithPrompt));
#endif
fConfirmed = (eval(fWithPrompt)) ? Printer.showPrintDialog() : Printer.ensurePrintDialogDefaults();
if ( fConfirmed )
{
if ( Printer.selection
&& dialogArguments.__IE_ContentSelectionUrl ) // (greglett) Check this too, in case the dlg was mishandled
{
// NB: (greglett)
// We always loaded the selection document in IE55
CreateDocument(dialogArguments.__IE_ContentSelectionUrl, "S", true);
}
#ifdef DEBUG
Log("Printer: Copies:" + Printer.deviceSupports("copies") + " Collate:" + Printer.deviceSupports("collate"));
#endif
Printer.usePrinterCopyCollate = ( Printer.deviceSupports("copies") >= Printer.copies
&& ( !Printer.collate
|| Printer.deviceSupports("collate") ));
PrintAll();
}
else
{
if ( !g_fPreview )
{
Close();
}
else
{
// TODO (greglett) (104826 - but really task level work)
// We may theoretically have changes even with a Cancel for two reasons:
// 1. In NT5, the Apply button may have been clicked, followed by Cancel.
// Right now, this doesn't work because the DHUI doesn't deal with this correctly.
// 2. The user may be printing to file, have clicked OK, then Cancel on the
// file query dialog. Right now, this doesn't work in CTemplatePrinter.
// Do we want this to work like this?
// The template is not currently robust enough to survive this, even if it were to
// work correctly. TableOfLinks has problems, as does AllLinkedDocs.
Printer.tableoflinks = false;
}
}
}
//----------------------------------------------------------------------
// HandlePrintClick()
// this is just a helper fucntion so that we close the window properly
// even when we are using this template to print with preview.
//----------------------------------------------------------------------
function HandlePrintClick()
{
// Call the PrintNow function, but indicate that we always want a
// print dialog and never want to close preview on completion.
PrintNow(true, true);
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
// CLASS CPrintDoc FUNCTIONS BEGIN HERE
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
// Member CPrintDoc::ReadyToPrint
//
// Synopsis: Is the print doc in a state where we can call print?
//----------------------------------------------------------------------
function CPrintDoc_ReadyToPrint()
{
if ( this._nStatus == READY_TO_PRINT
&& this._aaRect[LOADING_CONTENT][0].contentDocument.readyState == "complete")
{
return true;
}
return false;
}
//----------------------------------------------------------------------
// Member CPrintDoc::Print
//
// Synopsis: Prints the document, taking into acount # of copies, a page
// range, and collation.
//----------------------------------------------------------------------
function CPrintDoc_Print( fRecursionOK )
{
if (!this.ReadyToPrint())
{
// Don't localize this debug string
HandleError("Printing when not ready!", document.URL, "CPrintDoc::Print");
return;
}
var nCount = (Printer.usePrinterCopyCollate) ? 1 : Printer.copies;
var nFrom;
var nTo;
AssertSz(nCount > 0, "Printing 0 or less copies"); // We should have already checked this.
// Attempt to recurse if necessary (activeFrame, allLinkedDocuments, &c...)
if (fRecursionOK)
{
var fFrameset = (this._aaRect[LOADING_CONTENT][0].contentDocument.body.tagName.toUpperCase() == "FRAMESET");
if (Printer.frameActive) // Print active frame
{
var n = parseInt(this._aaRect[LOADING_CONTENT][0].contentDocument.all.tags("HTML").item(0).__IE_ActiveFrame);
if (n >= 0)
{
var oTargetFrame = (fFrameset)
? this._aaRect[LOADING_CONTENT][0].contentDocument.all.tags("FRAME").item(n)
: this._aaRect[LOADING_CONTENT][0].contentDocument.all.tags("IFRAME").item(n);
// Load active frame
if ( IsPersistedDoc()
&& ( oTargetFrame.src == "res://SHDOCLC.DLL/printnof.htm" // FRAME
|| oTargetFrame.src == "about:blank" )) // IFRAME
{
// Immediate subframe is a WebOC hosted document. Use special
// interface to print it (Trident couldn't marshall it due to external bugs)
Printer.printNonNativeFrames(this._aaRect[LOADING_CONTENT][0].contentDocument, true); // true for ActiveFrame
}
else
{
// Immediate subframe is an HTML document. Recurse.
this.CreateSubDocument(oTargetFrame.src, true);
this.PrintAllSubDocuments(true);
}
// Finish printing this document...
PrintDocumentComplete();
return;
}
}
if (fFrameset)
{
if (!Printer.frameAsShown) // Print all frames
{
this.PrintAllSubDocuments(true);
if (IsPersistedDoc())
{
// Print all Word document frames, too
Printer.printNonNativeFrames(this._aaRect[LOADING_CONTENT][0].contentDocument, false); // false for all frames
}
// Finish printing this document...
PrintDocumentComplete();
return;
}
else
{
// Print all Word document frames in addition to the as laid out
Printer.printNonNativeFrames(this._aaRect[LOADING_CONTENT][0].contentDocument, false); // false for all frames
}
}
else // BODY document.
{
// Build all linked documents, if necessary.
if (Printer.allLinkedDocuments)
{
this.BuildAllLinkedDocuments();
this.PrintAllSubDocuments(false);
}
}
}
// We may be a WebOC document. If we are, and it prints itself, we're done.
if (Printer.printNonNative(this._aaRect[LOADING_CONTENT][0].contentDocument) )
{
// HACKHACK (greglett) See defnition of this variable above for details.
g_fDelayClose = !g_fPreview;
PrintDocumentComplete();
return;
}
// Clip page range to this document/subdocument.
// NB (greglett)
// Selected Page/CurrentPage don't work as expected with AllLinkedDocuments.
// (We don't print only the linked documents on the given page)
// It can't unless we can get a collection with only with particular pages on it.
// NB (greglett)
// If asked to print a table of links and a page range, do we:
// 1. Always print a table of links (for the whole document).
// 2. Print whole TOL if the page range and the TOL range is nonintersecting
// or only the intersection if the range intersects.
// 3. Print only the part of the TOL that intersects the page range.
// Remember, NT5+ has an apply button and should be able to preview the TOL (though
// they can't yet, because we don't support Apply).
// We currently take the path of least resistance: #3.
if (Printer.selectedPages)
{
nFrom = Printer.pageFrom;
nTo = Printer.pageTo;
if (nFrom < 1)
nFrom = 1;
if (nTo > this.Pages())
nTo = this.Pages();
}
// CurrentPage only applies to the document being previewed. Any subdocuments that are
// printed should print in their entirity.
else if ( Printer.currentPage
&& this._strDoc == DisplayDocument())
{
nFrom = (this.Pages() >= g_nDispPage) ? g_nDispPage : this.Pages();
nTo = nFrom;
}
else
{
// Normal print job - print the whole kit n' kabootle
nFrom = 1;
nTo = this.Pages();
}
// In this case, we've been asked to print a valid range, but the document does not have
// any pages in the range. (ex: 2 to 3 of a 1 page document - nFrom = 2, nTo = 1)
// (We really only need to do this in selected pages above.)
if (nTo < nFrom)
{
PrintDocumentComplete();
return;
}
AssertSz(nFrom <= nTo, "pageTo is smaller than pageFrom!");
AssertSz(nFrom > 0, "pageFrom value 0 or less!");
AssertSz(nTo <= this.Pages(), "pageTo greater than number of pages in document!");
// The display URL goes onto the system spooler as a job title.
if (Printer.startDoc(this._aaRect[LOADING_CONTENT][0].contentDocument.URL))
{
if (Printer.collate)
{
// (greglett) (10084)
// Printing collated, multiple documents, we need to ensure the document has an even # of pages;
// This may require an extra page.
// [1|2] [3| ] [1|2] [3| ]
var fExtraPage = ( Printer.duplex
&& ((nFrom - nTo) % 2 == 0) );
for (j = 0; j < nCount; j++)
{
for (i = nFrom; i <= nTo; i++)
{
Printer.printPage(this.Page(i).children[0]);
}
if (fExtraPage)
Printer.printBlankPage();
}
}
else
{
// (greglett) (10084)
// If we are printing duplex, multiple documents, we need to print pairs of pages.
// We print front-to-back, producing the output (for a 3 page, 2 copies):
// [1|2] [1|2] [3| ] [3| ]...
var fDuplex = Printer.duplex;
for (i = nFrom; i <= nTo; i++)
{
for (j = 0; j < nCount; j++)
{
Printer.printPage(this.Page(i).children[0]);
if (fDuplex)
{
if (i < nTo)
Printer.printPage(this.Page(i+1));
else
Printer.printBlankPage();
}
}
if (fDuplex)
i++;
}
}
Printer.stopDoc();
}
// All done.
PrintDocumentComplete();
}
//----------------------------------------------------------------------
// Member CPrintDoc::RectComplete
//
// Synopsis: Called whenever an onlayout complete fires for this document's
// layout rects. Requires a "callback" function OnRectComplete,
// above.
// This function determines when a document is complete, and adds
// a table of links/headers/footers if necessary.
//----------------------------------------------------------------------
function CPrintDoc_RectComplete(fOverflow, strElement)
{
var nStatus = parseInt(strElement.substr(5,1));
var nPage = parseInt(strElement.substr(strElement.lastIndexOf("p") + 1));
AssertSz((nStatus >= LOADING_OEHEADER) && (nStatus <= LOADING_TABLEOFLINKS), "Status within recognized bounds");
AssertSz(nPage < this._aaRect[nStatus].length, "Page # not created!");
// Ignore premature event calls. We'll deal with them when we're good and ready.
if (nStatus > this._nStatus)
return false;
// Ignore event calls from pages before this one on the sheaf
if (nPage != this._acPage[nStatus] - 1 + this._anMerge[nStatus])
return false;
// If this is from a previous document within this one...
if (nStatus != this._nStatus)
{
// ...and it's just telling us again that we're done, ignore it...
if (!fOverflow)
return false;
// ...but if there's new content, dynamically switch back into this pagination.
this.StopFixupHF(); // Stop H/F fixup - we need to do it again.
if (this._nStatus == READY_TO_PRINT) // Add ourselves back into the queue of repaginating docs
g_nDocsToCalc++;
Transition(nStatus, "Status backslide - RectComplete"); // Backslide status.
}
// Need another page...
if (fOverflow)
{
this.AddPage();
}
else
{
// No more pages needed in this phase of document calculation.
// Move into the next calculation phase.
switch (this._nStatus)
{
case LOADING_OEHEADER:
// Stream header has finished - begin content calculation.
Transition(LOADING_CONTENT, "RectComplete");
this.AddFirstPage();
this._aaRect[this._nStatus][0].contentSrc = this._strDocURL;
break;
case LOADING_CONTENT:
// Content has finished calcing - create a table of links if requested.
Transition(LOADING_TABLEOFLINKS, "RectComplete");
this.AddTableOfLinks();
break;
case LOADING_TABLEOFLINKS:
// All done with pagination. Headers and Footers, please.
Transition(PAGING_COMPLETE, "RectComplete");
if (this._strDoc == DisplayDocument())
ChangeDispPage(g_nDispPage); // Clip to the maximum page, in case we are reflowing & have fewer pages.
this.FixupHF();
break;
}
}
// Update the display to reflect the correct # of pages.
if (this._strDoc == DisplayDocument())
{
spanPageTotal.innerText = this.Pages();
// make sure the nav buttons are in an appropriate state
updateNavButtons();
}
}
//----------------------------------------------------------------------
// Member CPrintDoc::AddPage
//
// Synopsis: Adds a page to the end of the current document.
//----------------------------------------------------------------------
function CPrintDoc_AddPage()
{
var newHTM = "";
var aPage = this._aaPage[this._nStatus];
var aRect = this._aaRect[this._nStatus];
AssertSz(this._nStatus < PAGING_COMPLETE, "Adding page when pagination done!");
// Increment page count in this section of the print document
(this._acPage[this._nStatus])++;
HeadFoot.URL = this.EnsureURL();
HeadFoot.title = this.EnsureTitle();
HeadFoot.pageTotal = this.Pages();
HeadFoot.page = HeadFoot.pageTotal;
// We conserve layout rects - if this page has already been created, use it.
if (this._acPage[this._nStatus] <= aPage.length)
{
// Reset H/F - it may have changed.
var oPage = aPage[this._acPage[this._nStatus] - 1];
oPage.children("header").innerHTML = HeadFoot.HtmlHead;
oPage.children("footer").innerHTML = HeadFoot.HtmlFoot;
}
else
{
// TODO: (greglett) (108939) We have to parse in the nextRect right now because it is
// the CGenericElement::Notify (ENTERTREE) that hooks up the LayoutRect. Changing
// this value *after* the EnterTree has no effect.
// NB (greglett)
// Q: Why wrap the DeviceRect in a DIV instead of just using the DeviceRect?
// A: Because the OM on the DeviceRect is messed up such that it does do a resolution change scale.
// Instead, it returns CSS pixels *within* the rect. Because we also screw up sizing the rect, this
// turns out to work for a 96DPI screen. However, for 120DPI (large fonts), we off by 1.25 (120/96).
// Since the DIV has no resolution issues, we don't have the problem when we wrap the DeviceRect in a DIV.
newHTM = "<DIV class=divPage><IE:DeviceRect media=\"print\" class=page id=mDiv" + this._nStatus + this._strDoc + "p" + aPage.length + ">";
newHTM += "<IE:LAYOUTRECT id=mRect" + this._nStatus + this._strDoc + "p" + aRect.length;
newHTM += " class=mRect nextRect=mRect" + this._nStatus + this._strDoc + "p" + (aRect.length + 1);
newHTM += " onlayoutcomplete=OnRectComplete('" + this._strDoc + "')";
newHTM += " tabindex=-1 onbeforefocusenter='event.returnValue=false;' ";
newHTM += " /><DIV class=divHead id=header>";
newHTM += HeadFoot.HtmlHead;
newHTM += "</DIV><DIV class=divFoot id=footer>";
newHTM += HeadFoot.HtmlFoot;
newHTM += " </DIV></IE:DeviceRect></DIV>";
MasterContainer.insertAdjacentHTML("beforeEnd", newHTM);
aPage[aPage.length] = eval( "document.all.mDiv" + this._nStatus + this._strDoc + "p" + aPage.length);
aRect[aRect.length] = eval("document.all.mRect" + this._nStatus + this._strDoc + "p" + aRect.length);
}
}
//----------------------------------------------------------------------
// Member CPrintDoc::AddFirstPage
//
// Synopsis: Adds a page to the end of the current document.
//----------------------------------------------------------------------
function CPrintDoc_AddFirstPage()
{
this._acPage[this._nStatus] = 0;
if (this._anMerge[this._nStatus] == 0)
{
this.AddPage();
}
else
{
var aRect = this._aaRect[this._nStatus];
var oPage = this._aaPage[this._nStatus - 1][this._acPage[this._nStatus - 1] - 1];
var oTop = this._aaRect[this._nStatus - 1][this._acPage[this._nStatus - 1] + this._anMerge[this._nStatus - 1] - 1];
var nTop = oTop.offsetTop + oTop.scrollHeight;
var nHeight = oTop.clientHeight - oTop.scrollHeight;
AssertSz(this._nStatus < PAGING_COMPLETE, "Merging page when pagination done!");
AssertSz(this._anMerge[this._nStatus] > 0, "Merging page when not requested!");
// We cannot dynamically get a stream header. Ergo, if we have content layout rects,
// we must be repaginating, and already have a content layout rect on a stream page.
// We (may) simply need to resize and reparent it.
if (aRect.length > 0)
{
var oNode = aRect[0];
oNode.style.marginTop = nTop + "px";
oNode.style.pixelHeight = nHeight;
// Reparent, if necessary.
if (oNode.parentElement != oPage)
oPage.insertBefore(oNode);
}
// We need to actually size & create the content layout rect to merge onto the stream page.
else
{
var newHTM;
var oNode;
// TODO: (greglett) (108939) We have to parse in the nextRect right now because it is
// the CGenericElement::Notify (ENTERTREE) that hooks up the LayoutRect. Changing
// this value *after* the EnterTree has no effect.
newHTM = "<IE:LAYOUTRECT id=mRect" + this._nStatus + this._strDoc + "p0";
newHTM += " class=mRect nextRect=mRect" + this._nStatus + this._strDoc + "p1";
newHTM += " onlayoutcomplete=OnRectComplete('" + this._strDoc + "')";
newHTM += " tabindex=-1 onbeforefocus='event.returnValue=false;' />";
oPage.insertAdjacentHTML("beforeEnd", newHTM);
oNode = eval("document.all.mRect" + this._nStatus + this._strDoc + "p0");
aRect[0] = oNode;
oNode.style.marginTop = nTop + "px";
oNode.style.height = nHeight + "px";
}
}
}
//----------------------------------------------------------------------
// Member CPrintDoc::InitDocument
//
// Synopsis: Begins pagination of document. This could be merged with
// the constructor.
//----------------------------------------------------------------------
function CPrintDoc_InitDocument( fUseStreamHeader )
{
var fReallyUseStreamHeader = (fUseStreamHeader && (dialogArguments.__IE_OutlookHeader != null));
this._anMerge[LOADING_CONTENT] = (fReallyUseStreamHeader) ? 1 : 0;
Transition((fReallyUseStreamHeader) ? LOADING_OEHEADER : LOADING_CONTENT, "Initialize Status");
this.AddFirstPage();
this._aaRect[this._nStatus][0].contentSrc = (fReallyUseStreamHeader)
? dialogArguments.__IE_OutlookHeader
: this._strDocURL;
}
function CPrintDoc_PrintAllSubDocuments( fRecursionOK )
{
if (!this._aDoc)
return;
var nDocs = this._aDoc.length;
var i;
g_cLeftToPrint += nDocs;
for (i = 0; i < nDocs; i++)
{
PrintSentinel(this._aDoc[i]._strDoc, fRecursionOK);
}
}
function CPrintDoc_BuildAllLinkedDocuments()
{
var strURL = this._aaRect[LOADING_CONTENT][0].contentDocument.URL;
var aLinks = this._aaRect[LOADING_CONTENT][0].contentDocument.links;
var nLinks = aLinks.length;
var i;
var j;
var strLink;
for (i = 0; i < nLinks; i++)
{
strLink = aLinks[i].href;
// Check against our own URL.
// Check to make sure we are not opening a bad URL
if ( (strURL == strLink)
|| UnprintableURL(strLink) )
continue;
// Check for a duplicate in the list. Yes, this is n^2... as in IE4+
for (j = 0; j < i; j++)
{
if (strLink == aLinks[j].href)
break;
}
if (j < i) // Duplicate found.
continue;
this.CreateSubDocument(strLink, false);
}
}
function OnBuildAllFrames( strDoc )
{
// We have to gate on the loading of the original document right now for
// frameset information.
if ( !g_aDocTree[strDoc]
|| !g_aDocTree[strDoc]._aaRect[LOADING_CONTENT][0]
|| !g_aDocTree[strDoc]._aaRect[LOADING_CONTENT][0].contentDocument.body) // 89002 - may not exist yet.
{
window.setTimeout("OnBuildAllFrames('" + strDoc + "');", 100);
return;
}
g_aDocTree[strDoc].BuildAllFrames();
}
function IsPersistedDoc()
{
// Since this is only called while printing, we can be sure the following exists...
return (!!g_aDocTree["C"]._aaRect[LOADING_CONTENT][0].contentDocument.all.tags("HTML")[0].__IE_DisplayURL);
}
function CPrintDoc_BuildAllFrames()
{
var aFrames = this._aaRect[LOADING_CONTENT][0].contentDocument.all.tags("FRAME");
var nFrames = aFrames.length;
var nActive = parseInt(this._aaRect[LOADING_CONTENT][0].contentDocument.all.tags("HTML").item(0).__IE_ActiveFrame);
var i;
var strSrc;
var strDoc;
if (nFrames > 0)
this._fFrameset = true;
for (i = 0; i < nFrames; i++)
{
strSrc = aFrames[i].src;
// This URL was created by Trident replacing a WebOC frame that it couldn't marshall.
// These will be printed via a call to "Printer.printNonNativeFrames(false)" in the caller.
if (strSrc == "res://SHDOCLC.DLL/printnof.htm")
continue;
// Make a document for the new URL.
// We can't use the markup because it's already slaved (to the frame)
strDoc = this.CreateSubDocument(strSrc, true);
if (i == nActive)
g_strActiveFrame = strDoc;
// Increment the semaphore, indicating that we're building a deeper branch of frames
// (see OnLoadBody() for more info)
g_nFramesLeft++;
// And then recurse to build its children frames
OnBuildAllFrames(strDoc);
}
// Decrement the semaphore, indicating that we've finished building this branch
// (see OnLoadBody() for more info)
g_nFramesLeft--;
if (g_nFramesLeft <= 0)
BuildAllFramesComplete();
}
function CPrintDoc_CreateSubDocument( docURL, fUseStreamHeader )
{
if (!this._aDoc)
this._aDoc = new Array();
var nDoc = this._aDoc.length;
var strDoc = this._strDoc + "_" + nDoc;
CreateDocument(docURL, strDoc, fUseStreamHeader);
this._aDoc[nDoc] = g_aDocTree[strDoc];
return (strDoc);
}
//----------------------------------------------------------------------
// Member CPrintDoc::AddTableOfLinks
//
// Synopsis: Appends a table of links to the end of the current document
// (this uses the documents current page value to determine the
// "end" - do not call if this number is not determined).
//----------------------------------------------------------------------
function CPrintDoc_AddTableOfLinks()
{
AssertSz(this._nStatus == LOADING_TABLEOFLINKS, "Call to AddTableOfLinks when not ready!");
// No table of links requested. Transition to header/footer work.
if (!g_fTableOfLinks)
{
Transition(PAGING_COMPLETE, "AddTableOfLinks, no table of links requested");
ChangeDispPage(g_nDispPage); // Clip to the maximum page, in case we are reflowing & have fewer pages.
this.FixupHF();
}
else
{
var oTableOfLinks = BuildTableOfLinks(this._aaRect[LOADING_CONTENT][0].contentDocument);
if (oTableOfLinks != null)
{
// NB (greglett)
// The markup for the oTableOfLinks document becomes null across the
// AddFirstPage below. The issue is timing related. A workaround is to store the body.
var oBody = oTableOfLinks.body;
this.AddFirstPage()
this._aaRect[this._nStatus][0].contentSrc = oBody.document;
}
else
{
// Table of links does not exist. Move straight to the HeadersAndFooters thing.
Transition(PAGING_COMPLETE, "AddTableOfLinks, no table");
ChangeDispPage(g_nDispPage); // Clip to the maximum page, in case we are reflowing & have fewer pages.
this.FixupHF();
}
}
}
//----------------------------------------------------------------------
// Member CPrintDoc::FixupHF
//
// Synopsis: Goes through all pages in the document, updating/creating
// their header/footers.
//----------------------------------------------------------------------
function OnTickHF( strDoc )
{
if (!g_aDocTree[strDoc])
{
// No need to localize the string - it is only displayed in debug mode.
HandleError("Document " + strDoc + " does not exist.", document.URL, "OnRectComplete");
return;
}
g_aDocTree[strDoc].TickHF();
}
// There are two magic numbers in this function - the n in the line iTo = nStartPage + n and the setTimeout delay.
// The first is directly proportional to the contiguous block of processor time we'll take at a time, but inversely proportional
// to the # of timeouts we'll have to set and the total amount of time required to do the job.
// The timeout delay is how long we allow Trident to update and process UI (button highlights, &c...).
function CPrintDoc_TickHF()
{
var i, j;
var iTo, jTo;
var aTok;
var oTok;
var nStartPage = this._nNextHF;
var cPages = this.Pages();
iTo = nStartPage + 2;
if (iTo > cPages)
iTo = cPages;
for (i = nStartPage; i <= iTo; i++)
{
// (greglett) Why first child? See comments in CPrintDoc_AddPage.
aTok = this.Page(i).children[0].getElementsByTagName("SPAN");
for (j=0, jTo = aTok.length; j < jTo; j++)
{
oTok = aTok[j];
if (oTok.className == "hfPageTotal")
oTok.innerText = cPages;
else if ( oTok.className == "hfUrl"
&& oTok.innerText == "" )
oTok.innerText = this.EnsureURL();
else if ( oTok.className == "hfTitle"
&& oTok.innerText == "" )
oTok.innerText = this.EnsureTitle();
}
}
// Update page # of next HF we need to fixup.
this._nNextHF = i;
#ifdef DEBUG
// DEBUG ONLY - Track H/F fixup speed visually.
spanDebugHF.innerText = this._nNextHF - 1;
#endif
// If we're not done crowning & shoeing the document yet, we need to set a timeout to get back to it.
// Timeout should be long enough to process UI.
if (iTo == cPages)
{
Transition(READY_TO_PRINT, "AddHAndF");
if (--g_nDocsToCalc == 0)
CalcDocsComplete();
}
else
{
this._nTimerHF = window.setTimeout("OnTickHF('" + this._strDoc + "');", 250);
}
}
//----------------------------------------------------------------------
// Member CPrintDoc::FixupHF
//
// Synopsis: Kicks off the
// their header/footers.
//----------------------------------------------------------------------
function CPrintDoc_FixupHF()
{
AssertSz(this._nStatus == PAGING_COMPLETE, "Call to FixupHF when not ready!");
#ifdef DEBUG
// DEBUG ONLY - Track H/F fixup speed visually.
spanDebugHF.innerText = this._nNextHF;
#endif
// Kick off the header/footer pass on the document.
this.TickHF();
}
//----------------------------------------------------------------------
// Member CPrintDoc::Pages, Page
//
// Synopsis: With multiple page arrays per CPrintDoc, these functions
// are to provide the illusion of one array. To make this
// closer to user UI, this virtual array is 1 based, not 0 based.
//----------------------------------------------------------------------
function CPrintDoc_Pages()
{
var i;
var c;
for (i = 0, c = 0; i < PAGING_COMPLETE; i++)
{
c += this._acPage[i];
}
return c;
}
function CPrintDoc_Page(nPage)
{
var i;
var n = nPage;
if (n <= 0)
return null;
for (i = 0; i < PAGING_COMPLETE; i++)
{
// (greglett) Why parentElement? See comments in CPrintDoc_AddPage.
if (n <= this._acPage[i])
return this._aaPage[i][n - 1].parentElement;
n -= this._acPage[i];
}
return null;
}
function CPrintDoc_EnsureURL()
{
if (this._strURL == null)
{
if ( this._aaRect[LOADING_CONTENT][0]
&& this._aaRect[LOADING_CONTENT][0].contentDocument)
{
this._strURL = this._aaRect[LOADING_CONTENT][0].contentDocument.URL;
}
// We must return a string.
if (this._strURL == null)
return "";
}
return this._strURL;
}
function CPrintDoc_EnsureTitle()
{
if (this._strTitle == null)
{
if ( this._aaRect[LOADING_CONTENT][0]
&& this._aaRect[LOADING_CONTENT][0].contentDocument)
{
this._strTitle = this._aaRect[LOADING_CONTENT][0].contentDocument.title;
}
// We must return a string.
if (this._strTitle == null)
return "";
}
return this._strTitle;
}
//----------------------------------------------------------------------
// Member CPrintDoc::ResetXXXX
//
// Synopsis: If the given quantity (Document, TableOfLinks... &c...) has been
// calculated, this will force it to be recalculated. If not, the
// functions essentially do nothing (because the quantity will be
// created as the document finishes loading).
//----------------------------------------------------------------------
function CPrintDoc_ResetDocument()
{
var i;
for (i = 0; i < PAGING_COMPLETE; i++)
{
this._acPage[i] = 0;
// HACKHACK (greglett) 94479
// The viewchain is not capable of recalcing if the layout rect properties are changed right now.
// So, we unhook the LR (HERE) change the properties, and then reload/reparse the entire document (LATER)
if (this._aaRect[i][0])
this._aaRect[i][0].contentSrc = "";
}
this.StopFixupHF();
}
function CPrintDoc_ResetTableOfLinks()
{
// A table of links will be generated as part of the document when we get to it.
if (this._nStatus <= LOADING_TABLEOFLINKS)
return;
this.StopFixupHF();
Transition(LOADING_TABLEOFLINKS, "ResetTableOfLinks");
this.AddTableOfLinks();
}
function CPrintDoc_StopFixupHF()
{
if (this._nTimerHF != -1)
window.clearTimeout(this._nTimerHF);
this._nTimerHF = -1;
this._nNextHF = 1; // Could be higher, to only reget the TOL pages.
}
//
// CPRINTDOC MEMBER FUNCTIONS
//
// This function is a constructor for the CPrintDoc Object.
// CPrintDoc contains per document information.
function CPrintDoc( nDocNum, strDocURL )
{
var i;
this._aDoc = null; // Array of frames/linked documents.
this._strDoc = nDocNum; // Document id of this document (in form "C_2_3")
this._strDocURL = strDocURL; // "Real" URL of document (for LayoutRect's contentSrc).
// _nStatus stores the phase of pagination/flow completion that the document is in:
// The values are defined in preview.h, and initialized in InitDocument
this._nStatus = 0;
this._aaPage = new Array(PAGING_COMPLETE);
this._aaRect = new Array(PAGING_COMPLETE);
this._acPage = new Array(PAGING_COMPLETE);
this._anMerge = new Array(PAGING_COMPLETE);
for (i=0; i<PAGING_COMPLETE; i++)
{
this._aaPage[i] = new Array();
this._aaRect[i] = new Array();
this._acPage[i] = 0;
this._anMerge[i] = 0;
}
this._nNextHF = 1;
this._nTimerHF = -1;
this._strURL = null;
this._strTitle = null;
this._fFrameset = false;
this._nStartingPage = 0;
}
// Pagination functions
MEMBER(CPrintDoc, RectComplete);
MEMBER(CPrintDoc, AddPage);
MEMBER(CPrintDoc, AddFirstPage);
MEMBER(CPrintDoc, AddTableOfLinks);
MEMBER(CPrintDoc, FixupHF);
MEMBER(CPrintDoc, StopFixupHF);
MEMBER(CPrintDoc, TickHF);
// Document status functions
MEMBER(CPrintDoc, InitDocument);
MEMBER(CPrintDoc, ResetDocument);
MEMBER(CPrintDoc, ResetTableOfLinks);
// Recursive document functions
MEMBER(CPrintDoc, BuildAllLinkedDocuments);
MEMBER(CPrintDoc, BuildAllFrames);
MEMBER(CPrintDoc, CreateSubDocument);
// Printing functions
MEMBER(CPrintDoc, Print);
MEMBER(CPrintDoc, PrintAllSubDocuments);
MEMBER(CPrintDoc, ReadyToPrint);
// Data access functions
MEMBER(CPrintDoc, Page);
MEMBER(CPrintDoc, Pages);
MEMBER(CPrintDoc, EnsureURL);
MEMBER(CPrintDoc, EnsureTitle);
</SCRIPT>
</HEAD>
<BODY onload="setTimeout('OnLoadBody()', 400);">
<!-- Controls for printing -->
<IE:TemplatePrinter id=Printer />
<IE:HeaderFooter id=HeadFoot />
<DIV id=idDivToolbar style="width:100%; overflow:hidden;">
<DIV style="width=100%; border:'thin threedhighlight groove';">
<TABLE><TR>
<TD class="UIPane"> <BUTTON id="butPrint" title="Print Document (Alt+P)" accesskey=p><U>P</U>rint...</BUTTON></TD>
<TD class="UISeparator"><IMG width=0 height=0></TD>
<TD class="UIPane"> <BUTTON id="butPageSetup" accesskey=u><IMG id="printCtl" src="printctl.gif" alt="Page Setup (Alt+U)"></BUTTON></TD>
<TD class="UISeparator"><IMG width=0 height=0></TD>
<TD class="UIPane"> <BUTTON id="butFirstPage"><IMG id="begin" src="begin_inactive.gif" alt="First Page (Alt+Home)"></BUTTON></TD>
<TD class="UIPane"> <BUTTON id="butBackPage"> <IMG id="prev" src="prev_inactive.gif" alt="Previous Page (Alt+LeftArrow)"></BUTTON></TD>
<TD class="UIPane"><SPAN style="color:windowtext;"><NOBR Loc> <ID id=idTdPageXofYLocText1>P<U>a</U>ge</ID> <INPUT type=text id="inputPageNum" title="Preview Page (Alt+A)" value="1" style="height:1.5em; width: 2em; color:windowtext;" accesskey=a><ID id=idTdPageXofYLocText2> of </ID><SPAN id="spanPageTotal"></SPAN>
#ifdef DEBUG
<SPAN id="spanDebugHF" style="color: red"></SPAN>
#endif
</SPAN></NOBR></TD>
<TD class="UIPane"> <BUTTON id="butNextPage"> <IMG id="next" src="next_inactive.gif" alt="Next Page (Alt+RightArrow)"></BUTTON></TD>
<TD class="UIPane"> <BUTTON id="butLastPage"> <IMG id="end" src="end_inactive.gif" alt="Last Page (Alt+End)"></BUTTON></TD>
<TD class="UISeparator"><IMG width=0 height=0></TD>
<TD class="UIPane"> <BUTTON id="butZoomOut"> <IMG id="zoomOut" base="zoomOut" src="zoomout.gif" alt="Zoom Out (Alt+Minus)"></BUTTON></TD>
<TD class="UIPane"> <BUTTON id="butZoomIn"> <IMG id="zoomIn" base="zoomIn" src="zoomin.gif" alt="Zoom In (Alt+Plus)"></BUTTON></TD>
<TD class="UIPane"> <SELECT id="selectZoom" accesskey=z>
<OPTION VALUE="500" >500%
<OPTION VALUE="200" >200%
<OPTION VALUE="150" >150%
<OPTION VALUE="100" >100%
<OPTION VALUE="75" SELECTED >75%
<OPTION VALUE="50" >50%
<OPTION VALUE="25" >25%
<OPTION VALUE="10" >10%
<!-- ID's are for localization -->
<OPTION VALUE=STR_ZOOM_PAGE_WIDTH id="idPageWidth">Page Width</OPTION>
<OPTION VALUE=STR_ZOOM_WHOLE_PAGE id="idWholePage">Whole Page</OPTION>
<OPTION VALUE=STR_ZOOM_TWO_PAGES id="idTwoPages" >Two Pages </OPTION>
</SELECT></TD>
<TD class="UISeparator" id="separatorFrameset" style="display:none"><IMG width=0 height=0></TD>
<TD class="UIPane" id="cellFrameset" style="display:none"> <SELECT id="selectFrameset" accesskey=f>
<OPTION VALUE=STR_FRAMESET_LAID_OUT id="idLaidOut">As laid out on screen</OPTION>
<OPTION VALUE=STR_FRAMESET_SELECTED id="idSelected">Only the selected frame</OPTION>
<OPTION VALUE=STR_FRAMESET_SEPARATE id="idSeparate">All frames individually</OPTION>
</SELECT></TD>
<TD class="UISeparator"><IMG width=0 height=0></TD>
<TD class="UIPane"> <BUTTON id="butHelp" title="Print Preview Help (Alt+H)" accesskey=h><U>H</U>elp</BUTTON></TD>
<TD class="UISeparator"><IMG width=0 height=0></TD>
<TD class="UIPane"> <BUTTON id="butClose" title="Close Print Preview (Alt+C)" accessKey=c><U>C</U>lose</BUTTON></TD>
</TR></TABLE>
</DIV>
</DIV>
<DIV id=OverflowContainer onclick="this.focus();" onfocus="butPrint.scrollIntoView();" tabindex=1 style="position:absolute; left:0; width:100%; overflow:auto; border:'thin threedhighlight inset'; background:threedshadow;">
<DIV id=MasterContainer tabindex=0 style="width:100%; position:absolute;">
<!-- Pages go here -->
</DIV>
#ifdef DEBUG
<!-- Div used to log template events for debugging only. No need to localize! -->
<DIV id=LogContainer style="display:none; position:absolute; background:C0FFC0; top:0px; left:0px; height:100%; width:100%; overflow-y:scroll; overflow-x:auto;"></DIV>
#endif
</DIV>
</BODY>
</HTML>