Esempio n. 1
0
  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;
  }
Esempio n. 2
0
  /**
   * 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 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();
        }
      }
    }
  }