/** * Tests if a cell range can be used as the source for a pattern drag-copy. * * @param cellRange * @return */ private static boolean isPatternSource(CellRange cellRange) { // don't allow empty cells if (cellRange.hasEmptyCells()) { return false; } // test for any unacceptable geos in the range ArrayList<GeoElement> list = cellRange.toGeoList(); for (GeoElement geo : list) { if (!(geo.isGeoNumeric() || geo.isGeoFunction() || geo.isGeoPoint())) { return false; } } return true; }
/** Set all elements in locusConsElements to the current values of the main construction */ private void resetMacroConstruction() { Iterator<ConstructionElement> it = locusConsOrigElements.iterator(); while (it.hasNext()) { ConstructionElement ce = it.next(); if (ce.isGeoElement()) { GeoElement geoOrig = (GeoElement) ce; // do not copy functions, their expressions already // include references to the correct other geos if (!geoOrig.isGeoFunction()) { GeoElement geoCopy = macroCons.lookupLabel(geoOrig.label); if (geoCopy != null) { try { geoCopy.set(geoOrig); geoCopy.update(); } catch (Exception e) { Application.debug("AlgoLocus: error in resetMacroConstruction(): " + e.getMessage()); } } } } } }
/** * 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(); } }
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 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(); } } }