Example #1
0
  /**
   * Parses given String str and tries to evaluate it to a GeoImplicitPoly object. Returns null if
   * something went wrong.
   *
   * @param str
   * @boolean showErrors if false, only stacktraces are printed
   * @return implicit polygon or null
   */
  public GeoElement evaluateToGeoElement(String str, boolean showErrors) {
    boolean oldMacroMode = cons.isSuppressLabelsActive();
    cons.setSuppressLabelCreation(true);

    GeoElement geo = null;
    try {
      ValidExpression ve = parser.parseGeoGebraExpression(str);
      GeoElement[] temp = processValidExpression(ve);
      geo = temp[0];
    } catch (CircularDefinitionException e) {
      Application.debug("CircularDefinition");
      app.showError("CircularDefinition");
    } catch (Exception e) {
      e.printStackTrace();
      if (showErrors) app.showError("InvalidInput", str);
    } catch (MyError e) {
      e.printStackTrace();
      if (showErrors) app.showError(e);
    } catch (Error e) {
      e.printStackTrace();
      if (showErrors) app.showError("InvalidInput", str);
    }

    cons.setSuppressLabelCreation(oldMacroMode);
    return geo;
  }
Example #2
0
  /**
   * Parses given String str and tries to evaluate it to a GeoFunction Returns null if something
   * went wrong. Michael Borcherds 2008-04-04
   */
  public GeoFunction evaluateToFunction(String str, boolean suppressErrors) {
    boolean oldMacroMode = cons.isSuppressLabelsActive();
    cons.setSuppressLabelCreation(true);

    GeoFunction func = null;
    try {
      ValidExpression ve = parser.parseGeoGebraExpression(str);
      GeoElement[] temp = processValidExpression(ve);

      if (temp[0].isGeoFunctionable()) {
        GeoFunctionable f = (GeoFunctionable) temp[0];
        func = f.getGeoFunction();
      } else if (!suppressErrors) app.showError("InvalidInput", str);

    } catch (CircularDefinitionException e) {
      Application.debug("CircularDefinition");
      if (!suppressErrors) app.showError("CircularDefinition");
    } catch (Exception e) {
      e.printStackTrace();
      if (!suppressErrors) app.showError("InvalidInput", str);
    } catch (MyError e) {
      e.printStackTrace();
      if (!suppressErrors) app.showError(e);
    } catch (Error e) {
      e.printStackTrace();
      if (!suppressErrors) app.showError("InvalidInput", str);
    }

    cons.setSuppressLabelCreation(oldMacroMode);
    return func;
  }
Example #3
0
  // G.Sturr 2010-7-5
  // added 'allowErrorDialog' flag to handle the case of unquoted text
  // entries in the spreadsheet
  public GeoElement[] processAlgebraCommandNoExceptionHandling(
      String cmd, boolean storeUndo, boolean allowErrorDialog, boolean throwMyError)
      throws Exception {
    ValidExpression ve;
    try {
      ve = parser.parseGeoGebraExpression(cmd);
    } catch (ParseException e) {
      // e.printStackTrace();
      if (allowErrorDialog) {
        app.showError(app.getError("InvalidInput") + ":\n" + cmd);
        return null;
      }
      throw new MyException(app.getError("InvalidInput") + ":\n" + cmd, MyException.INVALID_INPUT);
    } catch (MyError e) {
      // e.printStackTrace();
      if (allowErrorDialog) {
        app.showError(e.getLocalizedMessage());
        return null;
      }
      throw new Exception(e.getLocalizedMessage());
    } catch (Error e) {
      // e.printStackTrace();
      if (allowErrorDialog) {
        app.showError(app.getError("InvalidInput") + ":\n" + cmd);
        return null;
      }
      throw new Exception(app.getError("InvalidInput") + ":\n" + cmd);
    }

    // process ValidExpression (built by parser)
    GeoElement[] geoElements = null;
    try {
      geoElements = processValidExpression(ve);
      if (storeUndo && geoElements != null) app.storeUndoInfo();
    } catch (MyError e) {
      e.printStackTrace();
      // throw new Exception(e.getLocalizedMessage());

      // show error with nice "Show Online Help" box
      if (allowErrorDialog) { // G.Sturr 2010-7-5
        app.showError(e);
        e.printStackTrace();
      } else if (throwMyError) throw new MyError(app, e.getLocalizedMessage(), e.getcommandName());

      return null;
    } catch (CircularDefinitionException e) {
      Application.debug("CircularDefinition");
      throw e;
    } catch (Exception ex) {
      Application.debug("Exception");
      ex.printStackTrace();
      throw new Exception(app.getError("Error") + ":\n" + ex.getLocalizedMessage());
    }
    return geoElements;
  }
Example #4
0
  // returns non-null GeoElement array when successful
  public GeoElement[] processAlgebraCommand(String cmd, boolean storeUndo) {

    try {
      return processAlgebraCommandNoExceptionHandling(cmd, storeUndo, true, false);
    } catch (Exception e) {
      e.printStackTrace();
      app.showError(e.getMessage());
      return null;
    }
  }
Example #5
0
  /**
   * for AlgebraView changes in the tree selection and redefine dialog
   *
   * @return changed geo
   */
  public GeoElement changeGeoElement(
      GeoElement geo, String newValue, boolean redefineIndependent, boolean storeUndoInfo) {

    try {
      return changeGeoElementNoExceptionHandling(geo, newValue, redefineIndependent, storeUndoInfo);
    } catch (Exception e) {
      app.showError(e.getMessage());
      return null;
    }
  }
  /** shows dialog with syntax info cmd is the internal command name */
  private void showCommandHelp(String cmd) {
    // show help for current command (current word)
    String help = app.getCommandSyntax(cmd);

    // show help if available
    if (help != null) {
      app.showError(new MyError(app, app.getPlain("Syntax") + ":\n" + help, cmd));
    } else {
      app.getGuiManager().openCommandHelp(null);
    }
  }
Example #7
0
  /**
   * Parses given String str and tries to evaluate it to a GeoPoint. Returns null if something went
   * wrong.
   */
  public GeoPointND evaluateToPoint(String str, boolean showErrors) {
    boolean oldMacroMode = cons.isSuppressLabelsActive();
    cons.setSuppressLabelCreation(true);

    GeoPointND p = null;
    GeoElement[] temp = null;
    ;
    try {
      ValidExpression ve = parser.parseGeoGebraExpression(str);
      if (ve instanceof ExpressionNode) {
        ExpressionNode en = (ExpressionNode) ve;
        en.setForcePoint();
      }

      temp = processValidExpression(ve);
      p = (GeoPointND) temp[0];
    } catch (CircularDefinitionException e) {
      if (showErrors) {
        Application.debug("CircularDefinition");
        app.showError("CircularDefinition");
      }
    } catch (Exception e) {
      if (showErrors) {
        e.printStackTrace();
        app.showError("InvalidInput", str);
      }
    } catch (MyError e) {
      if (showErrors) {
        e.printStackTrace();
        app.showError(e);
      }
    } catch (Error e) {
      if (showErrors) {
        e.printStackTrace();
        app.showError("InvalidInput", str);
      }
    }

    cons.setSuppressLabelCreation(oldMacroMode);
    return p;
  }
Example #8
0
 /**
  * Parses given String str and tries to evaluate it to a double. Returns Double.NaN if something
  * went wrong.
  */
 public double evaluateToDouble(String str, boolean suppressErrors) {
   try {
     ValidExpression ve = parser.parseExpression(str);
     ExpressionNode en = (ExpressionNode) ve;
     en.resolveVariables();
     NumberValue nv = (NumberValue) en.evaluate();
     return nv.getDouble();
   } catch (Exception e) {
     e.printStackTrace();
     if (!suppressErrors) app.showError("InvalidInput", str);
     return Double.NaN;
   } catch (MyError e) {
     e.printStackTrace();
     if (!suppressErrors) app.showError(e);
     return Double.NaN;
   } catch (Error e) {
     e.printStackTrace();
     if (!suppressErrors) app.showError("InvalidInput", str);
     return Double.NaN;
   }
 }
  /*
   * attempt to give Syntax help for when eg "Radius[ <Conic> ]" is typed
   * see CommandProcessor.argErr() for similar error
   */
  public void showError(Exception e) {
    if (e instanceof MyException) {
      updateCurrentWord(true);
      int err = ((MyException) e).getErrorType();
      if (err == MyException.INVALID_INPUT) {
        String command = app.getReverseCommand(getCurrentWord());
        if (command != null) {

          app.showError(
              new MyError(
                  app,
                  app.getError("InvalidInput")
                      + "\n\n"
                      + app.getPlain("Syntax")
                      + ":\n"
                      + app.getCommandSyntax(command),
                  getCurrentWord()));
          return;
        }
      }
    }
    // can't work out anything better, just show "Invalid Input"
    app.showError(e.getLocalizedMessage());
  }
 /*
  * just show syntax error (already correctly formulated by CommandProcessor.argErr())
  */
 public void showError(MyError e) {
   app.showError(e);
 }
Example #11
0
  /**
   * Processes the given casCell, i.e. compute its output depending on its input. Note that this may
   * create an additional twin GeoElement.
   */
  public final void processCasCell(GeoCasCell casCell) throws MyError {
    // TODO: remove
    System.out.println("*** processCasCell: " + casCell);

    // check for CircularDefinition
    if (casCell.isCircularDefinition()) {
      // set twin geo to undefined
      casCell.computeOutput();
      casCell.updateCascade();
      app.showError("CircularDefinition");
      return;
    }

    AlgoElement algoParent = casCell.getParentAlgorithm();
    boolean prevFree = algoParent == null;
    boolean nowFree = casCell.getGeoElementVariables() == null;
    boolean needsRedefinition = false;

    if (prevFree) {
      if (nowFree) {
        // free -> free, e.g. m := 7  ->  m := 8
        cons.addToConstructionList(casCell, true);
        casCell.computeOutput(); // create twinGeo if necessary	
        casCell.setLabelOfTwinGeo();
        needsRedefinition = false;
      } else {
        // free -> dependent, e.g. m := 7  ->  m := c+2
        if (casCell.isOutputEmpty() && !casCell.hasChildren()) {
          // this is a new casCell
          cons.removeFromConstructionList(casCell);
          kernel.DependentCasCell(casCell);
          needsRedefinition = false;
        } else {
          // existing casCell with possible twinGeo
          needsRedefinition = true;
        }
      }
    } else {
      if (nowFree) {
        // dependent -> free, e.g. m := c+2  ->  m := 7
        // algorithm will be removed through redefinition
        needsRedefinition = true;
      } else {
        // dependent -> dependent, e.g. m := c+2  ->  m := c+d
        // we already have an algorithm but need redefinition
        // in order to move it to the right place in construction list
        needsRedefinition = true;
      }
    }

    if (needsRedefinition) {
      try {
        // update construction order and
        // rebuild construction using XML
        cons.changeCasCell(casCell);
      } catch (Exception e) {
        casCell.setError("RedefinitionFailed");
        // app.showError(e.getMessage());
      }
    } else {
      casCell.updateCascade();
    }
  }