322 lines
8.6 KiB
JavaScript
322 lines
8.6 KiB
JavaScript
/* -*- Mode: Java; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public
|
|
* License Version 1.1 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
* implied. See the License for the specific language governing
|
|
* rights and limitations under the License.
|
|
*
|
|
* The Original Code is mozilla.org code.
|
|
*
|
|
* The Initial Developer of the Original Code is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 2000 Netscape Communications Corporation. All
|
|
* Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*/
|
|
|
|
/* Main Composer window debug menu functions */
|
|
|
|
// --------------------------- Output ---------------------------
|
|
|
|
function EditorGetText()
|
|
{
|
|
if (editorShell) {
|
|
dump("Getting text\n");
|
|
var outputText = editorShell.GetContentsAs("text/plain", 2);
|
|
dump(outputText + "\n");
|
|
}
|
|
}
|
|
|
|
function EditorGetHTML()
|
|
{
|
|
if (editorShell) {
|
|
dump("Getting HTML\n");
|
|
var outputHTML = editorShell.GetContentsAs("text/html", 0);
|
|
dump(outputHTML + "\n");
|
|
}
|
|
}
|
|
|
|
function EditorGetXIF()
|
|
{
|
|
if (window.editorShell) {
|
|
dump("Getting XIF\n");
|
|
var outputHTML = editorShell.GetContentsAs("text/xif", 2);
|
|
dump(outputHTML + "\n");
|
|
}
|
|
}
|
|
|
|
function EditorDumpContent()
|
|
{
|
|
if (window.editorShell) {
|
|
dump("============== Content Tree: ================\n");
|
|
window.editorShell.DumpContentTree();
|
|
}
|
|
}
|
|
|
|
function EditorInsertText(textToInsert)
|
|
{
|
|
editorShell.InsertText(textToInsert);
|
|
}
|
|
|
|
function EditorTestSelection()
|
|
{
|
|
dump("Testing selection\n");
|
|
var selection = editorShell.editorSelection;
|
|
if (!selection)
|
|
{
|
|
dump("No selection!\n");
|
|
return;
|
|
}
|
|
|
|
dump("Selection contains:\n");
|
|
dump(selection.toString() + "\n");
|
|
|
|
var output;
|
|
|
|
dump("\n====== Selection as XIF =======================\n");
|
|
output = editorShell.GetContentsAs("text/xif", 1);
|
|
dump(output + "\n\n");
|
|
|
|
dump("====== Selection as unformatted text ==========\n");
|
|
output = editorShell.GetContentsAs("text/plain", 1);
|
|
dump(output + "\n\n");
|
|
|
|
dump("====== Selection as formatted text ============\n");
|
|
output = editorShell.GetContentsAs("text/plain", 3);
|
|
dump(output + "\n\n");
|
|
|
|
dump("====== Selection as HTML ======================\n");
|
|
output = editorShell.GetContentsAs("text/html", 1);
|
|
dump(output + "\n\n");
|
|
|
|
dump("====== Length and status =====================\n");
|
|
output = "Document is ";
|
|
if (editorShell.documentIsEmpty)
|
|
output += "empty\n";
|
|
else
|
|
output += "not empty\n";
|
|
output += "Document length is " + editorShell.documentLength + " characters";
|
|
dump(output + "\n\n");
|
|
}
|
|
|
|
function EditorTestTableLayout()
|
|
{
|
|
var table = editorShell.GetElementOrParentByTagName("table", null);
|
|
if (!table) {
|
|
dump("Enclosing Table not found: Place caret in a table cell to do this test\n\n");
|
|
return;
|
|
}
|
|
|
|
var cell;
|
|
var startRowIndexObj = new Object();
|
|
var startColIndexObj = new Object();
|
|
var rowSpanObj = new Object();
|
|
var colSpanObj = new Object();
|
|
var actualRowSpanObj = new Object();
|
|
var actualColSpanObj = new Object();
|
|
var isSelectedObj = new Object();
|
|
var startRowIndex = 0;
|
|
var startColIndex = 0;
|
|
var rowSpan;
|
|
var colSpan;
|
|
var actualRowSpan;
|
|
var actualColSpan;
|
|
var isSelected;
|
|
var col = 0;
|
|
var row = 0;
|
|
var rowCount = 0;
|
|
var maxColCount = 0;
|
|
var doneWithRow = false;
|
|
var doneWithCol = false;
|
|
|
|
dump("\n\n\n************ Starting Table Layout test ************\n");
|
|
|
|
// Note: We could also get the number of rows, cols and use for loops,
|
|
// but this tests using out-of-bounds offsets to detect end of row or column
|
|
|
|
while (!doneWithRow) // Iterate through rows
|
|
{
|
|
dump("* Data for ROW="+row+":\n");
|
|
while(!doneWithCol) // Iterate through cells in the row
|
|
{
|
|
try {
|
|
cell = editorShell.GetCellDataAt(table, row, col, startRowIndexObj, startColIndexObj,
|
|
rowSpanObj, colSpanObj, actualRowSpanObj, actualColSpanObj,
|
|
isSelectedObj);
|
|
|
|
if (cell)
|
|
{
|
|
rowSpan = rowSpanObj.value;
|
|
colSpan = colSpanObj.value;
|
|
actualRowSpan = actualRowSpanObj.value;
|
|
actualColSpan = actualColSpanObj.value;
|
|
isSelected = isSelectedObj.value;
|
|
|
|
dump(" Row="+row+", Col="+col+" StartRow="+startRowIndexObj.value+", StartCol="+startColIndexObj.value+"\n");
|
|
dump(" RowSpan="+rowSpan+", ColSpan="+colSpan+" ActualRowSpan="+actualRowSpan+", ActualColSpan="+actualColSpan);
|
|
if (isSelected)
|
|
dump(" Cell is selected\n");
|
|
else
|
|
dump(" Cell is NOT selected\n");
|
|
|
|
// Save the indexes of a cell that will span across the cellmap grid
|
|
if (rowSpan > 1)
|
|
startRowIndex = startRowIndexObj.value;
|
|
if (colSpan > 1)
|
|
startColIndex = startColIndexObj.value;
|
|
|
|
// Initialize these for efficient spanned-cell search
|
|
startRowIndexObj.value = startRowIndex;
|
|
startColIndexObj.value = startColIndex;
|
|
|
|
col++;
|
|
} else {
|
|
doneWithCol = true;
|
|
// Get maximum number of cells in any row
|
|
if (col > maxColCount)
|
|
maxColCount = col;
|
|
dump(" End of row found\n\n");
|
|
}
|
|
}
|
|
catch (e) {
|
|
dump(" *** GetCellDataAt failed at Row="+row+", Col="+col+" ***\n\n");
|
|
return;
|
|
}
|
|
}
|
|
if (col == 0) {
|
|
// Didn't find a cell in the first col of a row,
|
|
// thus no more rows in table
|
|
doneWithRow = true;
|
|
rowCount = row;
|
|
dump("No more rows in table\n\n");
|
|
} else {
|
|
// Setup for next row
|
|
col = 0;
|
|
row++;
|
|
doneWithCol = false;
|
|
}
|
|
}
|
|
dump("Counted during scan: Number of rows="+rowCount+" Number of Columns="+maxColCount+"\n");
|
|
rowCount = editorShell.GetTableRowCount(table);
|
|
maxColCount = editorShell.GetTableColumnCount(table);
|
|
dump("From nsITableLayout: Number of rows="+rowCount+" Number of Columns="+maxColCount+"\n****** End of Table Layout Test *****\n\n");
|
|
}
|
|
|
|
function EditorShowEmbeddedObjects()
|
|
{
|
|
dump("\nEmbedded Objects:\n");
|
|
var objectArray = editorShell.GetEmbeddedObjects();
|
|
dump(objectArray.Count() + " embedded objects\n");
|
|
for (var i=0; i < objectArray.Count(); ++i)
|
|
dump(objectArray.GetElementAt(i) + "\n");
|
|
}
|
|
|
|
function EditorUnitTests()
|
|
{
|
|
dump("Running Unit Tests\n");
|
|
editorShell.RunUnitTests();
|
|
}
|
|
|
|
function EditorTestDocument()
|
|
{
|
|
dump("Getting document\n");
|
|
var theDoc = editorShell.editorDocument;
|
|
if (theDoc)
|
|
{
|
|
dump("Got the doc\n");
|
|
dump("Document name:" + theDoc.nodeName + "\n");
|
|
dump("Document type:" + theDoc.doctype + "\n");
|
|
}
|
|
else
|
|
{
|
|
dump("Failed to get the doc\n");
|
|
}
|
|
}
|
|
|
|
// --------------------------- Logging stuff ---------------------------
|
|
|
|
function EditorExecuteScript(fileSpec)
|
|
{
|
|
fileSpec.openStreamForReading();
|
|
|
|
var buf = { value:null };
|
|
var tmpBuf = { value:null };
|
|
var didTruncate = { value:false };
|
|
var lineNum = 0;
|
|
var ex;
|
|
|
|
// Log files can be quite huge, so read in a line
|
|
// at a time and execute it:
|
|
|
|
while (!fileSpec.eof())
|
|
{
|
|
buf.value = "";
|
|
didTruncate.value = true;
|
|
|
|
// Keep looping until we get a complete line of
|
|
// text, or we hit the end of file:
|
|
|
|
while (didTruncate.value && !fileSpec.eof())
|
|
{
|
|
didTruncate.value = false;
|
|
fileSpec.readLine(tmpBuf, 1024, didTruncate);
|
|
buf.value += tmpBuf.value;
|
|
|
|
// XXX Need to null out tmpBuf.value to avoid crashing
|
|
// XXX in some JavaScript string allocation method.
|
|
// XXX This is probably leaking the buffer allocated
|
|
// XXX by the readLine() implementation.
|
|
|
|
tmpBuf.value = null;
|
|
}
|
|
|
|
++lineNum;
|
|
|
|
try { eval(buf.value); }
|
|
catch(ex) { dump("Playback ERROR: Line " + lineNum + " " + ex + "\n"); return; }
|
|
}
|
|
|
|
buf.value = null;
|
|
}
|
|
|
|
function EditorGetScriptFileSpec()
|
|
{
|
|
var fs = Components.classes["component://netscape/filespec"].createInstance();
|
|
fs = fs.QueryInterface(Components.interfaces.nsIFileSpec);
|
|
fs.unixStyleFilePath = "journal.js";
|
|
return fs;
|
|
}
|
|
|
|
function EditorStartLog()
|
|
{
|
|
var fs;
|
|
|
|
fs = EditorGetScriptFileSpec();
|
|
editorShell.StartLogging(fs);
|
|
contentWindow.focus();
|
|
|
|
fs = null;
|
|
}
|
|
|
|
function EditorStopLog()
|
|
{
|
|
editorShell.StopLogging();
|
|
contentWindow.focus();
|
|
}
|
|
|
|
function EditorRunLog()
|
|
{
|
|
var fs;
|
|
fs = EditorGetScriptFileSpec();
|
|
EditorExecuteScript(fs);
|
|
contentWindow.focus();
|
|
}
|
|
|
|
|