// calc the current value of the arithmetic tree
@Override
public final void compute() {
String col =
GeoElementSpreadsheet.getSpreadsheetColumnName(
geo.getLabel(StringTemplate.defaultTemplate));
if (col == null) text.setUndefined();
else text.setTextString(col);
}
/**
* Prepares a spreadsheet cell editor string for processing in the kernel and returns either (1) a
* new GeoElement for the cell or (2) null.
*
* @param kernel kernel
* @param app application
* @param inputText string representation of the new GeoElement
* @param oldValue current cell GeoElement
* @param column cell column
* @param row cell row
* @return either (1) a new GeoElement for the cell or (2) null
* @throws Exception
*/
public static GeoElement prepareAddingValueToTableNoStoringUndoInfo(
Kernel kernel, App app, String inputText, GeoElement oldValue, int column, int row)
throws Exception {
String text = inputText;
// get the cell name
String name = GeoElementSpreadsheet.getSpreadsheetCellName(column, row);
// trim the text
if (text != null) {
text = text.trim();
if (text.length() == 0) {
text = null;
}
}
// if "=" is required before commands and text is not a number
// or does not begin with "=" then surround it with quotes.
// This will force the cell to become GeoText.
if (app.getSettings().getSpreadsheet().equalsRequired() && text != null) {
if (!((text.charAt(0) == '=') || isNumber(text))) {
text = "\"" + text + "\"";
}
}
// if the cell is currently GeoText then prepare it for changes
// make sure it can be changed to something else
// eg (2,3 can be overwritten as (2,3)
// if (oldValue != null && oldValue.isGeoText() &&
// !oldValue.hasChildren()) {
// oldValue.remove();
// oldValue = null;
// }
// if the text is null then remove the current cell geo and return null
if (text == null) {
if (oldValue != null) {
oldValue.remove();
}
return null;
// else if the target cell is empty, try to create a new GeoElement
// for this cell
} else if (oldValue == null) {
try {
// this will be a new geo
return prepareNewValue(kernel, name, text);
} catch (Throwable t) {
return prepareNewValue(kernel, name, "");
}
// else the target cell is an existing GeoElement, so redefine it
} else {
return updateOldValue(kernel, oldValue, name, text);
}
}
/**
* Performs spreadsheet drag-copy operation.
*
* @param sx1 source minimum column
* @param sy1 source minimum row
* @param sx2 source maximum column
* @param sy2 source maximum row
* @param dx1 destination minimum column
* @param dy1 destination minimum row
* @param dx2 destination maximum column
* @param dy2 destination maximum row
* @return
*/
public boolean doDragCopy(
int sx1, int sy1, int sx2, int sy2, int dx1, int dy1, int dx2, int dy2) {
// -|1|-
// 2|-|3
// -|4|-
app.setWaitCursor();
Construction cons = kernel.getConstruction();
try {
boolean success = false;
// collect all redefine operations
cons.startCollectingRedefineCalls();
boolean patternOK = isPatternSource(new CellRange(app, sx1, sy1, sx2, sy2));
// ==============================================
// vertical drag
// ==============================================
if ((sx1 == dx1) && (sx2 == dx2)) {
if (dy2 < sy1) { // 1 ----- drag up
if (((sy1 + 1) == sy2) && patternOK) {
// two row source, so drag copy a linear pattern
for (int x = sx1; x <= sx2; ++x) {
GeoElement v1 = getValue(app, x, sy1);
GeoElement v2 = getValue(app, x, sy2);
if ((v1 == null) || (v2 == null)) {
continue;
}
for (int y = dy2; y >= dy1; --y) {
GeoElement v3 = getValue(app, x, y + 2);
GeoElement v4 = getValue(app, x, y + 1);
String vs1 = v3.isGeoFunction() ? "(x)" : "";
String vs2 = v4.isGeoFunction() ? "(x)" : "";
String d0 = GeoElementSpreadsheet.getSpreadsheetCellName(x, y + 2) + vs1;
String d1 = GeoElementSpreadsheet.getSpreadsheetCellName(x, y + 1) + vs2;
String text = "=2*" + d1 + "-" + d0;
doCopyNoStoringUndoInfo1(kernel, app, text, v4, x, y);
}
}
} else { // not two row source, so drag-copy the first row
// of the source
doCopyVerticalNoStoringUndoInfo1(sx1, sx2, sy1, dy1, dy2);
}
success = true;
} else if (dy1 > sy2) { // 4 ---- drag down
if (((sy1 + 1) == sy2) && patternOK) {
// two row source, so drag copy a linear pattern
for (int x = sx1; x <= sx2; ++x) {
GeoElement v1 = getValue(app, x, sy1);
GeoElement v2 = getValue(app, x, sy2);
if ((v1 == null) || (v2 == null)) {
continue;
}
for (int y = dy1; y <= dy2; ++y) {
GeoElement v3 = getValue(app, x, y - 2);
GeoElement v4 = getValue(app, x, y - 1);
String vs1 = v3.isGeoFunction() ? "(x)" : "";
String vs2 = v4.isGeoFunction() ? "(x)" : "";
String d0 = GeoElementSpreadsheet.getSpreadsheetCellName(x, y - 2) + vs1;
String d1 = GeoElementSpreadsheet.getSpreadsheetCellName(x, y - 1) + vs2;
String text = "=2*" + d1 + "-" + d0;
doCopyNoStoringUndoInfo1(kernel, app, text, v4, x, y);
}
}
} else {
// not two row source, so drag-copy the last row of the
// source
doCopyVerticalNoStoringUndoInfo1(sx1, sx2, sy2, dy1, dy2);
}
success = true;
}
}
// ==============================================
// horizontal drag
// ==============================================
else if ((sy1 == dy1) && (sy2 == dy2)) {
if (dx2 < sx1) { // 2 ---- drag left
if (((sx1 + 1) == sx2) && patternOK) {
// two column source, so drag copy a linear pattern
for (int y = sy1; y <= sy2; ++y) {
GeoElement v1 = getValue(app, sx1, y);
GeoElement v2 = getValue(app, sx2, y);
if ((v1 == null) || (v2 == null)) {
continue;
}
for (int x = dx2; x >= dx1; --x) {
GeoElement v3 = getValue(app, x + 2, y);
GeoElement v4 = getValue(app, x + 1, y);
String vs1 = v3.isGeoFunction() ? "(x)" : "";
String vs2 = v4.isGeoFunction() ? "(x)" : "";
String d0 = GeoElementSpreadsheet.getSpreadsheetCellName(x + 2, y) + vs1;
String d1 = GeoElementSpreadsheet.getSpreadsheetCellName(x + 1, y) + vs2;
String text = "=2*" + d1 + "-" + d0;
doCopyNoStoringUndoInfo1(kernel, app, text, v4, x, y);
}
}
} else {
// not two column source, so drag-copy the first column
// of the source
doCopyHorizontalNoStoringUndoInfo1(sy1, sy2, sx1, dx1, dx2);
}
success = true;
} else if (dx1 > sx2) { // 4 --- drag right
if (((sx1 + 1) == sx2) && patternOK) {
// two column source, so drag copy a linear pattern
for (int y = sy1; y <= sy2; ++y) {
GeoElement v1 = getValue(app, sx1, y);
GeoElement v2 = getValue(app, sx2, y);
if ((v1 == null) || (v2 == null)) {
continue;
}
for (int x = dx1; x <= dx2; ++x) {
GeoElement v3 = getValue(app, x - 2, y);
GeoElement v4 = getValue(app, x - 1, y);
String vs1 = v3.isGeoFunction() ? "(x)" : "";
String vs2 = v4.isGeoFunction() ? "(x)" : "";
String d0 = GeoElementSpreadsheet.getSpreadsheetCellName(x - 2, y) + vs1;
String d1 = GeoElementSpreadsheet.getSpreadsheetCellName(x - 1, y) + vs2;
String text = "=2*" + d1 + "-" + d0;
doCopyNoStoringUndoInfo1(kernel, app, text, v4, x, y);
}
}
} else {
// not two column source, so drag-copy the last column
// of the source
doCopyHorizontalNoStoringUndoInfo1(sy1, sy2, sx2, dx1, dx2);
}
success = true;
}
}
// now do all redefining and build new construction
cons.processCollectedRedefineCalls();
if (success) {
return true;
}
String msg =
"sx1 = " + sx1 + "\r\n" + "sy1 = " + sy1 + "\r\n" + "sx2 = " + sx2 + "\r\n" + "sy2 = "
+ sy2 + "\r\n" + "dx1 = " + dx1 + "\r\n" + "dy1 = " + dy1 + "\r\n" + "dx2 = " + dx2
+ "\r\n" + "dy2 = " + dy2 + "\r\n";
throw new RuntimeException("Error from RelativeCopy.doCopy:\r\n" + msg);
} catch (Exception ex) {
// kernel.getApplication().showError(ex.getMessage());
ex.printStackTrace();
return false;
} finally {
cons.stopCollectingRedefineCalls();
app.setDefaultCursor();
}
}
/**
* Updates the cell references in text according to a relative copy in the spreadsheet of offset
* (dx,dy) (changes only dependents of value) eg change A1 < 3 to A2 < 3 for a vertical copy
*/
public static String updateCellReferences(GeoElement value, String inputText, int dx, int dy) {
String text = inputText;
StringBuilder before = new StringBuilder();
StringBuilder after = new StringBuilder();
GeoElement[] dependents = getDependentObjects(value);
GeoElement[] dependents2 = new GeoElement[dependents.length + 1];
for (int i = 0; i < dependents.length; ++i) {
dependents2[i] = dependents[i];
}
dependents = dependents2;
dependents[dependents.length - 1] = value;
for (int i = 0; i < dependents.length; ++i) {
String name = dependents[i].getLabel(StringTemplate.defaultTemplate);
MatchResult matcher = GeoElementSpreadsheet.spreadsheetPatternPart.exec(name);
int column = GeoElementSpreadsheet.getSpreadsheetColumn(matcher);
int row = GeoElementSpreadsheet.getSpreadsheetRow(matcher);
if ((column == -1) || (row == -1)) {
continue;
}
String column1 = GeoElementSpreadsheet.getSpreadsheetColumnName(column);
String row1 = "" + (row + 1);
before.setLength(0);
before.append('$');
before.append(column1);
before.append(row1);
after.setLength(0);
after.append('$');
after.append(column1);
after.append("::");
after.append(row1);
text =
replaceAll(
GeoElementSpreadsheet.spreadsheetPatternPart,
text,
before.toString(),
after.toString());
// text = replaceAll(AbstractGeoElementSpreadsheet.spreadsheetPatternPart, text,
// "$" + column1 + row1, "$" + column1 + "::" + row1);
before.setLength(0);
before.append(column1);
before.append('$');
before.append(row1);
after.setLength(0);
after.append("::");
after.append(column1);
after.append('$');
after.append(row1);
text =
replaceAll(
GeoElementSpreadsheet.spreadsheetPatternPart,
text,
before.toString(),
after.toString());
// text = replaceAll(AbstractGeoElementSpreadsheet.spreadsheetPatternPart, text,
// column1 + "$" + row1, "::" + column1 + "$" + row1);
before.setLength(0);
before.append(column1);
before.append(row1);
after.setLength(0);
after.append("::");
after.append(column1);
after.append("::");
after.append(row1);
text =
replaceAll(
GeoElementSpreadsheet.spreadsheetPatternPart,
text,
before.toString(),
after.toString());
// text = replaceAll(AbstractGeoElementSpreadsheet.spreadsheetPatternPart, text,
// column1 + row1, "::" + column1 + "::" + row1);
}
// TODO is this a bug in the regex?
// needed for eg Mod[$A2, B$1] which gives Mod[$A2, ::::B$1]
// =$B$1 BinomialCoefficient[B$2, $A3] gives BinomialCoefficient[::::::B$2, $A::3]
text = text.replace("::::::", "::");
text = text.replace("::::", "::");
MatchResult matcher =
GeoElementSpreadsheet.spreadsheetPatternPart.exec(
value.getLabel(StringTemplate.defaultTemplate));
for (int i = 0; i < dependents.length; ++i) {
String name = dependents[i].getLabel(StringTemplate.defaultTemplate);
matcher = GeoElementSpreadsheet.spreadsheetPatternPart.exec(name);
int column = GeoElementSpreadsheet.getSpreadsheetColumn(matcher);
int row = GeoElementSpreadsheet.getSpreadsheetRow(matcher);
if ((column == -1) || (row == -1)) {
continue;
}
String column1 = GeoElementSpreadsheet.getSpreadsheetColumnName(column);
String row1 = "" + (row + 1);
String column2 = GeoElementSpreadsheet.getSpreadsheetColumnName(column + dx);
String row2 = "" + (row + dy + 1);
before.setLength(0);
before.append("::");
before.append(column1);
before.append("::");
before.append(row1);
after.setLength(0);
after.append(' '); // space important eg 2 E2 not 2E2
after.append(column2);
after.append(row2);
text = replaceAll(pattern2, text, before.toString(), after.toString());
// text = replaceAll(pattern2, text, "::" + column1 + "::" + row1,
// "("+ column2 + row2 + ")");
before.setLength(0);
before.append("$");
before.append(column1);
before.append("::");
before.append(row1);
after.setLength(0);
after.append('$');
after.append(column1);
after.append(row2);
text = replaceAll(pattern2, text, before.toString(), after.toString());
// text = replaceAll(pattern2, text, "$" + column1 + "::" + row1,
// "$" + column1 + row2);
before.setLength(0);
before.append("::");
before.append(column1);
before.append('$');
before.append(row1);
after.setLength(0);
after.append(column2);
after.append('$');
after.append(row1);
text = replaceAll(pattern2, text, before.toString(), after.toString());
// text = replaceAll(pattern2, text, "::" + column1 + "$" + row1,
// column2 + "$" + row1);
}
return text;
}
public static GeoElement doCopyNoStoringUndoInfo0(
Kernel kernel, App app, GeoElement value, GeoElement oldValue, int dx, int dy)
throws Exception {
if (value == null) {
if (oldValue != null) {
MatchResult matcher =
GeoElementSpreadsheet.spreadsheetPatternPart.exec(
oldValue.getLabel(StringTemplate.defaultTemplate));
int column = GeoElementSpreadsheet.getSpreadsheetColumn(matcher);
int row = GeoElementSpreadsheet.getSpreadsheetRow(matcher);
prepareAddingValueToTableNoStoringUndoInfo(kernel, app, null, oldValue, column, row);
}
return null;
}
String text = null;
// make sure a/0.001 doesn't become a/0
StringTemplate highPrecision = StringTemplate.maxPrecision;
if (value.isPointOnPath() || value.isPointInRegion()) {
text = value.getCommandDescription(highPrecision);
} else if (value.isChangeable()) {
text = value.toValueString(highPrecision);
} else {
text = value.getCommandDescription(highPrecision);
}
// handle GeoText source value
if (value.isGeoText() && !((GeoText) value).isTextCommand()) {
// enclose text in quotes if we are copying an independent GeoText,
// e.g. "2+3"
if (value.isIndependent()) {
text = "\"" + text + "\"";
} else {
// check if 'text' parses to a GeoText
GeoText testGeoText = kernel.getAlgebraProcessor().evaluateToText(text, false, false);
// if it doesn't then force it to by adding +"" on the end
if (testGeoText == null) {
text = text + "+\"\"";
}
}
}
// for E1 = Polynomial[D1] we need value.getCommandDescription();
// even though it's a GeoFunction
if (value.isGeoFunction() && text.equals("")) {
// we need the definition without A1(x)= on the front
text = ((GeoFunction) value).toSymbolicString(highPrecision);
}
boolean freeImage = false;
if (value.isGeoImage()) {
GeoImage image = (GeoImage) value;
if (image.getParentAlgorithm() == null) {
freeImage = true;
}
}
// Application.debug("before:"+text);
text = updateCellReferences(value, text, dx, dy);
// Application.debug("after:"+text);
// condition to show object
GeoBoolean bool = value.getShowObjectCondition();
String boolText = null, oldBoolText = null;
if (bool != null) {
if (bool.isChangeable()) {
oldBoolText = bool.toValueString(highPrecision);
} else {
oldBoolText = bool.getCommandDescription(highPrecision);
}
}
if (oldBoolText != null) {
boolText = updateCellReferences(bool, oldBoolText, dx, dy);
}
String startPoints[] = null;
if (value instanceof Locateable) {
Locateable loc = (Locateable) value;
GeoPointND[] pts = loc.getStartPoints();
startPoints = new String[pts.length];
for (int i = 0; i < pts.length; i++) {
startPoints[i] = ((GeoElement) pts[i]).getLabel(highPrecision);
startPoints[i] = updateCellReferences((GeoElement) pts[i], startPoints[i], dx, dy);
}
}
// dynamic color function
GeoList dynamicColorList = value.getColorFunction();
String colorText = null, oldColorText = null;
if (dynamicColorList != null) {
if (dynamicColorList.isChangeable()) {
oldColorText = dynamicColorList.toValueString(highPrecision);
} else {
oldColorText = dynamicColorList.getCommandDescription(highPrecision);
}
}
if (oldColorText != null) {
colorText = updateCellReferences(dynamicColorList, oldColorText, dx, dy);
}
// allow pasting blank strings
if (text.equals("")) {
text = "\"\"";
}
// make sure that non-GeoText elements are copied when the
// equalsRequired option is set
if (!value.isGeoText() && app.getSettings().getSpreadsheet().equalsRequired()) {
text = "=" + text;
}
// Application.debug("add text = " + text + ", name = " + (char)('A' +
// column + dx) + (row + dy + 1));
// create the new cell geo
MatchResult matcher =
GeoElementSpreadsheet.spreadsheetPatternPart.exec(
value.getLabel(StringTemplate.defaultTemplate));
int column0 = GeoElementSpreadsheet.getSpreadsheetColumn(matcher);
int row0 = GeoElementSpreadsheet.getSpreadsheetRow(matcher);
GeoElement value2;
if (freeImage || value.isGeoButton()) {
value2 = value.copy();
if (oldValue != null) {
oldValue.remove();
}
// value2.setLabel(table.getModel().getColumnName(column0 + dx)
// + (row0 + dy + 1));
value2.setLabel(GeoElementSpreadsheet.getSpreadsheetCellName(column0 + dx, row0 + dy + 1));
value2.updateRepaint();
} else {
value2 =
prepareAddingValueToTableNoStoringUndoInfo(
kernel, app, text, oldValue, column0 + dx, row0 + dy);
}
value2.setAllVisualProperties(value, false);
value2.setAuxiliaryObject(true);
// attempt to set updated condition to show object (if it's changed)
if ((boolText != null)) {
// removed as doesn't work for eg "random()<0.5" #388
// && !boolText.equals(oldBoolText)) {
try {
// Application.debug("new condition to show object: "+boolText);
GeoBoolean newConditionToShowObject =
kernel.getAlgebraProcessor().evaluateToBoolean(boolText);
value2.setShowObjectCondition(newConditionToShowObject);
value2.update(); // needed to hide/show object as appropriate
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
// attempt to set updated dynamic color function (if it's changed)
if ((colorText != null)) {
// removed as doesn't work for eg "random()" #388
// && !colorText.equals(oldColorText)) {
try {
// Application.debug("new color function: "+colorText);
GeoList newColorFunction = kernel.getAlgebraProcessor().evaluateToList(colorText);
value2.setColorFunction(newColorFunction);
// value2.update();
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
if (startPoints != null) {
for (int i = 0; i < startPoints.length; i++) {
((Locateable) value2)
.setStartPoint(
kernel.getAlgebraProcessor().evaluateToPoint(startPoints[i], false, true), i);
}
value2.update();
}
// Application.debug((row + dy) + "," + column);
// Application.debug("isGeoFunction()=" + value2.isGeoFunction());
// Application.debug("row0 ="+row0+" dy="+dy+" column0= "+column0+" dx="+dx);
return value2;
}
public void onMouseMove(MouseMoveEvent e) {
GPoint p = table.getIndexFromPixel(e.getClientX(), e.getClientY());
if (p.getY() == 0 && p.getX() > 0) {
table.scc.onMouseMove(e);
return;
} else if (p.getX() == 0 && p.getY() > 0) {
table.srh.onMouseMove(e);
return;
}
e.preventDefault();
boolean eConsumed = false;
// TODO: move the content of the mouseMoved method here
// DRAG
if (mouseIsDown) {
if (table.getTableMode() == MyTable.TABLE_MODE_AUTOFUNCTION
|| table.getTableMode() == MyTable.TABLE_MODE_DROP) {
// System.out.println("drop is dragging ");
return;
}
// handle editing mode drag
if (editor.isEditing()) {
GPoint point = table.getIndexFromPixel(e.getClientX(), e.getClientY());
if (point != null && selectedCellName != null) {
int column2 = point.getX() - 1;
int row2 = point.getY() - 1;
MatchResult matcher = GeoElementSpreadsheet.spreadsheetPattern.exec(selectedCellName);
int column1 = GeoElementSpreadsheet.getSpreadsheetColumn(matcher);
int row1 = GeoElementSpreadsheet.getSpreadsheetRow(matcher);
if (column1 > column2) {
int temp = column1;
column1 = column2;
column2 = temp;
}
if (row1 > row2) {
int temp = row1;
row1 = row2;
row2 = temp;
}
String name1 = GeoElementSpreadsheet.getSpreadsheetCellName(column1, row1);
String name2 = GeoElementSpreadsheet.getSpreadsheetCellName(column2, row2);
if (!name1.equals(name2)) {
name1 += ":" + name2;
}
name1 = prefix0 + name1 + postfix0;
editor.setLabel(name1);
table.minColumn2 = column1;
table.maxColumn2 = column2;
table.minRow2 = row1;
table.maxRow2 = row2;
table.repaint();
}
return;
}
// handle dot drag
if (table.isDragingDot) {
eConsumed = true;
int mouseX = e.getClientX();
int mouseY = e.getClientY();
GPoint mouseCell = table.getIndexFromPixel(mouseX, mouseY);
// save the selected cell position so it can be re-selected if
// needed
CellRange oldSelection = table.getSelectedCellRanges().get(0);
if (mouseCell == null) { // user has dragged outside the table, to
// left or above
table.dragingToRow = -1;
table.dragingToColumn = -1;
} else {
table.dragingToRow = mouseCell.getY();
table.dragingToColumn = mouseCell.getX();
GRectangle selRect = table.getSelectionRect(true);
// increase size if we're at the bottom of the spreadsheet
if (table.dragingToRow + 1 == table.getRowCount()
&& table.dragingToRow < Kernel.MAX_SPREADSHEET_ROWS) {
model.setRowCount(table.getRowCount() + 1);
}
// increase size if we go beyond the right edge
if (table.dragingToColumn + 1 == table.getColumnCount()
&& table.dragingToColumn < Kernel.MAX_SPREADSHEET_COLUMNS) {
model.setColumnCount(table.getColumnCount() + 1);
view.columnHeaderRevalidate();
// Java's addColumn method will clear selection, so
// re-select our cell
table.setSelection(oldSelection);
}
// scroll to show "highest" selected cell
// TODO//table.scrollRectToVisible(table.getCellRect(mouseCell.y, mouseCell.x, true));
if (!selRect.contains(e.getClientX(), e.getClientY())) {
int rowOffset = 0, colOffset = 0;
// get row distance
if (table.minSelectionRow > 0 && table.dragingToRow < table.minSelectionRow) {
rowOffset = mouseY - (int) selRect.getY();
if (-rowOffset
< 0.5
* table
.getCellRect(table.minSelectionRow - 1, table.minSelectionColumn, true)
.getHeight()) rowOffset = 0;
} else if (table.maxSelectionRow < Kernel.MAX_SPREADSHEET_ROWS
&& table.dragingToRow > table.maxSelectionRow) {
rowOffset = mouseY - ((int) selRect.getY() + (int) selRect.getHeight());
if (rowOffset
< 0.5
* table
.getCellRect(table.maxSelectionRow + 1, table.maxSelectionColumn, true)
.getHeight()) rowOffset = 0;
}
// get column distance
if (table.minSelectionColumn > 0 && table.dragingToColumn < table.minSelectionColumn) {
colOffset = mouseX - (int) selRect.getX();
if (-colOffset
< 0.5
* table
.getCellRect(table.minSelectionRow, table.minSelectionColumn - 1, true)
.getWidth()) colOffset = 0;
} else if (table.maxSelectionColumn < Kernel.MAX_SPREADSHEET_COLUMNS
&& table.dragingToColumn > table.maxSelectionColumn) {
colOffset = mouseX - ((int) selRect.getX() + (int) selRect.getWidth());
if (colOffset
< 0.5
* table
.getCellRect(table.maxSelectionRow, table.maxSelectionColumn + 1, true)
.getWidth()) colOffset = 0;
}
if (rowOffset == 0 && colOffset == 0) {
table.dragingToColumn = -1;
table.dragingToRow = -1;
} else if (Math.abs(rowOffset) > Math.abs(colOffset)) {
table.dragingToRow = mouseCell.y;
table.dragingToColumn =
(colOffset > 0) ? table.maxSelectionColumn : table.minSelectionColumn;
} else {
table.dragingToColumn = mouseCell.x;
table.dragingToRow = (rowOffset > 0) ? table.maxSelectionRow : table.minSelectionRow;
}
table.repaint();
}
// handle ctrl-select dragging of cell blocks
else {
/*TODO if (e.isControlDown()) {
table.handleControlDragSelect(e);
}*/
}
}
}
if (eConsumed) return;
// MyTable's default listeners follow, they should be simulated in Web e.g. here
// change selection if right click is outside current selection
if (p.getY() != table.leadSelectionRow + 1 || p.getX() != table.leadSelectionColumn + 1) {
// switch to cell selection mode
if (p.getY() > 0 && p.getX() > 0) {
if (table.getSelectionType() != MyTable.CELL_SELECT) {
table.setSelectionType(MyTable.CELL_SELECT);
}
// now change the selection
table.changeSelection(p.getY() - 1, p.getX() - 1, false, true);
table.repaint();
}
}
} else {
// MOVE, NO DRAG
if (table.isEditing()) return;
// get GeoElement at mouse location
int row = p.getY(); // ?//table.rowAtPoint(e.getPoint());
int col = p.getX(); // ?//table.columnAtPoint(e.getPoint());
GeoElement geo = (GeoElement) model.getValueAt(row - 1, col - 1);
// set tooltip with geo's description
if (geo != null & view.getAllowToolTips()) {
app.setTooltipFlag();
// TODO//table.setToolTipText(geo.getLongDescriptionHTML(true, true));
app.clearTooltipFlag();
} else {
// TODO//table.setToolTipText(null);
}
// check if over the dragging dot and update accordingly
GPoint maxPoint = table.getMaxSelectionPixel();
GPoint minPoint = table.getMinSelectionPixel();
if (maxPoint != null) {
int dotX = maxPoint.getX();
int dotY = maxPoint.getY();
int s = MyTableW.DOT_SIZE + 2;
GRectangle2DW dotRect = new GRectangle2DW(dotX - s / 2, dotY - s / 2, s, s);
boolean overDot = dotRect.contains(e.getClientX(), e.getClientY());
if (table.isOverDot != overDot) {
table.isOverDot = overDot;
// TODO//setTableCursor();
table.repaint();
}
}
// check if over the DnD region and update accordingly
GPoint testPoint = table.getMinSelectionPixel();
if (testPoint != null) {
int minX = minPoint.getX();
int minY = minPoint.getY();
int maxX = maxPoint.getX();
int w = maxX - minX;
GRectangle2DW dndRect = new GRectangle2DW(minX, minY - 2, w, 4);
boolean overDnD = dndRect.contains(e.getClientX(), e.getClientY());
if (table.isOverDnDRegion != overDnD) {
table.isOverDnDRegion = overDnD;
// TODO//setTableCursor();
}
}
}
}
public void onMouseDown(MouseDownEvent e) {
GPoint p = table.getIndexFromPixel(e.getClientX(), e.getClientY());
if (p.getY() == 0 && p.getX() > 0) {
if (table.isEditing()) editor.cancelCellEditing();
table.scc.onMouseDown(e);
return;
} else if (p.getX() == 0 && p.getY() > 0) {
if (table.isEditing()) editor.cancelCellEditing();
table.srh.onMouseDown(e);
return;
}
// if (!view.hasViewFocus())
// ((LayoutW) app.getGuiManager().getLayout()).getDockManager()
// .setFocusedPanel(App.VIEW_SPREADSHEET);
view.requestFocus();
mouseIsDown = true;
e.preventDefault();
boolean eConsumed = false;
boolean rightClick = (e.getNativeButton() == NativeEvent.BUTTON_RIGHT);
// tell selection listener about click on GeoElement
if (!rightClick && app.getMode() == EuclidianConstants.MODE_SELECTION_LISTENER) {
int row = p.getY(); // ?//table.rowAtPoint(e.getPoint());
int col = p.getX(); // ?//table.columnAtPoint(e.getPoint());
GeoElement geo = (GeoElement) model.getValueAt(row - 1, col - 1);
// double click or empty geo
if (geo != null) {
// tell selection listener about click
app.geoElementSelected(geo, false);
return;
}
}
if (!rightClick) {
// memory testing
// Application.debug("", true, true, 0);
if (table.getSelectionType() != MyTable.CELL_SELECT) {
table.setSelectionType(MyTable.CELL_SELECT);
}
// force column selection
if (view.isColumnSelect()) {
GPoint point = table.getIndexFromPixel(e.getClientX(), e.getClientY());
if (point != null) {
int column = point.getX();
table.setColumnSelectionInterval(column, column);
}
}
/*
* if (MyTable.this.getSelectionModel().getSelectionMode() !=
* ListSelectionModel.SINGLE_INTERVAL_SELECTION) {
* setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
* setColumnSelectionAllowed(true); setRowSelectionAllowed(true); }
*/
GPoint point1 = table.getMaxSelectionPixel();
if (point1 == null) return;
// Handle click in another cell while editing a cell:
// if the edit string begins with "=" then the clicked cell name
// is inserted into the edit text
if (editor.isEditing()) {
String text = editor.getEditingValue();
if (text.startsWith("=")) {
GPoint point = table.getIndexFromPixel(e.getClientX(), e.getClientY());
if (point != null && (point.getX() != editor.column || point.getY() != editor.row)) {
// in Web, it's necessary to distinguish the editor row and column
// because the event is not catched and not taken by the textfield
int column = point.getX();
int row = point.getY();
GeoElement geo = RelativeCopy.getValue(app, column - 1, row - 1);
if (geo != null) {
// get cell name
String name = GeoElementSpreadsheet.getSpreadsheetCellName(column - 1, row - 1);
if (geo.isGeoFunction()) name += "(x)";
selectedCellName = name;
// get prefix/post substrings for current text caret
// position
int caretPos = editor.getCaretPosition();
prefix0 = text.substring(0, caretPos);
postfix0 = text.substring(caretPos, text.length());
table.isDragging2 = true;
table.minColumn2 = column;
table.maxColumn2 = column;
table.minRow2 = row;
table.maxRow2 = row;
// insert the geo label into the editor string
editor.addLabel(name);
eConsumed = true;
table.repaint();
}
eConsumed = true;
}
} else {
// if text does not start with "=" then stop the editor
// and allow it to create/redefine a geo here
editor.setAllowProcessGeo(true);
editor.stopCellEditing();
editor.setAllowProcessGeo(false);
table.finishEditing();
// almost like MyCellEditorW.stopCellEditing(int,int)
}
} else if (table.isOverDot) {
table.isDragingDot = true;
eConsumed = true;
}
}
if (eConsumed) return;
// MyTable's default listeners follow, they should be simulated in Web e.g. here
// change selection if right click is outside current selection
if (p.getY() != table.anchorSelectionRow + 1 || p.getX() != table.anchorSelectionColumn + 1) {
// switch to cell selection mode
if (p.getY() > 0 && p.getX() > 0) {
if (table.getSelectionType() != MyTable.CELL_SELECT) {
table.setSelectionType(MyTable.CELL_SELECT);
}
// now change the selection
table.changeSelection(p.getY() - 1, p.getX() - 1, false, false);
table.repaint();
}
}
}