App-SocialCalc-Multiplayer
view release on metacpan or search on metacpan
socialcalc/socialcalctableeditor.js view on Meta::CPAN
SocialCalc.TableEditor = function(context) {
var scc = SocialCalc.Constants;
// Properties:
this.context = context; // editing context
this.toplevel = null; // top level HTML element for this table editor
this.fullgrid = null; // rendered editing context
this.noEdit = false; // if true, disable all edit UI and make read-only
this.width = null;
this.tablewidth = null;
this.height = null;
this.tableheight = null;
this.inputBox = null;
this.inputEcho = null;
this.verticaltablecontrol = null;
this.horizontaltablecontrol = null;
this.logo = null;
this.cellhandles = null;
// Dynamic properties:
this.timeout = null; // if non-null, timer id for position calculations
this.busy = false; // true when executing command, calculating, etc.
this.ensureecell = false; // if true, ensure ecell is visible after timeout
this.deferredCommands = []; // commands to execute after busy, in form: {cmdstr: "cmds", saveundo: t/f}
this.gridposition = null; // screen coords of full grid
this.headposition = null; // screen coords of upper left of grid within header rows
this.firstscrollingrow = null; // row number of top row in last (the scrolling) pane
this.firstscrollingrowtop = null; // position of top row in last (the scrolling) pane
this.lastnonscrollingrow = null; // row number of last displayed row in last non-scrolling
// pane, or zero (for thumb position calculations)
this.lastvisiblerow = null; // used for paging down
this.firstscrollingcol = null; // column number of top col in last (the scrolling) pane
this.firstscrollingcolleft = null; // position of top col in last (the scrolling) pane
this.lastnonscrollingcol = null; // col number of last displayed column in last non-scrolling
// pane, or zero (for thumb position calculations)
this.lastvisiblecol = null; // used for paging right
this.rowpositions = []; // screen positions of the top of some rows
this.colpositions = []; // screen positions of the left side of some rows
this.rowheight = []; // size in pixels of each row when last checked, or null/undefined, for page up
this.colwidth = []; // size in pixels of each column when last checked, or null/undefined, for page left
this.ecell = null; // either null or {coord: c, row: r, col: c}
this.state = "start"; // the keyboard states: see EditorProcessKey
this.workingvalues = {}; // values used during keyboard editing, etc.
// Constants:
this.imageprefix = scc.defaultImagePrefix; // URL prefix for images (e.g., "/images/sc")
this.idPrefix = scc.defaultTableEditorIDPrefix;
this.pageUpDnAmount = scc.defaultPageUpDnAmount; // number of rows to move cursor on PgUp/PgDn keys (numeric)
// Callbacks
// recalcFunction: if present, function(editor) {...}, called to do a recalc
// Default (sheet.RecalcSheet) does all the right stuff.
this.recalcFunction = function(editor) {
if (editor.context.sheetobj.RecalcSheet) {
editor.context.sheetobj.RecalcSheet(SocialCalc.EditorSheetStatusCallback, editor);
}
else return null;
};
// ctrlkeyFunction: if present, function(editor, charname) {...}, called to handle ctrl-V, etc., at top level
// Returns true (pass through for continued processing) or false (stop processing this key).
this.ctrlkeyFunction = function(editor, charname) {
var ta, ha, cell, position, cmd, sel, cliptext;
switch (charname) {
case "[ctrl-c]":
case "[ctrl-x]":
ta = editor.pasteTextarea;
ta.value = "";
cell=SocialCalc.GetEditorCellElement(editor, editor.ecell.row, editor.ecell.col);
if (cell) {
position = SocialCalc.GetElementPosition(cell.element);
ta.style.left = (position.left-1)+"px";
ta.style.top = (position.top-1)+"px";
}
if (editor.range.hasrange) {
sel = SocialCalc.crToCoord(editor.range.left, editor.range.top)+
":"+SocialCalc.crToCoord(editor.range.right, editor.range.bottom);
}
else {
sel = editor.ecell.coord;
}
// get what to copy to clipboard
cliptext = SocialCalc.ConvertSaveToOtherFormat(SocialCalc.CreateSheetSave(editor.context.sheetobj, sel), "tab");
if (charname == "[ctrl-c]" || editor.noEdit) { // if copy or cut but in no edit
cmd = "copy "+sel+" formulas";
}
else { // [ctrl-x]
cmd = "cut "+sel+" formulas";
}
editor.EditorScheduleSheetCommands(cmd, true, false); // queue up command to put on SocialCalc clipboard
/* Copy as HTML: This fails rather badly as it won't paste into Notepad as tab-delimited text. Oh well.
ha = editor.pasteHTMLarea;
if (editor.range.hasrange) {
cell = SocialCalc.GetEditorCellElement(editor, editor.range.top, editor.range.left);
}
else {
cell = SocialCalc.GetEditorCellElement(editor, editor.ecell.row, editor.ecell.col);
}
if (cell) position = SocialCalc.GetElementPosition(cell.element);
socialcalc/socialcalctableeditor.js view on Meta::CPAN
else {
if (editor.range.hasrange) {
sel = SocialCalc.crToCoord(editor.range.left, editor.range.top)+
":"+SocialCalc.crToCoord(editor.range.right, editor.range.bottom);
}
else {
sel = editor.ecell.coord;
}
cmd = "set "+sel+" nontextvalueformat "+newntvf;
}
editor.EditorScheduleSheetCommands(cmd, true, false);
}
},
200);
return false;
default:
break;
}
return true;
};
// Set sheet's status callback:
context.sheetobj.statuscallback = SocialCalc.EditorSheetStatusCallback;
context.sheetobj.statuscallbackparams = this; // this object: the table editor object
// StatusCallback: all values are called at appropriate times, add with unique name, delete when done
//
// Each value must be an object in the form of:
//
// func: function(editor, status, arg, params) {...},
// params: params value to call func with
//
// The values for status and arg are:
//
// all the SocialCalc RecalcSheet statuscallbacks, including:
//
// calccheckdone, calclist length
// calcorder, {coord: coord, total: celllist length, count: count}
// calcstep, {coord: coord, total: calclist length, count: count}
// calcfinished, time in milliseconds
//
// the command callbacks, like cmdstart and cmdend
// cmdendnorender
//
// calcstart, null
// moveecell, new ecell coord
// rangechange, "coord:coord" or "coord" or ""
// specialkey, keyname ("[esc]")
//
this.StatusCallback = {};
this.MoveECellCallback = {}; // all values are called with editor as arg; add with unique name, delete when done
this.RangeChangeCallback = {}; // all values are called with editor as arg; add with unique name, delete when done
this.SettingsCallbacks = {}; // See SocialCalc.SaveEditorSettings
// Set initial cursor
this.ecell = {coord: "A1", row: 1, col: 1};
context.highlights[this.ecell.coord] = "cursor";
// Initialize range data
// Range has at least hasrange (true/false).
// It may also have: anchorcoord, anchorrow, anchorcol, top, bottom, left, and right.
this.range = {hasrange: false};
// Initialize range2 data (used to show selections, such as for move)
// Range2 has at least hasrange (true/false).
// It may also have: top, bottom, left, and right.
this.range2 = {hasrange: false};
}
// Methods:
SocialCalc.TableEditor.prototype.CreateTableEditor = function(width, height) {return SocialCalc.CreateTableEditor(this, width, height);};
SocialCalc.TableEditor.prototype.ResizeTableEditor = function(width, height) {return SocialCalc.ResizeTableEditor(this, width, height);};
SocialCalc.TableEditor.prototype.SaveEditorSettings = function() {return SocialCalc.SaveEditorSettings(this);};
SocialCalc.TableEditor.prototype.LoadEditorSettings = function(str, flags) {return SocialCalc.LoadEditorSettings(this, str, flags);};
SocialCalc.TableEditor.prototype.EditorRenderSheet = function() {SocialCalc.EditorRenderSheet(this);};
SocialCalc.TableEditor.prototype.EditorScheduleSheetCommands = function(cmdstr, saveundo, ignorebusy) {SocialCalc.EditorScheduleSheetCommands(this, cmdstr, saveundo, ignorebusy);};
SocialCalc.TableEditor.prototype.ScheduleSheetCommands = function(cmdstr, saveundo) {
this.context.sheetobj.ScheduleSheetCommands(cmdstr, saveundo);
};
SocialCalc.TableEditor.prototype.SheetUndo = function() {
this.context.sheetobj.SheetUndo();
};
SocialCalc.TableEditor.prototype.SheetRedo = function() {
this.context.sheetobj.SheetRedo();
};
SocialCalc.TableEditor.prototype.EditorStepSet = function(status, arg) {SocialCalc.EditorStepSet(this, status, arg);};
SocialCalc.TableEditor.prototype.GetStatuslineString = function(status, arg, params) {return SocialCalc.EditorGetStatuslineString(this, status, arg, params);};
SocialCalc.TableEditor.prototype.EditorMouseRegister = function() {return SocialCalc.EditorMouseRegister(this);};
SocialCalc.TableEditor.prototype.EditorMouseUnregister = function() {return SocialCalc.EditorMouseUnregister(this);};
SocialCalc.TableEditor.prototype.EditorMouseRange = function(coord) {return SocialCalc.EditorMouseRange(this, coord);};
SocialCalc.TableEditor.prototype.EditorProcessKey = function(ch, e) {return SocialCalc.EditorProcessKey(this, ch, e);};
SocialCalc.TableEditor.prototype.EditorAddToInput = function(str, prefix) {return SocialCalc.EditorAddToInput(this, str, prefix);};
SocialCalc.TableEditor.prototype.DisplayCellContents = function() {return SocialCalc.EditorDisplayCellContents(this);};
SocialCalc.TableEditor.prototype.EditorSaveEdit = function(text) {return SocialCalc.EditorSaveEdit(this, text);};
SocialCalc.TableEditor.prototype.EditorApplySetCommandsToRange = function(cmdline, type) {return SocialCalc.EditorApplySetCommandsToRange(this, cmdline, type);};
SocialCalc.TableEditor.prototype.MoveECellWithKey = function(ch) {return SocialCalc.MoveECellWithKey(this, ch);};
SocialCalc.TableEditor.prototype.MoveECell = function(newcell) {return SocialCalc.MoveECell(this, newcell);};
SocialCalc.TableEditor.prototype.ReplaceCell = function(cell, row, col) {SocialCalc.ReplaceCell(this, cell, row, col);};
SocialCalc.TableEditor.prototype.UpdateCellCSS = function(cell, row, col) {SocialCalc.UpdateCellCSS(this, cell, row, col);};
SocialCalc.TableEditor.prototype.SetECellHeaders = function(selected) {SocialCalc.SetECellHeaders(this, selected);};
SocialCalc.TableEditor.prototype.EnsureECellVisible = function() {SocialCalc.EnsureECellVisible(this);};
SocialCalc.TableEditor.prototype.RangeAnchor = function(coord) {SocialCalc.RangeAnchor(this, coord);};
SocialCalc.TableEditor.prototype.RangeExtend = function(coord) {SocialCalc.RangeExtend(this, coord);};
SocialCalc.TableEditor.prototype.RangeRemove = function() {SocialCalc.RangeRemove(this);};
SocialCalc.TableEditor.prototype.Range2Remove = function() {SocialCalc.Range2Remove(this);};
SocialCalc.TableEditor.prototype.FitToEditTable = function() {SocialCalc.FitToEditTable(this);};
SocialCalc.TableEditor.prototype.CalculateEditorPositions = function() {SocialCalc.CalculateEditorPositions(this);};
SocialCalc.TableEditor.prototype.ScheduleRender = function() {SocialCalc.ScheduleRender(this);};
SocialCalc.TableEditor.prototype.DoRenderStep = function() {SocialCalc.DoRenderStep(this);};
SocialCalc.TableEditor.prototype.SchedulePositionCalculations = function() {SocialCalc.SchedulePositionCalculations(this);};
SocialCalc.TableEditor.prototype.DoPositionCalculations = function() {SocialCalc.DoPositionCalculations(this);};
SocialCalc.TableEditor.prototype.CalculateRowPositions = function(panenum, positions, sizes) {return SocialCalc.CalculateRowPositions(this, panenum, positions, sizes);};
SocialCalc.TableEditor.prototype.CalculateColPositions = function(panenum, positions, sizes) {return SocialCalc.CalculateColPositions(this, panenum, positions, sizes);};
SocialCalc.TableEditor.prototype.ScrollRelative = function(vertical, amount) {SocialCalc.ScrollRelative(this, vertical, amount);};
SocialCalc.TableEditor.prototype.ScrollRelativeBoth = function(vamount, hamount) {SocialCalc.ScrollRelativeBoth(this, vamount, hamount);};
SocialCalc.TableEditor.prototype.PageRelative = function(vertical, direction) {SocialCalc.PageRelative(this, vertical, direction);};
SocialCalc.TableEditor.prototype.LimitLastPanes = function() {SocialCalc.LimitLastPanes(this);};
SocialCalc.TableEditor.prototype.ScrollTableUpOneRow = function() {return SocialCalc.ScrollTableUpOneRow(this);};
SocialCalc.TableEditor.prototype.ScrollTableDownOneRow = function() {return SocialCalc.ScrollTableDownOneRow(this);};
SocialCalc.TableEditor.prototype.ScrollTableLeftOneCol = function() {return SocialCalc.ScrollTableLeftOneCol(this);};
SocialCalc.TableEditor.prototype.ScrollTableRightOneCol = function() {return SocialCalc.ScrollTableRightOneCol(this);};
// Functions:
SocialCalc.CreateTableEditor = function(editor, width, height) {
var scc = SocialCalc.Constants;
var AssignID = SocialCalc.AssignID;
editor.toplevel = document.createElement("div");
editor.width = width;
editor.height = height;
editor.griddiv = document.createElement("div");
editor.tablewidth = Math.max(0, width - scc.defaultTableControlThickness);
editor.tableheight = Math.max(0, height - scc.defaultTableControlThickness);
editor.griddiv.style.width=editor.tablewidth+"px";
editor.griddiv.style.height=editor.tableheight+"px";
editor.griddiv.style.overflow="hidden";
editor.griddiv.style.cursor="default";
if (scc.cteGriddivClass) editor.griddiv.className = scc.cteGriddivClass;
AssignID(editor, editor.griddiv, "griddiv");
editor.FitToEditTable();
editor.EditorRenderSheet();
editor.griddiv.appendChild(editor.fullgrid);
editor.verticaltablecontrol = new SocialCalc.TableControl(editor, true, editor.tableheight);
editor.verticaltablecontrol.CreateTableControl();
AssignID(editor, editor.verticaltablecontrol.main, "tablecontrolv");
editor.horizontaltablecontrol = new SocialCalc.TableControl(editor, false, editor.tablewidth);
editor.horizontaltablecontrol.CreateTableControl();
AssignID(editor, editor.horizontaltablecontrol.main, "tablecontrolh");
var table, tbody, tr, td, img, anchor, ta, ha;
table = document.createElement("table");
editor.layouttable = table;
table.cellSpacing = 0;
table.cellPadding = 0;
AssignID(editor, table, "layouttable");
tbody = document.createElement("tbody");
table.appendChild(tbody);
tr = document.createElement("tr");
tbody.appendChild(tr);
td = document.createElement("td");
td.appendChild(editor.griddiv);
tr.appendChild(td);
td = document.createElement("td");
td.appendChild(editor.verticaltablecontrol.main);
tr.appendChild(td);
tr = document.createElement("tr");
tbody.appendChild(tr);
td = document.createElement("td");
td.appendChild(editor.horizontaltablecontrol.main);
tr.appendChild(td);
td = document.createElement("td"); // logo display: Required by CPAL License for this code!
td.style.background="url("+editor.imageprefix+"logo.gif) no-repeat center center";
td.innerHTML = "<div style='cursor:pointer;font-size:1px;'><img src='"+editor.imageprefix+"1x1.gif' border='0' width='18' height='18'></div>";
tr.appendChild(td);
editor.logo = td;
AssignID(editor, editor.logo, "logo");
SocialCalc.TooltipRegister(td.firstChild.firstChild, "SocialCalc", null);
editor.toplevel.appendChild(editor.layouttable);
if (!editor.noEdit) {
editor.inputEcho = new SocialCalc.InputEcho(editor);
AssignID(editor, editor.inputEcho.main, "inputecho");
}
editor.cellhandles = new SocialCalc.CellHandles(editor);
ta = document.createElement("textarea"); // used for ctrl-c/ctrl-v where an invisible text area is needed
SocialCalc.setStyles(ta, "display:none;position:absolute;height:1px;width:1px;opacity:0;filter:alpha(opacity=0);");
ta.value = "";
editor.pasteTextarea = ta;
AssignID(editor, editor.pasteTextarea, "pastetextarea");
if (navigator.userAgent.match(/Safari\//) &&!navigator.userAgent.match(/Chrome\//)) { // special code for Safari 5 change
window.removeEventListener('beforepaste', SocialCalc.SafariPasteFunction, false);
window.addEventListener('beforepaste', SocialCalc.SafariPasteFunction, false);
window.removeEventListener('beforecopy', SocialCalc.SafariPasteFunction, false);
window.addEventListener('beforecopy', SocialCalc.SafariPasteFunction, false);
window.removeEventListener('beforecut', SocialCalc.SafariPasteFunction, false);
window.addEventListener('beforecut', SocialCalc.SafariPasteFunction, false);
}
editor.toplevel.appendChild(editor.pasteTextarea);
var div = document.createElement("div");
div.innerHTML = ' <br/>';
if (div.firstChild.nodeType == 1) {
/* We are running in IE -- Using HTML-based area for Ctrl-V */
ha = document.createElement("div"); // used for ctrl-v where an invisible html area is needed
editor.pasteHTMLarea = ha;
editor.toplevel.appendChild(editor.pasteHTMLarea);
ha.contentEditable = true;
AssignID(editor, editor.pasteHTMLarea, "pastehtmlarea");
SocialCalc.setStyles(ha, "display:block;visibility:hidden;position:absolute;height:1px;width:1px;opacity:0;filter:alpha(opacity=0);overflow:hidden");
}
SocialCalc.MouseWheelRegister(editor.toplevel, {WheelMove: SocialCalc.EditorProcessMouseWheel, editor: editor});
if (editor.inputBox) { // this seems to fix an obscure bug with Firefox 2 Mac where Ctrl-V doesn't get fired right
if (editor.inputBox.element) {
editor.inputBox.element.focus();
editor.inputBox.element.blur();
}
}
SocialCalc.KeyboardSetFocus(editor);
// do status reporting things
SocialCalc.EditorSheetStatusCallback(null, "startup", null, editor);
// done
return editor.toplevel;
socialcalc/socialcalctableeditor.js view on Meta::CPAN
if (editor.ecell) {
result += "ecell:"+editor.ecell.coord+"\n";
}
if (range.hasrange) {
result += "range:"+range.anchorcoord+":"+range.top+":"+range.bottom+":"+range.left+":"+range.right+"\n";
}
for (setting in editor.SettingsCallbacks) {
result += editor.SettingsCallbacks[setting].save(editor, setting);
}
return result;
}
//
// LoadEditorSettings(editor, str, flags)
//
// Sets the editor settings based on str. See SocialCalc.SaveEditorSettings for more details.
// Unrecognized lines are ignored.
//
SocialCalc.LoadEditorSettings = function(editor, str, flags) {
var lines=str.split(/\r\n|\n/);
var parts=[];
var line, i, cr, row, col, coord, setting;
var context = editor.context;
var highlights, range;
context.rowpanes = [{first: 1, last: 1}]; // reset to start
context.colpanes = [{first: 1, last: 1}];
editor.ecell = null;
editor.range = {hasrange: false};
editor.range2 = {hasrange: false};
range = editor.range;
context.highlights = {};
highlights = context.highlights;
for (i=0; i<lines.length; i++) {
line=lines[i];
parts = line.split(":");
setting = parts[0];
switch (setting) {
case "version":
break;
case "rowpane":
context.rowpanes[parts[1]-0] = {first: parts[2]-0, last: parts[3]-0};
break;
case "colpane":
context.colpanes[parts[1]-0] = {first: parts[2]-0, last: parts[3]-0};
break;
case "ecell":
editor.ecell = SocialCalc.coordToCr(parts[1]);
editor.ecell.coord = parts[1];
highlights[parts[1]] = "cursor";
break;
case "range":
range.hasrange = true;
range.anchorcoord = parts[1];
cr = SocialCalc.coordToCr(range.anchorcoord);
range.anchorrow = cr.row;
range.anchorcol = cr.col;
range.top = parts[2]-0;
range.bottom = parts[3]-0;
range.left = parts[4]-0;
range.right = parts[5]-0;
for (row=range.top; row<=range.bottom; row++) {
for (col=range.left; col<=range.right; col++) {
coord = SocialCalc.crToCoord(col, row);
if (highlights[coord]!="cursor") {
highlights[coord] = "range";
}
}
}
break;
default:
if (editor.SettingsCallbacks[setting]) {
editor.SettingsCallbacks[setting].load(editor, setting, line, flags);
}
break;
}
}
return;
}
//
// EditorRenderSheet(editor)
//
// Renders the sheet and updates editor.fullgrid.
// Sets event handlers.
//
SocialCalc.EditorRenderSheet = function(editor) {
editor.EditorMouseUnregister();
editor.fullgrid = editor.context.RenderSheet(editor.fullgrid);
if (editor.ecell) editor.SetECellHeaders("selected");
SocialCalc.AssignID(editor, editor.fullgrid, "fullgrid"); // give it an id
editor.EditorMouseRegister();
}
//
// EditorScheduleSheetCommands(editor, cmdstr, saveundo, ignorebusy)
//
SocialCalc.EditorScheduleSheetCommands = function(editor, cmdstr, saveundo, ignorebusy) {
if (editor.state!="start" && !ignorebusy) { // ignore commands if editing a cell
return;
}
if (editor.busy && !ignorebusy) { // hold off on commands if doing one
editor.deferredCommands.push({cmdstr: cmdstr, saveundo: saveundo});
return;
}
switch (cmdstr) {
case "recalc":
case "redisplay":
editor.context.sheetobj.ScheduleSheetCommands(cmdstr, false);
break;
socialcalc/socialcalctableeditor.js view on Meta::CPAN
}
signalstatus(status);
return;
}
// Timer-driven steps for use with SocialCalc.EditorSheetStatusCallback
SocialCalc.EditorStepInfo = {
// status: "", // saved value to pass to callback
editor: null // for callback
// arg: null, // for callback
// timerobj: null
};
/*
SocialCalc.EditorStepSet = function(editor, status, arg) {
var esi = SocialCalc.EditorStepInfo;
addmsg("step: "+status);
if (esi.timerobj) {
alert("Already waiting. Old/new: "+esi.status+"/"+status);
}
esi.editor = editor;
esi.status = status;
esi.timerobj = window.setTimeout(SocialCalc.EditorStepDone, 1);
}
SocialCalc.EditorStepDone = function() {
var esi = SocialCalc.EditorStepInfo;
esi.timerobj = null;
SocialCalc.EditorSheetStatusCallback(null, esi.status, null, esi.editor);
}
*/
//
// str = SocialCalc.EditorGetStatuslineString(editor, status, arg, params)
//
// Assumes params is an object where it can use "calculating" and "command"
// to keep track of state.
// Returns string for status line.
//
SocialCalc.EditorGetStatuslineString = function(editor, status, arg, params) {
var scc = SocialCalc.Constants;
var sstr, progress, coord, circ, r, c, cell, sum, ele;
progress = "";
switch (status) {
case "moveecell":
case "rangechange":
case "startup":
break;
case "cmdstart":
params.command = true;
document.body.style.cursor = "progress";
editor.griddiv.style.cursor = "progress";
progress = scc.s_statusline_executing;
break;
case "cmdextension":
progress = "Command Extension: "+arg;
break;
case "cmdend":
params.command = false;
break;
case "schedrender":
progress = scc.s_statusline_displaying;
break;
case "renderdone":
progress = " ";
break;
case "schedposcalc":
progress = scc.s_statusline_displaying;
break;
case "cmdendnorender":
case "doneposcalc":
document.body.style.cursor = "default";
editor.griddiv.style.cursor = "default";
break;
case "calcorder":
progress = scc.s_statusline_ordering+Math.floor(100*arg.count/(arg.total||1))+"%";
break;
case "calcstep":
progress = scc.s_statusline_calculating+Math.floor(100*arg.count/(arg.total||1))+"%";
break;
case "calcloading":
progress = scc.s_statusline_calculatingls+": "+arg.sheetname;
break;
case "calcserverfunc":
progress = scc.s_statusline_calculating+Math.floor(100*arg.count/(arg.total||1))+"%, "+scc.s_statusline_doingserverfunc+arg.funcname+scc.s_statusline_incell+arg.coord;
break;
case "calcstart":
params.calculating = true;
document.body.style.cursor = "progress";
editor.griddiv.style.cursor = "progress"; // griddiv has an explicit cursor style
progress = scc.s_statusline_calcstart;
break;
case "calccheckdone":
break;
case "calcfinished":
params.calculating = false;
break;
default:
progress = status;
break;
}
if (!progress && params.calculating) {
progress = scc.s_statusline_calculating;
}
// if there is a range, calculate sum (not during busy times)
if (!params.calculating && !params.command && !progress && editor.range.hasrange
&& (editor.range.left!=editor.range.right || editor.range.top!=editor.range.bottom)) {
sum = 0;
for (r=editor.range.top; r <= editor.range.bottom; r++) {
for (c=editor.range.left; c <= editor.range.right; c++) {
cell = editor.context.sheetobj.cells[SocialCalc.crToCoord(c, r)];
if (!cell) continue;
if (cell.valuetype && cell.valuetype.charAt(0)=="n") {
sum += cell.datavalue-0;
}
}
}
sum = SocialCalc.FormatNumber.formatNumberWithFormat(sum, "[,]General", "");
coord = SocialCalc.crToCoord(editor.range.left, editor.range.top) + ":" +
SocialCalc.crToCoord(editor.range.right, editor.range.bottom);
progress = coord + " (" + (editor.range.right-editor.range.left+1) + "x" + (editor.range.bottom-editor.range.top+1) +
") "+scc.s_statusline_sum+"=" + sum + " " + progress;
}
sstr = editor.ecell.coord+" "+progress;
if (!params.calculating && editor.context.sheetobj.attribs.needsrecalc=="yes") {
sstr += ' '+scc.s_statusline_recalcneeded;
}
circ = editor.context.sheetobj.attribs.circularreferencecell;
if (circ) {
circ = circ.replace(/\|/, " referenced by ");
sstr += ' '+scc.s_statusline_circref + circ + '</span>';
}
return sstr;
}
//
// Mouse stuff
//
SocialCalc.EditorMouseInfo = {
socialcalc/socialcalctableeditor.js view on Meta::CPAN
SocialCalc.ProcessEditorColsizeMouseUp = function(e) {
var event = e || window.event;
var mouseinfo = SocialCalc.EditorMouseInfo;
var editor = mouseinfo.editor;
if (!editor) return; // not us, ignore
element = mouseinfo.element;
var viewport = SocialCalc.GetViewportInfo();
var clientX = event.clientX + viewport.horizontalScroll;
if (event.stopPropagation) event.stopPropagation(); // DOM Level 2
else event.cancelBubble = true; // IE 5+
if (event.preventDefault) event.preventDefault(); // DOM Level 2
else event.returnValue = false; // IE 5+
if (document.removeEventListener) { // DOM Level 2
document.removeEventListener("mousemove", SocialCalc.ProcessEditorColsizeMouseMove, true);
document.removeEventListener("mouseup", SocialCalc.ProcessEditorColsizeMouseUp, true);
}
else if (editor.toplevel.detachEvent) { // IE
editor.toplevel.detachEvent("onlosecapture", SocialCalc.ProcessEditorColsizeMouseUp);
editor.toplevel.detachEvent("onmouseup", SocialCalc.ProcessEditorColsizeMouseUp);
editor.toplevel.detachEvent("onmousemove", SocialCalc.ProcessEditorColsizeMouseMove);
editor.toplevel.releaseCapture();
}
var newsize = (editor.context.colwidth[mouseinfo.mouseresizecolnum]-0) + (clientX - mouseinfo.mousedownclientx);
if (newsize < SocialCalc.Constants.defaultMinimumColWidth) newsize = SocialCalc.Constants.defaultMinimumColWidth;
editor.EditorScheduleSheetCommands("set "+mouseinfo.mouseresizecol+" width "+newsize, true, false);
if (editor.timeout) window.clearTimeout(editor.timeout);
editor.timeout = window.setTimeout(SocialCalc.FinishColsize, 1); // wait - Firefox 2 has a bug otherwise with next mousedown
return false;
}
SocialCalc.FinishColsize = function() {
var mouseinfo = SocialCalc.EditorMouseInfo;
var editor = mouseinfo.editor;
if (!editor) return;
editor.toplevel.removeChild(mouseinfo.mouseresizedisplay);
mouseinfo.mouseresizedisplay = null;
// editor.FitToEditTable();
// editor.EditorRenderSheet();
// editor.SchedulePositionCalculations();
mouseinfo.editor = null;
return;
}
//
// Handle auto-repeat of dragging the cursor into the borders of the sheet
//
SocialCalc.AutoRepeatInfo = {
timer: null, // timer object for repeating
mouseinfo: null, // result from SocialCalc.GridMousePosition
repeatinterval: 1000, // milliseconds to wait between repeats
editor: null, // editor object to use when it repeats
repeatcallback: null // used instead of default when repeating (e.g., for cellhandles)
// called as: repeatcallback(newcoord, direction)
};
// Control auto-repeat. If mouseinfo==null, cancel.
SocialCalc.SetDragAutoRepeat = function(editor, mouseinfo, callback) {
var repeatinfo = SocialCalc.AutoRepeatInfo;
var coord, direction;
repeatinfo.repeatcallback = callback; // null in regular case
if (!mouseinfo) { // cancel
if (repeatinfo.timer) { // If was repeating, stop
window.clearTimeout(repeatinfo.timer); // cancel timer
repeatinfo.timer = null;
}
repeatinfo.mouseinfo = null;
return; // done
}
repeatinfo.editor = editor;
if (repeatinfo.mouseinfo) { // check for change while repeating
if (mouseinfo.rowheader || mouseinfo.rowfooter) {
if (mouseinfo.row != repeatinfo.mouseinfo.row) { // changed row while dragging sidewards
coord = SocialCalc.crToCoord(editor.ecell.col, mouseinfo.row); // change to it
if (repeatinfo.repeatcallback) {
if (mouseinfo.row < repeatinfo.mouseinfo.row) {
direction = "left";
}
else if (mouseinfo.row > repeatinfo.mouseinfo.row) {
direction = "right";
}
else {
direction = "";
}
repeatinfo.repeatcallback(coord, direction);
}
else {
editor.MoveECell(coord);
editor.MoveECell(coord);
editor.RangeExtend();
editor.EditorMouseRange(coord);
}
}
}
else if (mouseinfo.colheader || mouseinfo.colfooter) {
if (mouseinfo.col != repeatinfo.mouseinfo.col) { // changed col while dragging vertically
coord = SocialCalc.crToCoord(mouseinfo.col, editor.ecell.row); // change to it
socialcalc/socialcalctableeditor.js view on Meta::CPAN
default:
return null;
}
if (!editor.range.hasrange) {
if (shifted)
editor.RangeAnchor();
}
coord = editor.MoveECell(SocialCalc.crToCoord(col, row));
if (editor.range.hasrange) {
if (shifted)
editor.RangeExtend();
else
editor.RangeRemove();
}
return coord;
}
//
// cellcoord = MoveECell(editor, newecell)
//
// Takes a coordinate and returns the new edit cell coordinate (which may be
// different if newecell is covered by a span).
//
SocialCalc.MoveECell = function(editor, newcell) {
var cell, f;
var highlights = editor.context.highlights;
if (editor.ecell) {
if (editor.ecell.coord==newcell) return newcell; // already there - don't do anything and don't tell anybody
if (SocialCalc.Callbacks.broadcast) {
SocialCalc.Callbacks.broadcast('ecell', { original: editor.ecell.coord, ecell: newcell });
}
cell=SocialCalc.GetEditorCellElement(editor, editor.ecell.row, editor.ecell.col);
delete highlights[editor.ecell.coord];
if (editor.range2.hasrange &&
editor.ecell.row>=editor.range2.top && editor.ecell.row<=editor.range2.bottom &&
editor.ecell.col>=editor.range2.left && editor.ecell.col<=editor.range2.right) {
highlights[editor.ecell.coord] = "range2";
}
editor.UpdateCellCSS(cell, editor.ecell.row, editor.ecell.col);
editor.SetECellHeaders(""); // set to regular col/rowname styles
editor.cellhandles.ShowCellHandles(false);
}
else if (SocialCalc.Callbacks.broadcast) {
SocialCalc.Callbacks.broadcast('ecell', { ecell: newcell });
}
newcell = editor.context.cellskip[newcell] || newcell;
editor.ecell = SocialCalc.coordToCr(newcell);
editor.ecell.coord = newcell;
cell=SocialCalc.GetEditorCellElement(editor, editor.ecell.row, editor.ecell.col);
highlights[newcell] = "cursor";
for (f in editor.MoveECellCallback) { // let others know
editor.MoveECellCallback[f](editor);
}
editor.UpdateCellCSS(cell, editor.ecell.row, editor.ecell.col);
editor.SetECellHeaders("selected");
for (f in editor.StatusCallback) { // let status line, etc., know
editor.StatusCallback[f].func(editor, "moveecell", newcell, editor.StatusCallback[f].params);
}
if (editor.busy) {
editor.ensureecell = true; // wait for when not busy
}
else {
editor.ensureecell = false;
editor.EnsureECellVisible();
}
return newcell;
}
SocialCalc.EnsureECellVisible = function(editor) {
var vamount = 0;
var hamount = 0;
if (editor.ecell.row > editor.lastnonscrollingrow) {
if (editor.ecell.row < editor.firstscrollingrow) {
vamount = editor.ecell.row - editor.firstscrollingrow;
}
else if (editor.ecell.row > editor.lastvisiblerow) {
vamount = editor.ecell.row - editor.lastvisiblerow;
}
}
if (editor.ecell.col > editor.lastnonscrollingcol) {
if (editor.ecell.col < editor.firstscrollingcol) {
hamount = editor.ecell.col - editor.firstscrollingcol;
}
else if (editor.ecell.col > editor.lastvisiblecol) {
hamount = editor.ecell.col- editor.lastvisiblecol;
}
}
if (vamount!=0 || hamount!=0) {
editor.ScrollRelativeBoth(vamount, hamount);
}
else {
editor.cellhandles.ShowCellHandles(true);
}
}
SocialCalc.ReplaceCell = function(editor, cell, row, col) {
var newelement, a;
if (!cell) return;
newelement = editor.context.RenderCell(row, col, cell.rowpane, cell.colpane, true, null);
socialcalc/socialcalctableeditor.js view on Meta::CPAN
var highlights = editor.context.highlights;
var range = editor.range;
var range2 = editor.range2;
var ecell;
if (ecoord) {
ecell = SocialCalc.coordToCr(ecoord);
ecell.coord = ecoord;
}
else ecell = editor.ecell;
if (!ecell) return; // just in case
if (!range.hasrange) { // called without RangeAnchor...
range.anchorcoord = ecell.coord;
range.anchorrow = ecell.row;
range.top = ecell.row;
range.bottom = ecell.row;
range.anchorcol = ecell.col;
range.left = ecell.col;
range.right = ecell.col;
range.hasrange = true;
}
if (range.anchorrow < ecell.row) {
range.top = range.anchorrow;
range.bottom = ecell.row;
}
else {
range.top = ecell.row;
range.bottom = range.anchorrow;
}
if (range.anchorcol < ecell.col) {
range.left = range.anchorcol;
range.right = ecell.col;
}
else {
range.left = ecell.col;
range.right = range.anchorcol;
}
for (coord in highlights) {
switch (highlights[coord]) {
case "range":
highlights[coord] = "unrange";
break;
case "range2":
highlights[coord] = "unrange2";
break;
}
}
for (row=range.top; row<=range.bottom; row++) {
for (col=range.left; col<=range.right; col++) {
coord = SocialCalc.crToCoord(col, row);
switch (highlights[coord]) {
case "unrange":
highlights[coord] = "range";
break;
case "cursor":
break;
case "unrange2":
default:
highlights[coord] = "newrange";
break;
}
}
}
for (row=range2.top; range2.hasrange && row<=range2.bottom; row++) {
for (col=range2.left; col<=range2.right; col++) {
coord = SocialCalc.crToCoord(col, row);
switch (highlights[coord]) {
case "unrange2":
highlights[coord] = "range2";
break;
case "range":
case "newrange":
case "cursor":
break;
default:
highlights[coord] = "newrange2";
break;
}
}
}
for (coord in highlights) {
switch (highlights[coord]) {
case "unrange":
delete highlights[coord];
break;
case "newrange":
highlights[coord] = "range";
break;
case "newrange2":
highlights[coord] = "range2";
break;
case "range":
case "range2":
case "cursor":
continue;
}
cr = SocialCalc.coordToCr(coord);
cell = SocialCalc.GetEditorCellElement(editor, cr.row, cr.col);
editor.UpdateCellCSS(cell, cr.row, cr.col);
}
for (f in editor.RangeChangeCallback) { // let others know
editor.RangeChangeCallback[f](editor);
}
// create range/coord string and do status callback
coord = SocialCalc.crToCoord(editor.range.left, editor.range.top);
if (editor.range.left!=editor.range.right || editor.range.top!=editor.range.bottom) { // more than one cell
coord += ":" + SocialCalc.crToCoord(editor.range.right, editor.range.bottom);
}
for (f in editor.StatusCallback) {
editor.StatusCallback[f].func(editor, "rangechange", coord, editor.StatusCallback[f].params);
}
return;
}
//
// RangeRemove(editor)
//
// Turns off the range.
//
SocialCalc.RangeRemove = function(editor) {
var cell, cr, coord, row, col, f;
var highlights = editor.context.highlights;
var range = editor.range;
var range2 = editor.range2;
if (!range.hasrange && !range2.hasrange) return;
for (row=range2.top; range2.hasrange && row<=range2.bottom; row++) {
for (col=range2.left; col<=range2.right; col++) {
coord = SocialCalc.crToCoord(col, row);
switch (highlights[coord]) {
case "range":
highlights[coord] = "newrange2";
break;
case "range2":
case "cursor":
break;
default:
highlights[coord] = "newrange2";
break;
}
}
}
for (coord in highlights) {
switch (highlights[coord]) {
case "range":
delete highlights[coord];
break;
case "newrange2":
highlights[coord] = "range2";
break;
case "cursor":
continue;
}
cr = SocialCalc.coordToCr(coord);
cell=SocialCalc.GetEditorCellElement(editor, cr.row, cr.col);
editor.UpdateCellCSS(cell, cr.row, cr.col);
}
range.hasrange = false;
for (f in editor.RangeChangeCallback) { // let others know
editor.RangeChangeCallback[f](editor);
}
for (f in editor.StatusCallback) {
editor.StatusCallback[f].func(editor, "rangechange", "", editor.StatusCallback[f].params);
}
return;
}
//
// Range2Remove(editor)
//
// Turns off the range2.
//
SocialCalc.Range2Remove = function(editor) {
var cell, cr, coord, row, col, f;
var highlights = editor.context.highlights;
var range2 = editor.range2;
if (!range2.hasrange) return;
for (coord in highlights) {
switch (highlights[coord]) {
case "range2":
delete highlights[coord];
break;
case "range":
case "cursor":
continue;
}
cr = SocialCalc.coordToCr(coord);
cell=SocialCalc.GetEditorCellElement(editor, cr.row, cr.col);
editor.UpdateCellCSS(cell, cr.row, cr.col);
}
range2.hasrange = false;
return;
}
//
// FitToEditTable(editor)
//
// Figure out (through column width declarations and approximation of pixels per row)
// how many rendered rows and columns you need to be at least a little larger than
// the editor's editing area.
//
SocialCalc.FitToEditTable = function(editor) {
var colnum, colname, colwidth, totalwidth, totalrows, rowpane, needed;
var context=editor.context;
var sheetobj=context.sheetobj;
var sheetcolattribs=sheetobj.colattribs;
// Calculate column width data
totalwidth=context.showRCHeaders ? context.rownamewidth-0 : 0;
for (colpane=0; colpane<context.colpanes.length-1; colpane++) { // Get width of all but last pane
for (colnum=context.colpanes[colpane].first; colnum<=context.colpanes[colpane].last; colnum++) {
colname=SocialCalc.rcColname(colnum);
colwidth = sheetobj.colattribs.width[colname] || sheetobj.attribs.defaultcolwidth || SocialCalc.Constants.defaultColWidth;
if (colwidth=="blank" || colwidth=="auto") colwidth="";
totalwidth+=(colwidth && ((colwidth-0)>0)) ? (colwidth-0) : 10;
}
}
for (colnum=context.colpanes[colpane].first; colnum<=10000; colnum++) { //!!! max for safety, but makes that col max!!!
colname=SocialCalc.rcColname(colnum);
colwidth = sheetobj.colattribs.width[colname] || sheetobj.attribs.defaultcolwidth || SocialCalc.Constants.defaultColWidth;
if (colwidth=="blank" || colwidth=="auto") colwidth="";
totalwidth+=(colwidth && ((colwidth-0)>0)) ? (colwidth-0) : 10;
if (totalwidth > editor.tablewidth) break;
}
context.colpanes[colpane].last = colnum;
// Calculate row height data
totalrows=context.showRCHeaders ? 1 : 0;
for (rowpane=0; rowpane<context.rowpanes.length-1; rowpane++) { // count all panes but last one
totalrows += context.rowpanes[rowpane].last - context.rowpanes[rowpane].first + 1;
}
needed = editor.tableheight - totalrows * context.pixelsPerRow; // estimate amount needed
socialcalc/socialcalctableeditor.js view on Meta::CPAN
var newstr = SocialCalc.special_chars(str);
newstr = newstr.replace(/\n/g,"<br>");
if (inputecho.text != newstr) {
inputecho.main.innerHTML = newstr;
inputecho.text = newstr;
}
var parts = str.match(/.*[\+\-\*\/\&\^\<\>\=\,\(]([A-Za-z][A-ZA-z]\w*?)\([^\)]*$/);
if (str.charAt(0)=="=" && parts) {
fname = parts[1].toUpperCase();
if (SocialCalc.Formula.FunctionList[fname]) {
SocialCalc.Formula.FillFunctionInfo(); // make sure filled
fstr = SocialCalc.special_chars(fname+"("+SocialCalc.Formula.FunctionArgString(fname)+")");
}
else {
fstr = scc.ietUnknownFunction+fname;
}
if (inputecho.prompt.innerHTML != fstr) {
inputecho.prompt.innerHTML = fstr;
inputecho.prompt.style.display = "block";
}
}
else if (inputecho.prompt.style.display != "none") {
inputecho.prompt.innerHTML = "";
inputecho.prompt.style.display = "none";
}
}
SocialCalc.InputEchoHeartbeat = function() {
var editor = SocialCalc.Keyboard.focusTable; // get TableEditor doing keyboard stuff
if (!editor) return true; // we're not handling it -- let browser do default
editor.inputEcho.SetText(editor.inputBox.GetText()+"_");
}
SocialCalc.InputEchoMouseDown = function(e) {
var event = e || window.event;
var editor = SocialCalc.Keyboard.focusTable; // get TableEditor doing keyboard stuff
if (!editor) return true; // we're not handling it -- let browser do default
// if (event.stopPropagation) event.stopPropagation(); // DOM Level 2
// else event.cancelBubble = true; // IE 5+
// if (event.preventDefault) event.preventDefault(); // DOM Level 2
// else event.returnValue = false; // IE 5+
editor.inputBox.element.focus();
// return false;
};
// *************************************
//
// CellHandles class:
//
// This object creates and controls the elements around the cursor cell for dragging, etc.
//
// *************************************
SocialCalc.CellHandles = function(editor) {
var scc = SocialCalc.Constants;
var functions;
if (editor.noEdit) return; // leave us with nothing
this.editor = editor; // the TableEditor this belongs to
this.noCursorSuffix = false;
this.movedmouse = false; // used to detect no-op
this.draghandle = document.createElement("div");
SocialCalc.setStyles(this.draghandle, "display:none;position:absolute;zIndex:8;border:1px solid white;width:4px;height:4px;fontSize:1px;backgroundColor:#0E93D8;cursor:default;");
this.draghandle.innerHTML = ' ';
editor.toplevel.appendChild(this.draghandle);
SocialCalc.AssignID(editor, this.draghandle, "draghandle");
var imagetype = "png";
if (navigator.userAgent.match(/MSIE 6\.0/)) {
imagetype = "gif";
}
this.dragpalette = document.createElement("div");
SocialCalc.setStyles(this.dragpalette, "display:none;position:absolute;zIndex:8;width:90px;height:90px;fontSize:1px;textAlign:center;cursor:default;"+
"backgroundImage:url("+SocialCalc.Constants.defaultImagePrefix+"drag-handles."+imagetype+");");
this.dragpalette.innerHTML = ' ';
editor.toplevel.appendChild(this.dragpalette);
SocialCalc.AssignID(editor, this.dragpalette, "dragpalette");
this.dragtooltip = document.createElement("div");
SocialCalc.setStyles(this.dragtooltip, "display:none;position:absolute;zIndex:9;border:1px solid black;width:100px;height:auto;fontSize:10px;backgroundColor:#FFFFFF;");
this.dragtooltip.innerHTML = ' ';
editor.toplevel.appendChild(this.dragtooltip);
SocialCalc.AssignID(editor, this.dragtooltip, "dragtooltip");
this.fillinghandle = document.createElement("div");
SocialCalc.setStyles(this.fillinghandle, "display:none;position:absolute;zIndex:9;border:1px solid black;width:auto;height:14px;fontSize:10px;backgroundColor:#FFFFFF;");
this.fillinghandle.innerHTML = ' ';
editor.toplevel.appendChild(this.fillinghandle);
SocialCalc.AssignID(editor, this.fillinghandle, "fillinghandle");
if (this.draghandle.addEventListener) { // DOM Level 2 -- Firefox, et al
this.draghandle.addEventListener("mousemove", SocialCalc.CellHandlesMouseMoveOnHandle, false);
this.dragpalette.addEventListener("mousedown", SocialCalc.CellHandlesMouseDown, false);
this.dragpalette.addEventListener("mousemove", SocialCalc.CellHandlesMouseMoveOnHandle, false);
}
else if (this.draghandle.attachEvent) { // IE 5+
this.draghandle.attachEvent("onmousemove", SocialCalc.CellHandlesMouseMoveOnHandle);
this.dragpalette.attachEvent("onmousedown", SocialCalc.CellHandlesMouseDown);
this.dragpalette.attachEvent("onmousemove", SocialCalc.CellHandlesMouseMoveOnHandle);
}
else { // don't handle this
throw "Browser not supported";
}
}
// Methods:
SocialCalc.CellHandles.prototype.ShowCellHandles = function(show, moveshow) {return SocialCalc.ShowCellHandles(this, show, moveshow);};
// Functions:
SocialCalc.ShowCellHandles = function(cellhandles, show, moveshow) {
var cell, cell2, position, position2;
var editor = cellhandles.editor;
var doshow = false;
var row, col, viewport;
if (!editor) return;
do { // a block that can you can "break" out of easily
if (!show) break;
row = editor.ecell.row;
col = editor.ecell.col;
if (editor.state != "start") break;
if (row >= editor.lastvisiblerow) break;
if (col >= editor.lastvisiblecol) break;
if (row < editor.firstscrollingrow) break;
if (col < editor.firstscrollingcol) break;
socialcalc/socialcalctableeditor.js view on Meta::CPAN
cellhandles.fillinghandle.style.display = "none";
if (!result) result = {};
if (!result.coord) result.coord = editor.ecell.coord;
switch (cellhandles.dragtype) {
case "Fill":
case "Move":
case "MoveI":
cmdtype2 = " all";
break;
case "FillC":
case "MoveC":
case "MoveIC":
cmdtype2 = " formulas";
break;
}
if (!cellhandles.movedmouse) { // didn't move: just leave one cell selected
cellhandles.dragtype = "Nothing";
}
switch (cellhandles.dragtype) {
case "Nothing":
editor.Range2Remove();
editor.RangeRemove();
break;
case "Fill":
case "FillC":
crstart = SocialCalc.coordToCr(cellhandles.startingcoord);
crend = SocialCalc.coordToCr(result.coord);
if (cellhandles.filltype) {
if (cellhandles.filltype=="Down") {
crend.col = crstart.col;
}
else {
crend.row = crstart.row;
}
}
result.coord = SocialCalc.crToCoord(crend.col, crend.row);
editor.MoveECell(result.coord);
editor.RangeExtend();
if (editor.cellhandles.filltype=="Right") {
cmdtype = "right";
}
else {
cmdtype = "down";
}
cstr = "fill"+cmdtype+" "+SocialCalc.crToCoord(editor.range.left, editor.range.top)+
":"+SocialCalc.crToCoord(editor.range.right, editor.range.bottom)+cmdtype2;
editor.EditorScheduleSheetCommands(cstr, true, false);
break;
case "Move":
case "MoveC":
editor.context.cursorsuffix = "";
cstr = "movepaste "+
SocialCalc.crToCoord(editor.range2.left, editor.range2.top) + ":" +
SocialCalc.crToCoord(editor.range2.right, editor.range2.bottom)
+" "+editor.ecell.coord+cmdtype2;
editor.EditorScheduleSheetCommands(cstr, true, false);
editor.Range2Remove();
break;
case "MoveI":
case "MoveIC":
editor.context.cursorsuffix = "";
sizec = editor.range2.right - editor.range2.left;
sizer = editor.range2.bottom - editor.range2.top;
deltac = editor.ecell.col - editor.range2.left;
deltar = editor.ecell.row - editor.range2.top;
cstr = "moveinsert "+
SocialCalc.crToCoord(editor.range2.left, editor.range2.top) + ":" +
SocialCalc.crToCoord(editor.range2.right, editor.range2.bottom)
+" "+editor.ecell.coord+cmdtype2;
editor.EditorScheduleSheetCommands(cstr, true, false);
editor.Range2Remove();
editor.RangeRemove();
if (editor.cellhandles.filltype==" Horizontal" && deltac > 0) {
editor.MoveECell(SocialCalc.crToCoord(editor.ecell.col-sizec-1, editor.ecell.row));
}
else if (editor.cellhandles.filltype==" Vertical" && deltar > 0) {
editor.MoveECell(SocialCalc.crToCoord(editor.ecell.col, editor.ecell.row-sizer-1));
}
editor.RangeAnchor(SocialCalc.crToCoord(editor.ecell.col+sizec, editor.ecell.row+sizer));
editor.RangeExtend();
break;
}
if (event.stopPropagation) event.stopPropagation(); // DOM Level 2
else event.cancelBubble = true; // IE 5+
if (event.preventDefault) event.preventDefault(); // DOM Level 2
else event.returnValue = false; // IE 5+
if (document.removeEventListener) { // DOM Level 2
document.removeEventListener("mousemove", SocialCalc.CellHandlesMouseMove, true);
document.removeEventListener("mouseup", SocialCalc.CellHandlesMouseUp, true);
}
else if (cellhandles.draghandle.detachEvent) { // IE
cellhandles.draghandle.detachEvent("onlosecapture", SocialCalc.CellHandlesMouseUp);
cellhandles.draghandle.detachEvent("onmouseup", SocialCalc.CellHandlesMouseUp);
cellhandles.draghandle.detachEvent("onmousemove", SocialCalc.CellHandlesMouseMove);
cellhandles.draghandle.releaseCapture();
}
mouseinfo.editor = null;
return false;
}
// *************************************
//
// TableControl class:
//
// This class deals with the horizontal and verical scrollbars and pane sliders.
//
// +--------------+
// | Endcap |
// +- - - - - - - +
// | |
// +--------------+
// | Pane Slider |
// +--------------+
// | |
( run in 0.570 second using v1.01-cache-2.11-cpan-39bf76dae61 )