TnSb/android-calculatorpp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

New architecture

Browse Source
This commit is contained in:
Sergey Solovyev 2012-09-21 23:29:44 +04:00
parent 0c698a6d39
commit d0fe0ca012
37 changed files with 3968 additions and 3998 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,34 +1,37 @@
package org.solovyev.android.calculator; package org.solovyev.android.calculator;
import jscl.NumeralBase; import jscl.NumeralBase;
import jscl.math.Generic; import jscl.math.Generic;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import org.solovyev.android.calculator.jscl.JsclOperation; import org.solovyev.android.calculator.jscl.JsclOperation;
import org.solovyev.common.msg.MessageRegistry;
/**
/** * User: Solovyev_S
* User: Solovyev_S * Date: 20.09.12
* Date: 20.09.12 * Time: 16:38
* Time: 16:38 */
*/ public interface Calculator extends CalculatorEventContainer {
public interface Calculator extends CalculatorEventContainer {
@NotNull
@NotNull CalculatorEventDataId createFirstEventDataId();
CalculatorEventDataId createFirstEventDataId();
@NotNull
void evaluate(@NotNull JsclOperation operation, CalculatorEventDataId evaluate(@NotNull JsclOperation operation,
@NotNull String expression); @NotNull String expression);
@NotNull @NotNull
CalculatorEventDataId evaluate(@NotNull JsclOperation operation, CalculatorEventDataId evaluate(@NotNull JsclOperation operation,
@NotNull String expression, @NotNull String expression,
@Nullable MessageRegistry mr); @NotNull Long sequenceId);
@NotNull @NotNull
CalculatorEventDataId convert(@NotNull Generic generic, @NotNull NumeralBase to); CalculatorEventDataId convert(@NotNull Generic generic, @NotNull NumeralBase to);
@NotNull @NotNull
CalculatorEventDataId fireCalculatorEvent(@NotNull CalculatorEventType calculatorEventType, @Nullable Object data); CalculatorEventDataId fireCalculatorEvent(@NotNull CalculatorEventType calculatorEventType, @Nullable Object data);
} @NotNull
CalculatorEventDataId fireCalculatorEvent(@NotNull CalculatorEventType calculatorEventType, @Nullable Object data, @NotNull Long sequenceId);
}

3
calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorDisplay.java
View File

@ -18,6 +18,9 @@ public interface CalculatorDisplay extends CalculatorEventListener {
void setView(@Nullable CalculatorDisplayView view); void setView(@Nullable CalculatorDisplayView view);
@Nullable
CalculatorDisplayView getView();
@NotNull @NotNull
CalculatorDisplayViewState getViewState(); CalculatorDisplayViewState getViewState();

17
calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorDisplayChangeEventData.java Normal file
View File

@ -0,0 +1,17 @@
package org.solovyev.android.calculator;
import org.jetbrains.annotations.NotNull;
/**
* User: serso
* Date: 9/21/12
* Time: 9:49 PM
*/
public interface CalculatorDisplayChangeEventData {
@NotNull
CalculatorDisplayViewState getOldState();
@NotNull
CalculatorDisplayViewState getNewState();
}

34
calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorDisplayChangeEventDataImpl.java Normal file
View File

@ -0,0 +1,34 @@
package org.solovyev.android.calculator;
import org.jetbrains.annotations.NotNull;
/**
* User: serso
* Date: 9/21/12
* Time: 9:50 PM
*/
public class CalculatorDisplayChangeEventDataImpl implements CalculatorDisplayChangeEventData {
@NotNull
private final CalculatorDisplayViewState oldState;
@NotNull
private final CalculatorDisplayViewState newState;
public CalculatorDisplayChangeEventDataImpl(@NotNull CalculatorDisplayViewState oldState, @NotNull CalculatorDisplayViewState newState) {
this.oldState = oldState;
this.newState = newState;
}
@NotNull
@Override
public CalculatorDisplayViewState getOldState() {
return this.oldState;
}
@NotNull
@Override
public CalculatorDisplayViewState getNewState() {
return this.newState;
}
}

76
calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorDisplayImpl.java
View File

@ -13,7 +13,7 @@ import static org.solovyev.android.calculator.CalculatorEventType.*;
public class CalculatorDisplayImpl implements CalculatorDisplay { public class CalculatorDisplayImpl implements CalculatorDisplay {
@NotNull @NotNull
private CalculatorEventData lastCalculatorEventData = CalculatorEventDataImpl.newInstance(CalculatorLocatorImpl.getInstance().getCalculator().createFirstEventDataId()); private CalculatorEventData lastCalculatorEventData;
@Nullable @Nullable
private CalculatorDisplayView view; private CalculatorDisplayView view;
@ -22,7 +22,15 @@ public class CalculatorDisplayImpl implements CalculatorDisplay {
private final Object viewLock = new Object(); private final Object viewLock = new Object();
@NotNull @NotNull
private CalculatorDisplayViewState lastViewState = CalculatorDisplayViewStateImpl.newDefaultInstance(); private CalculatorDisplayViewState viewState = CalculatorDisplayViewStateImpl.newDefaultInstance();
@NotNull
private final Calculator calculator;
public CalculatorDisplayImpl(@NotNull Calculator calculator) {
this.calculator = calculator;
this.lastCalculatorEventData = CalculatorEventDataImpl.newInstance(calculator.createFirstEventDataId());
}
@Override @Override
public void setView(@Nullable CalculatorDisplayView view) { public void setView(@Nullable CalculatorDisplayView view) {
@ -30,59 +38,51 @@ public class CalculatorDisplayImpl implements CalculatorDisplay {
this.view = view; this.view = view;
if (view != null) { if (view != null) {
this.view.setState(lastViewState);
}
}
}
@NotNull
@Override
public CalculatorDisplayViewState getViewState() {
return this.lastViewState;
}
@Override
public void setViewState(@NotNull CalculatorDisplayViewState viewState) {
synchronized (viewLock) {
this.lastViewState = viewState;
if (this.view != null) {
this.view.setState(viewState); this.view.setState(viewState);
} }
} }
} }
/* @Override
@Nullable @Nullable
public CharSequence getText() { @Override
synchronized (viewLock) { public CalculatorDisplayView getView() {
return view != null ? view.getText() : null; return this.view;
} }
@NotNull
@Override
public CalculatorDisplayViewState getViewState() {
return this.viewState;
} }
@Override @Override
public void setText(@Nullable CharSequence text) { public void setViewState(@NotNull CalculatorDisplayViewState newViewState) {
synchronized (viewLock) { synchronized (viewLock) {
if (view != null) { final CalculatorDisplayViewState oldViewState = setViewState0(newViewState);
view.setText(text);
} this.calculator.fireCalculatorEvent(display_state_changed, new CalculatorDisplayChangeEventDataImpl(oldViewState, newViewState));
} }
} }
@Override private void setViewStateForSequence(@NotNull CalculatorDisplayViewState newViewState, @NotNull Long sequenceId) {
public int getSelection() {
synchronized (viewLock) { synchronized (viewLock) {
return view != null ? view.getSelection() : 0; final CalculatorDisplayViewState oldViewState = setViewState0(newViewState);
this.calculator.fireCalculatorEvent(display_state_changed, new CalculatorDisplayChangeEventDataImpl(oldViewState, newViewState), sequenceId);
} }
} }
@Override // must be synchronized with viewLock
public void setSelection(int selection) { @NotNull
synchronized (viewLock) { private CalculatorDisplayViewState setViewState0(@NotNull CalculatorDisplayViewState newViewState) {
if (view != null) { final CalculatorDisplayViewState oldViewState = this.viewState;
view.setSelection(selection);
} this.viewState = newViewState;
if (this.view != null) {
this.view.setState(newViewState);
} }
}*/ return oldViewState;
}
@Override @Override
@NotNull @NotNull
@ -131,7 +131,7 @@ public class CalculatorDisplayImpl implements CalculatorDisplay {
} }
} }
this.setViewState(CalculatorDisplayViewStateImpl.newErrorState(calculatorEventData.getOperation(), errorMessage)); this.setViewStateForSequence(CalculatorDisplayViewStateImpl.newErrorState(calculatorEventData.getOperation(), errorMessage), calculatorEventData.getSequenceId());
} }
private void processCalculationCancelled(@NotNull CalculatorEvaluationEventData calculatorEventData) { private void processCalculationCancelled(@NotNull CalculatorEvaluationEventData calculatorEventData) {

149
calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorEditor.java
View File

@ -1,73 +1,76 @@
package org.solovyev.android.calculator; package org.solovyev.android.calculator;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
/** /**
* User: Solovyev_S * User: Solovyev_S
* Date: 21.09.12 * Date: 21.09.12
* Time: 11:47 * Time: 11:47
*/ */
public interface CalculatorEditor extends CalculatorEventListener/*, CursorControl*/ { public interface CalculatorEditor extends CalculatorEventListener/*, CursorControl*/ {
void setView(@Nullable CalculatorEditorView view); void setView(@Nullable CalculatorEditorView view);
@NotNull @NotNull
CalculatorEditorViewState getViewState(); CalculatorEditorViewState getViewState();
void setViewState(@NotNull CalculatorEditorViewState viewState); void setViewState(@NotNull CalculatorEditorViewState viewState);
/* /*
********************************************************************** **********************************************************************
* *
* CURSOR CONTROL * CURSOR CONTROL
* *
********************************************************************** **********************************************************************
*/ */
/** /**
* Method sets the cursor to the beginning * Method sets the cursor to the beginning
*/ */
@NotNull @NotNull
public CalculatorEditorViewState setCursorOnStart(); public CalculatorEditorViewState setCursorOnStart();
/** /**
* Method sets the cursor to the end * Method sets the cursor to the end
*/ */
@NotNull @NotNull
public CalculatorEditorViewState setCursorOnEnd(); public CalculatorEditorViewState setCursorOnEnd();
/** /**
* Method moves cursor to the left of current position * Method moves cursor to the left of current position
*/ */
@NotNull @NotNull
public CalculatorEditorViewState moveCursorLeft(); public CalculatorEditorViewState moveCursorLeft();
/** /**
* Method moves cursor to the right of current position * Method moves cursor to the right of current position
*/ */
@NotNull @NotNull
public CalculatorEditorViewState moveCursorRight(); public CalculatorEditorViewState moveCursorRight();
/* /*
********************************************************************** **********************************************************************
* *
* EDITOR OPERATIONS * EDITOR OPERATIONS
* *
********************************************************************** **********************************************************************
*/ */
@NotNull @NotNull
CalculatorEditorViewState erase(); CalculatorEditorViewState erase();
@NotNull @NotNull
CalculatorEditorViewState setText(@NotNull String text); CalculatorEditorViewState setText(@NotNull String text);
@NotNull @NotNull
CalculatorEditorViewState setText(@NotNull String text, int selection); CalculatorEditorViewState setText(@NotNull String text, int selection);
@NotNull @NotNull
CalculatorEditorViewState insert(@NotNull String text); CalculatorEditorViewState insert(@NotNull String text);
@NotNull @NotNull
CalculatorEditorViewState moveSelection(int offset); CalculatorEditorViewState moveSelection(int offset);
}
@NotNull
CalculatorEditorViewState setSelection(int selection);
}

69
calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorEditorChangeEventDataImpl.java
View File

@ -1,34 +1,35 @@
package org.solovyev.android.calculator; package org.solovyev.android.calculator;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
/** /**
* User: Solovyev_S * User: Solovyev_S
* Date: 21.09.12 * Date: 21.09.12
* Time: 13:46 * Time: 13:46
*/ */
public class CalculatorEditorChangeEventDataImpl implements CalculatorEditorChangeEventData { public class CalculatorEditorChangeEventDataImpl implements CalculatorEditorChangeEventData {
@NotNull @NotNull
private CalculatorEditorViewState oldState; private CalculatorEditorViewState oldState;
@NotNull @NotNull
private CalculatorEditorViewState newState; private CalculatorEditorViewState newState;
public CalculatorEditorChangeEventDataImpl(@NotNull CalculatorEditorViewState oldState, @NotNull CalculatorEditorViewState newState) { public CalculatorEditorChangeEventDataImpl(@NotNull CalculatorEditorViewState oldState,
this.oldState = oldState; @NotNull CalculatorEditorViewState newState) {
this.newState = newState; this.oldState = oldState;
} this.newState = newState;
}
@NotNull
@Override @NotNull
public CalculatorEditorViewState getOldState() { @Override
return this.oldState; public CalculatorEditorViewState getOldState() {
} return this.oldState;
}
@NotNull
@Override @NotNull
public CalculatorEditorViewState getNewState() { @Override
return this.newState; public CalculatorEditorViewState getNewState() {
} return this.newState;
} }
}

394
calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorEditorImpl.java
View File

@ -1,193 +1,201 @@
package org.solovyev.android.calculator; package org.solovyev.android.calculator;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
/** /**
* User: Solovyev_S * User: Solovyev_S
* Date: 21.09.12 * Date: 21.09.12
* Time: 11:53 * Time: 11:53
*/ */
public class CalculatorEditorImpl implements CalculatorEditor { public class CalculatorEditorImpl implements CalculatorEditor {
@Nullable @Nullable
private CalculatorEditorView view; private CalculatorEditorView view;
@NotNull @NotNull
private final Object viewLock = new Object(); private final Object viewLock = new Object();
@NotNull @NotNull
private CalculatorEditorViewState lastViewState = CalculatorEditorViewStateImpl.newDefaultInstance(); private CalculatorEditorViewState lastViewState = CalculatorEditorViewStateImpl.newDefaultInstance();
@NotNull @NotNull
private final Calculator calculator; private final Calculator calculator;
public CalculatorEditorImpl(@NotNull Calculator calculator) { public CalculatorEditorImpl(@NotNull Calculator calculator) {
this.calculator = calculator; this.calculator = calculator;
} }
@Override @Override
public void setView(@Nullable CalculatorEditorView view) { public void setView(@Nullable CalculatorEditorView view) {
synchronized (viewLock) { synchronized (viewLock) {
this.view = view; this.view = view;
if ( view != null ) { if ( view != null ) {
view.setState(lastViewState); view.setState(lastViewState);
} }
} }
} }
@NotNull @NotNull
@Override @Override
public CalculatorEditorViewState getViewState() { public CalculatorEditorViewState getViewState() {
return lastViewState; return lastViewState;
} }
@Override @Override
public void setViewState(@NotNull CalculatorEditorViewState newViewState) { public void setViewState(@NotNull CalculatorEditorViewState newViewState) {
synchronized (viewLock) { synchronized (viewLock) {
final CalculatorEditorViewState oldViewState = this.lastViewState; final CalculatorEditorViewState oldViewState = this.lastViewState;
this.lastViewState = newViewState; this.lastViewState = newViewState;
if (this.view != null) { if (this.view != null) {
this.view.setState(newViewState); this.view.setState(newViewState);
} }
calculator.fireCalculatorEvent(CalculatorEventType.editor_state_changed, new CalculatorEditorChangeEventDataImpl(oldViewState, newViewState)); calculator.fireCalculatorEvent(CalculatorEventType.editor_state_changed, new CalculatorEditorChangeEventDataImpl(oldViewState, newViewState));
} }
} }
@Override @Override
public void onCalculatorEvent(@NotNull CalculatorEventData calculatorEventData, public void onCalculatorEvent(@NotNull CalculatorEventData calculatorEventData,
@NotNull CalculatorEventType calculatorEventType, @NotNull CalculatorEventType calculatorEventType,
@Nullable Object data) { @Nullable Object data) {
//To change body of implemented methods use File | Settings | File Templates. //To change body of implemented methods use File | Settings | File Templates.
} }
@NotNull @NotNull
public CalculatorEditorViewState setCursorOnStart() { public CalculatorEditorViewState setCursorOnStart() {
synchronized (viewLock) { synchronized (viewLock) {
return newSelectionViewState(0); return newSelectionViewState(0);
} }
} }
@NotNull @NotNull
private CalculatorEditorViewState newSelectionViewState(int newSelection) { private CalculatorEditorViewState newSelectionViewState(int newSelection) {
if (this.lastViewState.getSelection() != newSelection) { if (this.lastViewState.getSelection() != newSelection) {
final CalculatorEditorViewState result = CalculatorEditorViewStateImpl.newSelection(this.lastViewState, newSelection); final CalculatorEditorViewState result = CalculatorEditorViewStateImpl.newSelection(this.lastViewState, newSelection);
setViewState(result); setViewState(result);
return result; return result;
} else { } else {
return this.lastViewState; return this.lastViewState;
} }
} }
@NotNull @NotNull
public CalculatorEditorViewState setCursorOnEnd() { public CalculatorEditorViewState setCursorOnEnd() {
synchronized (viewLock) { synchronized (viewLock) {
return newSelectionViewState(this.lastViewState.getText().length()); return newSelectionViewState(this.lastViewState.getText().length());
} }
} }
@NotNull @NotNull
public CalculatorEditorViewState moveCursorLeft() { public CalculatorEditorViewState moveCursorLeft() {
synchronized (viewLock) { synchronized (viewLock) {
if (this.lastViewState.getSelection() > 0) { if (this.lastViewState.getSelection() > 0) {
return newSelectionViewState(this.lastViewState.getSelection() - 1); return newSelectionViewState(this.lastViewState.getSelection() - 1);
} else { } else {
return this.lastViewState; return this.lastViewState;
} }
} }
} }
@NotNull @NotNull
public CalculatorEditorViewState moveCursorRight() { public CalculatorEditorViewState moveCursorRight() {
synchronized (viewLock) { synchronized (viewLock) {
if (this.lastViewState.getSelection() < this.lastViewState.getText().length()) { if (this.lastViewState.getSelection() < this.lastViewState.getText().length()) {
return newSelectionViewState(this.lastViewState.getSelection() + 1); return newSelectionViewState(this.lastViewState.getSelection() + 1);
} else { } else {
return this.lastViewState; return this.lastViewState;
} }
} }
} }
@NotNull @NotNull
@Override @Override
public CalculatorEditorViewState erase() { public CalculatorEditorViewState erase() {
synchronized (viewLock) { synchronized (viewLock) {
int selection = this.lastViewState.getSelection(); int selection = this.lastViewState.getSelection();
final String text = this.lastViewState.getText(); final String text = this.lastViewState.getText();
if (selection > 0 && text.length() > 0 && selection <= text.length()) { if (selection > 0 && text.length() > 0 && selection <= text.length()) {
final StringBuilder newText = new StringBuilder(text.length() - 1); final StringBuilder newText = new StringBuilder(text.length() - 1);
newText.append(text.substring(0, selection - 1)).append(text.substring(selection, text.length())); newText.append(text.substring(0, selection - 1)).append(text.substring(selection, text.length()));
final CalculatorEditorViewState result = CalculatorEditorViewStateImpl.newInstance(newText.toString(), selection - 1); final CalculatorEditorViewState result = CalculatorEditorViewStateImpl.newInstance(newText.toString(), selection - 1);
setViewState(result); setViewState(result);
return result; return result;
} else { } else {
return this.lastViewState; return this.lastViewState;
} }
} }
} }
@NotNull @NotNull
@Override @Override
public CalculatorEditorViewState setText(@NotNull String text) { public CalculatorEditorViewState setText(@NotNull String text) {
synchronized (viewLock) { synchronized (viewLock) {
final CalculatorEditorViewState result = CalculatorEditorViewStateImpl.newInstance(text, text.length()); final CalculatorEditorViewState result = CalculatorEditorViewStateImpl.newInstance(text, text.length());
setViewState(result); setViewState(result);
return result; return result;
} }
} }
@NotNull @NotNull
@Override @Override
public CalculatorEditorViewState setText(@NotNull String text, int selection) { public CalculatorEditorViewState setText(@NotNull String text, int selection) {
synchronized (viewLock) { synchronized (viewLock) {
selection = correctSelection(selection, text); selection = correctSelection(selection, text);
final CalculatorEditorViewState result = CalculatorEditorViewStateImpl.newInstance(text, selection); final CalculatorEditorViewState result = CalculatorEditorViewStateImpl.newInstance(text, selection);
setViewState(result); setViewState(result);
return result; return result;
} }
} }
@NotNull @NotNull
@Override @Override
public CalculatorEditorViewState insert(@NotNull String text) { public CalculatorEditorViewState insert(@NotNull String text) {
synchronized (viewLock) { synchronized (viewLock) {
final int selection = this.lastViewState.getSelection(); final int selection = this.lastViewState.getSelection();
final String oldText = this.lastViewState.getText(); final String oldText = this.lastViewState.getText();
final StringBuilder newText = new StringBuilder(text.length() + oldText.length()); final StringBuilder newText = new StringBuilder(text.length() + oldText.length());
newText.append(oldText.substring(0, selection)); newText.append(oldText.substring(0, selection));
newText.append(text); newText.append(text);
newText.append(oldText.substring(selection)); newText.append(oldText.substring(selection));
final CalculatorEditorViewState result = CalculatorEditorViewStateImpl.newInstance(newText.toString(), text.length() + selection); final CalculatorEditorViewState result = CalculatorEditorViewStateImpl.newInstance(newText.toString(), text.length() + selection);
setViewState(result); setViewState(result);
return result; return result;
} }
} }
@NotNull @NotNull
@Override @Override
public CalculatorEditorViewState moveSelection(int offset) { public CalculatorEditorViewState moveSelection(int offset) {
synchronized (viewLock) { synchronized (viewLock) {
int selection = this.lastViewState.getSelection() + offset; int selection = this.lastViewState.getSelection() + offset;
selection = correctSelection(selection, this.lastViewState.getText()); return setSelection(selection);
}
final CalculatorEditorViewState result = CalculatorEditorViewStateImpl.newSelection(this.lastViewState, selection); }
setViewState(result);
return result; @NotNull
} @Override
} public CalculatorEditorViewState setSelection(int selection) {
synchronized (viewLock) {
private int correctSelection(int selection, @NotNull String text) { selection = correctSelection(selection, this.lastViewState.getText());
int result = Math.max(selection, 0);
result = Math.min(result, text.length()); final CalculatorEditorViewState result = CalculatorEditorViewStateImpl.newSelection(this.lastViewState, selection);
return result; setViewState(result);
} return result;
} }
}
private int correctSelection(int selection, @NotNull String text) {
int result = Math.max(selection, 0);
result = Math.min(result, text.length());
return result;
}
}

126
calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorEvaluationEventDataImpl.java
View File

@ -1,63 +1,63 @@
package org.solovyev.android.calculator; package org.solovyev.android.calculator;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import org.solovyev.android.calculator.jscl.JsclOperation; import org.solovyev.android.calculator.jscl.JsclOperation;
/** /**
* User: serso * User: serso
* Date: 9/20/12 * Date: 9/20/12
* Time: 10:01 PM * Time: 10:01 PM
*/ */
public class CalculatorEvaluationEventDataImpl implements CalculatorEvaluationEventData { public class CalculatorEvaluationEventDataImpl implements CalculatorEvaluationEventData {
@NotNull @NotNull
private final CalculatorEventData calculatorEventData; private final CalculatorEventData calculatorEventData;
@NotNull @NotNull
private final JsclOperation operation; private final JsclOperation operation;
@NotNull @NotNull
private final String expression; private final String expression;
public CalculatorEvaluationEventDataImpl(@NotNull CalculatorEventData calculatorEventData, public CalculatorEvaluationEventDataImpl(@NotNull CalculatorEventData calculatorEventData,
@NotNull JsclOperation operation, @NotNull JsclOperation operation,
@NotNull String expression) { @NotNull String expression) {
this.calculatorEventData = calculatorEventData; this.calculatorEventData = calculatorEventData;
this.operation = operation; this.operation = operation;
this.expression = expression; this.expression = expression;
} }
@NotNull @NotNull
@Override @Override
public JsclOperation getOperation() { public JsclOperation getOperation() {
return this.operation; return this.operation;
} }
@NotNull @NotNull
@Override @Override
public String getExpression() { public String getExpression() {
return this.expression; return this.expression;
} }
@Override @Override
public long getEventId() { public long getEventId() {
return calculatorEventData.getEventId(); return calculatorEventData.getEventId();
} }
@Override @NotNull
@Nullable @Override
public Long getSequenceId() { public Long getSequenceId() {
return calculatorEventData.getSequenceId(); return calculatorEventData.getSequenceId();
} }
@Override @Override
public boolean isAfter(@NotNull CalculatorEventDataId that) { public boolean isAfter(@NotNull CalculatorEventDataId that) {
return calculatorEventData.isAfter(that); return calculatorEventData.isAfter(that);
} }
@Override @Override
public boolean isSameSequence(@NotNull CalculatorEventDataId that) { public boolean isSameSequence(@NotNull CalculatorEventDataId that) {
return this.calculatorEventData.isSameSequence(that); return this.calculatorEventData.isSameSequence(that);
} }
} }

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

@ -1,23 +1,22 @@
package org.solovyev.android.calculator; package org.solovyev.android.calculator;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
/** * User: Solovyev_S
* User: Solovyev_S * Date: 20.09.12
* Date: 20.09.12 * Time: 18:18
* Time: 18:18 */
*/ public interface CalculatorEventDataId {
public interface CalculatorEventDataId {
// the higher id => the later event
// the higher id => the later event long getEventId();
long getEventId();
// the higher id => the later event
// the higher id => the later event @NotNull
@Nullable Long getSequenceId();
Long getSequenceId();
boolean isAfter(@NotNull CalculatorEventDataId that);
boolean isAfter(@NotNull CalculatorEventDataId that);
boolean isSameSequence(@NotNull CalculatorEventDataId that);
boolean isSameSequence(@NotNull CalculatorEventDataId that); }
}

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

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

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

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

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

@ -1,66 +1,69 @@
package org.solovyev.android.calculator; package org.solovyev.android.calculator;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
/** /**
* User: Solovyev_S * User: Solovyev_S
* Date: 20.09.12 * Date: 20.09.12
* Time: 16:40 * Time: 16:40
*/ */
public enum CalculatorEventType { public enum CalculatorEventType {
/* /*
********************************************************************** **********************************************************************
* *
* org.solovyev.android.calculator.CalculatorEvaluationEventData * org.solovyev.android.calculator.CalculatorEvaluationEventData
* *
********************************************************************** **********************************************************************
*/ */
// @NotNull org.solovyev.android.calculator.CalculatorInput // @NotNull org.solovyev.android.calculator.CalculatorInput
calculation_started, calculation_started,
// @NotNull org.solovyev.android.calculator.CalculatorOutput // @NotNull org.solovyev.android.calculator.CalculatorOutput
calculation_result, calculation_result,
calculation_cancelled, calculation_cancelled,
calculation_finished, calculation_finished,
// @NotNull org.solovyev.android.calculator.CalculatorFailure // @NotNull org.solovyev.android.calculator.CalculatorFailure
calculation_failed, calculation_failed,
/* /*
********************************************************************** **********************************************************************
* *
* CONVERSION * CONVERSION
* *
********************************************************************** **********************************************************************
*/ */
conversion_started, conversion_started,
// @NotNull String conversion result // @NotNull String conversion result
conversion_finished, conversion_finished,
/* /*
********************************************************************** **********************************************************************
* *
* EDITOR * EDITOR
* *
********************************************************************** **********************************************************************
*/ */
// @NotNull org.solovyev.android.calculator.CalculatorEditorChangeEventData // @NotNull org.solovyev.android.calculator.CalculatorEditorChangeEventData
editor_state_changed; editor_state_changed,
public boolean isOfType(@NotNull CalculatorEventType... types) { // @NotNull CalculatorDisplayChangeEventData
for (CalculatorEventType type : types) { display_state_changed;
if ( this == type ) {
return true; public boolean isOfType(@NotNull CalculatorEventType... types) {
} for (CalculatorEventType type : types) {
} if ( this == type ) {
return true;
return false; }
} }
} return false;
}
}

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

@ -1,316 +1,338 @@
package org.solovyev.android.calculator; package org.solovyev.android.calculator;
import jscl.AbstractJsclArithmeticException; import jscl.AbstractJsclArithmeticException;
import jscl.NumeralBase; import jscl.NumeralBase;
import jscl.NumeralBaseException; import jscl.NumeralBaseException;
import jscl.math.Generic; import jscl.math.Generic;
import jscl.text.ParseInterruptedException; import jscl.text.ParseInterruptedException;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import org.solovyev.android.calculator.jscl.JsclOperation; import org.solovyev.android.calculator.jscl.JsclOperation;
import org.solovyev.android.calculator.text.TextProcessor; import org.solovyev.android.calculator.text.TextProcessor;
import org.solovyev.common.msg.MessageRegistry; import org.solovyev.common.msg.MessageRegistry;
import org.solovyev.common.msg.MessageType; import org.solovyev.common.msg.MessageType;
import org.solovyev.common.text.StringUtils; import org.solovyev.common.text.StringUtils;
import org.solovyev.math.units.UnitConverter; import org.solovyev.math.units.UnitConverter;
import org.solovyev.math.units.UnitImpl; import org.solovyev.math.units.UnitImpl;
import org.solovyev.math.units.UnitType; import org.solovyev.math.units.UnitType;
import java.util.List; import java.util.List;
import java.util.concurrent.Executor; import java.util.concurrent.Executor;
import java.util.concurrent.Executors; import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicLong;
/** /**
* User: Solovyev_S * User: Solovyev_S
* Date: 20.09.12 * Date: 20.09.12
* Time: 16:42 * Time: 16:42
*/ */
public class CalculatorImpl implements Calculator, CalculatorEventListener { public class CalculatorImpl implements Calculator, CalculatorEventListener {
private static final long FIRST_ID = 0; private static final long FIRST_ID = 0;
@NotNull @NotNull
private final CalculatorEventContainer calculatorEventContainer = new ListCalculatorEventContainer(); private final CalculatorEventContainer calculatorEventContainer = new ListCalculatorEventContainer();
@NotNull @NotNull
private final AtomicLong counter = new AtomicLong(FIRST_ID); private final AtomicLong counter = new AtomicLong(FIRST_ID);
@NotNull @NotNull
private final Object lock = new Object(); private final Object lock = new Object();
@NotNull @NotNull
private final TextProcessor<PreparedExpression, String> preprocessor = ToJsclTextProcessor.getInstance(); private final TextProcessor<PreparedExpression, String> preprocessor = ToJsclTextProcessor.getInstance();
@NotNull @NotNull
private final Executor threadPoolExecutor = Executors.newFixedThreadPool(10); private final Executor threadPoolExecutor = Executors.newFixedThreadPool(10);
public CalculatorImpl() { public CalculatorImpl() {
this.addCalculatorEventListener(this); this.addCalculatorEventListener(this);
} }
@NotNull @NotNull
public static String doConversion(@NotNull UnitConverter<String> converter, public static String doConversion(@NotNull UnitConverter<String> converter,
@Nullable String from, @Nullable String from,
@NotNull UnitType<String> fromUnitType, @NotNull UnitType<String> fromUnitType,
@NotNull UnitType<String> toUnitType) throws ConversionException{ @NotNull UnitType<String> toUnitType) throws ConversionException {
final String result; final String result;
if (StringUtils.isEmpty(from)) { if (StringUtils.isEmpty(from)) {
result = ""; result = "";
} else { } else {
String to = null; String to = null;
try { try {
if (converter.isSupported(fromUnitType, toUnitType)) { if (converter.isSupported(fromUnitType, toUnitType)) {
to = converter.convert(UnitImpl.newInstance(from, fromUnitType), toUnitType).getValue(); to = converter.convert(UnitImpl.newInstance(from, fromUnitType), toUnitType).getValue();
} }
} catch (RuntimeException e) { } catch (RuntimeException e) {
throw new ConversionException(e); throw new ConversionException(e);
} }
result = to; result = to;
} }
return result; return result;
} }
@NotNull @NotNull
private CalculatorEventDataId nextCalculatorEventDataId() { private CalculatorEventDataId nextEventDataId() {
long eventId = counter.incrementAndGet(); long eventId = counter.incrementAndGet();
return CalculatorEventDataIdImpl.newInstance(eventId, eventId); return CalculatorEventDataIdImpl.newInstance(eventId, eventId);
} }
@NotNull @NotNull
private CalculatorEventDataId nextEventDataId(@NotNull Long sequenceId) { private CalculatorEventDataId nextEventDataId(@NotNull Long sequenceId) {
long eventId = counter.incrementAndGet(); long eventId = counter.incrementAndGet();
return CalculatorEventDataIdImpl.newInstance(eventId, sequenceId); return CalculatorEventDataIdImpl.newInstance(eventId, sequenceId);
} }
/* /*
********************************************************************** **********************************************************************
* *
* CALCULATION * CALCULATION
* *
********************************************************************** **********************************************************************
*/ */
@NotNull @NotNull
@Override @Override
public CalculatorEventDataId createFirstEventDataId() { public CalculatorEventDataId createFirstEventDataId() {
return CalculatorEventDataIdImpl.newInstance(FIRST_ID, FIRST_ID); return CalculatorEventDataIdImpl.newInstance(FIRST_ID, FIRST_ID);
} }
@Override @NotNull
public void evaluate(@NotNull JsclOperation operation, @Override
@NotNull String expression) { public CalculatorEventDataId evaluate(@NotNull final JsclOperation operation,
evaluate(operation, expression, null); @NotNull final String expression) {
}
final CalculatorEventDataId eventDataId = nextEventDataId();
@Override
@NotNull threadPoolExecutor.execute(new Runnable() {
public CalculatorEventDataId evaluate(@NotNull final JsclOperation operation, @Override
@NotNull final String expression, public void run() {
@Nullable final MessageRegistry mr) { CalculatorImpl.this.evaluate(eventDataId.getSequenceId(), operation, expression, null);
}
final CalculatorEventDataId eventDataId = nextCalculatorEventDataId(); });
threadPoolExecutor.execute(new Runnable() { return eventDataId;
@Override }
public void run() {
CalculatorImpl.this.evaluate(eventDataId.getSequenceId(), operation, expression, mr); @NotNull
} @Override
}); public CalculatorEventDataId evaluate(@NotNull final JsclOperation operation, @NotNull final String expression, @NotNull Long sequenceId) {
final CalculatorEventDataId eventDataId = nextEventDataId(sequenceId);
return eventDataId;
} threadPoolExecutor.execute(new Runnable() {
@Override
@NotNull public void run() {
@Override CalculatorImpl.this.evaluate(eventDataId.getSequenceId(), operation, expression, null);
public CalculatorEventDataId convert(@NotNull final Generic generic, }
@NotNull final NumeralBase to) { });
final CalculatorEventDataId eventDataId = nextCalculatorEventDataId();
return eventDataId;
threadPoolExecutor.execute(new Runnable() { }
@Override
public void run() { @NotNull
final Long sequenceId = eventDataId.getSequenceId(); @Override
assert sequenceId != null; public CalculatorEventDataId convert(@NotNull final Generic generic,
@NotNull final NumeralBase to) {
fireCalculatorEvent(newConversionEventData(sequenceId), CalculatorEventType.conversion_started, null); final CalculatorEventDataId eventDataId = nextEventDataId();
final NumeralBase from = CalculatorLocatorImpl.getInstance().getCalculatorEngine().getEngine().getNumeralBase(); threadPoolExecutor.execute(new Runnable() {
@Override
if (from != to) { public void run() {
String fromString = generic.toString(); final Long sequenceId = eventDataId.getSequenceId();
if (!StringUtils.isEmpty(fromString)) {
try { fireCalculatorEvent(newConversionEventData(sequenceId), CalculatorEventType.conversion_started, null);
fromString = ToJsclTextProcessor.getInstance().process(fromString).getExpression();
} catch (CalculatorParseException e) { final NumeralBase from = CalculatorLocatorImpl.getInstance().getCalculatorEngine().getEngine().getNumeralBase();
// ok, problems while processing occurred
} if (from != to) {
} String fromString = generic.toString();
if (!StringUtils.isEmpty(fromString)) {
// todo serso: continue try {
//doConversion(AndroidNumeralBase.getConverter(), fromString, AndroidNumeralBase.valueOf(fromString), AndroidNumeralBase.valueOf(to)); fromString = ToJsclTextProcessor.getInstance().process(fromString).getExpression();
} else { } catch (CalculatorParseException e) {
fireCalculatorEvent(newConversionEventData(sequenceId), CalculatorEventType.conversion_finished, generic.toString()); // ok, problems while processing occurred
} }
} }
});
// todo serso: continue
return eventDataId; //doConversion(AndroidNumeralBase.getConverter(), fromString, AndroidNumeralBase.valueOf(fromString), AndroidNumeralBase.valueOf(to));
} } else {
fireCalculatorEvent(newConversionEventData(sequenceId), CalculatorEventType.conversion_finished, generic.toString());
@NotNull }
@Override }
public CalculatorEventDataId fireCalculatorEvent(@NotNull final CalculatorEventType calculatorEventType, @Nullable final Object data) { });
final CalculatorEventDataId eventDataId = nextCalculatorEventDataId();
return eventDataId;
threadPoolExecutor.execute(new Runnable() { }
@Override
public void run() { @NotNull
fireCalculatorEvent(CalculatorEventDataImpl.newInstance(eventDataId), calculatorEventType, data); @Override
} public CalculatorEventDataId fireCalculatorEvent(@NotNull final CalculatorEventType calculatorEventType, @Nullable final Object data) {
}); final CalculatorEventDataId eventDataId = nextEventDataId();
return eventDataId; threadPoolExecutor.execute(new Runnable() {
} @Override
public void run() {
@NotNull fireCalculatorEvent(CalculatorEventDataImpl.newInstance(eventDataId), calculatorEventType, data);
private CalculatorEventData newConversionEventData(@NotNull Long sequenceId) { }
return CalculatorEventDataImpl.newInstance(nextEventDataId(sequenceId)); });
}
return eventDataId;
private void evaluate(@NotNull Long sequenceId, }
@NotNull JsclOperation operation,
@NotNull String expression, @NotNull
@Nullable MessageRegistry mr) { @Override
synchronized (lock) { public CalculatorEventDataId fireCalculatorEvent(@NotNull final CalculatorEventType calculatorEventType, @Nullable final Object data, @NotNull Long sequenceId) {
final CalculatorEventDataId eventDataId = nextEventDataId(sequenceId);
PreparedExpression preparedExpression = null;
threadPoolExecutor.execute(new Runnable() {
fireCalculatorEvent(newCalculationEventData(operation, expression, sequenceId), CalculatorEventType.calculation_started, new CalculatorInputImpl(expression, operation)); @Override
public void run() {
try { fireCalculatorEvent(CalculatorEventDataImpl.newInstance(eventDataId), calculatorEventType, data);
preparedExpression = preprocessor.process(expression); }
});
final String jsclExpression = preparedExpression.toString();
return eventDataId;
try { }
final Generic result = operation.evaluateGeneric(jsclExpression); @NotNull
private CalculatorEventData newConversionEventData(@NotNull Long sequenceId) {
// NOTE: toString() method must be called here as ArithmeticOperationException may occur in it (just to avoid later check!) return CalculatorEventDataImpl.newInstance(nextEventDataId(sequenceId));
result.toString(); }
final CalculatorOutputImpl data = new CalculatorOutputImpl(operation.getFromProcessor().process(result), operation, result); private void evaluate(@NotNull Long sequenceId,
fireCalculatorEvent(newCalculationEventData(operation, expression, sequenceId), CalculatorEventType.calculation_result, data); @NotNull JsclOperation operation,
@NotNull String expression,
} catch (AbstractJsclArithmeticException e) { @Nullable MessageRegistry mr) {
handleException(sequenceId, operation, expression, mr, new CalculatorEvalException(e, e, jsclExpression)); synchronized (lock) {
}
PreparedExpression preparedExpression = null;
} catch (ArithmeticException e) {
handleException(sequenceId, operation, expression, mr, preparedExpression, new CalculatorParseException(expression, new CalculatorMessage(CalculatorMessages.msg_001, MessageType.error, e.getMessage()))); fireCalculatorEvent(newCalculationEventData(operation, expression, sequenceId), CalculatorEventType.calculation_started, new CalculatorInputImpl(expression, operation));
} catch (StackOverflowError e) {
handleException(sequenceId, operation, expression, mr, preparedExpression, new CalculatorParseException(expression, new CalculatorMessage(CalculatorMessages.msg_002, MessageType.error))); try {
} catch (jscl.text.ParseException e) { preparedExpression = preprocessor.process(expression);
handleException(sequenceId, operation, expression, mr, preparedExpression, new CalculatorParseException(e));
} catch (ParseInterruptedException e) { final String jsclExpression = preparedExpression.toString();
// do nothing - we ourselves interrupt the calculations try {
fireCalculatorEvent(newCalculationEventData(operation, expression, sequenceId), CalculatorEventType.calculation_cancelled, null);
final Generic result = operation.evaluateGeneric(jsclExpression);
} catch (CalculatorParseException e) {
handleException(sequenceId, operation, expression, mr, preparedExpression, e); // NOTE: toString() method must be called here as ArithmeticOperationException may occur in it (just to avoid later check!)
} finally { result.toString();
fireCalculatorEvent(newCalculationEventData(operation, expression, sequenceId), CalculatorEventType.calculation_finished, null);
} final CalculatorOutputImpl data = new CalculatorOutputImpl(operation.getFromProcessor().process(result), operation, result);
} fireCalculatorEvent(newCalculationEventData(operation, expression, sequenceId), CalculatorEventType.calculation_result, data);
}
} catch (AbstractJsclArithmeticException e) {
@NotNull handleException(sequenceId, operation, expression, mr, new CalculatorEvalException(e, e, jsclExpression));
private CalculatorEventData newCalculationEventData(@NotNull JsclOperation operation, }
@NotNull String expression,
@NotNull Long calculationId) { } catch (ArithmeticException e) {
return new CalculatorEvaluationEventDataImpl(CalculatorEventDataImpl.newInstance(nextEventDataId(calculationId)), operation, expression); handleException(sequenceId, operation, expression, mr, preparedExpression, new CalculatorParseException(expression, new CalculatorMessage(CalculatorMessages.msg_001, MessageType.error, e.getMessage())));
} } catch (StackOverflowError e) {
handleException(sequenceId, operation, expression, mr, preparedExpression, new CalculatorParseException(expression, new CalculatorMessage(CalculatorMessages.msg_002, MessageType.error)));
private void handleException(@NotNull Long calculationId, } catch (jscl.text.ParseException e) {
@NotNull JsclOperation operation, handleException(sequenceId, operation, expression, mr, preparedExpression, new CalculatorParseException(e));
@NotNull String expression, } catch (ParseInterruptedException e) {
@Nullable MessageRegistry mr,
@Nullable PreparedExpression preparedExpression, // do nothing - we ourselves interrupt the calculations
@NotNull CalculatorParseException parseException) { fireCalculatorEvent(newCalculationEventData(operation, expression, sequenceId), CalculatorEventType.calculation_cancelled, null);
if (operation == JsclOperation.numeric } catch (CalculatorParseException e) {
&& preparedExpression != null handleException(sequenceId, operation, expression, mr, preparedExpression, e);
&& preparedExpression.isExistsUndefinedVar()) { } finally {
fireCalculatorEvent(newCalculationEventData(operation, expression, sequenceId), CalculatorEventType.calculation_finished, null);
evaluate(calculationId, JsclOperation.simplify, expression, mr); }
}
} }
fireCalculatorEvent(newCalculationEventData(operation, expression, calculationId), CalculatorEventType.calculation_failed, new CalculatorFailureImpl(parseException)); @NotNull
} private CalculatorEventData newCalculationEventData(@NotNull JsclOperation operation,
@NotNull String expression,
private void handleException(@NotNull Long calculationId, @NotNull Long calculationId) {
@NotNull JsclOperation operation, return new CalculatorEvaluationEventDataImpl(CalculatorEventDataImpl.newInstance(nextEventDataId(calculationId)), operation, expression);
@NotNull String expression, }
@Nullable MessageRegistry mr,
@NotNull CalculatorEvalException evalException) { private void handleException(@NotNull Long calculationId,
@NotNull JsclOperation operation,
if (operation == JsclOperation.numeric && evalException.getCause() instanceof NumeralBaseException) { @NotNull String expression,
evaluate(calculationId, JsclOperation.simplify, expression, mr); @Nullable MessageRegistry mr,
} @Nullable PreparedExpression preparedExpression,
@NotNull CalculatorParseException parseException) {
fireCalculatorEvent(newCalculationEventData(operation, expression, calculationId), CalculatorEventType.calculation_failed, new CalculatorFailureImpl(evalException));
} if (operation == JsclOperation.numeric
&& preparedExpression != null
/* && preparedExpression.isExistsUndefinedVar()) {
**********************************************************************
* evaluate(calculationId, JsclOperation.simplify, expression, mr);
* EVENTS
* }
**********************************************************************
*/ fireCalculatorEvent(newCalculationEventData(operation, expression, calculationId), CalculatorEventType.calculation_failed, new CalculatorFailureImpl(parseException));
}
@Override
public void addCalculatorEventListener(@NotNull CalculatorEventListener calculatorEventListener) { private void handleException(@NotNull Long calculationId,
calculatorEventContainer.addCalculatorEventListener(calculatorEventListener); @NotNull JsclOperation operation,
} @NotNull String expression,
@Nullable MessageRegistry mr,
@Override @NotNull CalculatorEvalException evalException) {
public void removeCalculatorEventListener(@NotNull CalculatorEventListener calculatorEventListener) {
calculatorEventContainer.removeCalculatorEventListener(calculatorEventListener); if (operation == JsclOperation.numeric && evalException.getCause() instanceof NumeralBaseException) {
} evaluate(calculationId, JsclOperation.simplify, expression, mr);
}
@Override
public void fireCalculatorEvent(@NotNull CalculatorEventData calculatorEventData, @NotNull CalculatorEventType calculatorEventType, @Nullable Object data) { fireCalculatorEvent(newCalculationEventData(operation, expression, calculationId), CalculatorEventType.calculation_failed, new CalculatorFailureImpl(evalException));
calculatorEventContainer.fireCalculatorEvent(calculatorEventData, calculatorEventType, data); }
}
/*
@Override **********************************************************************
public void fireCalculatorEvents(@NotNull List<CalculatorEvent> calculatorEvents) { *
calculatorEventContainer.fireCalculatorEvents(calculatorEvents); * EVENTS
} *
**********************************************************************
@Override */
public void onCalculatorEvent(@NotNull CalculatorEventData calculatorEventData, @NotNull CalculatorEventType calculatorEventType, @Nullable Object data) {
if ( calculatorEventType == CalculatorEventType.editor_state_changed ) { @Override
final CalculatorEditorChangeEventData changeEventData = (CalculatorEditorChangeEventData) data; public void addCalculatorEventListener(@NotNull CalculatorEventListener calculatorEventListener) {
calculatorEventContainer.addCalculatorEventListener(calculatorEventListener);
evaluate(JsclOperation.numeric, changeEventData.getNewState().getText()); }
}
} @Override
public void removeCalculatorEventListener(@NotNull CalculatorEventListener calculatorEventListener) {
public static final class ConversionException extends Exception { calculatorEventContainer.removeCalculatorEventListener(calculatorEventListener);
private ConversionException() { }
}
@Override
private ConversionException(Throwable throwable) { public void fireCalculatorEvent(@NotNull CalculatorEventData calculatorEventData, @NotNull CalculatorEventType calculatorEventType, @Nullable Object data) {
super(throwable); calculatorEventContainer.fireCalculatorEvent(calculatorEventData, calculatorEventType, data);
} }
}
} @Override
public void fireCalculatorEvents(@NotNull List<CalculatorEvent> calculatorEvents) {
calculatorEventContainer.fireCalculatorEvents(calculatorEvents);
}
@Override
public void onCalculatorEvent(@NotNull CalculatorEventData calculatorEventData, @NotNull CalculatorEventType calculatorEventType, @Nullable Object data) {
if (calculatorEventType == CalculatorEventType.editor_state_changed) {
final CalculatorEditorChangeEventData changeEventData = (CalculatorEditorChangeEventData) data;
evaluate(JsclOperation.numeric, changeEventData.getNewState().getText(), calculatorEventData.getSequenceId());
}
}
public static final class ConversionException extends Exception {
private ConversionException() {
}
private ConversionException(Throwable throwable) {
super(throwable);
}
}
}

126
calculatorpp-core/src/main/java/org/solovyev/android/calculator/CalculatorLocatorImpl.java
View File

@ -1,63 +1,63 @@
package org.solovyev.android.calculator; package org.solovyev.android.calculator;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
/** /**
* User: Solovyev_S * User: Solovyev_S
* Date: 20.09.12 * Date: 20.09.12
* Time: 12:45 * Time: 12:45
*/ */
public class CalculatorLocatorImpl implements CalculatorLocator { public class CalculatorLocatorImpl implements CalculatorLocator {
@NotNull @NotNull
private JCalculatorEngine calculatorEngine; private JCalculatorEngine calculatorEngine;
@NotNull @NotNull
private final CalculatorDisplay calculatorDisplay = new CalculatorDisplayImpl(); private final Calculator calculator = new CalculatorImpl();
@NotNull @NotNull
private final Calculator calculator = new CalculatorImpl(); private final CalculatorEditor calculatorEditor = new CalculatorEditorImpl(calculator);
@NotNull @NotNull
private final CalculatorEditor calculatorEditor = new CalculatorEditorImpl(calculator); private final CalculatorDisplay calculatorDisplay = new CalculatorDisplayImpl(calculator);
@NotNull @NotNull
private static final CalculatorLocator instance = new CalculatorLocatorImpl(); private static final CalculatorLocator instance = new CalculatorLocatorImpl();
private CalculatorLocatorImpl() { private CalculatorLocatorImpl() {
} }
@NotNull @NotNull
public static CalculatorLocator getInstance() { public static CalculatorLocator getInstance() {
return instance; return instance;
} }
@NotNull @NotNull
@Override @Override
public JCalculatorEngine getCalculatorEngine() { public JCalculatorEngine getCalculatorEngine() {
return calculatorEngine; return calculatorEngine;
} }
@NotNull @NotNull
@Override @Override
public Calculator getCalculator() { public Calculator getCalculator() {
return this.calculator; return this.calculator;
} }
@Override @Override
public void setCalculatorEngine(@NotNull JCalculatorEngine calculatorEngine) { public void setCalculatorEngine(@NotNull JCalculatorEngine calculatorEngine) {
this.calculatorEngine = calculatorEngine; this.calculatorEngine = calculatorEngine;
} }
@Override @Override
@NotNull @NotNull
public CalculatorDisplay getCalculatorDisplay() { public CalculatorDisplay getCalculatorDisplay() {
return calculatorDisplay; return calculatorDisplay;
} }
@NotNull @NotNull
@Override @Override
public CalculatorEditor getCalculatorEditor() { public CalculatorEditor getCalculatorEditor() {
return calculatorEditor; return calculatorEditor;
} }
} }

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

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

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

@ -1,159 +1,169 @@
package org.solovyev.android.calculator.history; package org.solovyev.android.calculator.history;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import org.solovyev.android.calculator.*; import org.solovyev.android.calculator.*;
import org.solovyev.common.history.HistoryAction; import org.solovyev.common.history.HistoryAction;
import org.solovyev.common.history.HistoryHelper; import org.solovyev.common.history.HistoryHelper;
import org.solovyev.common.history.SimpleHistoryHelper; import org.solovyev.common.history.SimpleHistoryHelper;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections; import java.util.Collections;
import java.util.List; import java.util.List;
import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicInteger;
/** import static org.solovyev.android.calculator.CalculatorEventType.display_state_changed;
* User: Solovyev_S import static org.solovyev.android.calculator.CalculatorEventType.editor_state_changed;
* Date: 20.09.12
* Time: 16:12 /**
*/ * User: Solovyev_S
public class CalculatorHistoryImpl implements CalculatorHistory { * Date: 20.09.12
* Time: 16:12
private final AtomicInteger counter = new AtomicInteger(0); */
public class CalculatorHistoryImpl implements CalculatorHistory {
@NotNull
private final HistoryHelper<CalculatorHistoryState> history = new SimpleHistoryHelper<CalculatorHistoryState>(); private final AtomicInteger counter = new AtomicInteger(0);
@NotNull @NotNull
private final List<CalculatorHistoryState> savedHistory = new ArrayList<CalculatorHistoryState>(); private final HistoryHelper<CalculatorHistoryState> history = new SimpleHistoryHelper<CalculatorHistoryState>();
@NotNull @NotNull
private CalculatorEventDataId lastEventDataId = CalculatorLocatorImpl.getInstance().getCalculator().createFirstEventDataId(); private final List<CalculatorHistoryState> savedHistory = new ArrayList<CalculatorHistoryState>();
@Override @NotNull
public boolean isEmpty() { private volatile CalculatorEventDataId lastEventDataId = CalculatorLocatorImpl.getInstance().getCalculator().createFirstEventDataId();
return this.history.isEmpty();
} @Nullable
private volatile CalculatorEditorViewState lastEditorViewState;
@Override
public CalculatorHistoryState getLastHistoryState() { @Override
return this.history.getLastHistoryState(); public boolean isEmpty() {
} return this.history.isEmpty();
}
@Override
public boolean isUndoAvailable() { @Override
return history.isUndoAvailable(); public CalculatorHistoryState getLastHistoryState() {
} return this.history.getLastHistoryState();
}
@Override
public CalculatorHistoryState undo(@Nullable CalculatorHistoryState currentState) { @Override
return history.undo(currentState); public boolean isUndoAvailable() {
} return history.isUndoAvailable();
}
@Override
public boolean isRedoAvailable() { @Override
return history.isRedoAvailable(); public CalculatorHistoryState undo(@Nullable CalculatorHistoryState currentState) {
} return history.undo(currentState);
}
@Override
public CalculatorHistoryState redo(@Nullable CalculatorHistoryState currentState) { @Override
return history.redo(currentState); public boolean isRedoAvailable() {
} return history.isRedoAvailable();
}
@Override
public boolean isActionAvailable(@NotNull HistoryAction historyAction) { @Override
return history.isActionAvailable(historyAction); public CalculatorHistoryState redo(@Nullable CalculatorHistoryState currentState) {
} return history.redo(currentState);
}
@Override
public CalculatorHistoryState doAction(@NotNull HistoryAction historyAction, @Nullable CalculatorHistoryState currentState) { @Override
return history.doAction(historyAction, currentState); public boolean isActionAvailable(@NotNull HistoryAction historyAction) {
} return history.isActionAvailable(historyAction);
}
@Override
public void addState(@Nullable CalculatorHistoryState currentState) { @Override
history.addState(currentState); public CalculatorHistoryState doAction(@NotNull HistoryAction historyAction, @Nullable CalculatorHistoryState currentState) {
} return history.doAction(historyAction, currentState);
}
@NotNull
@Override @Override
public List<CalculatorHistoryState> getStates() { public void addState(@Nullable CalculatorHistoryState currentState) {
return history.getStates(); history.addState(currentState);
} }
@Override @NotNull
public void clear() { @Override
this.history.clear(); public List<CalculatorHistoryState> getStates() {
} return history.getStates();
}
@NotNull
public List<CalculatorHistoryState> getSavedHistory() { @Override
return Collections.unmodifiableList(savedHistory); public void clear() {
} this.history.clear();
}
@NotNull
public CalculatorHistoryState addSavedState(@NotNull CalculatorHistoryState historyState) { @NotNull
if (historyState.isSaved()) { public List<CalculatorHistoryState> getSavedHistory() {
return historyState; return Collections.unmodifiableList(savedHistory);
} else { }
final CalculatorHistoryState savedState = historyState.clone();
@NotNull
savedState.setId(counter.incrementAndGet()); public CalculatorHistoryState addSavedState(@NotNull CalculatorHistoryState historyState) {
savedState.setSaved(true); if (historyState.isSaved()) {
return historyState;
savedHistory.add(savedState); } else {
final CalculatorHistoryState savedState = historyState.clone();
return savedState;
} savedState.setId(counter.incrementAndGet());
} savedState.setSaved(true);
@Override savedHistory.add(savedState);
public void fromXml(@NotNull String xml) {
clearSavedHistory(); return savedState;
}
HistoryUtils.fromXml(xml, this.savedHistory); }
for (CalculatorHistoryState historyState : savedHistory) {
historyState.setSaved(true); @Override
historyState.setId(counter.incrementAndGet()); public void fromXml(@NotNull String xml) {
} clearSavedHistory();
}
HistoryUtils.fromXml(xml, this.savedHistory);
@Override for (CalculatorHistoryState historyState : savedHistory) {
public String toXml() { historyState.setSaved(true);
return HistoryUtils.toXml(this.savedHistory); historyState.setId(counter.incrementAndGet());
} }
}
@Override
public void clearSavedHistory() { @Override
this.savedHistory.clear(); public String toXml() {
} return HistoryUtils.toXml(this.savedHistory);
}
@Override
public void removeSavedHistory(@NotNull CalculatorHistoryState historyState) { @Override
this.savedHistory.remove(historyState); public void clearSavedHistory() {
} this.savedHistory.clear();
}
@Override
public void onCalculatorEvent(@NotNull CalculatorEventData calculatorEventData, @Override
@NotNull CalculatorEventType calculatorEventType, public void removeSavedHistory(@NotNull CalculatorHistoryState historyState) {
@Nullable Object data) { this.savedHistory.remove(historyState);
if (calculatorEventType.isOfType(CalculatorEventType.calculation_started, CalculatorEventType.calculation_result, CalculatorEventType.calculation_failed)) { }
if ( calculatorEventData.isAfter(this.lastEventDataId) ) { @Override
/* public void onCalculatorEvent(@NotNull CalculatorEventData calculatorEventData,
@NotNull CalculatorEventType calculatorEventType,
switch (calculatorEventType) { @Nullable Object data) {
case calculation_started: if (calculatorEventType.isOfType(editor_state_changed, display_state_changed)) {
CalculatorHistoryState.newInstance()
break; if (calculatorEventData.isAfter(this.lastEventDataId)) {
} final boolean sameSequence = calculatorEventData.isSameSequence(this.lastEventDataId);
CalculatorLocatorImpl.getInstance().getCalculatorDisplay().get this.lastEventDataId = calculatorEventData;
CalculatorHistoryState.newInstance(new TextViewEditorAdapter(this.editor), display);
*/ switch (calculatorEventType) {
case editor_state_changed:
this.lastEventDataId = calculatorEventData; final CalculatorEditorChangeEventData changeEventData = (CalculatorEditorChangeEventData) data;
} lastEditorViewState = changeEventData.getNewState();
} break;
} case display_state_changed:
} if (sameSequence) {
} else {
lastEditorViewState = null;
}
break;
}
}
}
}
}

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

@ -1,115 +1,123 @@
/* /*
* Copyright (c) 2009-2011. Created by serso aka se.solovyev. * Copyright (c) 2009-2011. Created by serso aka se.solovyev.
* For more information, please, contact se.solovyev@gmail.com * For more information, please, contact se.solovyev@gmail.com
*/ */
package org.solovyev.android.calculator.history; package org.solovyev.android.calculator.history;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.simpleframework.xml.Element; import org.simpleframework.xml.Element;
import org.simpleframework.xml.Root; import org.simpleframework.xml.Root;
import org.solovyev.android.calculator.CalculatorDisplay; import org.solovyev.android.calculator.*;
import org.solovyev.android.calculator.CalculatorEditor;
import org.solovyev.android.calculator.Editor; /**
* User: serso
/** * Date: 9/11/11
* User: serso * Time: 12:16 AM
* Date: 9/11/11 */
* Time: 12:16 AM
*/ @Root
public class CalculatorHistoryState extends AbstractHistoryState {
@Root
public class CalculatorHistoryState extends AbstractHistoryState { @Element
@NotNull
@Element private EditorHistoryState editorState;
@NotNull
private EditorHistoryState editorState; @Element
@NotNull
@Element private CalculatorDisplayHistoryState displayState;
@NotNull
private CalculatorDisplayHistoryState displayState; private CalculatorHistoryState() {
// for xml
private CalculatorHistoryState() { }
// for xml
} private CalculatorHistoryState(@NotNull EditorHistoryState editorState,
@NotNull CalculatorDisplayHistoryState displayState) {
private CalculatorHistoryState(@NotNull EditorHistoryState editorState, this.editorState = editorState;
@NotNull CalculatorDisplayHistoryState displayState) { this.displayState = displayState;
this.editorState = editorState; }
this.displayState = displayState;
} @NotNull
public static CalculatorHistoryState newInstance(@NotNull CalculatorEditor editor,
public static CalculatorHistoryState newInstance(@NotNull CalculatorEditor editor, @NotNull CalculatorDisplay display) {
@NotNull CalculatorDisplay display) { final CalculatorEditorViewState editorViewState = editor.getViewState();
final EditorHistoryState editorHistoryState = EditorHistoryState.newInstance(editor.getViewState()); final CalculatorDisplayViewState displayViewState = display.getViewState();
final CalculatorDisplayHistoryState displayHistoryState = CalculatorDisplayHistoryState.newInstance(display.getViewState()); return newInstance(editorViewState, displayViewState);
}
return new CalculatorHistoryState(editorHistoryState, displayHistoryState);
} @NotNull
public static CalculatorHistoryState newInstance(@NotNull CalculatorEditorViewState editorViewState,
@NotNull @NotNull CalculatorDisplayViewState displayViewState) {
public EditorHistoryState getEditorState() { final EditorHistoryState editorHistoryState = EditorHistoryState.newInstance(editorViewState);
return editorState;
} final CalculatorDisplayHistoryState displayHistoryState = CalculatorDisplayHistoryState.newInstance(displayViewState);
public void setEditorState(@NotNull EditorHistoryState editorState) { return new CalculatorHistoryState(editorHistoryState, displayHistoryState);
this.editorState = editorState; }
}
@NotNull
@NotNull public EditorHistoryState getEditorState() {
public CalculatorDisplayHistoryState getDisplayState() { return editorState;
return displayState; }
}
public void setEditorState(@NotNull EditorHistoryState editorState) {
public void setDisplayState(@NotNull CalculatorDisplayHistoryState displayState) { this.editorState = editorState;
this.displayState = displayState; }
}
@NotNull
@Override public CalculatorDisplayHistoryState getDisplayState() {
public String toString() { return displayState;
return "CalculatorHistoryState{" + }
"editorState=" + editorState +
", displayState=" + displayState + public void setDisplayState(@NotNull CalculatorDisplayHistoryState displayState) {
'}'; this.displayState = displayState;
} }
@Override @Override
public boolean equals(Object o) { public String toString() {
if (this == o) return true; return "CalculatorHistoryState{" +
if (o == null || getClass() != o.getClass()) return false; "editorState=" + editorState +
", displayState=" + displayState +
CalculatorHistoryState that = (CalculatorHistoryState) o; '}';
}
if (this.isSaved() != that.isSaved()) return false;
if (this.getId() != that.getId()) return false; @Override
if (!displayState.equals(that.displayState)) return false; public boolean equals(Object o) {
if (!editorState.equals(that.editorState)) return false; if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
return true;
} CalculatorHistoryState that = (CalculatorHistoryState) o;
@Override if (this.isSaved() != that.isSaved()) return false;
public int hashCode() { if (this.getId() != that.getId()) return false;
int result = Boolean.valueOf(isSaved()).hashCode(); if (!displayState.equals(that.displayState)) return false;
result = 31 * result + getId(); if (!editorState.equals(that.editorState)) return false;
result = 31 * result + editorState.hashCode();
result = 31 * result + displayState.hashCode(); return true;
return result; }
}
@Override
public void setValuesFromHistory(@NotNull Editor editor, @NotNull CalculatorDisplay display) { public int hashCode() {
this.getEditorState().setValuesFromHistory(editor); int result = Boolean.valueOf(isSaved()).hashCode();
this.getDisplayState().setValuesFromHistory(display); result = 31 * result + getId();
} result = 31 * result + editorState.hashCode();
result = 31 * result + displayState.hashCode();
@Override return result;
protected CalculatorHistoryState clone() { }
final CalculatorHistoryState clone = (CalculatorHistoryState)super.clone();
public void setValuesFromHistory(@NotNull CalculatorEditor editor, @NotNull CalculatorDisplay display) {
clone.editorState = this.editorState.clone(); this.getEditorState().setValuesFromHistory(editor);
clone.displayState = this.displayState.clone(); this.getDisplayState().setValuesFromHistory(display);
}
return clone;
} @Override
} protected CalculatorHistoryState clone() {
final CalculatorHistoryState clone = (CalculatorHistoryState)super.clone();
clone.editorState = this.editorState.clone();
clone.displayState = this.displayState.clone();
return clone;
}
}

201
calculatorpp-core/src/main/java/org/solovyev/android/calculator/history/EditorHistoryState.java
View File

@ -1,100 +1,101 @@
/* /*
* Copyright (c) 2009-2011. Created by serso aka se.solovyev. * Copyright (c) 2009-2011. Created by serso aka se.solovyev.
* For more information, please, contact se.solovyev@gmail.com * For more information, please, contact se.solovyev@gmail.com
*/ */
package org.solovyev.android.calculator.history; package org.solovyev.android.calculator.history;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import org.simpleframework.xml.Element; import org.simpleframework.xml.Element;
import org.simpleframework.xml.Root; import org.simpleframework.xml.Root;
import org.solovyev.android.calculator.CalculatorDisplayViewState; import org.solovyev.android.calculator.CalculatorDisplayViewState;
import org.solovyev.android.calculator.CalculatorEditorViewState; import org.solovyev.android.calculator.CalculatorEditor;
import org.solovyev.android.calculator.Editor; import org.solovyev.android.calculator.CalculatorEditorViewState;
import org.solovyev.common.text.StringUtils;
@Root
public class EditorHistoryState implements Cloneable{ @Root
public class EditorHistoryState implements Cloneable{
@Element
private int cursorPosition; @Element
private int cursorPosition;
@Element(required = false)
@Nullable @Element(required = false)
private String text; @Nullable
private String text;
private EditorHistoryState() {
// for xml private EditorHistoryState() {
} // for xml
}
@NotNull
public static EditorHistoryState newInstance(@NotNull CalculatorEditorViewState viewState) { @NotNull
final EditorHistoryState result = new EditorHistoryState(); public static EditorHistoryState newInstance(@NotNull CalculatorEditorViewState viewState) {
final EditorHistoryState result = new EditorHistoryState();
result.text = String.valueOf(viewState.getText());
result.cursorPosition = viewState.getSelection(); result.text = String.valueOf(viewState.getText());
result.cursorPosition = viewState.getSelection();
return result;
} return result;
}
@NotNull
public static EditorHistoryState newInstance(@NotNull CalculatorDisplayViewState viewState) { @NotNull
final EditorHistoryState result = new EditorHistoryState(); public static EditorHistoryState newInstance(@NotNull CalculatorDisplayViewState viewState) {
final EditorHistoryState result = new EditorHistoryState();
result.text = viewState.getText();
result.cursorPosition = viewState.getSelection(); result.text = viewState.getText();
result.cursorPosition = viewState.getSelection();
return result;
} return result;
}
public void setValuesFromHistory(@NotNull Editor editor) {
editor.setText(this.getText()); public void setValuesFromHistory(@NotNull CalculatorEditor editor) {
editor.setSelection(this.getCursorPosition()); editor.setText(StringUtils.getNotEmpty(this.getText(), ""));
} editor.setSelection(this.getCursorPosition());
}
@Nullable
public String getText() { @Nullable
return text; public String getText() {
} return text;
}
public int getCursorPosition() {
return cursorPosition; public int getCursorPosition() {
} return cursorPosition;
}
@Override
public boolean equals(Object o) { @Override
if (this == o) return true; public boolean equals(Object o) {
if (!(o instanceof EditorHistoryState)) return false; if (this == o) return true;
if (!(o instanceof EditorHistoryState)) return false;
EditorHistoryState that = (EditorHistoryState) o;
EditorHistoryState that = (EditorHistoryState) o;
if (cursorPosition != that.cursorPosition) return false;
if (text != null ? !text.equals(that.text) : that.text != null) return false; if (cursorPosition != that.cursorPosition) return false;
if (text != null ? !text.equals(that.text) : that.text != null) return false;
return true;
} return true;
}
@Override
public int hashCode() { @Override
int result = cursorPosition; public int hashCode() {
result = 31 * result + (text != null ? text.hashCode() : 0); int result = cursorPosition;
return result; result = 31 * result + (text != null ? text.hashCode() : 0);
} return result;
}
@Override
public String toString() { @Override
return "EditorHistoryState{" + public String toString() {
"cursorPosition=" + cursorPosition + return "EditorHistoryState{" +
", text='" + text + '\'' + "cursorPosition=" + cursorPosition +
'}'; ", text='" + text + '\'' +
} '}';
}
@Override
protected EditorHistoryState clone() { @Override
try { protected EditorHistoryState clone() {
return (EditorHistoryState)super.clone(); try {
} catch (CloneNotSupportedException e) { return (EditorHistoryState)super.clone();
throw new UnsupportedOperationException(e); } catch (CloneNotSupportedException e) {
} throw new UnsupportedOperationException(e);
} }
} }
}

77
calculatorpp-service/pom.xml
View File

@ -1,35 +1,44 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" <project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent> <parent>
<groupId>org.solovyev.android</groupId> <groupId>org.solovyev.android</groupId>
<artifactId>calculatorpp-parent</artifactId> <artifactId>calculatorpp-parent</artifactId>
<version>1.3.2</version> <version>1.3.2</version>
</parent> </parent>
<modelVersion>4.0.0</modelVersion> <modelVersion>4.0.0</modelVersion>
<groupId>org.solovyev.android</groupId> <groupId>org.solovyev.android</groupId>
<artifactId>calculatorpp-service</artifactId> <artifactId>calculatorpp-service</artifactId>
<version>0.1</version> <version>1.3.2</version>
<packaging>apklib</packaging> <packaging>apklib</packaging>
<name>Calculator++ Service</name> <name>Calculator++ Service</name>
<dependencies> <dependencies>
<dependency> <dependency>
<groupId>com.intellij</groupId> <groupId>com.intellij</groupId>
<artifactId>annotations</artifactId> <artifactId>annotations</artifactId>
</dependency> </dependency>
<dependency> <dependency>
<groupId>com.google.android</groupId> <groupId>com.google.android</groupId>
<artifactId>android</artifactId> <artifactId>android</artifactId>
<scope>provided</scope> <scope>provided</scope>
</dependency> </dependency>
</dependencies> </dependencies>
<build>
<extensions>
<extension>
<groupId>com.jayway.maven.plugins.android.generation2</groupId>
<artifactId>android-maven-plugin</artifactId>
</extension>
</extensions>
</build>
</project> </project>

162
calculatorpp/AndroidManifest.xml
View File

@ -1,92 +1,72 @@
<?xml version="1.0" encoding="utf-8"?> <?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android" android:installLocation="auto" <manifest xmlns:android="http://schemas.android.com/apk/res/android" android:installLocation="auto" android:versionCode="81" android:versionName="1.3.2"
android:versionCode="81" android:versionName="1.3.1" package="org.solovyev.android.calculator"> package="org.solovyev.android.calculator">
<uses-permission android:name="android.permission.VIBRATE"/> <uses-permission android:name="android.permission.VIBRATE"/>
<uses-permission android:name="android.permission.INTERNET"/> <uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/> <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission android:name="com.android.vending.BILLING"/> <uses-permission android:name="com.android.vending.BILLING"/>
<uses-sdk android:minSdkVersion="4" android:targetSdkVersion="8"/> <uses-sdk android:minSdkVersion="4" android:targetSdkVersion="8"/>
<application android:debuggable="true" android:hardwareAccelerated="false" android:icon="@drawable/icon" <application android:debuggable="true" android:hardwareAccelerated="false" android:icon="@drawable/icon" android:label="@string/c_app_name" android:name=".CalculatorApplication">
android:label="@string/c_app_name" android:name=".CalculatorApplication">
<activity android:label="@string/c_app_name" android:name=".CalculatorActivity" android:windowSoftInputMode="adjustPan">
<activity android:label="@string/c_app_name" android:name=".CalculatorActivity"
android:windowSoftInputMode="adjustPan"> <intent-filter>
<action android:name="android.intent.action.MAIN"/>
<intent-filter> <category android:name="android.intent.category.LAUNCHER"/>
<action android:name="android.intent.action.MAIN"/> </intent-filter>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter> </activity>
</activity> <service android:name=".CalculationServiceImpl"/>
<service android:name=".CalculationServiceImpl"/> <!--NOTE: a:configChanges="orientation|keyboardHidden" is needed to correct work of dialog windows (not to close them on orientation change) -->
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_app_settings" android:name=".CalculatorPreferencesActivity"/>
<!--NOTE: a:configChanges="orientation|keyboardHidden" is needed to correct work of dialog windows (not to close them on orientation change) -->
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_app_settings" <activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_app_history" android:name=".history.CalculatorHistoryTabActivity"/>
android:name=".CalculatorPreferencesActivity"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_history" android:name=".history.HistoryActivityTab"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_app_history"
android:name=".history.CalculatorHistoryTabActivity"/> <activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_saved_history" android:name=".history.SavedHistoryActivityTab"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_history" <activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_about" android:name=".about.CalculatorAboutTabActivity"/>
android:name=".history.HistoryActivityTab"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_about" android:name=".about.CalculatorAboutActivity"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_saved_history"
android:name=".history.SavedHistoryActivityTab"/> <activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_about" android:name=".about.CalculatorReleaseNotesActivity"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_about" <activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_help" android:name=".help.CalculatorHelpTabActivity"/>
android:name=".about.CalculatorAboutTabActivity"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_help" android:name=".help.HelpFaqActivity"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_about"
android:name=".about.CalculatorAboutActivity"/> <activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_help" android:name=".help.HelpHintsActivity"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_about" <activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_help" android:name=".help.HelpScreensActivity"/>
android:name=".about.CalculatorReleaseNotesActivity"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_functions" android:name=".math.edit.CalculatorFunctionsTabActivity"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_help"
android:name=".help.CalculatorHelpTabActivity"/> <activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_functions" android:name=".math.edit.CalculatorFunctionsActivity"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_help" <activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_operators" android:name=".math.edit.CalculatorOperatorsActivity"/>
android:name=".help.HelpFaqActivity"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_vars_and_constants" android:name=".math.edit.CalculatorVarsTabActivity"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_help"
android:name=".help.HelpHintsActivity"/> <activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_vars_and_constants" android:name=".math.edit.CalculatorVarsActivity"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_help" <activity android:label="@string/c_plot_graph" android:name=".plot.CalculatorPlotActivity"/>
android:name=".help.HelpScreensActivity"/>
<activity android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|uiMode|screenSize|smallestScreenSize" android:name="com.google.ads.AdActivity"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_functions"
android:name=".math.edit.CalculatorFunctionsTabActivity"/> <service android:name="net.robotmedia.billing.BillingService"/>
<receiver android:name="net.robotmedia.billing.BillingReceiver">
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_functions" <intent-filter>
android:name=".math.edit.CalculatorFunctionsActivity"/> <action android:name="com.android.vending.billing.IN_APP_NOTIFY"/>
<action android:name="com.android.vending.billing.RESPONSE_CODE"/>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_operators" <action android:name="com.android.vending.billing.PURCHASE_STATE_CHANGED"/>
android:name=".math.edit.CalculatorOperatorsActivity"/> </intent-filter>
</receiver>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_vars_and_constants"
android:name=".math.edit.CalculatorVarsTabActivity"/> </application>
<activity android:configChanges="orientation|keyboardHidden" android:label="@string/c_vars_and_constants"
android:name=".math.edit.CalculatorVarsActivity"/>
<activity android:label="@string/c_plot_graph" android:name=".plot.CalculatorPlotActivity"/>
<activity
android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|uiMode|screenSize|smallestScreenSize"
android:name="com.google.ads.AdActivity"/>
<service android:name="net.robotmedia.billing.BillingService"/>
<receiver android:name="net.robotmedia.billing.BillingReceiver">
<intent-filter>
<action android:name="com.android.vending.billing.IN_APP_NOTIFY"/>
<action android:name="com.android.vending.billing.RESPONSE_CODE"/>
<action android:name="com.android.vending.billing.PURCHASE_STATE_CHANGED"/>
</intent-filter>
</receiver>
</application>
</manifest> </manifest>

669
calculatorpp/pom.xml
View File

@ -1,340 +1,331 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" <project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent> <parent>
<groupId>org.solovyev.android</groupId> <groupId>org.solovyev.android</groupId>
<artifactId>calculatorpp-parent</artifactId> <artifactId>calculatorpp-parent</artifactId>
<version>1.3.2</version> <version>1.3.2</version>
</parent> </parent>
<modelVersion>4.0.0</modelVersion> <modelVersion>4.0.0</modelVersion>
<groupId>org.solovyev.android</groupId> <groupId>org.solovyev.android</groupId>
<artifactId>calculatorpp</artifactId> <artifactId>calculatorpp</artifactId>
<packaging>apk</packaging> <packaging>apk</packaging>
<name>Calculator++ Application</name> <name>Calculator++ Application</name>
<dependencies> <dependencies>
<!-- OWN --> <!-- OWN -->
<dependency> <dependency>
<groupId>org.solovyev.android</groupId> <groupId>org.solovyev.android</groupId>
<artifactId>calculatorpp-core</artifactId> <artifactId>calculatorpp-core</artifactId>
<version>1.3.2</version> <version>1.3.2</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.solovyev</groupId> <groupId>org.solovyev.android</groupId>
<artifactId>common-core</artifactId> <artifactId>calculatorpp-service</artifactId>
</dependency> <version>1.3.2</version>
<type>apklib</type>
<dependency> </dependency>
<groupId>org.solovyev</groupId>
<artifactId>common-text</artifactId> <dependency>
</dependency> <groupId>org.solovyev</groupId>
<artifactId>common-core</artifactId>
<dependency> </dependency>
<groupId>org.solovyev.android</groupId>
<artifactId>android-common-core</artifactId> <dependency>
<type>apklib</type> <groupId>org.solovyev</groupId>
</dependency> <artifactId>common-text</artifactId>
</dependency>
<dependency>
<groupId>org.solovyev.android</groupId> <dependency>
<artifactId>android-common-ads</artifactId> <groupId>org.solovyev.android</groupId>
<type>apklib</type> <artifactId>android-common-core</artifactId>
</dependency> <type>apklib</type>
</dependency>
<dependency>
<groupId>org.solovyev.android</groupId> <dependency>
<artifactId>android-common-view</artifactId> <groupId>org.solovyev.android</groupId>
<type>apklib</type> <artifactId>android-common-ads</artifactId>
</dependency> <type>apklib</type>
</dependency>
<dependency>
<groupId>org.solovyev.android</groupId> <dependency>
<artifactId>android-common-preferences</artifactId> <groupId>org.solovyev.android</groupId>
<type>apklib</type> <artifactId>android-common-view</artifactId>
</dependency> <type>apklib</type>
</dependency>
<dependency>
<groupId>org.solovyev.android</groupId> <dependency>
<artifactId>android-common-other</artifactId> <groupId>org.solovyev.android</groupId>
<type>apklib</type> <artifactId>android-common-preferences</artifactId>
</dependency> <type>apklib</type>
</dependency>
<dependency>
<groupId>org.solovyev.android</groupId> <dependency>
<artifactId>android-common-menu</artifactId> <groupId>org.solovyev.android</groupId>
<type>apklib</type> <artifactId>android-common-other</artifactId>
</dependency> <type>apklib</type>
</dependency>
<dependency>
<groupId>org.solovyev.android</groupId> <dependency>
<artifactId>calculatorpp-service</artifactId> <groupId>org.solovyev.android</groupId>
<version>0.1</version> <artifactId>android-common-menu</artifactId>
<type>apklib</type> <type>apklib</type>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.solovyev</groupId> <groupId>org.solovyev.android</groupId>
<artifactId>jscl</artifactId> <artifactId>calculatorpp-service</artifactId>
</dependency> <version>0.1</version>
<type>apklib</type>
<!--OTHER--> </dependency>
<dependency> <dependency>
<groupId>com.google.android</groupId> <groupId>org.solovyev</groupId>
<artifactId>android</artifactId> <artifactId>jscl</artifactId>
<scope>provided</scope> </dependency>
</dependency>
<!--OTHER-->
<dependency>
<groupId>net.sf.opencsv</groupId> <dependency>
<artifactId>opencsv</artifactId> <groupId>com.google.android</groupId>
<version>2.0</version> <artifactId>android</artifactId>
<scope>test</scope> <scope>provided</scope>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.simpleframework</groupId> <groupId>net.sf.opencsv</groupId>
<artifactId>simple-xml</artifactId> <artifactId>opencsv</artifactId>
</dependency> <version>2.0</version>
<scope>test</scope>
<dependency> </dependency>
<groupId>achartengine</groupId>
<artifactId>achartengine</artifactId> <dependency>
<version>0.7.0</version> <groupId>org.simpleframework</groupId>
</dependency> <artifactId>simple-xml</artifactId>
</dependency>
<dependency>
<groupId>admob</groupId> <dependency>
<artifactId>admob</artifactId> <groupId>achartengine</groupId>
<version>6.1.0</version> <artifactId>achartengine</artifactId>
</dependency> <version>0.7.0</version>
</dependency>
<dependency>
<groupId>org.solovyev.android</groupId> <dependency>
<artifactId>billing</artifactId> <groupId>admob</groupId>
<version>0.1</version> <artifactId>admob</artifactId>
<!--<type>apklib</type>--> <version>6.1.0</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>com.google.guava</groupId> <groupId>org.solovyev.android</groupId>
<artifactId>guava</artifactId> <artifactId>billing</artifactId>
<version>11.0.2</version> <version>0.1</version>
</dependency> <!--<type>apklib</type>-->
</dependency>
<dependency>
<groupId>junit</groupId> <dependency>
<artifactId>junit</artifactId> <groupId>com.google.guava</groupId>
<scope>test</scope> <artifactId>guava</artifactId>
</dependency> <version>11.0.2</version>
</dependency>
<dependency>
<groupId>com.intellij</groupId> <dependency>
<artifactId>annotations</artifactId> <groupId>junit</groupId>
</dependency> <artifactId>junit</artifactId>
<scope>test</scope>
</dependencies> </dependency>
<build> <dependency>
<groupId>com.intellij</groupId>
<artifactId>annotations</artifactId>
<plugins> </dependency>
<plugin> </dependencies>
<groupId>com.jayway.maven.plugins.android.generation2</groupId>
<artifactId>android-maven-plugin</artifactId> <build>
<extensions>true</extensions>
<configuration>
<manifest> <plugins>
<debuggable>true</debuggable>
</manifest> <plugin>
</configuration> <groupId>com.jayway.maven.plugins.android.generation2</groupId>
<executions> <artifactId>android-maven-plugin</artifactId>
<execution> <extensions>true</extensions>
<id>manifestUpdate</id> <configuration>
<phase>process-resources</phase> <manifest>
<goals> <debuggable>true</debuggable>
<goal>manifest-update</goal> </manifest>
</goals> </configuration>
</execution> <executions>
<execution> <execution>
<id>alignApk</id> <id>manifestUpdate</id>
<phase>package</phase> <phase>process-resources</phase>
<goals> <goals>
<goal>zipalign</goal> <goal>manifest-update</goal>
</goals> </goals>
</execution> </execution>
</executions> <execution>
</plugin> <id>alignApk</id>
<phase>package</phase>
</plugins> <goals>
<goal>zipalign</goal>
</build> </goals>
</execution>
<profiles> </executions>
</plugin>
<profile>
<id>release</id> </plugins>
<!-- via this activation the profile is automatically used when the release is done with the maven release
plugin --> </build>
<activation>
<property> <profiles>
<name>performRelease</name>
<value>true</value> <profile>
</property> <id>release</id>
</activation> <!-- via this activation the profile is automatically used when the release is done with the maven release
plugin -->
<build> <activation>
<plugins> <property>
<name>performRelease</name>
<plugin> <value>true</value>
<groupId>com.jayway.maven.plugins.android.generation2</groupId> </property>
<artifactId>android-maven-plugin</artifactId> </activation>
<executions> <build>
<execution> <plugins>
<id>alignApk</id>
<phase>package</phase> <plugin>
<goals> <groupId>org.codehaus.mojo</groupId>
<goal>zipalign</goal> <artifactId>properties-maven-plugin</artifactId>
</goals> <version>1.0-alpha-2</version>
</execution> <executions>
</executions> <execution>
<phase>initialize</phase>
</plugin> <goals>
<goal>read-project-properties</goal>
<plugin> </goals>
<groupId>org.codehaus.mojo</groupId> <configuration>
<artifactId>properties-maven-plugin</artifactId> <files>
<version>1.0-alpha-2</version> <file>${project.basedir}/misc/env/jarsigner.properties</file>
<executions> </files>
<execution> </configuration>
<phase>initialize</phase> </execution>
<goals> </executions>
<goal>read-project-properties</goal> </plugin>
</goals>
<configuration> <plugin>
<files> <groupId>org.apache.maven.plugins</groupId>
<file>${project.basedir}/misc/env/jarsigner.properties</file> <artifactId>maven-jarsigner-plugin</artifactId>
</files> <executions>
</configuration> <execution>
</execution> <id>signing</id>
</executions> <goals>
</plugin> <goal>sign</goal>
<goal>verify</goal>
<plugin> </goals>
<groupId>org.apache.maven.plugins</groupId> <phase>package</phase>
<artifactId>maven-jarsigner-plugin</artifactId> <inherited>true</inherited>
<executions> <configuration>
<execution> <removeExistingSignatures>true</removeExistingSignatures>
<id>signing</id> <archiveDirectory/>
<goals> <includes>
<goal>sign</goal> <include>${project.build.directory}/${project.artifactId}-${project.version}.apk</include>
<goal>verify</goal> </includes>
</goals> <keystore>${sign.keystore}</keystore>
<phase>package</phase> <alias>${sign.alias}</alias>
<inherited>true</inherited> <storepass>${sign.storepass}</storepass>
<configuration> <keypass>${sign.keypass}</keypass>
<removeExistingSignatures>true</removeExistingSignatures> <verbose>false</verbose>
<archiveDirectory/> </configuration>
<includes> </execution>
<include>${project.build.directory}/${project.artifactId}-${project.version}.apk</include> </executions>
</includes> </plugin>
<keystore>${sign.keystore}</keystore>
<alias>${sign.alias}</alias> <!-- the signed apk then needs to be zipaligned and we activate proguard and we run the manifest
<storepass>${sign.storepass}</storepass> update -->
<keypass>${sign.keypass}</keypass> <plugin>
<verbose>false</verbose> <groupId>com.jayway.maven.plugins.android.generation2</groupId>
</configuration> <artifactId>android-maven-plugin</artifactId>
</execution> <inherited>true</inherited>
</executions> <configuration>
</plugin>
<sign>
<!-- the signed apk then needs to be zipaligned and we activate proguard and we run the manifest <debug>false</debug>
update --> </sign>
<plugin>
<groupId>com.jayway.maven.plugins.android.generation2</groupId> <zipalign>
<artifactId>android-maven-plugin</artifactId> <verbose>false</verbose>
<inherited>true</inherited> <inputApk>${project.build.directory}/${project.artifactId}-${project.version}.apk</inputApk>
<configuration> <outputApk>${project.build.directory}/${project.artifactId}-${project.version}-signed-aligned.apk</outputApk>
</zipalign>
<sign>
<debug>false</debug> <manifest>
</sign> <debuggable>false</debuggable>
<versionCodeAutoIncrement>true</versionCodeAutoIncrement>
<zipalign> </manifest>
<verbose>false</verbose>
<inputApk>${project.build.directory}/${project.artifactId}-${project.version}.apk</inputApk> <proguard>
<outputApk>${project.build.directory}/${project.artifactId}-${project.version}-signed-aligned.apk</outputApk> <skip>true</skip>
</zipalign> </proguard>
</configuration>
<manifest>
<debuggable>false</debuggable> <executions>
<versionCodeAutoIncrement>true</versionCodeAutoIncrement> <execution>
</manifest> <id>manifestUpdate</id>
<phase>process-resources</phase>
<proguard> <goals>
<skip>true</skip> <goal>manifest-update</goal>
</proguard> </goals>
</configuration> </execution>
<execution>
<executions> <id>alignApk</id>
<execution> <phase>package</phase>
<id>manifestUpdate</id> <goals>
<phase>process-resources</phase> <goal>zipalign</goal>
<goals> </goals>
<goal>manifest-update</goal> </execution>
</goals> </executions>
</execution> </plugin>
<execution>
<id>alignApk</id> <plugin>
<phase>package</phase> <groupId>org.codehaus.mojo</groupId>
<goals> <artifactId>build-helper-maven-plugin</artifactId>
<goal>zipalign</goal> <configuration>
</goals> <artifacts>
</execution> <artifact>
</executions> <file>${project.build.directory}/${project.artifactId}-${project.version}-signed-aligned.apk</file>
</plugin> <type>apk</type>
<classifier>signed-aligned</classifier>
<plugin> </artifact>
<groupId>org.codehaus.mojo</groupId> <artifact>
<artifactId>build-helper-maven-plugin</artifactId> <file>${project.build.directory}/proguard/mapping.txt</file>
<configuration> <type>map</type>
<artifacts> <classifier>release</classifier>
<artifact> </artifact>
<file>${project.build.directory}/${project.artifactId}-${project.version}-signed-aligned.apk</file> </artifacts>
<type>apk</type> </configuration>
<classifier>signed-aligned</classifier> <executions>
</artifact> <execution>
<artifact> <id>attach-signed-aligned</id>
<file>${project.build.directory}/proguard/mapping.txt</file> <phase>package</phase>
<type>map</type> <goals>
<classifier>release</classifier> <goal>attach-artifact</goal>
</artifact> </goals>
</artifacts> </execution>
</configuration> </executions>
<executions> </plugin>
<execution>
<id>attach-signed-aligned</id> </plugins>
<phase>package</phase> </build>
<goals> </profile>
<goal>attach-artifact</goal> </profiles>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
</profiles>
</project> </project>

13
calculatorpp/project.properties
View File

@ -9,11 +9,12 @@
# Project target. # Project target.
target=android-15 target=android-15
android.library.reference.1=gen-external-apklibs/org.solovyev.android_android-common-core_1.0.0 android.library.reference.1=gen-external-apklibs/org.solovyev.android_calculatorpp-service_0.1
android.library.reference.2=gen-external-apklibs/org.solovyev.android_android-common-ads_1.0.0 android.library.reference.2=gen-external-apklibs/org.solovyev.android_android-common-core_1.0.0
android.library.reference.3=gen-external-apklibs/org.solovyev.android_android-common-view_1.0.0 android.library.reference.3=gen-external-apklibs/org.solovyev.android_android-common-ads_1.0.0
android.library.reference.4=gen-external-apklibs/org.solovyev.android_android-common-preferences_1.0.0 android.library.reference.4=gen-external-apklibs/org.solovyev.android_android-common-view_1.0.0
android.library.reference.5=gen-external-apklibs/org.solovyev.android_android-common-other_1.0.0 android.library.reference.5=gen-external-apklibs/org.solovyev.android_android-common-preferences_1.0.0
android.library.reference.6=gen-external-apklibs/org.solovyev.android_android-common-menu_1.0.0 android.library.reference.6=gen-external-apklibs/org.solovyev.android_android-common-other_1.0.0
android.library.reference.7=gen-external-apklibs/org.solovyev.android_android-common-menu_1.0.0

274
calculatorpp/src/main/java/org/solovyev/android/calculator/AndroidCalculatorEditorView.java
View File

@ -1,132 +1,142 @@
/* /*
* Copyright (c) 2009-2011. Created by serso aka se.solovyev. * Copyright (c) 2009-2011. Created by serso aka se.solovyev.
* For more information, please, contact se.solovyev@gmail.com * For more information, please, contact se.solovyev@gmail.com
*/ */
package org.solovyev.android.calculator; package org.solovyev.android.calculator;
import android.content.Context; import android.content.Context;
import android.content.SharedPreferences; import android.content.SharedPreferences;
import android.graphics.Color; import android.graphics.Color;
import android.os.Build; import android.os.Build;
import android.text.Html; import android.text.Html;
import android.util.AttributeSet; import android.util.AttributeSet;
import android.util.Log; import android.util.Log;
import android.view.ContextMenu; import android.view.ContextMenu;
import android.widget.EditText; import android.widget.EditText;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.solovyev.android.calculator.model.CalculatorEngine; import org.solovyev.android.calculator.model.CalculatorEngine;
import org.solovyev.android.calculator.text.TextProcessor; import org.solovyev.android.calculator.text.TextProcessor;
import org.solovyev.android.calculator.view.TextHighlighter; import org.solovyev.android.calculator.view.TextHighlighter;
import org.solovyev.common.collections.CollectionsUtils; import org.solovyev.common.collections.CollectionsUtils;
/** /**
* User: serso * User: serso
* Date: 9/17/11 * Date: 9/17/11
* Time: 12:25 AM * Time: 12:25 AM
*/ */
public class AndroidCalculatorEditorView extends EditText implements SharedPreferences.OnSharedPreferenceChangeListener, CalculatorEditorView { public class AndroidCalculatorEditorView extends EditText implements SharedPreferences.OnSharedPreferenceChangeListener, CalculatorEditorView {
private static final String CALC_COLOR_DISPLAY_KEY = "org.solovyev.android.calculator.CalculatorModel_color_display"; private static final String CALC_COLOR_DISPLAY_KEY = "org.solovyev.android.calculator.CalculatorModel_color_display";
private static final boolean CALC_COLOR_DISPLAY_DEFAULT = true; private static final boolean CALC_COLOR_DISPLAY_DEFAULT = true;
private boolean highlightText = true; private boolean highlightText = true;
@NotNull @NotNull
private final static TextProcessor<TextHighlighter.Result, String> textHighlighter = new TextHighlighter(Color.WHITE, true, CalculatorEngine.instance.getEngine()); private final static TextProcessor<TextHighlighter.Result, String> textHighlighter = new TextHighlighter(Color.WHITE, true, CalculatorEngine.instance.getEngine());
public AndroidCalculatorEditorView(Context context) { @NotNull
super(context); private CalculatorEditorViewState viewState = CalculatorEditorViewStateImpl.newDefaultInstance();
}
public AndroidCalculatorEditorView(Context context) {
public AndroidCalculatorEditorView(Context context, AttributeSet attrs) { super(context);
super(context, attrs); }
}
public AndroidCalculatorEditorView(Context context, AttributeSet attrs) {
public AndroidCalculatorEditorView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs);
super(context, attrs, defStyle); }
}
public AndroidCalculatorEditorView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
@Override }
public boolean onCheckIsTextEditor() {
// NOTE: code below can be used carefully and should not be copied without special intention
// The main purpose of code is to disable soft input (virtual keyboard) but leave all the TextEdit functionality, like cursor, scrolling, copy/paste menu etc @Override
public boolean onCheckIsTextEditor() {
if ( Build.VERSION.SDK_INT >= 11 ) { // NOTE: code below can be used carefully and should not be copied without special intention
// fix for missing cursor in android 3 and higher // The main purpose of code is to disable soft input (virtual keyboard) but leave all the TextEdit functionality, like cursor, scrolling, copy/paste menu etc
try {
// IDEA: return false always except if method was called from TextView.isCursorVisible() method if ( Build.VERSION.SDK_INT >= 11 ) {
for (StackTraceElement stackTraceElement : CollectionsUtils.asList(Thread.currentThread().getStackTrace())) { // fix for missing cursor in android 3 and higher
if ( "isCursorVisible".equals(stackTraceElement.getMethodName()) ) { try {
return true; // IDEA: return false always except if method was called from TextView.isCursorVisible() method
} for (StackTraceElement stackTraceElement : CollectionsUtils.asList(Thread.currentThread().getStackTrace())) {
} if ( "isCursorVisible".equals(stackTraceElement.getMethodName()) ) {
} catch (RuntimeException e) { return true;
// just in case... }
} }
} catch (RuntimeException e) {
return false; // just in case...
} else { }
return false;
} return false;
} } else {
return false;
@Override }
protected void onCreateContextMenu(ContextMenu menu) { }
super.onCreateContextMenu(menu);
@Override
menu.removeItem(android.R.id.selectAll); protected void onCreateContextMenu(ContextMenu menu) {
} super.onCreateContextMenu(menu);
public synchronized void redraw() { menu.removeItem(android.R.id.selectAll);
String text = getText().toString(); }
int selectionStart = getSelectionStart(); public synchronized void redraw() {
int selectionEnd = getSelectionEnd(); String text = getText().toString();
if (highlightText) { int selectionStart = getSelectionStart();
int selectionEnd = getSelectionEnd();
Log.d(this.getClass().getName(), text);
if (highlightText) {
try {
final TextHighlighter.Result result = textHighlighter.process(text); Log.d(this.getClass().getName(), text);
selectionStart += result.getOffset();
selectionEnd += result.getOffset(); try {
text = result.toString(); final TextHighlighter.Result result = textHighlighter.process(text);
} catch (CalculatorParseException e) { selectionStart += result.getOffset();
Log.e(this.getClass().getName(), e.getMessage(), e); selectionEnd += result.getOffset();
} text = result.toString();
} catch (CalculatorParseException e) {
Log.d(this.getClass().getName(), text); Log.e(this.getClass().getName(), e.getMessage(), e);
super.setText(Html.fromHtml(text), BufferType.EDITABLE); }
} else {
super.setText(text, BufferType.EDITABLE); Log.d(this.getClass().getName(), text);
} super.setText(Html.fromHtml(text), BufferType.EDITABLE);
} else {
Log.d(this.getClass().getName(), getText().toString()); super.setText(text, BufferType.EDITABLE);
}
int length = getText().length();
setSelection(Math.max(Math.min(length, selectionStart), 0), Math.max(Math.min(length, selectionEnd), 0)); Log.d(this.getClass().getName(), getText().toString());
}
int length = getText().length();
public boolean isHighlightText() { setSelection(Math.max(Math.min(length, selectionStart), 0), Math.max(Math.min(length, selectionEnd), 0));
return highlightText; }
}
public boolean isHighlightText() {
public void setHighlightText(boolean highlightText) { return highlightText;
this.highlightText = highlightText; }
redraw();
} public void setHighlightText(boolean highlightText) {
this.highlightText = highlightText;
@Override redraw();
public void onSharedPreferenceChanged(SharedPreferences preferences, String key) { }
if (CALC_COLOR_DISPLAY_KEY.equals(key)) {
this.setHighlightText(preferences.getBoolean(CALC_COLOR_DISPLAY_KEY, CALC_COLOR_DISPLAY_DEFAULT)); @Override
} public void onSharedPreferenceChanged(SharedPreferences preferences, String key) {
} if (CALC_COLOR_DISPLAY_KEY.equals(key)) {
this.setHighlightText(preferences.getBoolean(CALC_COLOR_DISPLAY_KEY, CALC_COLOR_DISPLAY_DEFAULT));
public void init(@NotNull SharedPreferences preferences) { }
onSharedPreferenceChanged(preferences, CALC_COLOR_DISPLAY_KEY); }
}
} public void init(@NotNull SharedPreferences preferences) {
onSharedPreferenceChanged(preferences, CALC_COLOR_DISPLAY_KEY);
}
@Override
public void setState(@NotNull CalculatorEditorViewState viewState) {
this.viewState = viewState;
this.setText(viewState.getText());
this.setSelection(viewState.getSelection());
}
}

1555
calculatorpp/src/main/java/org/solovyev/android/calculator/CalculatorActivity.java
View File

File diff suppressed because it is too large Load Diff

5
calculatorpp/src/main/java/org/solovyev/android/calculator/CalculatorActivityLauncher.java
View File

@ -61,8 +61,9 @@ public class CalculatorActivityLauncher {
} }
public static void createVar(@NotNull final Context context, @NotNull CalculatorModel calculatorModel) { public static void createVar(@NotNull final Context context, @NotNull CalculatorModel calculatorModel) {
if (calculatorModel.getDisplay().isValid() ) { final CalculatorDisplayViewState viewState = calculatorModel.getDisplay().getViewState();
final String varValue = calculatorModel.getDisplay().getText().toString(); if (viewState.isValid() ) {
final String varValue = viewState.getText();
if (!StringUtils.isEmpty(varValue)) { if (!StringUtils.isEmpty(varValue)) {
if (CalculatorVarsActivity.isValidValue(varValue)) { if (CalculatorVarsActivity.isValidValue(varValue)) {
final Intent intent = new Intent(context, CalculatorVarsTabActivity.class); final Intent intent = new Intent(context, CalculatorVarsTabActivity.class);

604
calculatorpp/src/main/java/org/solovyev/android/calculator/CalculatorModel.java
View File

@ -1,375 +1,229 @@
/* /*
* Copyright (c) 2009-2011. Created by serso aka se.solovyev. * Copyright (c) 2009-2011. Created by serso aka se.solovyev.
* For more information, please, contact se.solovyev@gmail.com * For more information, please, contact se.solovyev@gmail.com
*/ */
package org.solovyev.android.calculator; package org.solovyev.android.calculator;
import android.app.Activity; import android.app.Activity;
import android.app.AlertDialog; import android.app.AlertDialog;
import android.content.Context; import android.content.Context;
import android.content.SharedPreferences; import android.content.SharedPreferences;
import android.os.Handler; import android.text.ClipboardManager;
import android.text.ClipboardManager; import android.util.Log;
import android.util.Log; import android.view.LayoutInflater;
import android.view.LayoutInflater; import android.view.View;
import android.view.View; import android.widget.TextView;
import android.widget.TextView; import android.widget.Toast;
import android.widget.Toast; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.Nullable; import org.solovyev.android.CursorControl;
import org.solovyev.android.CursorControl; import org.solovyev.android.calculator.history.AndroidCalculatorHistoryImpl;
import org.solovyev.android.calculator.history.AndroidCalculatorHistoryImpl; import org.solovyev.android.calculator.history.CalculatorHistoryState;
import org.solovyev.android.calculator.history.CalculatorHistoryState; import org.solovyev.android.calculator.jscl.JsclOperation;
import org.solovyev.android.calculator.history.TextViewEditorAdapter; import org.solovyev.android.calculator.math.MathType;
import org.solovyev.android.calculator.jscl.JsclOperation; import org.solovyev.android.calculator.model.CalculatorEngine;
import org.solovyev.android.calculator.math.MathType; import org.solovyev.android.history.HistoryControl;
import org.solovyev.android.calculator.model.CalculatorEngine; import org.solovyev.common.history.HistoryAction;
import org.solovyev.android.history.HistoryControl; import org.solovyev.common.text.StringUtils;
import org.solovyev.common.MutableObject;
import org.solovyev.common.history.HistoryAction; /**
import org.solovyev.common.msg.Message; * User: serso
import org.solovyev.common.text.StringUtils; * Date: 9/12/11
* Time: 11:15 PM
/** */
* User: serso public enum CalculatorModel implements HistoryControl<CalculatorHistoryState>, CalculatorEngineControl, CursorControl {
* Date: 9/12/11
* Time: 11:15 PM instance;
*/
public enum CalculatorModel implements HistoryControl<CalculatorHistoryState>, CalculatorEngineControl, CursorControl { // millis to wait before evaluation after user edit action
public static final int EVAL_DELAY_MILLIS = 0;
instance;
@NotNull
// millis to wait before evaluation after user edit action private final CalculatorEditor editor;
public static final int EVAL_DELAY_MILLIS = 0;
@NotNull
@NotNull private final CalculatorDisplay display;
private final CalculatorEditor editor;
@NotNull
@NotNull private CalculatorEngine calculatorEngine;
private final CalculatorDisplay display;
private CalculatorModel() {
@NotNull display = CalculatorLocatorImpl.getInstance().getCalculatorDisplay();
private CalculatorEngine calculatorEngine; editor = CalculatorLocatorImpl.getInstance().getCalculatorEditor();
}
private CalculatorModel() {
display = CalculatorLocatorImpl.getInstance().getCalculatorDisplay(); public CalculatorModel init(@NotNull final Activity activity, @NotNull SharedPreferences preferences, @NotNull CalculatorEngine calculator) {
editor = CalculatorLocatorImpl.getInstance().getCalculatorEditor(); Log.d(this.getClass().getName(), "CalculatorModel initialization with activity: " + activity);
} this.calculatorEngine = calculator;
public CalculatorModel init(@NotNull final Activity activity, @NotNull SharedPreferences preferences, @NotNull CalculatorEngine calculator) { final AndroidCalculatorEditorView editorView = (AndroidCalculatorEditorView) activity.findViewById(R.id.calculatorEditor);
Log.d(this.getClass().getName(), "CalculatorModel initialization with activity: " + activity); editorView.init(preferences);
this.calculatorEngine = calculator; preferences.registerOnSharedPreferenceChangeListener(editorView);
editor.setView(editorView);
final AndroidCalculatorEditorView editorView = (AndroidCalculatorEditorView) activity.findViewById(R.id.calculatorEditor);
editorView.init(preferences); final AndroidCalculatorDisplayView displayView = (AndroidCalculatorDisplayView) activity.findViewById(R.id.calculatorDisplay);
preferences.registerOnSharedPreferenceChangeListener(editorView); displayView.setOnClickListener(new CalculatorDisplayOnClickListener(activity));
editor.setView(editorView); display.setView(displayView);
final AndroidCalculatorDisplayView displayView = (AndroidCalculatorDisplayView) activity.findViewById(R.id.calculatorDisplay); final CalculatorHistoryState lastState = AndroidCalculatorHistoryImpl.instance.getLastHistoryState();
displayView.setOnClickListener(new CalculatorDisplayOnClickListener(activity)); if (lastState == null) {
display.setView(displayView); saveHistoryState();
} else {
final CalculatorHistoryState lastState = AndroidCalculatorHistoryImpl.instance.getLastHistoryState(); setCurrentHistoryState(lastState);
if (lastState == null) { }
saveHistoryState();
} else {
setCurrentHistoryState(lastState); return this;
} }
public static void showEvaluationError(@NotNull Activity activity, @NotNull final String errorMessage) {
return this; final LayoutInflater layoutInflater = (LayoutInflater) activity.getSystemService(Activity.LAYOUT_INFLATER_SERVICE);
}
final View errorMessageView = layoutInflater.inflate(R.layout.display_error_message, null);
public static void showEvaluationError(@NotNull Activity activity, @NotNull final String errorMessage) { ((TextView) errorMessageView.findViewById(R.id.error_message_text_view)).setText(errorMessage);
final LayoutInflater layoutInflater = (LayoutInflater) activity.getSystemService(Activity.LAYOUT_INFLATER_SERVICE);
final AlertDialog.Builder builder = new AlertDialog.Builder(activity)
final View errorMessageView = layoutInflater.inflate(R.layout.display_error_message, null); .setPositiveButton(R.string.c_cancel, null)
((TextView) errorMessageView.findViewById(R.id.error_message_text_view)).setText(errorMessage); .setView(errorMessageView);
final AlertDialog.Builder builder = new AlertDialog.Builder(activity) builder.create().show();
.setPositiveButton(R.string.c_cancel, null) }
.setView(errorMessageView);
public void copyResult(@NotNull Context context) {
builder.create().show(); copyResult(context, display.getViewState());
} }
public void copyResult(@NotNull Context context) { public static void copyResult(@NotNull Context context,
copyResult(context, display.getViewState()); @NotNull final CalculatorDisplayViewState viewState) {
} if (viewState.isValid()) {
final CharSequence text = viewState.getText();
public static void copyResult(@NotNull Context context, @NotNull final CalculatorDisplayViewState viewState) { if (!StringUtils.isEmpty(text)) {
if (viewState.isValid()) { final ClipboardManager clipboard = (ClipboardManager) context.getSystemService(Activity.CLIPBOARD_SERVICE);
final CharSequence text = viewState.getText(); clipboard.setText(text.toString());
if (!StringUtils.isEmpty(text)) { Toast.makeText(context, context.getText(R.string.c_result_copied), Toast.LENGTH_SHORT).show();
final ClipboardManager clipboard = (ClipboardManager) context.getSystemService(Activity.CLIPBOARD_SERVICE); }
clipboard.setText(text.toString()); }
Toast.makeText(context, context.getText(R.string.c_result_copied), Toast.LENGTH_SHORT).show(); }
}
} private void saveHistoryState() {
} AndroidCalculatorHistoryImpl.instance.addState(getCurrentHistoryState());
}
private void saveHistoryState() {
AndroidCalculatorHistoryImpl.instance.addState(getCurrentHistoryState()); public void doTextOperation(@NotNull TextOperation operation) {
} operation.doOperation(CalculatorLocatorImpl.getInstance().getCalculatorEditor());
}
public void doTextOperation(@NotNull TextOperation operation) {
doTextOperation(operation, true); public void processDigitButtonAction(@Nullable final String text) {
}
if (!StringUtils.isEmpty(text)) {
public void doTextOperation(@NotNull TextOperation operation, boolean delayEvaluate) { doTextOperation(new CalculatorModel.TextOperation() {
doTextOperation(operation, delayEvaluate, JsclOperation.numeric, false);
} @Override
public void doOperation(@NotNull CalculatorEditor editor) {
public void doTextOperation(@NotNull TextOperation operation, boolean delayEvaluate, @NotNull JsclOperation jsclOperation, boolean forceEval) { int cursorPositionOffset = 0;
final String editorStateBefore = this.editor.getText().toString(); final StringBuilder textToBeInserted = new StringBuilder(text);
Log.d(CalculatorModel.class.getName(), "Editor state changed before '" + editorStateBefore + "'"); final MathType.Result mathType = MathType.getType(text, 0, false);
operation.doOperation(this.editor); switch (mathType.getMathType()) {
//Log.d(CalculatorModel.class.getName(), "Doing text operation" + StringUtils.fromStackTrace(Thread.currentThread().getStackTrace())); case function:
textToBeInserted.append("()");
final String editorStateAfter = this.editor.getText().toString(); cursorPositionOffset = -1;
if (forceEval ||!editorStateBefore.equals(editorStateAfter)) { break;
case operator:
editor.redraw(); textToBeInserted.append("()");
cursorPositionOffset = -1;
evaluate(delayEvaluate, editorStateAfter, jsclOperation, null); break;
} case comma:
} textToBeInserted.append(" ");
break;
@NotNull }
private final static MutableObject<Runnable> pendingOperation = new MutableObject<Runnable>();
if (cursorPositionOffset == 0) {
private void evaluate(boolean delayEvaluate, if (MathType.openGroupSymbols.contains(text)) {
@NotNull final String expression, cursorPositionOffset = -1;
@NotNull final JsclOperation operation, }
@Nullable CalculatorHistoryState historyState) { }
final CalculatorHistoryState localHistoryState; editor.insert(textToBeInserted.toString());
if (historyState == null) { editor.moveSelection(cursorPositionOffset);
//this.display.setText(""); }
localHistoryState = getCurrentHistoryState(); });
} else { }
this.display.setText(historyState.getDisplayState().getEditorState().getText()); }
localHistoryState = historyState;
} @Override
public void setCursorOnStart() {
pendingOperation.setObject(new Runnable() { this.editor.setCursorOnStart();
@Override }
public void run() {
// allow only one runner at one time @Override
synchronized (pendingOperation) { public void setCursorOnEnd() {
//lock all operations with history this.editor.setCursorOnEnd();
if (pendingOperation.getObject() == this) { }
// actually nothing shall be logged while text operations are done
evaluate(expression, operation, this); @Override
public void moveCursorLeft() {
if (pendingOperation.getObject() == this) { this.editor.moveCursorLeft();
// todo serso: of course there is small probability that someone will set pendingOperation after if statement but before .setObject(null) }
pendingOperation.setObject(null);
localHistoryState.setDisplayState(getCurrentHistoryState().getDisplayState()); @Override
} public void moveCursorRight() {
} this.editor.moveCursorRight();
} }
}
}); @Override
public void evaluate() {
if (delayEvaluate) { CalculatorLocatorImpl.getInstance().getCalculator().evaluate(JsclOperation.numeric, this.editor.getViewState().getText());
if (historyState == null) { }
AndroidCalculatorHistoryImpl.instance.addState(localHistoryState);
} @Override
// todo serso: this is not correct - operation is processing still in the same thread public void simplify() {
new Handler().postDelayed(pendingOperation.getObject(), EVAL_DELAY_MILLIS); CalculatorLocatorImpl.getInstance().getCalculator().evaluate(JsclOperation.simplify, this.editor.getViewState().getText());
} else { }
pendingOperation.getObject().run();
if (historyState == null) { public void clear() {
AndroidCalculatorHistoryImpl.instance.addState(localHistoryState); // todo serso:
} }
}
} public static interface TextOperation {
@Override void doOperation(@NotNull CalculatorEditor editor);
public void evaluate() {
evaluate(false, this.editor.getText().toString(), JsclOperation.numeric, null); }
}
@Override
public void evaluate(@NotNull JsclOperation operation) { public void doHistoryAction(@NotNull HistoryAction historyAction) {
evaluate(false, this.editor.getText().toString(), operation, null); synchronized (AndroidCalculatorHistoryImpl.instance) {
} if (AndroidCalculatorHistoryImpl.instance.isActionAvailable(historyAction)) {
final CalculatorHistoryState newState = AndroidCalculatorHistoryImpl.instance.doAction(historyAction, getCurrentHistoryState());
@Override if (newState != null) {
public void simplify() { setCurrentHistoryState(newState);
evaluate(false, this.editor.getText().toString(), JsclOperation.simplify, null); }
} }
}
private void evaluate(@Nullable final String expression, }
@NotNull JsclOperation operation,
@NotNull Runnable currentRunner) { @Override
public void setCurrentHistoryState(@NotNull CalculatorHistoryState editorHistoryState) {
if (!StringUtils.isEmpty(expression)) { synchronized (AndroidCalculatorHistoryImpl.instance) {
try { Log.d(this.getClass().getName(), "Saved history found: " + editorHistoryState);
Log.d(CalculatorModel.class.getName(), "Trying to evaluate '" + operation + "': " + expression /*+ StringUtils.fromStackTrace(Thread.currentThread().getStackTrace())*/);
final CalculatorOutput result = calculatorEngine.evaluate(operation, expression); editorHistoryState.setValuesFromHistory(this.editor, this.display);
}
// todo serso: second condition might replaced with expression.equals(this.editor.getText().toString()) ONLY if expression will be formatted with text highlighter }
if (currentRunner == pendingOperation.getObject() && this.editor.getText().length() > 0) {
display.setText(result.getStringResult()); @Override
} else { @NotNull
display.setText(""); public CalculatorHistoryState getCurrentHistoryState() {
} synchronized (AndroidCalculatorHistoryImpl.instance) {
display.setJsclOperation(result.getOperation()); return CalculatorHistoryState.newInstance(this.editor, display);
display.setGenericResult(result.getResult()); }
} catch (CalculatorParseException e) { }
handleEvaluationException(expression, display, operation, e);
} catch (CalculatorEvalException e) { @NotNull
handleEvaluationException(expression, display, operation, e); public CalculatorDisplay getDisplay() {
} return display;
} else { }
this.display.setText("");
this.display.setJsclOperation(operation); }
this.display.setGenericResult(null);
}
this.display.redraw();
}
private void handleEvaluationException(@NotNull String expression,
@NotNull AndroidCalculatorDisplayView localDisplay,
@NotNull JsclOperation operation,
@NotNull Message e) {
Log.d(CalculatorModel.class.getName(), "Evaluation failed for : " + expression + ". Error message: " + e);
if ( StringUtils.isEmpty(localDisplay.getText()) ) {
// if previous display state was empty -> show error
localDisplay.setText(R.string.c_syntax_error);
} else {
// show previous result instead of error caption (actually previous result will be greyed)
}
localDisplay.setJsclOperation(operation);
localDisplay.setGenericResult(null);
localDisplay.setValid(false);
localDisplay.setErrorMessage(e.getLocalizedMessage());
}
public void clear() {
if (!StringUtils.isEmpty(editor.getText()) || !StringUtils.isEmpty(display.getText())) {
editor.getText().clear();
display.setText("");
saveHistoryState();
}
}
public void processDigitButtonAction(@Nullable final String text) {
processDigitButtonAction(text, true);
}
public void processDigitButtonAction(@Nullable final String text, boolean delayEvaluate) {
if (!StringUtils.isEmpty(text)) {
doTextOperation(new CalculatorModel.TextOperation() {
@Override
public void doOperation(@NotNull CalculatorEditor editor) {
int cursorPositionOffset = 0;
final StringBuilder textToBeInserted = new StringBuilder(text);
final MathType.Result mathType = MathType.getType(text, 0, false);
switch (mathType.getMathType()) {
case function:
textToBeInserted.append("()");
cursorPositionOffset = -1;
break;
case operator:
textToBeInserted.append("()");
cursorPositionOffset = -1;
break;
case comma:
textToBeInserted.append(" ");
break;
}
if (cursorPositionOffset == 0) {
if (MathType.openGroupSymbols.contains(text)) {
cursorPositionOffset = -1;
}
}
editor.insert(textToBeInserted.toString());
editor.moveSelection(cursorPositionOffset);
}
}, delayEvaluate);
}
}
@Override
public void setCursorOnStart() {
this.editor.setCursorOnStart();
}
@Override
public void setCursorOnEnd() {
this.editor.setCursorOnEnd();
}
@Override
public void moveCursorLeft() {
this.editor.moveCursorLeft();
}
@Override
public void moveCursorRight() {
this.editor.moveCursorRight();
}
public static interface TextOperation {
void doOperation(@NotNull CalculatorEditor editor);
}
@Override
public void doHistoryAction(@NotNull HistoryAction historyAction) {
synchronized (AndroidCalculatorHistoryImpl.instance) {
if (AndroidCalculatorHistoryImpl.instance.isActionAvailable(historyAction)) {
final CalculatorHistoryState newState = AndroidCalculatorHistoryImpl.instance.doAction(historyAction, getCurrentHistoryState());
if (newState != null) {
setCurrentHistoryState(newState);
}
}
}
}
@Override
public void setCurrentHistoryState(@NotNull CalculatorHistoryState editorHistoryState) {
synchronized (AndroidCalculatorHistoryImpl.instance) {
Log.d(this.getClass().getName(), "Saved history found: " + editorHistoryState);
editorHistoryState.setValuesFromHistory(new TextViewEditorAdapter(this.editor), this.display);
final String expression = this.editor.getText().toString();
if ( !StringUtils.isEmpty(expression) ) {
if ( StringUtils.isEmpty(this.display.getText().toString()) ) {
evaluate(false, expression, this.display.getJsclOperation(), editorHistoryState);
}
}
editor.redraw();
//display.redraw();
}
}
@Override
@NotNull
public CalculatorHistoryState getCurrentHistoryState() {
synchronized (AndroidCalculatorHistoryImpl.instance) {
return CalculatorHistoryState.newInstance(new TextViewEditorAdapter(this.editor), display);
}
}
@NotNull
public CalculatorDisplay getDisplay() {
return display;
}
}

11
calculatorpp/src/main/java/org/solovyev/android/calculator/ConversionMenuItem.java
View File

@ -31,15 +31,10 @@ enum ConversionMenuItem implements AMenuItem<CalculatorDisplayViewState> {
if (operation == JsclOperation.numeric) { if (operation == JsclOperation.numeric) {
if (generic.getConstants().isEmpty()) { if (generic.getConstants().isEmpty()) {
try { convert(generic);
convert(generic);
// conversion possible => return true // conversion possible => return true
result = true; result = true;
} catch (CalculatorImpl.ConversionException e) {
// conversion is not possible => return false
}
} }
} }

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

@ -1,253 +1,251 @@
/* /*
* Copyright (c) 2009-2011. Created by serso aka se.solovyev. * Copyright (c) 2009-2011. Created by serso aka se.solovyev.
* For more information, please, contact se.solovyev@gmail.com * For more information, please, contact se.solovyev@gmail.com
* or visit http://se.solovyev.org * or visit http://se.solovyev.org
*/ */
package org.solovyev.android.calculator.history; package org.solovyev.android.calculator.history;
import android.app.ListActivity; import android.app.ListActivity;
import android.content.Context; import android.content.Context;
import android.os.Bundle; import android.os.Bundle;
import android.view.MenuInflater; import android.view.MenuInflater;
import android.view.MenuItem; import android.view.MenuItem;
import android.view.View; import android.view.View;
import android.widget.AdapterView; import android.widget.AdapterView;
import android.widget.ArrayAdapter; import android.widget.ArrayAdapter;
import android.widget.ListView; import android.widget.ListView;
import com.google.ads.AdView; import com.google.ads.AdView;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import org.solovyev.android.ads.AdsController; import org.solovyev.android.ads.AdsController;
import org.solovyev.android.calculator.CalculatorEditor; import org.solovyev.android.calculator.CalculatorLocatorImpl;
import org.solovyev.android.calculator.CalculatorLocatorImpl; import org.solovyev.android.calculator.R;
import org.solovyev.android.calculator.CalculatorModel; import org.solovyev.android.calculator.jscl.JsclOperation;
import org.solovyev.android.calculator.R; import org.solovyev.android.menu.AMenuBuilder;
import org.solovyev.android.calculator.jscl.JsclOperation; import org.solovyev.android.menu.MenuImpl;
import org.solovyev.android.menu.AMenuBuilder; import org.solovyev.common.collections.CollectionsUtils;
import org.solovyev.android.menu.MenuImpl; import org.solovyev.common.equals.Equalizer;
import org.solovyev.common.collections.CollectionsUtils; import org.solovyev.common.filter.Filter;
import org.solovyev.common.equals.Equalizer; import org.solovyev.common.filter.FilterRule;
import org.solovyev.common.filter.Filter; import org.solovyev.common.filter.FilterRulesChain;
import org.solovyev.common.filter.FilterRule; import org.solovyev.common.text.StringUtils;
import org.solovyev.common.filter.FilterRulesChain;
import org.solovyev.common.text.StringUtils; import java.util.ArrayList;
import java.util.Collections;
import java.util.ArrayList; import java.util.Comparator;
import java.util.Collections; import java.util.List;
import java.util.Comparator;
import java.util.List; /**
* User: serso
/** * Date: 10/15/11
* User: serso * Time: 1:13 PM
* Date: 10/15/11 */
* Time: 1:13 PM public abstract class AbstractHistoryActivity extends ListActivity {
*/
public abstract class AbstractHistoryActivity extends ListActivity { public static final Comparator<CalculatorHistoryState> COMPARATOR = new Comparator<CalculatorHistoryState>() {
@Override
public static final Comparator<CalculatorHistoryState> COMPARATOR = new Comparator<CalculatorHistoryState>() { public int compare(CalculatorHistoryState state1, CalculatorHistoryState state2) {
@Override if (state1.isSaved() == state2.isSaved()) {
public int compare(CalculatorHistoryState state1, CalculatorHistoryState state2) { long l = state2.getTime() - state1.getTime();
if (state1.isSaved() == state2.isSaved()) { return l > 0l ? 1 : (l < 0l ? -1 : 0);
long l = state2.getTime() - state1.getTime(); } else if (state1.isSaved()) {
return l > 0l ? 1 : (l < 0l ? -1 : 0); return -1;
} else if (state1.isSaved()) { } else if (state2.isSaved()) {
return -1; return 1;
} else if (state2.isSaved()) { }
return 1; return 0;
} }
return 0; };
}
};
@NotNull
private ArrayAdapter<CalculatorHistoryState> adapter;
@NotNull
private ArrayAdapter<CalculatorHistoryState> adapter; @Nullable
private AdView adView;
@Nullable
private AdView adView; @Override
protected void onCreate(Bundle savedInstanceState) {
@Override super.onCreate(savedInstanceState);
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState); setContentView(R.layout.history_activity);
setContentView(R.layout.history_activity); adView = AdsController.getInstance().inflateAd(this);
adView = AdsController.getInstance().inflateAd(this); adapter = new HistoryArrayAdapter(this, getLayoutId(), R.id.history_item, new ArrayList<CalculatorHistoryState>());
setListAdapter(adapter);
adapter = new HistoryArrayAdapter(this, getLayoutId(), R.id.history_item, new ArrayList<CalculatorHistoryState>());
setListAdapter(adapter); final ListView lv = getListView();
lv.setTextFilterEnabled(true);
final ListView lv = getListView();
lv.setTextFilterEnabled(true); lv.setOnItemClickListener(new AdapterView.OnItemClickListener() {
public void onItemClick(final AdapterView<?> parent,
lv.setOnItemClickListener(new AdapterView.OnItemClickListener() { final View view,
public void onItemClick(final AdapterView<?> parent, final int position,
final View view, final long id) {
final int position,
final long id) { useHistoryItem((CalculatorHistoryState) parent.getItemAtPosition(position), AbstractHistoryActivity.this);
}
useHistoryItem((CalculatorHistoryState) parent.getItemAtPosition(position), AbstractHistoryActivity.this); });
}
}); lv.setOnItemLongClickListener(new AdapterView.OnItemLongClickListener() {
@Override
lv.setOnItemLongClickListener(new AdapterView.OnItemLongClickListener() { public boolean onItemLongClick(AdapterView<?> parent, View view, final int position, long id) {
@Override final CalculatorHistoryState historyState = (CalculatorHistoryState) parent.getItemAtPosition(position);
public boolean onItemLongClick(AdapterView<?> parent, View view, final int position, long id) {
final CalculatorHistoryState historyState = (CalculatorHistoryState) parent.getItemAtPosition(position); final Context context = AbstractHistoryActivity.this;
final Context context = AbstractHistoryActivity.this; final HistoryItemMenuData data = new HistoryItemMenuData(historyState, adapter);
final HistoryItemMenuData data = new HistoryItemMenuData(historyState, adapter); final List<HistoryItemMenuItem> menuItems = CollectionsUtils.asList(HistoryItemMenuItem.values());
final List<HistoryItemMenuItem> menuItems = CollectionsUtils.asList(HistoryItemMenuItem.values()); if (historyState.isSaved()) {
menuItems.remove(HistoryItemMenuItem.save);
if (historyState.isSaved()) { } else {
menuItems.remove(HistoryItemMenuItem.save); if (isAlreadySaved(historyState)) {
} else { menuItems.remove(HistoryItemMenuItem.save);
if (isAlreadySaved(historyState)) { }
menuItems.remove(HistoryItemMenuItem.save); menuItems.remove(HistoryItemMenuItem.remove);
} menuItems.remove(HistoryItemMenuItem.edit);
menuItems.remove(HistoryItemMenuItem.remove); }
menuItems.remove(HistoryItemMenuItem.edit);
} if (historyState.getDisplayState().isValid() && StringUtils.isEmpty(historyState.getDisplayState().getEditorState().getText())) {
menuItems.remove(HistoryItemMenuItem.copy_result);
if (historyState.getDisplayState().isValid() && StringUtils.isEmpty(historyState.getDisplayState().getEditorState().getText())) { }
menuItems.remove(HistoryItemMenuItem.copy_result);
} final AMenuBuilder<HistoryItemMenuItem, HistoryItemMenuData> menuBuilder = AMenuBuilder.newInstance(context, MenuImpl.newInstance(menuItems));
menuBuilder.create(data).show();
final AMenuBuilder<HistoryItemMenuItem, HistoryItemMenuData> menuBuilder = AMenuBuilder.newInstance(context, MenuImpl.newInstance(menuItems));
menuBuilder.create(data).show(); return true;
}
return true; });
} }
});
} @Override
protected void onDestroy() {
@Override if ( this.adView != null ) {
protected void onDestroy() { this.adView.destroy();
if ( this.adView != null ) { }
this.adView.destroy(); super.onDestroy();
} }
super.onDestroy();
} protected abstract int getLayoutId();
protected abstract int getLayoutId(); @Override
protected void onResume() {
@Override super.onResume();
protected void onResume() {
super.onResume(); final List<CalculatorHistoryState> historyList = getHistoryList();
try {
final List<CalculatorHistoryState> historyList = getHistoryList(); this.adapter.setNotifyOnChange(false);
try { this.adapter.clear();
this.adapter.setNotifyOnChange(false); for (CalculatorHistoryState historyState : historyList) {
this.adapter.clear(); this.adapter.add(historyState);
for (CalculatorHistoryState historyState : historyList) { }
this.adapter.add(historyState); } finally {
} this.adapter.setNotifyOnChange(true);
} finally { }
this.adapter.setNotifyOnChange(true);
} this.adapter.notifyDataSetChanged();
}
this.adapter.notifyDataSetChanged();
} public static boolean isAlreadySaved(@NotNull CalculatorHistoryState historyState) {
assert !historyState.isSaved();
public static boolean isAlreadySaved(@NotNull CalculatorHistoryState historyState) {
assert !historyState.isSaved(); boolean result = false;
try {
boolean result = false; historyState.setSaved(true);
try { if ( CollectionsUtils.contains(historyState, AndroidCalculatorHistoryImpl.instance.getSavedHistory(), new Equalizer<CalculatorHistoryState>() {
historyState.setSaved(true); @Override
if ( CollectionsUtils.contains(historyState, AndroidCalculatorHistoryImpl.instance.getSavedHistory(), new Equalizer<CalculatorHistoryState>() { public boolean equals(@Nullable CalculatorHistoryState first, @Nullable CalculatorHistoryState second) {
@Override return first != null && second != null &&
public boolean equals(@Nullable CalculatorHistoryState first, @Nullable CalculatorHistoryState second) { first.getTime() == second.getTime() &&
return first != null && second != null && first.getDisplayState().equals(second.getDisplayState()) &&
first.getTime() == second.getTime() && first.getEditorState().equals(second.getEditorState());
first.getDisplayState().equals(second.getDisplayState()) && }
first.getEditorState().equals(second.getEditorState()); }) ) {
} result = true;
}) ) { }
result = true; } finally {
} historyState.setSaved(false);
} finally { }
historyState.setSaved(false); return result;
} }
return result;
} public static void useHistoryItem(@NotNull final CalculatorHistoryState historyState, @NotNull AbstractHistoryActivity activity) {
final EditorHistoryState editorState = historyState.getEditorState();
public static void useHistoryItem(@NotNull final CalculatorHistoryState historyState, @NotNull AbstractHistoryActivity activity) { CalculatorLocatorImpl.getInstance().getCalculatorEditor().setText(StringUtils.getNotEmpty(editorState.getText(), ""), editorState.getCursorPosition());
final EditorHistoryState editorState = historyState.getEditorState();
CalculatorLocatorImpl.getInstance().getCalculatorEditor().setText(StringUtils.getNotEmpty(editorState.getText(), ""), editorState.getCursorPosition()) activity.finish();
}
activity.finish();
} @NotNull
private List<CalculatorHistoryState> getHistoryList() {
@NotNull final List<CalculatorHistoryState> calculatorHistoryStates = getHistoryItems();
private List<CalculatorHistoryState> getHistoryList() {
final List<CalculatorHistoryState> calculatorHistoryStates = getHistoryItems(); Collections.sort(calculatorHistoryStates, COMPARATOR);
Collections.sort(calculatorHistoryStates, COMPARATOR); final FilterRulesChain<CalculatorHistoryState> filterRulesChain = new FilterRulesChain<CalculatorHistoryState>();
filterRulesChain.addFilterRule(new FilterRule<CalculatorHistoryState>() {
final FilterRulesChain<CalculatorHistoryState> filterRulesChain = new FilterRulesChain<CalculatorHistoryState>(); @Override
filterRulesChain.addFilterRule(new FilterRule<CalculatorHistoryState>() { public boolean isFiltered(CalculatorHistoryState object) {
@Override return object == null || StringUtils.isEmpty(object.getEditorState().getText());
public boolean isFiltered(CalculatorHistoryState object) { }
return object == null || StringUtils.isEmpty(object.getEditorState().getText()); });
}
}); new Filter<CalculatorHistoryState>(filterRulesChain).filter(calculatorHistoryStates.iterator());
new Filter<CalculatorHistoryState>(filterRulesChain).filter(calculatorHistoryStates.iterator()); return calculatorHistoryStates;
}
return calculatorHistoryStates;
} @NotNull
protected abstract List<CalculatorHistoryState> getHistoryItems();
@NotNull
protected abstract List<CalculatorHistoryState> getHistoryItems(); @NotNull
public static String getHistoryText(@NotNull CalculatorHistoryState state) {
@NotNull final StringBuilder result = new StringBuilder();
public static String getHistoryText(@NotNull CalculatorHistoryState state) { result.append(state.getEditorState().getText());
final StringBuilder result = new StringBuilder(); result.append(getIdentitySign(state.getDisplayState().getJsclOperation()));
result.append(state.getEditorState().getText()); final String expressionResult = state.getDisplayState().getEditorState().getText();
result.append(getIdentitySign(state.getDisplayState().getJsclOperation())); if (expressionResult != null) {
final String expressionResult = state.getDisplayState().getEditorState().getText(); result.append(expressionResult);
if (expressionResult != null) { }
result.append(expressionResult); return result.toString();
} }
return result.toString();
} @NotNull
private static String getIdentitySign(@NotNull JsclOperation jsclOperation) {
@NotNull return jsclOperation == JsclOperation.simplify ? "≡" : "=";
private static String getIdentitySign(@NotNull JsclOperation jsclOperation) { }
return jsclOperation == JsclOperation.simplify ? "≡" : "=";
} @Override
public boolean onCreateOptionsMenu(android.view.Menu menu) {
@Override final MenuInflater menuInflater = getMenuInflater();
public boolean onCreateOptionsMenu(android.view.Menu menu) { menuInflater.inflate(R.menu.history_menu, menu);
final MenuInflater menuInflater = getMenuInflater(); return true;
menuInflater.inflate(R.menu.history_menu, menu); }
return true;
} @Override
public boolean onOptionsItemSelected(MenuItem item) {
@Override boolean result;
public boolean onOptionsItemSelected(MenuItem item) {
boolean result; switch (item.getItemId()) {
case R.id.history_menu_clear_history:
switch (item.getItemId()) { clearHistory();
case R.id.history_menu_clear_history: result = true;
clearHistory(); break;
result = true; default:
break; result = super.onOptionsItemSelected(item);
default: }
result = super.onOptionsItemSelected(item);
} return result;
}
return result;
} protected abstract void clearHistory();
protected abstract void clearHistory(); @NotNull
protected ArrayAdapter<CalculatorHistoryState> getAdapter() {
@NotNull return adapter;
protected ArrayAdapter<CalculatorHistoryState> getAdapter() { }
return adapter; }
}
}

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

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

2
calculatorpp/src/main/java/org/solovyev/android/calculator/math/edit/AbstractMathEntityListActivity.java
View File

@ -106,7 +106,7 @@ public abstract class AbstractMathEntityListActivity<T extends MathEntity> exten
final int position, final int position,
final long id) { final long id) {
CalculatorModel.instance.processDigitButtonAction(((MathEntity) parent.getItemAtPosition(position)).getName(), false); CalculatorModel.instance.processDigitButtonAction(((MathEntity) parent.getItemAtPosition(position)).getName());
AbstractMathEntityListActivity.this.finish(); AbstractMathEntityListActivity.this.finish();
} }

2
calculatorpp/src/main/java/org/solovyev/android/calculator/math/edit/CalculatorFunctionsActivity.java
View File

@ -33,7 +33,7 @@ public class CalculatorFunctionsActivity extends AbstractMathEntityListActivity<
use(R.string.c_use) { use(R.string.c_use) {
@Override @Override
public void onClick(@NotNull Function data, @NotNull Context context) { public void onClick(@NotNull Function data, @NotNull Context context) {
CalculatorModel.instance.processDigitButtonAction(data.getName(), false); CalculatorModel.instance.processDigitButtonAction(data.getName());
if (context instanceof Activity) { if (context instanceof Activity) {
((Activity) context).finish(); ((Activity) context).finish();
} }

2
calculatorpp/src/main/java/org/solovyev/android/calculator/math/edit/CalculatorOperatorsActivity.java
View File

@ -28,7 +28,7 @@ public class CalculatorOperatorsActivity extends AbstractMathEntityListActivity<
use(R.string.c_use) { use(R.string.c_use) {
@Override @Override
public void onClick(@NotNull Operator data, @NotNull Context context) { public void onClick(@NotNull Operator data, @NotNull Context context) {
CalculatorModel.instance.processDigitButtonAction(data.getName(), false); CalculatorModel.instance.processDigitButtonAction(data.getName());
if (context instanceof Activity) { if (context instanceof Activity) {
((Activity) context).finish(); ((Activity) context).finish();
} }

2
calculatorpp/src/main/java/org/solovyev/android/calculator/math/edit/CalculatorVarsActivity.java
View File

@ -46,7 +46,7 @@ public class CalculatorVarsActivity extends AbstractMathEntityListActivity<ICons
use(R.string.c_use) { use(R.string.c_use) {
@Override @Override
public void onClick(@NotNull IConstant data, @NotNull Context context) { public void onClick(@NotNull IConstant data, @NotNull Context context) {
CalculatorModel.instance.processDigitButtonAction(data.getName(), false); CalculatorModel.instance.processDigitButtonAction(data.getName());
if (context instanceof Activity) { if (context instanceof Activity) {
((Activity) context).finish(); ((Activity) context).finish();
} }

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

@ -1,99 +1,99 @@
package org.solovyev.android.calculator.view; package org.solovyev.android.calculator.view;
import android.app.AlertDialog; import android.app.AlertDialog;
import android.content.Context; import android.content.Context;
import android.view.View; import android.view.View;
import android.view.WindowManager; import android.view.WindowManager;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import org.solovyev.math.units.Unit; import org.solovyev.math.units.Unit;
import org.solovyev.math.units.UnitImpl; import org.solovyev.math.units.UnitImpl;
import org.solovyev.android.calculator.AndroidNumeralBase; import org.solovyev.android.calculator.AndroidNumeralBase;
import org.solovyev.android.calculator.CalculatorModel; import org.solovyev.android.calculator.CalculatorModel;
import org.solovyev.android.calculator.R; import org.solovyev.android.calculator.R;
import org.solovyev.android.calculator.model.CalculatorEngine; import org.solovyev.android.calculator.model.CalculatorEngine;
import org.solovyev.android.calculator.CalculatorParseException; import org.solovyev.android.calculator.CalculatorParseException;
import org.solovyev.android.calculator.ToJsclTextProcessor; import org.solovyev.android.calculator.ToJsclTextProcessor;
import org.solovyev.common.MutableObject; import org.solovyev.common.MutableObject;
import org.solovyev.common.text.StringUtils; import org.solovyev.common.text.StringUtils;
import java.util.Arrays; import java.util.Arrays;
/** /**
* User: serso * User: serso
* Date: 4/22/12 * Date: 4/22/12
* Time: 12:20 AM * Time: 12:20 AM
*/ */
public class NumeralBaseConverterDialog { public class NumeralBaseConverterDialog {
@Nullable @Nullable
private String initialFromValue; private String initialFromValue;
public NumeralBaseConverterDialog(String initialFromValue) { public NumeralBaseConverterDialog(String initialFromValue) {
this.initialFromValue = initialFromValue; this.initialFromValue = initialFromValue;
} }
public void show(@NotNull Context context) { public void show(@NotNull Context context) {
final UnitConverterViewBuilder b = new UnitConverterViewBuilder(); final UnitConverterViewBuilder b = new UnitConverterViewBuilder();
b.setFromUnitTypes(Arrays.asList(AndroidNumeralBase.values())); b.setFromUnitTypes(Arrays.asList(AndroidNumeralBase.values()));
b.setToUnitTypes(Arrays.asList(AndroidNumeralBase.values())); b.setToUnitTypes(Arrays.asList(AndroidNumeralBase.values()));
if (!StringUtils.isEmpty(initialFromValue)) { if (!StringUtils.isEmpty(initialFromValue)) {
String value = initialFromValue; String value = initialFromValue;
try { try {
value = ToJsclTextProcessor.getInstance().process(value).getExpression(); value = ToJsclTextProcessor.getInstance().process(value).getExpression();
b.setFromValue(UnitImpl.newInstance(value, AndroidNumeralBase.valueOf(CalculatorEngine.instance.getEngine().getNumeralBase()))); b.setFromValue(UnitImpl.newInstance(value, AndroidNumeralBase.valueOf(CalculatorEngine.instance.getEngine().getNumeralBase())));
} catch (CalculatorParseException e) { } catch (CalculatorParseException e) {
b.setFromValue(UnitImpl.newInstance(value, AndroidNumeralBase.valueOf(CalculatorEngine.instance.getEngine().getNumeralBase()))); b.setFromValue(UnitImpl.newInstance(value, AndroidNumeralBase.valueOf(CalculatorEngine.instance.getEngine().getNumeralBase())));
} }
} else { } else {
b.setFromValue(UnitImpl.newInstance("", AndroidNumeralBase.valueOf(CalculatorEngine.instance.getEngine().getNumeralBase()))); b.setFromValue(UnitImpl.newInstance("", AndroidNumeralBase.valueOf(CalculatorEngine.instance.getEngine().getNumeralBase())));
} }
b.setConverter(AndroidNumeralBase.getConverter()); b.setConverter(AndroidNumeralBase.getConverter());
final MutableObject<AlertDialog> alertDialogHolder = new MutableObject<AlertDialog>(); final MutableObject<AlertDialog> alertDialogHolder = new MutableObject<AlertDialog>();
b.setOkButtonOnClickListener(new View.OnClickListener() { b.setOkButtonOnClickListener(new View.OnClickListener() {
@Override @Override
public void onClick(View v) { public void onClick(View v) {
final AlertDialog alertDialog = alertDialogHolder.getObject(); final AlertDialog alertDialog = alertDialogHolder.getObject();
if (alertDialog != null) { if (alertDialog != null) {
alertDialog.dismiss(); alertDialog.dismiss();
} }
} }
}); });
b.setCustomButtonData(new UnitConverterViewBuilder.CustomButtonData(context.getString(R.string.c_use_short), new UnitConverterViewBuilder.CustomButtonOnClickListener() { b.setCustomButtonData(new UnitConverterViewBuilder.CustomButtonData(context.getString(R.string.c_use_short), new UnitConverterViewBuilder.CustomButtonOnClickListener() {
@Override @Override
public void onClick(@NotNull Unit<String> fromUnits, @NotNull Unit<String> toUnits) { public void onClick(@NotNull Unit<String> fromUnits, @NotNull Unit<String> toUnits) {
String toUnitsValue = toUnits.getValue(); String toUnitsValue = toUnits.getValue();
if (!toUnits.getUnitType().equals(AndroidNumeralBase.valueOf(CalculatorEngine.instance.getEngine().getNumeralBase()))) { if (!toUnits.getUnitType().equals(AndroidNumeralBase.valueOf(CalculatorEngine.instance.getEngine().getNumeralBase()))) {
toUnitsValue = ((AndroidNumeralBase) toUnits.getUnitType()).getNumeralBase().getJsclPrefix() + toUnitsValue; toUnitsValue = ((AndroidNumeralBase) toUnits.getUnitType()).getNumeralBase().getJsclPrefix() + toUnitsValue;
} }
CalculatorModel.instance.processDigitButtonAction(toUnitsValue, false); CalculatorModel.instance.processDigitButtonAction(toUnitsValue);
final AlertDialog alertDialog = alertDialogHolder.getObject(); final AlertDialog alertDialog = alertDialogHolder.getObject();
if (alertDialog != null) { if (alertDialog != null) {
alertDialog.dismiss(); alertDialog.dismiss();
} }
} }
})); }));
final AlertDialog.Builder alertBuilder = new AlertDialog.Builder(context); final AlertDialog.Builder alertBuilder = new AlertDialog.Builder(context);
alertBuilder.setView(b.build(context)); alertBuilder.setView(b.build(context));
alertBuilder.setTitle(R.string.c_conversion_tool); alertBuilder.setTitle(R.string.c_conversion_tool);
final AlertDialog alertDialog = alertBuilder.create(); final AlertDialog alertDialog = alertBuilder.create();
final WindowManager.LayoutParams lp = new WindowManager.LayoutParams(); final WindowManager.LayoutParams lp = new WindowManager.LayoutParams();
lp.copyFrom(alertDialog.getWindow().getAttributes()); lp.copyFrom(alertDialog.getWindow().getAttributes());
lp.width = WindowManager.LayoutParams.FILL_PARENT; lp.width = WindowManager.LayoutParams.FILL_PARENT;
lp.height = WindowManager.LayoutParams.WRAP_CONTENT; lp.height = WindowManager.LayoutParams.WRAP_CONTENT;
alertDialogHolder.setObject(alertDialog); alertDialogHolder.setObject(alertDialog);
alertDialog.show(); alertDialog.show();
alertDialog.getWindow().setAttributes(lp); alertDialog.getWindow().setAttributes(lp);
} }
} }

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

@ -6,22 +6,9 @@
package org.solovyev.android.calculator.history; package org.solovyev.android.calculator.history;
import jscl.math.Generic;
import junit.framework.Assert;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import org.junit.Test; import org.junit.Test;
import org.solovyev.android.calculator.CalculatorDisplay;
import org.solovyev.android.calculator.Editor; import org.solovyev.android.calculator.Editor;
import org.solovyev.android.calculator.jscl.JsclOperation;
import org.solovyev.common.equals.CollectionEqualizer;
import org.solovyev.common.equals.EqualsTool;
import org.solovyev.common.history.HistoryHelper;
import org.solovyev.common.history.SimpleHistoryHelper;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
/** /**
* User: serso * User: serso
@ -121,7 +108,7 @@ public class HistoryUtilsTest {
@Test @Test
public void testToXml() throws Exception { public void testToXml() throws Exception {
final Date date = new Date(100000000); /*final Date date = new Date(100000000);
HistoryHelper<CalculatorHistoryState> history = new SimpleHistoryHelper<CalculatorHistoryState>(); HistoryHelper<CalculatorHistoryState> history = new SimpleHistoryHelper<CalculatorHistoryState>();
@ -211,11 +198,11 @@ public class HistoryUtilsTest {
historyState.setId(0); historyState.setId(0);
historyState.setSaved(true); historyState.setSaved(true);
} }
Assert.assertTrue(EqualsTool.areEqual(history.getStates(), historyFromXml.getStates(), new CollectionEqualizer<CalculatorHistoryState>(null))); Assert.assertTrue(EqualsTool.areEqual(history.getStates(), historyFromXml.getStates(), new CollectionEqualizer<CalculatorHistoryState>(null)));*/
} }
private static class TestCalculatorDisplay implements CalculatorDisplay { /* private static class TestCalculatorDisplay implements CalculatorDisplay {
@NotNull @NotNull
private final TestEditor testEditor = new TestEditor(); private final TestEditor testEditor = new TestEditor();
@ -288,7 +275,40 @@ public class HistoryUtilsTest {
public void setSelection(int selection) { public void setSelection(int selection) {
this.testEditor.setSelection(selection); this.testEditor.setSelection(selection);
} }
}
@Override
public void setView(@Nullable CalculatorDisplayView view) {
//To change body of implemented methods use File | Settings | File Templates.
}
@NotNull
@Override
public CalculatorDisplayView getView() {
return null; //To change body of implemented methods use File | Settings | File Templates.
}
@NotNull
@Override
public CalculatorDisplayViewState getViewState() {
return null; //To change body of implemented methods use File | Settings | File Templates.
}
@Override
public void setViewState(@NotNull CalculatorDisplayViewState viewState) {
//To change body of implemented methods use File | Settings | File Templates.
}
@NotNull
@Override
public CalculatorEventData getLastEventData() {
return null; //To change body of implemented methods use File | Settings | File Templates.
}
@Override
public void onCalculatorEvent(@NotNull CalculatorEventData calculatorEventData, @NotNull CalculatorEventType calculatorEventType, @Nullable Object data) {
//To change body of implemented methods use File | Settings | File Templates.
}
}*/
private static class TestEditor implements Editor { private static class TestEditor implements Editor {

498
pom.xml
View File

@ -1,254 +1,246 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" <project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion> <modelVersion>4.0.0</modelVersion>
<groupId>org.solovyev.android</groupId> <groupId>org.solovyev.android</groupId>
<artifactId>calculatorpp-parent</artifactId> <artifactId>calculatorpp-parent</artifactId>
<packaging>pom</packaging> <packaging>pom</packaging>
<version>1.3.2</version> <version>1.3.2</version>
<name>Calculator++</name> <name>Calculator++</name>
<modules> <modules>
<module>calculatorpp</module> <module>calculatorpp</module>
<module>calculatorpp-service</module> <module>calculatorpp-service</module>
<module>calculatorpp-test</module> <module>calculatorpp-test</module>
<module>calculatorpp-core</module> <module>calculatorpp-core</module>
</modules> </modules>
<properties> <properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties> </properties>
<dependencyManagement> <dependencyManagement>
<dependencies> <dependencies>
<dependency> <dependency>
<groupId>org.solovyev</groupId> <groupId>org.solovyev</groupId>
<artifactId>common-core</artifactId> <artifactId>common-core</artifactId>
<version>1.0.0</version> <version>1.0.0</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.solovyev</groupId> <groupId>org.solovyev</groupId>
<artifactId>common-text</artifactId> <artifactId>common-text</artifactId>
<version>1.0.1</version> <version>1.0.1</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.solovyev.android</groupId> <groupId>org.solovyev.android</groupId>
<artifactId>android-common-core</artifactId> <artifactId>android-common-core</artifactId>
<type>apklib</type> <type>apklib</type>
<version>1.0.0</version> <version>1.0.0</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.solovyev.android</groupId> <groupId>org.solovyev.android</groupId>
<artifactId>android-common-ads</artifactId> <artifactId>android-common-ads</artifactId>
<type>apklib</type> <type>apklib</type>
<version>1.0.0</version> <version>1.0.0</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.solovyev.android</groupId> <groupId>org.solovyev.android</groupId>
<artifactId>android-common-view</artifactId> <artifactId>android-common-view</artifactId>
<type>apklib</type> <type>apklib</type>
<version>1.0.0</version> <version>1.0.0</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.solovyev.android</groupId> <groupId>org.solovyev.android</groupId>
<artifactId>android-common-preferences</artifactId> <artifactId>android-common-preferences</artifactId>
<type>apklib</type> <type>apklib</type>
<version>1.0.0</version> <version>1.0.0</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.solovyev.android</groupId> <groupId>org.solovyev.android</groupId>
<artifactId>android-common-menu</artifactId> <artifactId>android-common-menu</artifactId>
<type>apklib</type> <type>apklib</type>
<version>1.0.0</version> <version>1.0.0</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.solovyev</groupId> <groupId>org.solovyev</groupId>
<artifactId>jscl</artifactId> <artifactId>jscl</artifactId>
<version>0.0.2</version> <version>0.0.2</version>
<exclusions> <exclusions>
<exclusion> <exclusion>
<artifactId>xercesImpl</artifactId> <artifactId>xercesImpl</artifactId>
<groupId>xerces</groupId> <groupId>xerces</groupId>
</exclusion> </exclusion>
</exclusions> </exclusions>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.solovyev.android</groupId> <groupId>org.solovyev.android</groupId>
<artifactId>android-common-other</artifactId> <artifactId>android-common-other</artifactId>
<type>apklib</type> <type>apklib</type>
<version>1.0.0</version> <version>1.0.0</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>junit</groupId> <groupId>junit</groupId>
<artifactId>junit</artifactId> <artifactId>junit</artifactId>
<version>4.8.2</version> <version>4.8.2</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>com.intellij</groupId> <groupId>com.intellij</groupId>
<artifactId>annotations</artifactId> <artifactId>annotations</artifactId>
<version>7.0.3</version> <version>7.0.3</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>com.google.android</groupId> <groupId>com.google.android</groupId>
<artifactId>android</artifactId> <artifactId>android</artifactId>
<version>4.0.1.2</version> <version>4.0.1.2</version>
<scope>provided</scope> <scope>provided</scope>
</dependency> </dependency>
<dependency> <dependency>
<groupId>com.google.android</groupId> <groupId>com.google.android</groupId>
<artifactId>android-test</artifactId> <artifactId>android-test</artifactId>
<version>2.3.1</version> <version>2.3.1</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>com.google.guava</groupId> <groupId>com.google.guava</groupId>
<artifactId>guava</artifactId> <artifactId>guava</artifactId>
<version>11.0.2</version> <version>11.0.2</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.simpleframework</groupId> <groupId>org.simpleframework</groupId>
<artifactId>simple-xml</artifactId> <artifactId>simple-xml</artifactId>
<version>2.6.1</version> <version>2.6.1</version>
<exclusions> <exclusions>
<exclusion> <exclusion>
<artifactId>stax-api</artifactId> <artifactId>stax-api</artifactId>
<groupId>stax</groupId> <groupId>stax</groupId>
</exclusion> </exclusion>
<exclusion> <exclusion>
<artifactId>xpp3</artifactId> <artifactId>xpp3</artifactId>
<groupId>xpp3</groupId> <groupId>xpp3</groupId>
</exclusion> </exclusion>
</exclusions> </exclusions>
</dependency> </dependency>
</dependencies> </dependencies>
</dependencyManagement> </dependencyManagement>
<build> <build>
<plugins> <plugins>
<plugin> <plugin>
<groupId>com.electriccloud</groupId> <groupId>com.electriccloud</groupId>
<artifactId>javac2-maven-plugin</artifactId> <artifactId>javac2-maven-plugin</artifactId>
<version>1.0.1</version> <version>1.0.1</version>
<executions> <executions>
<execution> <execution>
<id>@NotNull Instrumentation</id> <id>@NotNull Instrumentation</id>
<goals> <goals>
<goal>instrument</goal> <goal>instrument</goal>
</goals> </goals>
<!--compile phase instead of process-classes because of proguard. <!--compile phase instead of process-classes because of proguard.
@NotNull instrumentation will be done now after compilation and before proguard--> @NotNull instrumentation will be done now after compilation and before proguard-->
<phase>compile</phase> <phase>compile</phase>
</execution> </execution>
</executions> </executions>
</plugin> </plugin>
</plugins> </plugins>
<pluginManagement> <pluginManagement>
<plugins> <plugins>
<plugin> <plugin>
<groupId>org.apache.maven.plugins</groupId> <groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jarsigner-plugin</artifactId> <artifactId>maven-jarsigner-plugin</artifactId>
<version>1.2</version> <version>1.2</version>
</plugin> </plugin>
<plugin> <plugin>
<groupId>com.jayway.maven.plugins.android.generation2</groupId> <groupId>com.jayway.maven.plugins.android.generation2</groupId>
<artifactId>android-maven-plugin</artifactId> <artifactId>android-maven-plugin</artifactId>
<version>3.1.1</version> <version>3.1.1</version>
<configuration> <configuration>
<sourceDirectories> <sourceDirectories>
<sourceDirectory>${project.basedir}/src/main/java</sourceDirectory> <sourceDirectory>${project.basedir}/src/main/java</sourceDirectory>
</sourceDirectories> </sourceDirectories>
<sdk> <sdk>
<platform>15</platform> <platform>15</platform>
</sdk> </sdk>
<emulator> <emulator>
<avd>23</avd> <avd>23</avd>
<wait>10000</wait> <wait>10000</wait>
<!--<options>-no-skin</options>--> <!--<options>-no-skin</options>-->
</emulator> </emulator>
<zipalign> <zipalign>
<verbose>true</verbose> <verbose>true</verbose>
</zipalign> </zipalign>
<undeployBeforeDeploy>true</undeployBeforeDeploy> <undeployBeforeDeploy>true</undeployBeforeDeploy>
</configuration> </configuration>
</plugin> </plugin>
<plugin> <plugin>
<groupId>com.pyx4me</groupId> <groupId>com.pyx4me</groupId>
<artifactId>proguard-maven-plugin</artifactId> <artifactId>proguard-maven-plugin</artifactId>
<version>2.0.4</version> <version>2.0.4</version>
</plugin> </plugin>
<plugin> <plugin>
<groupId>org.codehaus.mojo</groupId> <groupId>org.codehaus.mojo</groupId>
<artifactId>build-helper-maven-plugin</artifactId> <artifactId>build-helper-maven-plugin</artifactId>
<version>1.5</version> <version>1.5</version>
</plugin> </plugin>
</plugins> </plugins>
</pluginManagement> </pluginManagement>
<extensions> </build>
<extension>
<groupId>com.jayway.maven.plugins.android.generation2</groupId> <profiles>
<artifactId>android-maven-plugin</artifactId>
<version>3.1.1</version> <profile>
</extension> <!-- the standard profile runs instrumentation tests -->
</extensions> <id>standard</id>
</profile>
</build>
<profile>
<profiles> <!-- the release profile does sign, proguard, zipalign -->
<id>release</id>
<profile> <!-- via this activation the profile is automatically used when the release is done with the maven release
<!-- the standard profile runs instrumentation tests --> plugin -->
<id>standard</id> <activation>
</profile> <property>
<name>performRelease</name>
<profile> <value>true</value>
<!-- the release profile does sign, proguard, zipalign --> </property>
<id>release</id> </activation>
<!-- via this activation the profile is automatically used when the release is done with the maven release
plugin --> </profile>
<activation> </profiles>
<property>
<name>performRelease</name>
<value>true</value>
</property>
</activation>
</profile>
</profiles>
</project> </project>