New core implementation

calculatorpp-core/src/main/java/org/solovyev/android/calculator/AbstractNumberBuilder.java

@@ -4,7 +4,7 @@
  * or visit http://se.solovyev.org
  */
 
-package org.solovyev.android.calculator.model;
+package org.solovyev.android.calculator;
 
 import jscl.MathEngine;
 import jscl.NumeralBase;

calculatorpp-core/src/main/java/org/solovyev/android/calculator/Calculator.java

@@ -0,0 +1,9 @@
+package org.solovyev.android.calculator;
+
+/**
+ * User: Solovyev_S
+ * Date: 20.09.12
+ * Time: 16:38
+ */
+public interface Calculator extends CalculatorEventContainer {
+}

calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorEvalException.java

@@ -4,9 +4,8 @@
  * or visit http://se.solovyev.org
  */
 
-package org.solovyev.android.calculator.model;
+package org.solovyev.android.calculator;
 
-import jscl.AbstractJsclArithmeticException;
 import org.jetbrains.annotations.NotNull;
 import org.solovyev.common.exceptions.SersoException;
 import org.solovyev.common.msg.Message;

calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorEventContainer.java

@@ -0,0 +1,57 @@
+package org.solovyev.android.calculator;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+/**
+ * User: Solovyev_S
+ * Date: 20.09.12
+ * Time: 16:39
+ */
+public interface CalculatorEventContainer {
+
+    void addCalculatorEventListener(@NotNull CalculatorEventListener calculatorEventListener);
+
+    void removeCalculatorEventListener(@NotNull CalculatorEventListener calculatorEventListener);
+
+    void fireCalculatorEvent(@NotNull CalculatorEventData calculatorEventData, @NotNull CalculatorEventType calculatorEventType, @Nullable Object data);
+
+    void fireCalculatorEvents(@NotNull List<CalculatorEvent> calculatorEvents);
+
+    public static class CalculatorEvent {
+
+        @NotNull
+        private CalculatorEventData calculatorEventData;
+
+        @NotNull
+        private CalculatorEventType calculatorEventType;
+
+        @Nullable
+        private Object data;
+
+        public CalculatorEvent(@NotNull CalculatorEventData calculatorEventData,
+                               @NotNull CalculatorEventType calculatorEventType,
+                               @Nullable Object data) {
+            this.calculatorEventData = calculatorEventData;
+            this.calculatorEventType = calculatorEventType;
+            this.data = data;
+        }
+
+        @NotNull
+        public CalculatorEventData getCalculatorEventData() {
+            return calculatorEventData;
+        }
+
+        @NotNull
+        public CalculatorEventType getCalculatorEventType() {
+            return calculatorEventType;
+        }
+
+        @Nullable
+        public Object getData() {
+            return data;
+        }
+    }
+}

calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorEventData.java

@@ -0,0 +1,11 @@
+package org.solovyev.android.calculator;
+
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * User: Solovyev_S
+ * Date: 20.09.12
+ * Time: 16:51
+ */
+public interface CalculatorEventData extends CalculatorEventDataId {
+}

calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorEventDataId.java

@@ -0,0 +1,17 @@
+package org.solovyev.android.calculator;
+
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * User: Solovyev_S
+ * Date: 20.09.12
+ * Time: 18:18
+ */
+public interface CalculatorEventDataId {
+
+    // the higher id => the later event
+    long getEventId();
+
+    @Nullable
+    Long getCalculationId();
+}

calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorEventDataIdImpl.java

@@ -0,0 +1,61 @@
+package org.solovyev.android.calculator;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * User: Solovyev_S
+ * Date: 20.09.12
+ * Time: 18:18
+ */
+public class CalculatorEventDataIdImpl implements CalculatorEventDataId {
+
+    private final long eventId;
+
+    @Nullable
+    private final Long calculationId;
+
+    private CalculatorEventDataIdImpl(long id,
+                                      @Nullable Long calculationId) {
+        this.eventId = id;
+        this.calculationId = calculationId;
+    }
+
+    @NotNull
+    public static CalculatorEventDataId newInstance(long id,
+                                                    @Nullable Long calculationId) {
+        return new CalculatorEventDataIdImpl(id, calculationId);
+    }
+
+    @Override
+    public long getEventId() {
+        return this.eventId;
+    }
+
+    @Nullable
+    @Override
+    public Long getCalculationId() {
+        return this.calculationId;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof CalculatorEventDataIdImpl)) return false;
+
+        CalculatorEventDataIdImpl that = (CalculatorEventDataIdImpl) o;
+
+        if (eventId != that.eventId) return false;
+        if (calculationId != null ? !calculationId.equals(that.calculationId) : that.calculationId != null)
+            return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = (int) (eventId ^ (eventId >>> 32));
+        result = 31 * result + (calculationId != null ? calculationId.hashCode() : 0);
+        return result;
+    }
+}

calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorEventDataImpl.java

@@ -0,0 +1,47 @@
+package org.solovyev.android.calculator;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * User: Solovyev_S
+ * Date: 20.09.12
+ * Time: 16:54
+ */
+class CalculatorEventDataImpl implements CalculatorEventData {
+
+    @NotNull
+    private CalculatorEventDataId calculatorEventDataId;
+
+    CalculatorEventDataImpl(@NotNull CalculatorEventDataId calculatorEventDataId) {
+        this.calculatorEventDataId = calculatorEventDataId;
+    }
+
+    @Override
+    public long getEventId() {
+        return calculatorEventDataId.getEventId();
+    }
+
+    @Override
+    @Nullable
+    public Long getCalculationId() {
+        return calculatorEventDataId.getCalculationId();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof CalculatorEventDataImpl)) return false;
+
+        CalculatorEventDataImpl that = (CalculatorEventDataImpl) o;
+
+        if (!calculatorEventDataId.equals(that.calculatorEventDataId)) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        return calculatorEventDataId.hashCode();
+    }
+}

calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorEventListener.java

@@ -0,0 +1,17 @@
+package org.solovyev.android.calculator;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.EventListener;
+
+/**
+ * User: Solovyev_S
+ * Date: 20.09.12
+ * Time: 16:39
+ */
+public interface CalculatorEventListener extends EventListener {
+
+    void onCalculatorEvent(@NotNull CalculatorEventData calculatorEventData, @NotNull CalculatorEventType calculatorEventType, @Nullable Object data);
+
+}

calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorEventType.java

@@ -0,0 +1,9 @@
+package org.solovyev.android.calculator;
+
+/**
+ * User: Solovyev_S
+ * Date: 20.09.12
+ * Time: 16:40
+ */
+public enum CalculatorEventType {
+}

calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorImpl.java

@@ -0,0 +1,168 @@
+package org.solovyev.android.calculator;
+
+import jscl.AbstractJsclArithmeticException;
+import jscl.NumeralBaseException;
+import jscl.math.Generic;
+import jscl.text.ParseInterruptedException;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.solovyev.android.calculator.jscl.JsclOperation;
+import org.solovyev.android.calculator.text.TextProcessor;
+import org.solovyev.common.msg.MessageRegistry;
+
+import java.util.List;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicLong;
+
+/**
+ * User: Solovyev_S
+ * Date: 20.09.12
+ * Time: 16:42
+ */
+public class CalculatorImpl implements Calculator {
+
+    @NotNull
+    private final CalculatorEventContainer calculatorEventContainer = new ListCalculatorEventContainer();
+
+    @NotNull
+    private static final Calculator instance = new CalculatorImpl();
+
+    @NotNull
+    private final AtomicLong counter = new AtomicLong(0);
+
+    @NotNull
+    private final Object lock = new Object();
+
+    @NotNull
+    private final TextProcessor<PreparedExpression, String> preprocessor = ToJsclTextProcessor.getInstance();
+
+    @NotNull
+    private final Executor threadPoolExecutor = Executors.newFixedThreadPool(10);
+
+    private CalculatorImpl() {
+    }
+
+    @NotNull
+    public static Calculator getInstance() {
+        return instance;
+    }
+
+    @NotNull
+    private CalculatorEventDataId nextCalculatorEventDataId() {
+        long eventId = counter.incrementAndGet();
+        return CalculatorEventDataIdImpl.newInstance(eventId, eventId);
+    }
+
+    /*
+    **********************************************************************
+    *
+    *                           CALCULATION
+    *
+    **********************************************************************
+    */
+
+    public void evaluate(@NotNull JsclOperation operation,
+                         @NotNull String expression) {
+        evaluate(operation, expression, null);
+    }
+
+    public void evaluate(@NotNull final JsclOperation operation,
+                         @NotNull final String expression,
+                         @Nullable final MessageRegistry mr) {
+
+        final CalculatorEventDataId eventDataId = nextCalculatorEventDataId();
+
+        threadPoolExecutor.execute(new Runnable() {
+            @Override
+            public void run() {
+                CalculatorImpl.this.evaluate(eventDataId, operation, expression, mr);
+            }
+        });
+    }
+
+    private void evaluate(@NotNull CalculatorEventDataId eventDataId,
+                          @NotNull JsclOperation operation,
+                          @NotNull String expression,
+                          @Nullable MessageRegistry mr) {
+        synchronized (lock) {
+            PreparedExpression preparedExpression = null;
+
+            try {
+                preparedExpression = preprocessor.process(expression);
+
+                final String jsclExpression = preparedExpression.toString();
+                try {
+
+                    final Generic genericResult = operation.evaluateGeneric(jsclExpression);
+
+                    // NOTE: toString() method must be called here as ArithmeticOperationException may occur in it (just to avoid later check!)
+                    genericResult.toString();
+
+                    //return new Result(operation.getFromProcessor().process(genericResult), operation, genericResult);
+                } catch (AbstractJsclArithmeticException e) {
+                    handleException(eventDataId, operation, expression, mr, preparedExpression, null, new CalculatorEvalException(e, e, jsclExpression));
+                }
+
+            } catch (ArithmeticException e) {
+                //final AndroidMessage androidMessage = new AndroidMessage(R.string.msg_1, MessageType.error, CalculatorApplication.getInstance(), e.getMessage());
+                handleException(operation, expression, mr, preparedExpression, new CalculatorParseException(jsclExpression, androidMessage));
+            } catch (StackOverflowError e) {
+                //final AndroidMessage androidMessage = new AndroidMessage(R.string.msg_2, MessageType.error, CalculatorApplication.getInstance());
+                handleException(eventDataId, operation, expression, mr, preparedExpression, new CalculatorParseException(e), null);
+            } catch (jscl.text.ParseException e) {
+                //System.out.println(e.getMessage());
+                handleException(eventDataId, operation, expression, mr, preparedExpression, new CalculatorParseException(e), null);
+            } catch (ParseInterruptedException e) {
+                // do nothing - we ourselves interrupt the calculations
+            } catch (CalculatorParseException e) {
+                handleException(eventDataId, operation, expression, mr, preparedExpression, e, null);
+            }
+        }
+    }
+
+    private void handleException(@NotNull CalculatorEventDataId eventDataId,
+                                 @NotNull JsclOperation operation,
+                                 @NotNull String expression,
+                                 @Nullable MessageRegistry mr,
+                                 @Nullable PreparedExpression preparedExpression,
+                                 @Nullable CalculatorParseException parseException,
+                                 @Nullable CalculatorEvalException evalException) {
+        if (operation == JsclOperation.numeric && (preparedExpression != null && preparedExpression.isExistsUndefinedVar() || (evalException != null && evalException.getCause() instanceof NumeralBaseException))) {
+            evaluate(eventDataId, JsclOperation.simplify, expression, mr);
+        }
+
+        if (parseException != null) {
+            throw parseException;
+        } else {
+            throw evalException;
+        }
+    }
+
+    /*
+    **********************************************************************
+    *
+    *                           EVENTS
+    *
+    **********************************************************************
+    */
+
+    @Override
+    public void addCalculatorEventListener(@NotNull CalculatorEventListener calculatorEventListener) {
+        calculatorEventContainer.addCalculatorEventListener(calculatorEventListener);
+    }
+
+    @Override
+    public void removeCalculatorEventListener(@NotNull CalculatorEventListener calculatorEventListener) {
+        calculatorEventContainer.removeCalculatorEventListener(calculatorEventListener);
+    }
+
+    @Override
+    public void fireCalculatorEvent(@NotNull CalculatorEventData calculatorEventData, @NotNull CalculatorEventType calculatorEventType, @Nullable Object data) {
+        calculatorEventContainer.fireCalculatorEvent(calculatorEventData, calculatorEventType, data);
+    }
+
+    @Override
+    public void fireCalculatorEvents(@NotNull List<CalculatorEvent> calculatorEvents) {
+        calculatorEventContainer.fireCalculatorEvents(calculatorEvents);
+    }
+}

calculatorpp-core/src/main/java/org/solovyev/android/calculator/JCalculatorDisplay.java

@@ -17,7 +17,7 @@ import org.solovyev.android.calculator.jscl.JsclOperation;
  * Date: 12/17/11
  * Time: 9:45 PM
  */
-public interface ICalculatorDisplay extends Editor{
+public interface JCalculatorDisplay extends Editor{
 
 	boolean isValid();
 

calculatorpp-core/src/main/java/org/solovyev/android/calculator/ListCalculatorEventContainer.java

@@ -0,0 +1,50 @@
+package org.solovyev.android.calculator;
+
+import android.util.Log;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.solovyev.common.utils.ListListenersContainer;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * User: Solovyev_S
+ * Date: 20.09.12
+ * Time: 16:42
+ */
+public class ListCalculatorEventContainer implements CalculatorEventContainer {
+
+    @NotNull
+    private static final String TAG = "CalculatorEventData";
+
+    @NotNull
+    private final ListListenersContainer<CalculatorEventListener> listeners = new ListListenersContainer<CalculatorEventListener>();
+
+    @Override
+    public void addCalculatorEventListener(@NotNull CalculatorEventListener calculatorEventListener) {
+        listeners.addListener(calculatorEventListener);
+    }
+
+    @Override
+    public void removeCalculatorEventListener(@NotNull CalculatorEventListener calculatorEventListener) {
+        listeners.removeListener(calculatorEventListener);
+    }
+
+    @Override
+    public void fireCalculatorEvent(@NotNull CalculatorEventData calculatorEventData, @NotNull CalculatorEventType calculatorEventType, @Nullable Object data) {
+        fireCalculatorEvents(Arrays.asList(new CalculatorEvent(calculatorEventData, calculatorEventType, data)));
+    }
+
+    @Override
+    public void fireCalculatorEvents(@NotNull List<CalculatorEvent> calculatorEvents) {
+        final List<CalculatorEventListener> listeners = this.listeners.getListeners();
+
+        for (CalculatorEvent e : calculatorEvents) {
+            Log.d(TAG, "Event: " + e.getCalculatorEventType() + " with data: " + e.getData());
+            for (CalculatorEventListener listener : listeners) {
+                listener.onCalculatorEvent(e.getCalculatorEventData(), e.getCalculatorEventType(), e.getData());
+            }
+        }
+    }
+}

calculatorpp-core/src/main/java/org/solovyev/android/calculator/LiteNumberBuilder.java

@@ -4,7 +4,7 @@
  * or visit http://se.solovyev.org
  */
 
-package org.solovyev.android.calculator.model;
+package org.solovyev.android.calculator;
 
 import jscl.MathEngine;
 import jscl.NumeralBase;

calculatorpp-core/src/main/java/org/solovyev/android/calculator/NumberBuilder.java

@@ -4,7 +4,7 @@
  * or visit http://se.solovyev.org
  */
 
-package org.solovyev.android.calculator.model;
+package org.solovyev.android.calculator;
 
 import jscl.MathContext;
 import jscl.MathEngine;
@@ -13,6 +13,7 @@ import jscl.math.numeric.Real;
 import jscl.text.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.solovyev.android.calculator.AbstractNumberBuilder;
 import org.solovyev.android.calculator.math.MathType;
 import org.solovyev.common.MutableObject;
 
@@ -82,7 +83,7 @@ public class NumberBuilder extends AbstractNumberBuilder {
 
 		String number = null;
 
-		// save numeral base (as later it might be replaced)
+		// toXml numeral base (as later it might be replaced)
 		final NumeralBase localNb = getNumeralBase();
 
 		if (numberBuilder != null) {

calculatorpp-core/src/main/java/org/solovyev/android/calculator/PreparedExpression.java

@@ -4,7 +4,7 @@
  * or visit http://se.solovyev.org
  */
 
-package org.solovyev.android.calculator.model;
+package org.solovyev.android.calculator;
 
 import jscl.math.function.IConstant;
 import org.jetbrains.annotations.NotNull;

calculatorpp-core/src/main/java/org/solovyev/android/calculator/ToJsclTextProcessor.java

@@ -4,12 +4,13 @@
  * or visit http://se.solovyev.org
  */
 
-package org.solovyev.android.calculator.model;
+package org.solovyev.android.calculator;
 
 import jscl.math.function.IConstant;
 import org.jetbrains.annotations.NotNull;
 import org.solovyev.android.calculator.CalculatorApplication;
 import org.solovyev.android.calculator.CalculatorParseException;
+import org.solovyev.android.calculator.PreparedExpression;
 import org.solovyev.android.calculator.R;
 import org.solovyev.android.calculator.text.TextProcessor;
 import org.solovyev.android.msg.AndroidMessage;

calculatorpp-core/src/main/java/org/solovyev/android/calculator/history/CalculatorDisplayHistoryState.java

@@ -11,7 +11,7 @@ import org.jetbrains.annotations.Nullable;
 import org.simpleframework.xml.Element;
 import org.simpleframework.xml.Root;
 import org.simpleframework.xml.Transient;
-import org.solovyev.android.calculator.ICalculatorDisplay;
+import org.solovyev.android.calculator.JCalculatorDisplay;
 import org.solovyev.android.calculator.jscl.JsclOperation;
 
 /**
@@ -47,7 +47,7 @@ public class CalculatorDisplayHistoryState implements Cloneable {
 	}
 
 	@NotNull
-	public static CalculatorDisplayHistoryState newInstance(@NotNull ICalculatorDisplay display) {
+	public static CalculatorDisplayHistoryState newInstance(@NotNull JCalculatorDisplay display) {
 		final CalculatorDisplayHistoryState result = new CalculatorDisplayHistoryState();
 
 		result.editorState = EditorHistoryState.newInstance(display);
@@ -59,7 +59,7 @@ public class CalculatorDisplayHistoryState implements Cloneable {
 		return result;
 	}
 
-	public void setValuesFromHistory(@NotNull ICalculatorDisplay display) {
+	public void setValuesFromHistory(@NotNull JCalculatorDisplay display) {
 		this.getEditorState().setValuesFromHistory(display);
 		display.setValid(this.isValid());
 		display.setErrorMessage(this.getErrorMessage());

calculatorpp-core/src/main/java/org/solovyev/android/calculator/history/CalculatorHistory.java

@@ -0,0 +1,20 @@
+package org.solovyev.android.calculator.history;
+
+import org.jetbrains.annotations.NotNull;
+import org.solovyev.common.history.HistoryHelper;
+
+/**
+ * User: Solovyev_S
+ * Date: 20.09.12
+ * Time: 16:11
+ */
+public interface CalculatorHistory extends HistoryHelper<CalculatorHistoryState> {
+
+    void fromXml(@NotNull String xml);
+
+    String toXml();
+
+    void clearSavedHistory();
+
+    void removeSavedHistory(@NotNull CalculatorHistoryState historyState);
+}

calculatorpp-core/src/main/java/org/solovyev/android/calculator/history/CalculatorHistoryImpl.java

@@ -0,0 +1,131 @@
+package org.solovyev.android.calculator.history;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.solovyev.common.history.HistoryAction;
+import org.solovyev.common.history.HistoryHelper;
+import org.solovyev.common.history.SimpleHistoryHelper;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * User: Solovyev_S
+ * Date: 20.09.12
+ * Time: 16:12
+ */
+public class CalculatorHistoryImpl implements CalculatorHistory {
+
+    private final AtomicInteger counter = new AtomicInteger(0);
+
+    @NotNull
+    private final HistoryHelper<CalculatorHistoryState> history = new SimpleHistoryHelper<CalculatorHistoryState>();
+
+    @NotNull
+    private final List<CalculatorHistoryState> savedHistory = new ArrayList<CalculatorHistoryState>();
+
+    @Override
+    public boolean isEmpty() {
+        return this.history.isEmpty();
+    }
+
+    @Override
+    public CalculatorHistoryState getLastHistoryState() {
+        return this.history.getLastHistoryState();
+    }
+
+    @Override
+    public boolean isUndoAvailable() {
+        return history.isUndoAvailable();
+    }
+
+    @Override
+    public CalculatorHistoryState undo(@Nullable CalculatorHistoryState currentState) {
+        return history.undo(currentState);
+    }
+
+    @Override
+    public boolean isRedoAvailable() {
+        return history.isRedoAvailable();
+    }
+
+    @Override
+    public CalculatorHistoryState redo(@Nullable CalculatorHistoryState currentState) {
+        return history.redo(currentState);
+    }
+
+    @Override
+    public boolean isActionAvailable(@NotNull HistoryAction historyAction) {
+        return history.isActionAvailable(historyAction);
+    }
+
+    @Override
+    public CalculatorHistoryState doAction(@NotNull HistoryAction historyAction, @Nullable CalculatorHistoryState currentState) {
+        return history.doAction(historyAction, currentState);
+    }
+
+    @Override
+    public void addState(@Nullable CalculatorHistoryState currentState) {
+        history.addState(currentState);
+    }
+
+    @NotNull
+    @Override
+    public List<CalculatorHistoryState> getStates() {
+        return history.getStates();
+    }
+
+    @Override
+    public void clear() {
+        this.history.clear();
+    }
+
+    @NotNull
+    public List<CalculatorHistoryState> getSavedHistory() {
+        return Collections.unmodifiableList(savedHistory);
+    }
+
+    @NotNull
+    public CalculatorHistoryState addSavedState(@NotNull CalculatorHistoryState historyState) {
+        if (historyState.isSaved()) {
+            return historyState;
+        } else {
+            final CalculatorHistoryState savedState = historyState.clone();
+
+            savedState.setId(counter.incrementAndGet());
+            savedState.setSaved(true);
+
+            savedHistory.add(savedState);
+
+            return savedState;
+        }
+    }
+
+    @Override
+    public void fromXml(@NotNull String xml) {
+        clearSavedHistory();
+
+        HistoryUtils.fromXml(xml, this.savedHistory);
+        for (CalculatorHistoryState historyState : savedHistory) {
+            historyState.setSaved(true);
+            historyState.setId(counter.incrementAndGet());
+        }
+    }
+
+    @Override
+    public String toXml() {
+        return HistoryUtils.toXml(this.savedHistory);
+    }
+
+    @Override
+    public void clearSavedHistory() {
+        this.savedHistory.clear();
+    }
+
+    @Override
+    public void removeSavedHistory(@NotNull CalculatorHistoryState historyState) {
+        this.savedHistory.remove(historyState);
+    }
+}

calculatorpp-core/src/main/java/org/solovyev/android/calculator/history/CalculatorHistoryState.java

@@ -9,7 +9,7 @@ import org.jetbrains.annotations.NotNull;
 import org.simpleframework.xml.Element;
 import org.simpleframework.xml.Root;
 import org.solovyev.android.calculator.Editor;
-import org.solovyev.android.calculator.ICalculatorDisplay;
+import org.solovyev.android.calculator.JCalculatorDisplay;
 
 /**
  * User: serso
@@ -38,7 +38,7 @@ public class CalculatorHistoryState extends AbstractHistoryState {
 		this.displayState = displayState;
 	}
 
-	public static CalculatorHistoryState newInstance(@NotNull Editor editor, @NotNull ICalculatorDisplay display) {
+	public static CalculatorHistoryState newInstance(@NotNull Editor editor, @NotNull JCalculatorDisplay display) {
 		final EditorHistoryState editorHistoryState = EditorHistoryState.newInstance(editor);
 		final CalculatorDisplayHistoryState displayHistoryState = CalculatorDisplayHistoryState.newInstance(display);
 		return new CalculatorHistoryState(editorHistoryState, displayHistoryState);
@@ -94,7 +94,7 @@ public class CalculatorHistoryState extends AbstractHistoryState {
 		return result;
 	}
 
-	public void setValuesFromHistory(@NotNull Editor editor, @NotNull ICalculatorDisplay display) {
+	public void setValuesFromHistory(@NotNull Editor editor, @NotNull JCalculatorDisplay display) {
 		this.getEditorState().setValuesFromHistory(editor);
 		this.getDisplayState().setValuesFromHistory(display);
 	}

calculatorpp-core/src/main/java/org/solovyev/common/utils/ListListenersContainer.java

@@ -0,0 +1,77 @@
+package org.solovyev.common.utils;
+
+import com.google.common.base.Predicate;
+import com.google.common.collect.Iterables;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * User: Solovyev_S
+ * Date: 20.09.12
+ * Time: 16:43
+ */
+// todo serso: move to common
+public class ListListenersContainer<T> {
+
+    @NotNull
+    private final List<WeakReference<T>> listeners = new ArrayList<WeakReference<T>>();
+
+    public void addListener(@NotNull final T listener) {
+        synchronized (listeners) {
+            boolean contains = Iterables.any(listeners, new WeakReferencePredicate<T>(listener));
+
+            if (!contains) {
+                listeners.add(new WeakReference<T>(listener));
+            }
+        }
+    }
+
+    public void removeListener(@NotNull T listener) {
+        synchronized (listeners) {
+            Iterables.removeIf(listeners, new WeakReferencePredicate<T>(listener));
+        }
+    }
+
+    @NotNull
+    public List<T> getListeners() {
+        final List<T> localListeners;
+
+        synchronized (listeners) {
+            localListeners = new ArrayList<T>(listeners.size());
+
+            // copy listeners and remove garbage collected references
+            for ( Iterator<WeakReference<T>> it = listeners.iterator(); it.hasNext();  ) {
+                final WeakReference<T> r = it.next();
+                final T t = r.get();
+                if ( t == null ) {
+                    it.remove();
+                } else {
+                    localListeners.add(t);
+                }
+            }
+        }
+
+        return localListeners;
+    }
+
+    private static class WeakReferencePredicate<T> implements Predicate<WeakReference<T>> {
+
+        @NotNull
+        private final T t;
+
+        public WeakReferencePredicate(T t) {
+            this.t = t;
+        }
+
+        @Override
+        public boolean apply(@Nullable WeakReference<T> r) {
+            final T t = r != null ? r.get() : null;
+            return this.t.equals(t);
+        }
+    }
+}

calculatorpp/src/main/java/org/solovyev/android/calculator/CalculatorActivity.java

@@ -32,7 +32,7 @@ import org.solovyev.android.AndroidUtils;
 import org.solovyev.android.FontSizeAdjuster;
 import org.solovyev.android.LocalBinder;
 import org.solovyev.android.calculator.about.CalculatorReleaseNotesActivity;
-import org.solovyev.android.calculator.history.CalculatorHistory;
+import org.solovyev.android.calculator.history.AndroidCalculatorHistoryImpl;
 import org.solovyev.android.calculator.history.CalculatorHistoryState;
 import org.solovyev.android.calculator.model.CalculatorEngine;
 import org.solovyev.android.calculator.view.AngleUnitsButton;
@@ -136,7 +136,7 @@ public class CalculatorActivity extends Activity implements FontSizeAdjuster, Sh
 
 		vibrator = (Vibrator) this.getSystemService(VIBRATOR_SERVICE);
 
-		CalculatorHistory.instance.load(this, preferences);
+		AndroidCalculatorHistoryImpl.instance.load(this, preferences);
 		calculatorModel = CalculatorModel.instance.init(this, preferences, CalculatorEngine.instance);
 
 		dpclRegister.clear();

calculatorpp/src/main/java/org/solovyev/android/calculator/CalculatorDisplay.java

@@ -19,7 +19,7 @@ import org.jetbrains.annotations.Nullable;
 import org.solovyev.android.calculator.jscl.JsclOperation;
 import org.solovyev.android.calculator.model.CalculatorEngine;
 import org.solovyev.android.calculator.text.TextProcessor;
-import org.solovyev.android.calculator.model.ToJsclTextProcessor;
+import org.solovyev.android.calculator.ToJsclTextProcessor;
 import org.solovyev.android.calculator.view.NumeralBaseConverterDialog;
 import org.solovyev.android.calculator.view.TextHighlighter;
 import org.solovyev.android.calculator.view.UnitConverterViewBuilder;
@@ -37,7 +37,7 @@ import java.util.Set;
  * Date: 9/17/11
  * Time: 10:58 PM
  */
-public class CalculatorDisplay extends AutoResizeTextView implements ICalculatorDisplay{
+public class CalculatorDisplay extends AutoResizeTextView implements JCalculatorDisplay {
 
     private static enum ConversionMenuItem implements AMenuItem<CalculatorDisplay> {
         convert_to_bin(NumeralBase.bin),

calculatorpp/src/main/java/org/solovyev/android/calculator/CalculatorModel.java

@@ -20,13 +20,12 @@ import android.widget.Toast;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.solovyev.android.CursorControl;
-import org.solovyev.android.calculator.history.CalculatorHistory;
+import org.solovyev.android.calculator.history.AndroidCalculatorHistoryImpl;
 import org.solovyev.android.calculator.history.CalculatorHistoryState;
 import org.solovyev.android.calculator.history.TextViewEditorAdapter;
 import org.solovyev.android.calculator.jscl.JsclOperation;
 import org.solovyev.android.calculator.math.MathType;
 import org.solovyev.android.calculator.model.CalculatorEngine;
-import org.solovyev.android.calculator.model.CalculatorEvalException;
 import org.solovyev.android.history.HistoryControl;
 import org.solovyev.android.menu.AMenuBuilder;
 import org.solovyev.android.menu.MenuImpl;
@@ -70,7 +69,7 @@ public enum CalculatorModel implements CursorControl, HistoryControl<CalculatorH
 		this.display = (CalculatorDisplay) activity.findViewById(R.id.calculatorDisplay);
 		this.display.setOnClickListener(new CalculatorDisplayOnClickListener(activity));
 
-		final CalculatorHistoryState lastState = CalculatorHistory.instance.getLastHistoryState();
+		final CalculatorHistoryState lastState = AndroidCalculatorHistoryImpl.instance.getLastHistoryState();
 		if (lastState == null) {
 			saveHistoryState();
 		} else {
@@ -110,7 +109,7 @@ public enum CalculatorModel implements CursorControl, HistoryControl<CalculatorH
 	}
 
 	private void saveHistoryState() {
-		CalculatorHistory.instance.addState(getCurrentHistoryState());
+		AndroidCalculatorHistoryImpl.instance.addState(getCurrentHistoryState());
 	}
 
 	public void setCursorOnStart() {
@@ -196,14 +195,14 @@ public enum CalculatorModel implements CursorControl, HistoryControl<CalculatorH
 
 		if (delayEvaluate) {
 			if (historyState == null) {
-				CalculatorHistory.instance.addState(localHistoryState);
+				AndroidCalculatorHistoryImpl.instance.addState(localHistoryState);
 			}
             // todo serso: this is not correct - operation is processing still in the same thread
 			new Handler().postDelayed(pendingOperation.getObject(), EVAL_DELAY_MILLIS);
 		} else {
 			pendingOperation.getObject().run();
 			if (historyState == null) {
-				CalculatorHistory.instance.addState(localHistoryState);
+				AndroidCalculatorHistoryImpl.instance.addState(localHistoryState);
 			}
 		}
 	}
@@ -330,9 +329,9 @@ public enum CalculatorModel implements CursorControl, HistoryControl<CalculatorH
 
     @Override
     public void doHistoryAction(@NotNull HistoryAction historyAction) {
-        synchronized (CalculatorHistory.instance) {
+        synchronized (AndroidCalculatorHistoryImpl.instance) {
-            if (CalculatorHistory.instance.isActionAvailable(historyAction)) {
+            if (AndroidCalculatorHistoryImpl.instance.isActionAvailable(historyAction)) {
-                final CalculatorHistoryState newState = CalculatorHistory.instance.doAction(historyAction, getCurrentHistoryState());
+                final CalculatorHistoryState newState = AndroidCalculatorHistoryImpl.instance.doAction(historyAction, getCurrentHistoryState());
                 if (newState != null) {
                     setCurrentHistoryState(newState);
                 }
@@ -342,7 +341,7 @@ public enum CalculatorModel implements CursorControl, HistoryControl<CalculatorH
 
     @Override
 	public void setCurrentHistoryState(@NotNull CalculatorHistoryState editorHistoryState) {
-		synchronized (CalculatorHistory.instance) {
+		synchronized (AndroidCalculatorHistoryImpl.instance) {
 			Log.d(this.getClass().getName(), "Saved history found: " + editorHistoryState);
 
 			editorHistoryState.setValuesFromHistory(new TextViewEditorAdapter(this.editor), this.display);
@@ -362,7 +361,7 @@ public enum CalculatorModel implements CursorControl, HistoryControl<CalculatorH
 	@Override
 	@NotNull
 	public CalculatorHistoryState getCurrentHistoryState() {
-		synchronized (CalculatorHistory.instance) {
+		synchronized (AndroidCalculatorHistoryImpl.instance) {
 			return CalculatorHistoryState.newInstance(new TextViewEditorAdapter(this.editor), this.display);
 		}
 	}

calculatorpp/src/main/java/org/solovyev/android/calculator/history/AbstractHistoryActivity.java

@@ -157,7 +157,7 @@ public abstract class AbstractHistoryActivity extends ListActivity {
 		boolean result = false;
 		try {
 			historyState.setSaved(true);
-			if ( CollectionsUtils.contains(historyState, CalculatorHistory.instance.getSavedHistory(), new Equalizer<CalculatorHistoryState>() {
+			if ( CollectionsUtils.contains(historyState, AndroidCalculatorHistoryImpl.instance.getSavedHistory(), new Equalizer<CalculatorHistoryState>() {
 				@Override
 				public boolean equals(@Nullable CalculatorHistoryState first, @Nullable CalculatorHistoryState second) {
 					return first != null && second != null &&

calculatorpp/src/main/java/org/solovyev/android/calculator/history/AndroidCalculatorHistory.java

@@ -0,0 +1,18 @@
+package org.solovyev.android.calculator.history;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * User: Solovyev_S
+ * Date: 20.09.12
+ * Time: 16:07
+ */
+public interface AndroidCalculatorHistory extends CalculatorHistory {
+
+	void load(@Nullable Context context, @Nullable SharedPreferences preferences);
+
+	void save(@NotNull Context context);
+}

calculatorpp/src/main/java/org/solovyev/android/calculator/history/AndroidCalculatorHistoryImpl.java

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2009-2011. Created by serso aka se.solovyev.
+ * For more information, please, contact se.solovyev@gmail.com
+ * or visit http://se.solovyev.org
+ */
+
+package org.solovyev.android.calculator.history;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.preference.PreferenceManager;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.solovyev.android.calculator.R;
+import org.solovyev.common.history.HistoryAction;
+
+import java.util.List;
+
+/**
+ * User: serso
+ * Date: 10/9/11
+ * Time: 6:35 PM
+ */
+public enum AndroidCalculatorHistoryImpl implements AndroidCalculatorHistory {
+
+    instance;
+
+    @NotNull
+    private final CalculatorHistoryImpl calculatorHistory = new CalculatorHistoryImpl();
+
+	@Override
+	public void load(@Nullable Context context, @Nullable SharedPreferences preferences) {
+		if (context != null && preferences != null) {
+			final String value = preferences.getString(context.getString(R.string.p_calc_history), null);
+			calculatorHistory.fromXml(value);
+		}
+	}
+
+	@Override
+	public void save(@NotNull Context context) {
+		final SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(context);
+		final SharedPreferences.Editor editor = settings.edit();
+
+		editor.putString(context.getString(R.string.p_calc_history), calculatorHistory.toXml());
+
+		editor.commit();
+	}
+
+    public void clearSavedHistory(@NotNull Context context) {
+        calculatorHistory.clearSavedHistory();
+        save(context);
+    }
+
+    public void removeSavedHistory(@NotNull CalculatorHistoryState historyState, @NotNull Context context) {
+        historyState.setSaved(false);
+        calculatorHistory.removeSavedHistory(historyState);
+        save(context);
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return calculatorHistory.isEmpty();
+    }
+
+    @Override
+    public CalculatorHistoryState getLastHistoryState() {
+        return calculatorHistory.getLastHistoryState();
+    }
+
+    @Override
+    public boolean isUndoAvailable() {
+        return calculatorHistory.isUndoAvailable();
+    }
+
+    @Override
+    public CalculatorHistoryState undo(@Nullable CalculatorHistoryState currentState) {
+        return calculatorHistory.undo(currentState);
+    }
+
+    @Override
+    public boolean isRedoAvailable() {
+        return calculatorHistory.isRedoAvailable();
+    }
+
+    @Override
+    public CalculatorHistoryState redo(@Nullable CalculatorHistoryState currentState) {
+        return calculatorHistory.redo(currentState);
+    }
+
+    @Override
+    public boolean isActionAvailable(@NotNull HistoryAction historyAction) {
+        return calculatorHistory.isActionAvailable(historyAction);
+    }
+
+    @Override
+    public CalculatorHistoryState doAction(@NotNull HistoryAction historyAction, @Nullable CalculatorHistoryState currentState) {
+        return calculatorHistory.doAction(historyAction, currentState);
+    }
+
+    @Override
+    public void addState(@Nullable CalculatorHistoryState currentState) {
+        calculatorHistory.addState(currentState);
+    }
+
+    @NotNull
+    @Override
+    public List<CalculatorHistoryState> getStates() {
+        return calculatorHistory.getStates();
+    }
+
+    @Override
+    public void clear() {
+        calculatorHistory.clear();
+    }
+
+    @NotNull
+    public List<CalculatorHistoryState> getSavedHistory() {
+        return calculatorHistory.getSavedHistory();
+    }
+
+    @NotNull
+    public CalculatorHistoryState addSavedState(@NotNull CalculatorHistoryState historyState) {
+        return calculatorHistory.addSavedState(historyState);
+    }
+
+    @Override
+    public void fromXml(@NotNull String xml) {
+        calculatorHistory.fromXml(xml);
+    }
+
+    @Override
+    public String toXml() {
+        return calculatorHistory.toXml();
+    }
+
+    @Override
+    public void clearSavedHistory() {
+        calculatorHistory.clearSavedHistory();
+    }
+
+    @Override
+    public void removeSavedHistory(@NotNull CalculatorHistoryState historyState) {
+        calculatorHistory.removeSavedHistory(historyState);
+    }
+}

calculatorpp/src/main/java/org/solovyev/android/calculator/history/CalculatorHistory.java

@@ -1,149 +0,0 @@
-/*
- * Copyright (c) 2009-2011. Created by serso aka se.solovyev.
- * For more information, please, contact se.solovyev@gmail.com
- * or visit http://se.solovyev.org
- */
-
-package org.solovyev.android.calculator.history;
-
-import android.content.Context;
-import android.content.SharedPreferences;
-import android.preference.PreferenceManager;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.solovyev.android.calculator.R;
-import org.solovyev.common.history.HistoryAction;
-import org.solovyev.common.history.HistoryHelper;
-import org.solovyev.common.history.SimpleHistoryHelper;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-/**
- * User: serso
- * Date: 10/9/11
- * Time: 6:35 PM
- */
-public enum CalculatorHistory implements HistoryHelper<CalculatorHistoryState> {
-
-	instance;
-
-	// todo serso: not synchronized
-	private int counter = 0;
-
-	@NotNull
-	private final HistoryHelper<CalculatorHistoryState> history = new SimpleHistoryHelper<CalculatorHistoryState>();
-
-	@NotNull
-	private final List<CalculatorHistoryState> savedHistory = new ArrayList<CalculatorHistoryState> ();
-
-	@Override
-	public boolean isEmpty() {
-		return this.history.isEmpty();
-	}
-
-	@Override
-	public CalculatorHistoryState getLastHistoryState() {
-		return this.history.getLastHistoryState();
-	}
-
-	@Override
-	public boolean isUndoAvailable() {
-		return history.isUndoAvailable();
-	}
-
-	@Override
-	public CalculatorHistoryState undo(@Nullable CalculatorHistoryState currentState) {
-		return history.undo(currentState);
-	}
-
-	@Override
-	public boolean isRedoAvailable() {
-		return history.isRedoAvailable();
-	}
-
-	@Override
-	public CalculatorHistoryState redo(@Nullable CalculatorHistoryState currentState) {
-		return history.redo(currentState);
-	}
-
-	@Override
-	public boolean isActionAvailable(@NotNull HistoryAction historyAction) {
-		return history.isActionAvailable(historyAction);
-	}
-
-	@Override
-	public CalculatorHistoryState doAction(@NotNull HistoryAction historyAction, @Nullable CalculatorHistoryState currentState) {
-		return history.doAction(historyAction, currentState);
-	}
-
-	@Override
-	public void addState(@Nullable CalculatorHistoryState currentState) {
-		history.addState(currentState);
-	}
-
-	@NotNull
-	@Override
-	public List<CalculatorHistoryState> getStates() {
-		return history.getStates();
-	}
-
-	@Override
-	public void clear() {
-		this.history.clear();
-	}
-
-	public void load(@Nullable Context context, @Nullable SharedPreferences preferences) {
-		if (context != null && preferences != null) {
-			final String value = preferences.getString(context.getString(R.string.p_calc_history), null);
-			this.savedHistory.clear();
-			HistoryUtils.fromXml(value, this.savedHistory);
-			for (CalculatorHistoryState historyState : savedHistory) {
-				historyState.setSaved(true);
-				historyState.setId(counter++);
-			}
-		}
-	}
-
-	public void save(@NotNull Context context) {
-		final SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(context);
-		final SharedPreferences.Editor editor = settings.edit();
-
-		editor.putString(context.getString(R.string.p_calc_history), HistoryUtils.toXml(this.savedHistory));
-
-		editor.commit();
-	}
-
-	@NotNull
-	public List<CalculatorHistoryState> getSavedHistory() {
-		return Collections.unmodifiableList(savedHistory);
-	}
-
-	@NotNull
-	public CalculatorHistoryState addSavedState(@NotNull CalculatorHistoryState historyState) {
-		if (historyState.isSaved()) {
-			return historyState;
-		} else {
-			final CalculatorHistoryState savedState = historyState.clone();
-
-			savedState.setId(counter++);
-			savedState.setSaved(true);
-
-			savedHistory.add(savedState);
-
-			return savedState;
-		}
-	}
-
-	public void clearSavedHistory(@NotNull Context context) {
-		this.savedHistory.clear();
-		save(context);
-	}
-
-	public void removeSavedHistory(@NotNull CalculatorHistoryState historyState, @NotNull Context context) {
-		historyState.setSaved(false);
-		this.savedHistory.remove(historyState);
-		save(context);
-	}
-}

calculatorpp/src/main/java/org/solovyev/android/calculator/history/HistoryActivityTab.java

@@ -26,12 +26,12 @@ public class HistoryActivityTab extends AbstractHistoryActivity {
 	@NotNull
 	@Override
 	protected List<CalculatorHistoryState> getHistoryItems() {
-		return new ArrayList<CalculatorHistoryState>(CalculatorHistory.instance.getStates());
+		return new ArrayList<CalculatorHistoryState>(AndroidCalculatorHistoryImpl.instance.getStates());
 	}
 
 	@Override
 	protected void clearHistory() {
-		CalculatorHistory.instance.clear();
+		AndroidCalculatorHistoryImpl.instance.clear();
 		getAdapter().clear();
 	}
 }

calculatorpp/src/main/java/org/solovyev/android/calculator/history/HistoryItemMenuItem.java

@@ -96,7 +96,7 @@ public enum HistoryItemMenuItem implements LabeledMenuItem<HistoryItemMenuData>
 			final CalculatorHistoryState historyState = data.getHistoryState();
 			if (historyState.isSaved()) {
 				data.getAdapter().remove(historyState);
-				CalculatorHistory.instance.removeSavedHistory(historyState, context);
+				AndroidCalculatorHistoryImpl.instance.removeSavedHistory(historyState, context);
 				Toast.makeText(context, context.getText(R.string.c_history_was_removed), Toast.LENGTH_LONG).show();
 				data.getAdapter().notifyDataSetChanged();
 			}
@@ -122,14 +122,14 @@ public enum HistoryItemMenuItem implements LabeledMenuItem<HistoryItemMenuData>
 					@Override
 					public void onClick(DialogInterface dialog, int which) {
 						if (save) {
-							final CalculatorHistoryState savedHistoryItem = CalculatorHistory.instance.addSavedState(historyState);
+							final CalculatorHistoryState savedHistoryItem = AndroidCalculatorHistoryImpl.instance.addSavedState(historyState);
 							savedHistoryItem.setComment(comment.getText().toString());
-							CalculatorHistory.instance.save(context);
+							AndroidCalculatorHistoryImpl.instance.save(context);
 							// we don't need to add element to the adapter as adapter of another activity must be updated and not this
 							//data.getAdapter().add(savedHistoryItem);
 						} else {
 							historyState.setComment(comment.getText().toString());
-							CalculatorHistory.instance.save(context);
+							AndroidCalculatorHistoryImpl.instance.save(context);
 						}
 						data.getAdapter().notifyDataSetChanged();
 						Toast.makeText(context, context.getText(R.string.c_history_saved), Toast.LENGTH_LONG).show();

calculatorpp/src/main/java/org/solovyev/android/calculator/history/SavedHistoryActivityTab.java

@@ -26,12 +26,12 @@ public class SavedHistoryActivityTab extends AbstractHistoryActivity {
 	@NotNull
 	@Override
 	protected List<CalculatorHistoryState> getHistoryItems() {
-		return new ArrayList<CalculatorHistoryState>(CalculatorHistory.instance.getSavedHistory());
+		return new ArrayList<CalculatorHistoryState>(AndroidCalculatorHistoryImpl.instance.getSavedHistory());
 	}
 
 	@Override
 	protected void clearHistory() {
-		CalculatorHistory.instance.clearSavedHistory(this);
+		AndroidCalculatorHistoryImpl.instance.clearSavedHistory(this);
 		getAdapter().clear();
 	}
 }

calculatorpp/src/main/java/org/solovyev/android/calculator/model/CalculatorEngine.java

@@ -15,10 +15,7 @@ import jscl.math.operator.Operator;
 import jscl.text.ParseInterruptedException;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.solovyev.android.calculator.CalculatorApplication;
+import org.solovyev.android.calculator.*;
-import org.solovyev.android.calculator.CalculatorParseException;
-import org.solovyev.android.calculator.JCalculatorEngine;
-import org.solovyev.android.calculator.R;
 import org.solovyev.android.calculator.jscl.JsclOperation;
 import org.solovyev.android.calculator.text.TextProcessor;
 import org.solovyev.android.msg.AndroidMessage;

calculatorpp/src/main/java/org/solovyev/android/calculator/plot/CalculatorPlotActivity.java

@@ -36,8 +36,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.solovyev.android.calculator.R;
 import org.solovyev.android.calculator.CalculatorParseException;
-import org.solovyev.android.calculator.model.PreparedExpression;
+import org.solovyev.android.calculator.PreparedExpression;
-import org.solovyev.android.calculator.model.ToJsclTextProcessor;
+import org.solovyev.android.calculator.ToJsclTextProcessor;
 import org.solovyev.common.MutableObject;
 
 import java.io.Serializable;

calculatorpp/src/main/java/org/solovyev/android/calculator/view/NumeralBaseConverterDialog.java

@@ -13,7 +13,7 @@ import org.solovyev.android.calculator.CalculatorModel;
 import org.solovyev.android.calculator.R;
 import org.solovyev.android.calculator.model.CalculatorEngine;
 import org.solovyev.android.calculator.CalculatorParseException;
-import org.solovyev.android.calculator.model.ToJsclTextProcessor;
+import org.solovyev.android.calculator.ToJsclTextProcessor;
 import org.solovyev.common.MutableObject;
 import org.solovyev.common.text.StringUtils;
 

calculatorpp/src/main/java/org/solovyev/android/calculator/view/TextHighlighter.java

@@ -9,7 +9,10 @@ package org.solovyev.android.calculator.view;
 import jscl.MathContext;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.solovyev.android.calculator.AbstractNumberBuilder;
 import org.solovyev.android.calculator.CalculatorParseException;
+import org.solovyev.android.calculator.LiteNumberBuilder;
+import org.solovyev.android.calculator.NumberBuilder;
 import org.solovyev.android.calculator.math.MathType;
 import org.solovyev.android.calculator.model.*;
 import org.solovyev.android.calculator.text.TextProcessor;

calculatorpp/src/test/java/org/solovyev/android/calculator/history/HistoryUtilsTest.java

@@ -12,7 +12,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.junit.Test;
 import org.solovyev.android.calculator.Editor;
-import org.solovyev.android.calculator.ICalculatorDisplay;
+import org.solovyev.android.calculator.JCalculatorDisplay;
 import org.solovyev.android.calculator.jscl.JsclOperation;
 import org.solovyev.common.equals.CollectionEqualizer;
 import org.solovyev.common.equals.EqualsTool;
@@ -125,7 +125,7 @@ public class HistoryUtilsTest {
 
 		HistoryHelper<CalculatorHistoryState> history = new SimpleHistoryHelper<CalculatorHistoryState>();
 
-		ICalculatorDisplay calculatorDisplay = new TestCalculatorDisplay();
+		JCalculatorDisplay calculatorDisplay = new TestCalculatorDisplay();
 		calculatorDisplay.setErrorMessage("error_msg1");
 		calculatorDisplay.setText("Error");
 		calculatorDisplay.setSelection(1);
@@ -215,7 +215,7 @@ public class HistoryUtilsTest {
 	}
 
 
-	private static class TestCalculatorDisplay implements ICalculatorDisplay {
+	private static class TestCalculatorDisplay implements JCalculatorDisplay {
 
 		@NotNull
 		private final TestEditor testEditor = new TestEditor();

calculatorpp/src/test/java/org/solovyev/android/calculator/model/CalculatorEngineTest.java

@@ -15,6 +15,7 @@ import jscl.math.function.CustomFunction;
 import org.junit.Assert;
 import org.junit.BeforeClass;
 import org.junit.Test;
+import org.solovyev.android.calculator.CalculatorEvalException;
 import org.solovyev.android.calculator.CalculatorParseException;
 import org.solovyev.android.calculator.jscl.JsclOperation;
 

calculatorpp/src/test/java/org/solovyev/android/calculator/model/NumeralBaseTest.java

@@ -10,6 +10,7 @@ import org.jetbrains.annotations.NotNull;
 import org.junit.Assert;
 import org.junit.BeforeClass;
 import org.junit.Test;
+import org.solovyev.android.calculator.CalculatorEvalException;
 import org.solovyev.android.calculator.CalculatorParseException;
 import org.solovyev.android.calculator.jscl.JsclOperation;
 import org.solovyev.common.Converter;

calculatorpp/src/test/java/org/solovyev/android/calculator/model/ToJsclTextProcessorTest.java

@@ -12,6 +12,8 @@ import org.junit.Assert;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.solovyev.android.calculator.CalculatorParseException;
+import org.solovyev.android.calculator.PreparedExpression;
+import org.solovyev.android.calculator.ToJsclTextProcessor;
 import org.solovyev.android.calculator.text.TextProcessor;
 
 /**