History refactor
This commit is contained in:
serso
parent
0badc913c0
commit
b21d8084f0
@ -22,6 +22,8 @@
|
||||
|
||||
package org.solovyev.android;
|
||||
|
||||
import android.os.Looper;
|
||||
|
||||
import javax.annotation.Nonnull;
|
||||
import javax.annotation.Nullable;
|
||||
import java.util.Collection;
|
||||
@ -48,9 +50,15 @@ public final class Check {
|
||||
}
|
||||
|
||||
public static void isMainThread() {
|
||||
/*if (!junit && Looper.getMainLooper() != Looper.myLooper()) {
|
||||
if (!junit && Looper.getMainLooper() != Looper.myLooper()) {
|
||||
throw new AssertionException("Should be called on the main thread");
|
||||
}*/
|
||||
}
|
||||
}
|
||||
|
||||
public static void isNotMainThread() {
|
||||
if (!junit && Looper.getMainLooper() == Looper.myLooper()) {
|
||||
throw new AssertionException("Should not be called on the main thread");
|
||||
}
|
||||
}
|
||||
|
||||
public static void isNotNull(@Nullable Object o) {
|
||||
|
||||
@ -27,7 +27,7 @@ import android.content.SharedPreferences;
|
||||
import android.preference.PreferenceManager;
|
||||
import jscl.NumeralBase;
|
||||
import jscl.math.Generic;
|
||||
import org.solovyev.android.calculator.history.HistoryState;
|
||||
import org.solovyev.android.calculator.history.OldHistoryState;
|
||||
import org.solovyev.android.calculator.jscl.JsclOperation;
|
||||
import org.solovyev.common.history.HistoryAction;
|
||||
import org.solovyev.common.msg.Message;
|
||||
@ -156,12 +156,12 @@ public class AndroidCalculator implements Calculator, CalculatorEventListener, S
|
||||
|
||||
@Override
|
||||
@Nonnull
|
||||
public HistoryState getCurrentHistoryState() {
|
||||
public OldHistoryState getCurrentHistoryState() {
|
||||
return calculator.getCurrentHistoryState();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setCurrentHistoryState(@Nonnull HistoryState editorHistoryState) {
|
||||
public void setCurrentHistoryState(@Nonnull OldHistoryState editorHistoryState) {
|
||||
calculator.setCurrentHistoryState(editorHistoryState);
|
||||
}
|
||||
|
||||
|
||||
@ -40,7 +40,7 @@ import org.solovyev.android.views.dragbutton.DragButton;
|
||||
import org.solovyev.android.views.dragbutton.DragDirection;
|
||||
import org.solovyev.android.views.dragbutton.DragListener;
|
||||
import org.solovyev.android.views.dragbutton.SimpleDragListener;
|
||||
import org.solovyev.android.calculator.history.HistoryState;
|
||||
import org.solovyev.android.calculator.history.OldHistoryState;
|
||||
import org.solovyev.android.calculator.history.HistoryDragProcessor;
|
||||
import org.solovyev.android.calculator.view.AngleUnitsButton;
|
||||
import org.solovyev.android.calculator.view.LongClickEraser;
|
||||
@ -165,7 +165,7 @@ public abstract class BaseUi implements SharedPreferences.OnSharedPreferenceChan
|
||||
final ViewsCache views = ViewsCache.forView(root);
|
||||
setOnDragListeners(views, activity);
|
||||
|
||||
HistoryDragProcessor<HistoryState> historyDragProcessor = new HistoryDragProcessor<>(getCalculator());
|
||||
HistoryDragProcessor<OldHistoryState> historyDragProcessor = new HistoryDragProcessor<>(getCalculator());
|
||||
final DragListener historyDragListener = newDragListener(historyDragProcessor, activity);
|
||||
final DragButton historyButton = getButton(views, R.id.cpp_button_history);
|
||||
if (historyButton != null) {
|
||||
|
||||
@ -24,7 +24,7 @@ package org.solovyev.android.calculator;
|
||||
|
||||
import jscl.NumeralBase;
|
||||
import jscl.math.Generic;
|
||||
import org.solovyev.android.calculator.history.HistoryState;
|
||||
import org.solovyev.android.calculator.history.OldHistoryState;
|
||||
import org.solovyev.android.calculator.jscl.JsclOperation;
|
||||
import org.solovyev.common.history.HistoryControl;
|
||||
|
||||
@ -36,7 +36,7 @@ import javax.annotation.Nullable;
|
||||
* Date: 20.09.12
|
||||
* Time: 16:38
|
||||
*/
|
||||
public interface Calculator extends CalculatorEventContainer, HistoryControl<HistoryState> {
|
||||
public interface Calculator extends CalculatorEventContainer, HistoryControl<OldHistoryState> {
|
||||
|
||||
void init();
|
||||
|
||||
|
||||
@ -30,7 +30,7 @@ import org.acra.ACRA;
|
||||
import org.acra.ACRAConfiguration;
|
||||
import org.acra.sender.HttpSender;
|
||||
import org.solovyev.android.Android;
|
||||
import org.solovyev.android.calculator.history.AndroidCalculatorHistory;
|
||||
import org.solovyev.android.calculator.history.CalculatorHistory;
|
||||
import org.solovyev.android.calculator.language.Language;
|
||||
import org.solovyev.android.calculator.language.Languages;
|
||||
import org.solovyev.android.calculator.model.AndroidCalculatorEngine;
|
||||
@ -74,7 +74,7 @@ public class CalculatorApplication extends android.app.Application implements Sh
|
||||
new AndroidCalculatorEngine(this),
|
||||
new AndroidCalculatorClipboard(this),
|
||||
new AndroidCalculatorNotifier(this),
|
||||
new AndroidCalculatorHistory(this, calculator),
|
||||
new CalculatorHistory(),
|
||||
new AndroidCalculatorLogger(),
|
||||
new AndroidCalculatorPreferenceService(this),
|
||||
new CalculatorKeyboard(),
|
||||
@ -93,14 +93,7 @@ public class CalculatorApplication extends android.app.Application implements Sh
|
||||
App.getInitializer().execute(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
try {
|
||||
// warm-up engine
|
||||
CalculatorMathEngine mathEngine = Locator.getInstance().getEngine().getMathEngine();
|
||||
mathEngine.evaluate("1+1");
|
||||
mathEngine.evaluate("1*1");
|
||||
} catch (Throwable e) {
|
||||
Log.e(App.TAG, e.getMessage(), e);
|
||||
}
|
||||
warmUpEngine();
|
||||
}
|
||||
});
|
||||
|
||||
@ -113,6 +106,17 @@ public class CalculatorApplication extends android.app.Application implements Sh
|
||||
}, 100);
|
||||
}
|
||||
|
||||
private void warmUpEngine() {
|
||||
try {
|
||||
// warm-up engine
|
||||
CalculatorMathEngine mathEngine = Locator.getInstance().getEngine().getMathEngine();
|
||||
mathEngine.evaluate("1+1");
|
||||
mathEngine.evaluate("1*1");
|
||||
} catch (Throwable e) {
|
||||
Log.e(App.TAG, e.getMessage(), e);
|
||||
}
|
||||
}
|
||||
|
||||
private void onPreCreate(@Nonnull SharedPreferences preferences, @Nonnull Languages languages) {
|
||||
// first we need to setup crash handler and memory leak analyzer
|
||||
if (!BuildConfig.DEBUG) {
|
||||
|
||||
@ -33,7 +33,7 @@ import jscl.math.function.IConstant;
|
||||
import jscl.math.operator.Operator;
|
||||
import jscl.text.ParseInterruptedException;
|
||||
import org.solovyev.android.calculator.history.CalculatorHistory;
|
||||
import org.solovyev.android.calculator.history.HistoryState;
|
||||
import org.solovyev.android.calculator.history.OldHistoryState;
|
||||
import org.solovyev.android.calculator.jscl.JsclOperation;
|
||||
import org.solovyev.android.calculator.model.Var;
|
||||
import org.solovyev.android.calculator.text.TextProcessor;
|
||||
@ -560,7 +560,7 @@ public class CalculatorImpl implements Calculator, CalculatorEventListener {
|
||||
public void doHistoryAction(@Nonnull HistoryAction historyAction) {
|
||||
final CalculatorHistory history = Locator.getInstance().getHistory();
|
||||
if (history.isActionAvailable(historyAction)) {
|
||||
final HistoryState newState = history.doAction(historyAction, getCurrentHistoryState());
|
||||
final OldHistoryState newState = history.doAction(historyAction, getCurrentHistoryState());
|
||||
if (newState != null) {
|
||||
setCurrentHistoryState(newState);
|
||||
}
|
||||
@ -569,12 +569,12 @@ public class CalculatorImpl implements Calculator, CalculatorEventListener {
|
||||
|
||||
@Nonnull
|
||||
@Override
|
||||
public HistoryState getCurrentHistoryState() {
|
||||
return HistoryState.create(getEditor(), getDisplay());
|
||||
public OldHistoryState getCurrentHistoryState() {
|
||||
return OldHistoryState.create(getEditor(), getDisplay());
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setCurrentHistoryState(@Nonnull HistoryState editorHistoryState) {
|
||||
public void setCurrentHistoryState(@Nonnull OldHistoryState editorHistoryState) {
|
||||
editorHistoryState.setValuesFromHistory(getEditor(), getDisplay());
|
||||
}
|
||||
|
||||
|
||||
@ -23,7 +23,7 @@
|
||||
package org.solovyev.android.calculator;
|
||||
|
||||
import org.solovyev.android.Check;
|
||||
import org.solovyev.android.calculator.history.EditorHistoryState;
|
||||
import org.solovyev.android.calculator.history.OldEditorHistoryState;
|
||||
import org.solovyev.android.calculator.text.TextProcessor;
|
||||
import org.solovyev.android.calculator.text.TextProcessorEditorResult;
|
||||
import org.solovyev.common.text.Strings;
|
||||
@ -104,7 +104,7 @@ public class Editor {
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public EditorState setState(@Nonnull EditorHistoryState state) {
|
||||
public EditorState setState(@Nonnull OldEditorHistoryState state) {
|
||||
Check.isMainThread();
|
||||
return setText(Strings.getNotEmpty(state.getText(), ""), state.getCursorPosition());
|
||||
}
|
||||
|
||||
@ -108,8 +108,6 @@ public final class Preferences {
|
||||
applyDefaultPreference(preferences, Gui.language);
|
||||
|
||||
applyDefaultPreference(preferences, Graph.plotImag);
|
||||
applyDefaultPreference(preferences, History.showIntermediateCalculations);
|
||||
applyDefaultPreference(preferences, History.showDatetime);
|
||||
applyDefaultPreference(preferences, Calculations.calculateOnFly);
|
||||
applyDefaultPreference(preferences, Calculations.preferredAngleUnits);
|
||||
applyDefaultPreference(preferences, Calculations.preferredNumeralBase);
|
||||
|
||||
@ -1,175 +0,0 @@
|
||||
/*
|
||||
* Copyright 2013 serso aka se.solovyev
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
* Contact details
|
||||
*
|
||||
* Email: se.solovyev@gmail.com
|
||||
* Site: http://se.solovyev.org
|
||||
*/
|
||||
|
||||
package org.solovyev.android.calculator.history;
|
||||
|
||||
import android.app.Application;
|
||||
import android.content.Context;
|
||||
import android.content.SharedPreferences;
|
||||
import android.preference.PreferenceManager;
|
||||
|
||||
import org.solovyev.android.calculator.Calculator;
|
||||
import org.solovyev.android.calculator.CalculatorEventData;
|
||||
import org.solovyev.android.calculator.CalculatorEventType;
|
||||
import org.solovyev.common.history.HistoryAction;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import javax.annotation.Nonnull;
|
||||
import javax.annotation.Nullable;
|
||||
|
||||
/**
|
||||
* User: serso
|
||||
* Date: 10/9/11
|
||||
* Time: 6:35 PM
|
||||
*/
|
||||
public class AndroidCalculatorHistory implements CalculatorHistory {
|
||||
|
||||
@Nonnull
|
||||
private final CalculatorHistoryImpl calculatorHistory;
|
||||
|
||||
@Nonnull
|
||||
private final Context context;
|
||||
|
||||
public AndroidCalculatorHistory(@Nonnull Application application, @Nonnull Calculator calculator) {
|
||||
this.context = application;
|
||||
calculatorHistory = new CalculatorHistoryImpl(calculator);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void load() {
|
||||
final SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
|
||||
if (preferences != null) {
|
||||
final String value = preferences.getString("org.solovyev.android.calculator.CalculatorModel_history", null);
|
||||
if (value != null) {
|
||||
calculatorHistory.fromXml(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void save() {
|
||||
final SharedPreferences settings = PreferenceManager.getDefaultSharedPreferences(context);
|
||||
final SharedPreferences.Editor editor = settings.edit();
|
||||
|
||||
editor.putString("org.solovyev.android.calculator.CalculatorModel_history", calculatorHistory.toXml());
|
||||
|
||||
editor.apply();
|
||||
}
|
||||
|
||||
public void clearSavedHistory() {
|
||||
calculatorHistory.clearSavedHistory();
|
||||
save();
|
||||
}
|
||||
|
||||
public void removeSavedHistory(@Nonnull HistoryState historyState) {
|
||||
historyState.setSaved(false);
|
||||
calculatorHistory.removeSavedHistory(historyState);
|
||||
save();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
return calculatorHistory.isEmpty();
|
||||
}
|
||||
|
||||
@Override
|
||||
public HistoryState getLastHistoryState() {
|
||||
return calculatorHistory.getLastHistoryState();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isUndoAvailable() {
|
||||
return calculatorHistory.isUndoAvailable();
|
||||
}
|
||||
|
||||
@Override
|
||||
public HistoryState undo(@Nullable HistoryState currentState) {
|
||||
return calculatorHistory.undo(currentState);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isRedoAvailable() {
|
||||
return calculatorHistory.isRedoAvailable();
|
||||
}
|
||||
|
||||
@Override
|
||||
public HistoryState redo(@Nullable HistoryState currentState) {
|
||||
return calculatorHistory.redo(currentState);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isActionAvailable(@Nonnull HistoryAction historyAction) {
|
||||
return calculatorHistory.isActionAvailable(historyAction);
|
||||
}
|
||||
|
||||
@Override
|
||||
public HistoryState doAction(@Nonnull HistoryAction historyAction, @Nullable HistoryState currentState) {
|
||||
return calculatorHistory.doAction(historyAction, currentState);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addState(@Nullable HistoryState currentState) {
|
||||
calculatorHistory.addState(currentState);
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
@Override
|
||||
public List<HistoryState> getStates() {
|
||||
return calculatorHistory.getStates();
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
@Override
|
||||
public List<HistoryState> getStates(boolean includeIntermediateStates) {
|
||||
return calculatorHistory.getStates(includeIntermediateStates);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clear() {
|
||||
calculatorHistory.clear();
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public List<HistoryState> getSavedHistory() {
|
||||
return calculatorHistory.getSavedHistory();
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public HistoryState addSavedState(@Nonnull HistoryState historyState) {
|
||||
return calculatorHistory.addSavedState(historyState);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void fromXml(@Nonnull String xml) {
|
||||
calculatorHistory.fromXml(xml);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toXml() {
|
||||
return calculatorHistory.toXml();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onCalculatorEvent(@Nonnull CalculatorEventData calculatorEventData, @Nonnull CalculatorEventType calculatorEventType, @Nullable Object data) {
|
||||
calculatorHistory.onCalculatorEvent(calculatorEventData, calculatorEventType, data);
|
||||
}
|
||||
}
|
||||
@ -61,9 +61,9 @@ import static org.solovyev.android.calculator.CalculatorEventType.clear_history_
|
||||
|
||||
public abstract class BaseHistoryFragment extends ListFragment implements CalculatorEventListener {
|
||||
|
||||
public static final Comparator<HistoryState> COMPARATOR = new Comparator<HistoryState>() {
|
||||
public static final Comparator<OldHistoryState> COMPARATOR = new Comparator<OldHistoryState>() {
|
||||
@Override
|
||||
public int compare(HistoryState state1, HistoryState state2) {
|
||||
public int compare(OldHistoryState state1, OldHistoryState state2) {
|
||||
if (state1.isSaved() == state2.isSaved()) {
|
||||
long l = state2.getTime() - state1.getTime();
|
||||
return l > 0l ? 1 : (l < 0l ? -1 : 0);
|
||||
@ -103,15 +103,15 @@ public abstract class BaseHistoryFragment extends ListFragment implements Calcul
|
||||
ui = new FragmentUi(fragmentType.getDefaultLayoutId(), fragmentType.getDefaultTitleResId(), false);
|
||||
}
|
||||
|
||||
public static boolean isAlreadySaved(@Nonnull HistoryState historyState) {
|
||||
public static boolean isAlreadySaved(@Nonnull OldHistoryState historyState) {
|
||||
Check.isTrue(!historyState.isSaved());
|
||||
|
||||
boolean result = false;
|
||||
try {
|
||||
historyState.setSaved(true);
|
||||
if (Collections.contains(historyState, Locator.getInstance().getHistory().getSavedHistory(), new Equalizer<HistoryState>() {
|
||||
if (Collections.contains(historyState, Locator.getInstance().getHistory().getSavedOldHistory(), new Equalizer<OldHistoryState>() {
|
||||
@Override
|
||||
public boolean areEqual(@Nullable HistoryState first, @Nullable HistoryState second) {
|
||||
public boolean areEqual(@Nullable OldHistoryState first, @Nullable OldHistoryState second) {
|
||||
return first != null && second != null &&
|
||||
first.getTime() == second.getTime() &&
|
||||
first.getDisplayState().equals(second.getDisplayState()) &&
|
||||
@ -127,7 +127,7 @@ public abstract class BaseHistoryFragment extends ListFragment implements Calcul
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public static String getHistoryText(@Nonnull HistoryState state) {
|
||||
public static String getHistoryText(@Nonnull OldHistoryState state) {
|
||||
final StringBuilder result = new StringBuilder();
|
||||
result.append(state.getEditorState().getText());
|
||||
result.append(getIdentitySign(state.getDisplayState().getJsclOperation()));
|
||||
@ -143,7 +143,7 @@ public abstract class BaseHistoryFragment extends ListFragment implements Calcul
|
||||
return jsclOperation == JsclOperation.simplify ? "≡" : "=";
|
||||
}
|
||||
|
||||
public void useState(@Nonnull final HistoryState state) {
|
||||
public void useState(@Nonnull final OldHistoryState state) {
|
||||
App.getEditor().setState(state.getEditorState());
|
||||
final FragmentActivity activity = getActivity();
|
||||
if (!(activity instanceof CalculatorActivity)) {
|
||||
@ -180,7 +180,7 @@ public abstract class BaseHistoryFragment extends ListFragment implements Calcul
|
||||
|
||||
ui.onViewCreated(this, root);
|
||||
|
||||
adapter = new HistoryArrayAdapter(this.getActivity(), getItemLayoutId(), org.solovyev.android.calculator.R.id.history_item, new ArrayList<HistoryState>(), showDatetime);
|
||||
adapter = new HistoryArrayAdapter(this.getActivity(), getItemLayoutId(), org.solovyev.android.calculator.R.id.history_item, new ArrayList<OldHistoryState>(), showDatetime);
|
||||
setListAdapter(adapter);
|
||||
|
||||
final ListView lv = getListView();
|
||||
@ -200,7 +200,7 @@ public abstract class BaseHistoryFragment extends ListFragment implements Calcul
|
||||
final View view,
|
||||
final int position,
|
||||
final long id) {
|
||||
useState((HistoryState) parent.getItemAtPosition(position));
|
||||
useState((OldHistoryState) parent.getItemAtPosition(position));
|
||||
}
|
||||
});
|
||||
|
||||
@ -221,7 +221,7 @@ public abstract class BaseHistoryFragment extends ListFragment implements Calcul
|
||||
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
|
||||
super.onCreateContextMenu(menu, v, menuInfo);
|
||||
final AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo) menuInfo;
|
||||
final HistoryState state = (HistoryState) getListView().getItemAtPosition(info.position);
|
||||
final OldHistoryState state = (OldHistoryState) getListView().getItemAtPosition(info.position);
|
||||
|
||||
if (state.isSaved()) {
|
||||
menu.add(NONE, R.string.c_use, NONE, R.string.c_use);
|
||||
@ -247,7 +247,7 @@ public abstract class BaseHistoryFragment extends ListFragment implements Calcul
|
||||
public boolean onContextItemSelected(MenuItem item) {
|
||||
final Context context = getActivity();
|
||||
final AdapterView.AdapterContextMenuInfo info = (AdapterView.AdapterContextMenuInfo) item.getMenuInfo();
|
||||
final HistoryState state = (HistoryState) getListView().getItemAtPosition(info.position);
|
||||
final OldHistoryState state = (OldHistoryState) getListView().getItemAtPosition(info.position);
|
||||
|
||||
switch (item.getItemId()) {
|
||||
case R.string.c_use:
|
||||
@ -296,7 +296,7 @@ public abstract class BaseHistoryFragment extends ListFragment implements Calcul
|
||||
return super.onContextItemSelected(item);
|
||||
}
|
||||
|
||||
private void createEditHistoryDialog(@Nonnull final HistoryState state, @Nonnull final Context context, final boolean save) {
|
||||
private void createEditHistoryDialog(@Nonnull final OldHistoryState state, @Nonnull final Context context, final boolean save) {
|
||||
final LayoutInflater layoutInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
|
||||
final View editView = layoutInflater.inflate(R.layout.history_edit, null);
|
||||
final TextView historyExpression = (TextView) editView.findViewById(R.id.history_edit_expression);
|
||||
@ -313,7 +313,7 @@ public abstract class BaseHistoryFragment extends ListFragment implements Calcul
|
||||
@Override
|
||||
public void onClick(DialogInterface dialog, int which) {
|
||||
if (save) {
|
||||
final HistoryState savedHistoryItem = Locator.getInstance().getHistory().addSavedState(state);
|
||||
final OldHistoryState savedHistoryItem = Locator.getInstance().getHistory().addSavedState(state);
|
||||
savedHistoryItem.setComment(comment.getText().toString());
|
||||
Locator.getInstance().getHistory().save();
|
||||
// we don't need to add element to the adapter as adapter of another activity must be updated and not this
|
||||
@ -331,7 +331,7 @@ public abstract class BaseHistoryFragment extends ListFragment implements Calcul
|
||||
builder.create().show();
|
||||
}
|
||||
|
||||
private boolean shouldHaveCopyResult(@Nonnull HistoryState state) {
|
||||
private boolean shouldHaveCopyResult(@Nonnull OldHistoryState state) {
|
||||
return !state.getDisplayState().isValid() || !Strings.isEmpty(state.getDisplayState().getEditorState().getText());
|
||||
}
|
||||
|
||||
@ -365,13 +365,13 @@ public abstract class BaseHistoryFragment extends ListFragment implements Calcul
|
||||
protected abstract int getItemLayoutId();
|
||||
|
||||
private void updateAdapter() {
|
||||
final List<HistoryState> historyList = getHistoryList();
|
||||
final List<OldHistoryState> historyList = getHistoryList();
|
||||
|
||||
final ArrayAdapter<HistoryState> adapter = getAdapter();
|
||||
final ArrayAdapter<OldHistoryState> adapter = getAdapter();
|
||||
try {
|
||||
adapter.setNotifyOnChange(false);
|
||||
adapter.clear();
|
||||
for (HistoryState historyState : historyList) {
|
||||
for (OldHistoryState historyState : historyList) {
|
||||
adapter.add(historyState);
|
||||
}
|
||||
} finally {
|
||||
@ -382,15 +382,15 @@ public abstract class BaseHistoryFragment extends ListFragment implements Calcul
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
private List<HistoryState> getHistoryList() {
|
||||
final List<HistoryState> historyStates = getHistoryItems();
|
||||
private List<OldHistoryState> getHistoryList() {
|
||||
final List<OldHistoryState> historyStates = getHistoryItems();
|
||||
|
||||
java.util.Collections.sort(historyStates, COMPARATOR);
|
||||
|
||||
final FilterRulesChain<HistoryState> filterRulesChain = new FilterRulesChain<>();
|
||||
filterRulesChain.addFilterRule(new JPredicate<HistoryState>() {
|
||||
final FilterRulesChain<OldHistoryState> filterRulesChain = new FilterRulesChain<>();
|
||||
filterRulesChain.addFilterRule(new JPredicate<OldHistoryState>() {
|
||||
@Override
|
||||
public boolean apply(HistoryState object) {
|
||||
public boolean apply(OldHistoryState object) {
|
||||
return object == null || Strings.isEmpty(object.getEditorState().getText());
|
||||
}
|
||||
});
|
||||
@ -401,7 +401,7 @@ public abstract class BaseHistoryFragment extends ListFragment implements Calcul
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
protected abstract List<HistoryState> getHistoryItems();
|
||||
protected abstract List<OldHistoryState> getHistoryItems();
|
||||
|
||||
protected abstract void clearHistory();
|
||||
|
||||
|
||||
@ -22,42 +22,204 @@
|
||||
|
||||
package org.solovyev.android.calculator.history;
|
||||
|
||||
import org.solovyev.android.calculator.CalculatorEventListener;
|
||||
import android.content.SharedPreferences;
|
||||
import android.text.TextUtils;
|
||||
import com.squareup.otto.Subscribe;
|
||||
import org.solovyev.android.Check;
|
||||
import org.solovyev.android.calculator.*;
|
||||
import org.solovyev.common.history.HistoryAction;
|
||||
import org.solovyev.common.history.HistoryHelper;
|
||||
|
||||
import java.util.List;
|
||||
import org.solovyev.common.history.SimpleHistoryHelper;
|
||||
|
||||
import javax.annotation.Nonnull;
|
||||
import javax.annotation.Nullable;
|
||||
import java.util.Collections;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
|
||||
/**
|
||||
* User: Solovyev_S
|
||||
* Date: 20.09.12
|
||||
* Time: 16:11
|
||||
*/
|
||||
public interface CalculatorHistory extends HistoryHelper<HistoryState>, CalculatorEventListener {
|
||||
public class CalculatorHistory {
|
||||
|
||||
void load();
|
||||
|
||||
void save();
|
||||
|
||||
void fromXml(@Nonnull String xml);
|
||||
|
||||
String toXml();
|
||||
|
||||
void clearSavedHistory();
|
||||
|
||||
void removeSavedHistory(@Nonnull HistoryState historyState);
|
||||
private final AtomicInteger counter = new AtomicInteger(0);
|
||||
|
||||
@Nonnull
|
||||
List<HistoryState> getSavedHistory();
|
||||
private final HistoryHelper<OldHistoryState> history = SimpleHistoryHelper.newInstance();
|
||||
|
||||
@Nonnull
|
||||
HistoryState addSavedState(@Nonnull HistoryState historyState);
|
||||
private final OldHistory savedOldHistory = new OldHistory();
|
||||
|
||||
@Nullable
|
||||
private EditorState lastEditorState;
|
||||
|
||||
public CalculatorHistory() {
|
||||
App.getBus().register(this);
|
||||
App.getInitializer().execute(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
init();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
private void init() {
|
||||
Check.isNotMainThread();
|
||||
migrateOldHistory();
|
||||
}
|
||||
|
||||
private void migrateOldHistory() {
|
||||
final SharedPreferences preferences = App.getPreferences();
|
||||
final String xml = preferences.getString("org.solovyev.android.calculator.CalculatorModel_history", null);
|
||||
if (TextUtils.isEmpty(xml)) {
|
||||
return;
|
||||
}
|
||||
final OldHistory history = OldHistory.fromXml(xml);
|
||||
if (history == null) {
|
||||
// strange, history seems to be broken. Avoid clearing the preference
|
||||
return;
|
||||
}
|
||||
for (OldHistoryState state : history.getItems()) {
|
||||
state.setSaved(true);
|
||||
state.setId(counter.incrementAndGet());
|
||||
savedOldHistory.add(state);
|
||||
}
|
||||
}
|
||||
|
||||
public boolean isEmpty() {
|
||||
Check.isMainThread();
|
||||
return history.isEmpty();
|
||||
}
|
||||
|
||||
public boolean isActionAvailable(@Nonnull HistoryAction action) {
|
||||
Check.isMainThread();
|
||||
return history.isActionAvailable(action);
|
||||
}
|
||||
|
||||
public OldHistoryState doAction(@Nonnull HistoryAction action, @Nullable OldHistoryState state) {
|
||||
Check.isMainThread();
|
||||
return history.doAction(action, state);
|
||||
}
|
||||
|
||||
public void addState(@Nullable OldHistoryState currentState) {
|
||||
Check.isMainThread();
|
||||
history.addState(currentState);
|
||||
Locator.getInstance().getCalculator().fireCalculatorEvent(CalculatorEventType.history_state_added, currentState);
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
List<HistoryState> getStates();
|
||||
public List<OldHistoryState> getStates() {
|
||||
Check.isMainThread();
|
||||
return history.getStates();
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
List<HistoryState> getStates(boolean includeIntermediateStates);
|
||||
public List<OldHistoryState> getStates(boolean includeIntermediateStates) {
|
||||
Check.isMainThread();
|
||||
if (includeIntermediateStates) {
|
||||
return getStates();
|
||||
} else {
|
||||
final List<OldHistoryState> states = getStates();
|
||||
|
||||
final List<OldHistoryState> result = new LinkedList<>();
|
||||
|
||||
OldHistoryState laterState = null;
|
||||
for (OldHistoryState state : org.solovyev.common.collections.Collections.reversed(states)) {
|
||||
if (laterState != null) {
|
||||
final String laterEditorText = laterState.getEditorState().getText();
|
||||
final String editorText = state.getEditorState().getText();
|
||||
if (laterEditorText != null && editorText != null && isIntermediate(laterEditorText, editorText)) {
|
||||
// intermediate result => skip from add
|
||||
} else {
|
||||
result.add(0, state);
|
||||
}
|
||||
} else {
|
||||
result.add(0, state);
|
||||
}
|
||||
|
||||
laterState = state;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
private boolean isIntermediate(@Nonnull String laterEditorText,
|
||||
@Nonnull String editorText) {
|
||||
if (Math.abs(laterEditorText.length() - editorText.length()) <= 1) {
|
||||
if (laterEditorText.length() > editorText.length()) {
|
||||
return laterEditorText.startsWith(editorText);
|
||||
} else {
|
||||
return editorText.startsWith(laterEditorText);
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public void clear() {
|
||||
Check.isMainThread();
|
||||
history.clear();
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public List<OldHistoryState> getSavedOldHistory() {
|
||||
return Collections.unmodifiableList(savedOldHistory.getItems());
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public OldHistoryState addSavedState(@Nonnull OldHistoryState state) {
|
||||
if (state.isSaved()) {
|
||||
return state;
|
||||
} else {
|
||||
final OldHistoryState savedState = state.clone();
|
||||
|
||||
savedState.setId(counter.incrementAndGet());
|
||||
savedState.setSaved(true);
|
||||
|
||||
savedOldHistory.add(savedState);
|
||||
|
||||
return savedState;
|
||||
}
|
||||
}
|
||||
|
||||
public void load() {
|
||||
}
|
||||
|
||||
public void save() {
|
||||
final SharedPreferences settings = App.getPreferences();
|
||||
final SharedPreferences.Editor editor = settings.edit();
|
||||
editor.putString("org.solovyev.android.calculator.CalculatorModel_history", toXml());
|
||||
editor.apply();
|
||||
}
|
||||
|
||||
public String toXml() {
|
||||
return savedOldHistory.toXml();
|
||||
}
|
||||
|
||||
public void clearSavedHistory() {
|
||||
savedOldHistory.clear();
|
||||
save();
|
||||
}
|
||||
|
||||
public void removeSavedHistory(@Nonnull OldHistoryState historyState) {
|
||||
historyState.setSaved(false);
|
||||
this.savedOldHistory.remove(historyState);
|
||||
save();
|
||||
}
|
||||
|
||||
@Subscribe
|
||||
public void onEditorChanged(@Nonnull Editor.ChangedEvent e) {
|
||||
lastEditorState = e.newState;
|
||||
}
|
||||
|
||||
@Subscribe
|
||||
public void onDisplayChanged(@Nonnull Display.ChangedEvent e) {
|
||||
if (lastEditorState == null) {
|
||||
return;
|
||||
}
|
||||
if (lastEditorState.sequence != e.newState.getSequence()) {
|
||||
return;
|
||||
}
|
||||
addState(OldHistoryState.create(lastEditorState, e.newState));
|
||||
lastEditorState = null;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,279 +0,0 @@
|
||||
/*
|
||||
* Copyright 2013 serso aka se.solovyev
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
* Contact details
|
||||
*
|
||||
* Email: se.solovyev@gmail.com
|
||||
* Site: http://se.solovyev.org
|
||||
*/
|
||||
|
||||
package org.solovyev.android.calculator.history;
|
||||
|
||||
import com.squareup.otto.Subscribe;
|
||||
import org.solovyev.android.calculator.*;
|
||||
import org.solovyev.common.history.HistoryAction;
|
||||
import org.solovyev.common.history.HistoryHelper;
|
||||
import org.solovyev.common.history.SimpleHistoryHelper;
|
||||
|
||||
import javax.annotation.Nonnull;
|
||||
import javax.annotation.Nullable;
|
||||
import java.util.Collections;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
|
||||
import static org.solovyev.android.calculator.CalculatorEventType.manual_calculation_requested;
|
||||
|
||||
public class CalculatorHistoryImpl implements CalculatorHistory {
|
||||
|
||||
private final AtomicInteger counter = new AtomicInteger(0);
|
||||
|
||||
@Nonnull
|
||||
private final HistoryHelper<HistoryState> history = SimpleHistoryHelper.newInstance();
|
||||
|
||||
@Nonnull
|
||||
private final History savedHistory = new History();
|
||||
|
||||
@Nonnull
|
||||
private final CalculatorEventHolder lastEventData = new CalculatorEventHolder(CalculatorUtils.createFirstEventDataId());
|
||||
|
||||
@Nullable
|
||||
private EditorState lastEditorState;
|
||||
|
||||
public CalculatorHistoryImpl(@Nonnull Calculator calculator) {
|
||||
calculator.addCalculatorEventListener(this);
|
||||
App.getBus().register(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isEmpty() {
|
||||
synchronized (history) {
|
||||
return this.history.isEmpty();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public HistoryState getLastHistoryState() {
|
||||
synchronized (history) {
|
||||
return this.history.getLastHistoryState();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isUndoAvailable() {
|
||||
synchronized (history) {
|
||||
return history.isUndoAvailable();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public HistoryState undo(@Nullable HistoryState currentState) {
|
||||
synchronized (history) {
|
||||
return history.undo(currentState);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isRedoAvailable() {
|
||||
return history.isRedoAvailable();
|
||||
}
|
||||
|
||||
@Override
|
||||
public HistoryState redo(@Nullable HistoryState currentState) {
|
||||
synchronized (history) {
|
||||
return history.redo(currentState);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isActionAvailable(@Nonnull HistoryAction historyAction) {
|
||||
synchronized (history) {
|
||||
return history.isActionAvailable(historyAction);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public HistoryState doAction(@Nonnull HistoryAction historyAction, @Nullable HistoryState currentState) {
|
||||
synchronized (history) {
|
||||
return history.doAction(historyAction, currentState);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void addState(@Nullable HistoryState currentState) {
|
||||
synchronized (history) {
|
||||
history.addState(currentState);
|
||||
Locator.getInstance().getCalculator().fireCalculatorEvent(CalculatorEventType.history_state_added, currentState);
|
||||
}
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
@Override
|
||||
public List<HistoryState> getStates() {
|
||||
synchronized (history) {
|
||||
return history.getStates();
|
||||
}
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
@Override
|
||||
public List<HistoryState> getStates(boolean includeIntermediateStates) {
|
||||
synchronized (history) {
|
||||
if (includeIntermediateStates) {
|
||||
return getStates();
|
||||
} else {
|
||||
final List<HistoryState> states = getStates();
|
||||
|
||||
final List<HistoryState> result = new LinkedList<HistoryState>();
|
||||
|
||||
HistoryState laterState = null;
|
||||
for (HistoryState state : org.solovyev.common.collections.Collections.reversed(states)) {
|
||||
if (laterState != null) {
|
||||
final String laterEditorText = laterState.getEditorState().getText();
|
||||
final String editorText = state.getEditorState().getText();
|
||||
if (laterEditorText != null && editorText != null && isIntermediate(laterEditorText, editorText)) {
|
||||
// intermediate result => skip from add
|
||||
} else {
|
||||
result.add(0, state);
|
||||
}
|
||||
} else {
|
||||
result.add(0, state);
|
||||
}
|
||||
|
||||
laterState = state;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private boolean isIntermediate(@Nonnull String laterEditorText,
|
||||
@Nonnull String editorText) {
|
||||
if (Math.abs(laterEditorText.length() - editorText.length()) <= 1) {
|
||||
if (laterEditorText.length() > editorText.length()) {
|
||||
return laterEditorText.startsWith(editorText);
|
||||
} else {
|
||||
return editorText.startsWith(laterEditorText);
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clear() {
|
||||
synchronized (history) {
|
||||
this.history.clear();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
@Nonnull
|
||||
public List<HistoryState> getSavedHistory() {
|
||||
return Collections.unmodifiableList(savedHistory.getItems());
|
||||
}
|
||||
|
||||
@Override
|
||||
@Nonnull
|
||||
public HistoryState addSavedState(@Nonnull HistoryState historyState) {
|
||||
if (historyState.isSaved()) {
|
||||
return historyState;
|
||||
} else {
|
||||
final HistoryState savedState = historyState.clone();
|
||||
|
||||
savedState.setId(counter.incrementAndGet());
|
||||
savedState.setSaved(true);
|
||||
|
||||
savedHistory.add(savedState);
|
||||
|
||||
return savedState;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void load() {
|
||||
// todo serso: create saved/loader class
|
||||
}
|
||||
|
||||
@Override
|
||||
public void save() {
|
||||
// todo serso: create saved/loader class
|
||||
}
|
||||
|
||||
@Override
|
||||
public void fromXml(@Nonnull String xml) {
|
||||
clearSavedHistory();
|
||||
|
||||
final History history = History.fromXml(xml);
|
||||
if (history == null) {
|
||||
return;
|
||||
}
|
||||
for (HistoryState historyState : history.getItems()) {
|
||||
historyState.setSaved(true);
|
||||
historyState.setId(counter.incrementAndGet());
|
||||
savedHistory.add(historyState);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toXml() {
|
||||
return savedHistory.toXml();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clearSavedHistory() {
|
||||
savedHistory.clear();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void removeSavedHistory(@Nonnull HistoryState historyState) {
|
||||
this.savedHistory.remove(historyState);
|
||||
}
|
||||
|
||||
@Subscribe
|
||||
public void onEditorChanged(@Nonnull Editor.ChangedEvent e) {
|
||||
lastEditorState = e.newState;
|
||||
}
|
||||
|
||||
@Subscribe
|
||||
public void onDisplayChanged(@Nonnull Display.ChangedEvent e) {
|
||||
if (lastEditorState == null) {
|
||||
return;
|
||||
}
|
||||
if (lastEditorState.sequence != e.newState.getSequence()) {
|
||||
return;
|
||||
}
|
||||
addState(HistoryState.create(lastEditorState, e.newState));
|
||||
lastEditorState = null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onCalculatorEvent(@Nonnull CalculatorEventData calculatorEventData,
|
||||
@Nonnull CalculatorEventType calculatorEventType,
|
||||
@Nullable Object data) {
|
||||
if (calculatorEventType.isOfType(manual_calculation_requested)) {
|
||||
final CalculatorEventHolder.Result result = lastEventData.apply(calculatorEventData);
|
||||
if (result.isNewAfter() && result.isNewSameOrAfterSequence()) {
|
||||
switch (calculatorEventType) {
|
||||
case manual_calculation_requested:
|
||||
lastEditorState = (EditorState) data;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -47,12 +47,12 @@ import static org.solovyev.android.calculator.history.BaseHistoryFragment.isAlre
|
||||
* Date: 12/18/11
|
||||
* Time: 7:39 PM
|
||||
*/
|
||||
public class HistoryArrayAdapter extends ArrayAdapter<HistoryState> {
|
||||
public class HistoryArrayAdapter extends ArrayAdapter<OldHistoryState> {
|
||||
|
||||
private static final int DATETIME_FORMAT = DateUtils.FORMAT_SHOW_TIME | DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_ABBREV_MONTH | DateUtils.FORMAT_ABBREV_TIME;
|
||||
private boolean showDatetime;
|
||||
|
||||
HistoryArrayAdapter(Context context, int resource, int textViewResourceId, @Nonnull List<HistoryState> historyList, boolean showDatetime) {
|
||||
HistoryArrayAdapter(Context context, int resource, int textViewResourceId, @Nonnull List<OldHistoryState> historyList, boolean showDatetime) {
|
||||
super(context, resource, textViewResourceId, historyList);
|
||||
this.showDatetime = showDatetime;
|
||||
}
|
||||
@ -61,7 +61,7 @@ public class HistoryArrayAdapter extends ArrayAdapter<HistoryState> {
|
||||
public View getView(int position, View convertView, ViewGroup parent) {
|
||||
final ViewGroup result = (ViewGroup) super.getView(position, convertView, parent);
|
||||
|
||||
final HistoryState state = getItem(position);
|
||||
final OldHistoryState state = getItem(position);
|
||||
|
||||
final TextView time = (TextView) result.findViewById(R.id.history_time);
|
||||
if (showDatetime) {
|
||||
|
||||
@ -22,19 +22,14 @@
|
||||
|
||||
package org.solovyev.android.calculator.history;
|
||||
|
||||
import android.content.SharedPreferences;
|
||||
import android.preference.PreferenceManager;
|
||||
|
||||
import org.solovyev.android.calculator.CalculatorFragmentType;
|
||||
import org.solovyev.android.calculator.Locator;
|
||||
import org.solovyev.android.calculator.Preferences;
|
||||
import org.solovyev.android.calculator.R;
|
||||
|
||||
import javax.annotation.Nonnull;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import javax.annotation.Nonnull;
|
||||
|
||||
public class HistoryFragment extends BaseHistoryFragment {
|
||||
|
||||
public HistoryFragment() {
|
||||
@ -48,11 +43,8 @@ public class HistoryFragment extends BaseHistoryFragment {
|
||||
|
||||
@Nonnull
|
||||
@Override
|
||||
protected List<HistoryState> getHistoryItems() {
|
||||
final SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(getActivity());
|
||||
final boolean showIntermediateCalculations = Preferences.History.showIntermediateCalculations.getPreference(preferences);
|
||||
final List<HistoryState> historyStates = Locator.getInstance().getHistory().getStates(showIntermediateCalculations);
|
||||
return new ArrayList<HistoryState>(historyStates);
|
||||
protected List<OldHistoryState> getHistoryItems() {
|
||||
return new ArrayList<>(Locator.getInstance().getHistory().getStates(false));
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@ -34,23 +34,23 @@ import javax.annotation.Nonnull;
|
||||
public class HistoryItemMenuData {
|
||||
|
||||
@Nonnull
|
||||
private final ArrayAdapter<HistoryState> adapter;
|
||||
private final ArrayAdapter<OldHistoryState> adapter;
|
||||
|
||||
@Nonnull
|
||||
private final HistoryState historyState;
|
||||
private final OldHistoryState historyState;
|
||||
|
||||
public HistoryItemMenuData(@Nonnull HistoryState historyState, ArrayAdapter<HistoryState> adapter) {
|
||||
public HistoryItemMenuData(@Nonnull OldHistoryState historyState, ArrayAdapter<OldHistoryState> adapter) {
|
||||
this.historyState = historyState;
|
||||
this.adapter = adapter;
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public HistoryState getHistoryState() {
|
||||
public OldHistoryState getHistoryState() {
|
||||
return historyState;
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public ArrayAdapter<HistoryState> getAdapter() {
|
||||
public ArrayAdapter<OldHistoryState> getAdapter() {
|
||||
return adapter;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,32 +0,0 @@
|
||||
/*
|
||||
* Copyright 2013 serso aka se.solovyev
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
* Contact details
|
||||
*
|
||||
* Email: se.solovyev@gmail.com
|
||||
* Site: http://se.solovyev.org
|
||||
*/
|
||||
|
||||
package org.solovyev.android.calculator.history;
|
||||
|
||||
final class HistoryUtils {
|
||||
|
||||
// not intended for instantiation
|
||||
private HistoryUtils() {
|
||||
throw new AssertionError();
|
||||
}
|
||||
|
||||
}
|
||||
@ -35,8 +35,8 @@ import org.solovyev.common.text.Strings;
|
||||
import javax.annotation.Nonnull;
|
||||
import javax.annotation.Nullable;
|
||||
|
||||
@Root
|
||||
public class DisplayHistoryState implements Cloneable {
|
||||
@Root(name = "DisplayHistoryState")
|
||||
public class OldDisplayHistoryState implements Cloneable {
|
||||
|
||||
@Transient
|
||||
private boolean valid = true;
|
||||
@ -47,7 +47,7 @@ public class DisplayHistoryState implements Cloneable {
|
||||
|
||||
@Element
|
||||
@Nonnull
|
||||
private EditorHistoryState editorState;
|
||||
private OldEditorHistoryState editorState;
|
||||
|
||||
@Element
|
||||
@Nonnull
|
||||
@ -57,15 +57,15 @@ public class DisplayHistoryState implements Cloneable {
|
||||
@Nullable
|
||||
private Generic genericResult;
|
||||
|
||||
private DisplayHistoryState() {
|
||||
private OldDisplayHistoryState() {
|
||||
// for xml
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public static DisplayHistoryState newInstance(@Nonnull DisplayState viewState) {
|
||||
final DisplayHistoryState result = new DisplayHistoryState();
|
||||
public static OldDisplayHistoryState newInstance(@Nonnull DisplayState viewState) {
|
||||
final OldDisplayHistoryState result = new OldDisplayHistoryState();
|
||||
|
||||
result.editorState = EditorHistoryState.create(viewState);
|
||||
result.editorState = OldEditorHistoryState.create(viewState);
|
||||
|
||||
result.valid = viewState.isValid();
|
||||
result.jsclOperation = viewState.getOperation();
|
||||
@ -89,7 +89,7 @@ public class DisplayHistoryState implements Cloneable {
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public EditorHistoryState getEditorState() {
|
||||
public OldEditorHistoryState getEditorState() {
|
||||
return editorState;
|
||||
}
|
||||
|
||||
@ -114,7 +114,7 @@ public class DisplayHistoryState implements Cloneable {
|
||||
if (this == o) return true;
|
||||
if (o == null || getClass() != o.getClass()) return false;
|
||||
|
||||
DisplayHistoryState that = (DisplayHistoryState) o;
|
||||
OldDisplayHistoryState that = (OldDisplayHistoryState) o;
|
||||
|
||||
if (!editorState.equals(that.editorState)) return false;
|
||||
if (jsclOperation != that.jsclOperation) return false;
|
||||
@ -140,9 +140,9 @@ public class DisplayHistoryState implements Cloneable {
|
||||
}
|
||||
|
||||
@Override
|
||||
protected DisplayHistoryState clone() {
|
||||
protected OldDisplayHistoryState clone() {
|
||||
try {
|
||||
final DisplayHistoryState clone = (DisplayHistoryState) super.clone();
|
||||
final OldDisplayHistoryState clone = (OldDisplayHistoryState) super.clone();
|
||||
|
||||
clone.editorState = this.editorState.clone();
|
||||
|
||||
@ -32,8 +32,8 @@ import org.solovyev.common.text.Strings;
|
||||
import javax.annotation.Nonnull;
|
||||
import javax.annotation.Nullable;
|
||||
|
||||
@Root
|
||||
public class EditorHistoryState implements Cloneable {
|
||||
@Root(name = "EditorHistoryState")
|
||||
public class OldEditorHistoryState implements Cloneable {
|
||||
|
||||
@Element
|
||||
private int cursorPosition;
|
||||
@ -42,13 +42,13 @@ public class EditorHistoryState implements Cloneable {
|
||||
@Nullable
|
||||
private String text = "";
|
||||
|
||||
private EditorHistoryState() {
|
||||
private OldEditorHistoryState() {
|
||||
// for xml
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public static EditorHistoryState create(@Nonnull EditorState state) {
|
||||
final EditorHistoryState result = new EditorHistoryState();
|
||||
public static OldEditorHistoryState create(@Nonnull EditorState state) {
|
||||
final OldEditorHistoryState result = new OldEditorHistoryState();
|
||||
|
||||
result.text = state.getTextString();
|
||||
result.cursorPosition = state.selection;
|
||||
@ -57,8 +57,8 @@ public class EditorHistoryState implements Cloneable {
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public static EditorHistoryState create(@Nonnull DisplayState viewState) {
|
||||
final EditorHistoryState result = new EditorHistoryState();
|
||||
public static OldEditorHistoryState create(@Nonnull DisplayState viewState) {
|
||||
final OldEditorHistoryState result = new OldEditorHistoryState();
|
||||
|
||||
result.text = viewState.getText();
|
||||
result.cursorPosition = viewState.getSelection();
|
||||
@ -83,9 +83,9 @@ public class EditorHistoryState implements Cloneable {
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
if (this == o) return true;
|
||||
if (!(o instanceof EditorHistoryState)) return false;
|
||||
if (!(o instanceof OldEditorHistoryState)) return false;
|
||||
|
||||
EditorHistoryState that = (EditorHistoryState) o;
|
||||
OldEditorHistoryState that = (OldEditorHistoryState) o;
|
||||
|
||||
if (cursorPosition != that.cursorPosition) return false;
|
||||
if (text != null ? !text.equals(that.text) : that.text != null) return false;
|
||||
@ -109,9 +109,9 @@ public class EditorHistoryState implements Cloneable {
|
||||
}
|
||||
|
||||
@Override
|
||||
protected EditorHistoryState clone() {
|
||||
protected OldEditorHistoryState clone() {
|
||||
try {
|
||||
return (EditorHistoryState) super.clone();
|
||||
return (OldEditorHistoryState) super.clone();
|
||||
} catch (CloneNotSupportedException e) {
|
||||
throw new UnsupportedOperationException(e);
|
||||
}
|
||||
@ -34,24 +34,24 @@ import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
|
||||
@Root
|
||||
public class History {
|
||||
@Root(name = "History")
|
||||
public class OldHistory {
|
||||
|
||||
@Nonnull
|
||||
@ElementList(type = HistoryState.class, name = "historyItems")
|
||||
private List<HistoryState> items = new ArrayList<HistoryState>();
|
||||
@ElementList(type = OldHistoryState.class, name = "historyItems")
|
||||
private List<OldHistoryState> items = new ArrayList<OldHistoryState>();
|
||||
|
||||
public History() {
|
||||
public OldHistory() {
|
||||
}
|
||||
|
||||
@Nullable
|
||||
public static History fromXml(@Nullable String xml) {
|
||||
public static OldHistory fromXml(@Nullable String xml) {
|
||||
if (xml == null) {
|
||||
return null;
|
||||
}
|
||||
final Serializer serializer = new Persister();
|
||||
try {
|
||||
return serializer.read(History.class, xml);
|
||||
return serializer.read(OldHistory.class, xml);
|
||||
} catch (Exception e) {
|
||||
return null;
|
||||
}
|
||||
@ -70,15 +70,15 @@ public class History {
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public List<HistoryState> getItems() {
|
||||
public List<OldHistoryState> getItems() {
|
||||
return items;
|
||||
}
|
||||
|
||||
public void add(@Nonnull HistoryState state) {
|
||||
public void add(@Nonnull OldHistoryState state) {
|
||||
items.add(state);
|
||||
}
|
||||
|
||||
public void addAll(@Nonnull Collection<HistoryState> states) {
|
||||
public void addAll(@Nonnull Collection<OldHistoryState> states) {
|
||||
items.addAll(states);
|
||||
}
|
||||
|
||||
@ -86,7 +86,7 @@ public class History {
|
||||
items.clear();
|
||||
}
|
||||
|
||||
public void remove(@Nonnull HistoryState state) {
|
||||
public void remove(@Nonnull OldHistoryState state) {
|
||||
items.remove(state);
|
||||
}
|
||||
}
|
||||
@ -31,46 +31,46 @@ import org.solovyev.android.calculator.EditorState;
|
||||
|
||||
import javax.annotation.Nonnull;
|
||||
|
||||
@Root
|
||||
public class HistoryState extends BaseHistoryState {
|
||||
@Root(name = "HistoryState")
|
||||
public class OldHistoryState extends BaseHistoryState {
|
||||
|
||||
@Element
|
||||
@Nonnull
|
||||
private EditorHistoryState editorState;
|
||||
private OldEditorHistoryState editorState;
|
||||
|
||||
@Element
|
||||
@Nonnull
|
||||
private DisplayHistoryState displayState;
|
||||
private OldDisplayHistoryState displayState;
|
||||
|
||||
private HistoryState() {
|
||||
private OldHistoryState() {
|
||||
// for xml
|
||||
}
|
||||
|
||||
private HistoryState(@Nonnull EditorHistoryState editorState,
|
||||
@Nonnull DisplayHistoryState displayState) {
|
||||
private OldHistoryState(@Nonnull OldEditorHistoryState editorState,
|
||||
@Nonnull OldDisplayHistoryState displayState) {
|
||||
this.editorState = editorState;
|
||||
this.displayState = displayState;
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public static HistoryState create(@Nonnull Editor editor,
|
||||
public static OldHistoryState create(@Nonnull Editor editor,
|
||||
@Nonnull Display display) {
|
||||
return create(editor.getState(), display.getState());
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public static HistoryState create(@Nonnull EditorState editorState,
|
||||
public static OldHistoryState create(@Nonnull EditorState editorState,
|
||||
@Nonnull DisplayState displayState) {
|
||||
return new HistoryState(EditorHistoryState.create(editorState), DisplayHistoryState.newInstance(displayState));
|
||||
return new OldHistoryState(OldEditorHistoryState.create(editorState), OldDisplayHistoryState.newInstance(displayState));
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public EditorHistoryState getEditorState() {
|
||||
public OldEditorHistoryState getEditorState() {
|
||||
return editorState;
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
public DisplayHistoryState getDisplayState() {
|
||||
public OldDisplayHistoryState getDisplayState() {
|
||||
return displayState;
|
||||
}
|
||||
|
||||
@ -87,7 +87,7 @@ public class HistoryState extends BaseHistoryState {
|
||||
if (this == o) return true;
|
||||
if (o == null || getClass() != o.getClass()) return false;
|
||||
|
||||
HistoryState that = (HistoryState) o;
|
||||
OldHistoryState that = (OldHistoryState) o;
|
||||
|
||||
if (this.isSaved() != that.isSaved()) return false;
|
||||
if (this.getId() != that.getId()) return false;
|
||||
@ -112,8 +112,8 @@ public class HistoryState extends BaseHistoryState {
|
||||
}
|
||||
|
||||
@Override
|
||||
protected HistoryState clone() {
|
||||
final HistoryState that = (HistoryState) super.clone();
|
||||
protected OldHistoryState clone() {
|
||||
final OldHistoryState that = (OldHistoryState) super.clone();
|
||||
|
||||
that.editorState = this.editorState.clone();
|
||||
that.displayState = this.displayState.clone();
|
||||
@ -44,8 +44,8 @@ public class SavedHistoryFragment extends BaseHistoryFragment {
|
||||
|
||||
@Nonnull
|
||||
@Override
|
||||
protected List<HistoryState> getHistoryItems() {
|
||||
return new ArrayList<HistoryState>(Locator.getInstance().getHistory().getSavedHistory());
|
||||
protected List<OldHistoryState> getHistoryItems() {
|
||||
return new ArrayList<OldHistoryState>(Locator.getInstance().getHistory().getSavedOldHistory());
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
BIN
app/src/main/res/drawable-nodpi/divider.9.png
Normal file
BIN
app/src/main/res/drawable-nodpi/divider.9.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 97 B |
@ -294,6 +294,7 @@
|
||||
<style name="CppListView">
|
||||
<item name="android:id">@android:id/list</item>
|
||||
<item name="android:dividerHeight">1px</item>
|
||||
<item name="android:divider">@drawable/divider</item>
|
||||
<item name="android:cacheColorHint">@android:color/transparent</item>
|
||||
<item name="android:layout_height">match_parent</item>
|
||||
<item name="android:layout_width">match_parent</item>
|
||||
|
||||
@ -25,21 +25,19 @@ package org.solovyev.android.calculator.history;
|
||||
import org.junit.Assert;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
import org.solovyev.android.calculator.CalculatorTestUtils;
|
||||
import org.solovyev.android.calculator.DisplayState;
|
||||
import org.solovyev.android.calculator.EditorState;
|
||||
import org.solovyev.android.calculator.CalculatorTestUtils;
|
||||
import org.solovyev.android.calculator.Locator;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import javax.annotation.Nonnull;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* User: Solovyev_S
|
||||
* Date: 10.10.12
|
||||
* Time: 15:07
|
||||
*/
|
||||
public class CalculatorHistoryImplTest {
|
||||
public class CalculatorHistoryTest {
|
||||
|
||||
@BeforeClass
|
||||
public static void setUp() throws Exception {
|
||||
@ -48,7 +46,7 @@ public class CalculatorHistoryImplTest {
|
||||
|
||||
@Test
|
||||
public void testGetStates() throws Exception {
|
||||
CalculatorHistory calculatorHistory = new CalculatorHistoryImpl(Locator.getInstance().getCalculator());
|
||||
CalculatorHistory calculatorHistory = new CalculatorHistory();
|
||||
|
||||
addState(calculatorHistory, "1");
|
||||
addState(calculatorHistory, "12");
|
||||
@ -64,13 +62,13 @@ public class CalculatorHistoryImplTest {
|
||||
addState(calculatorHistory, "2354");
|
||||
addState(calculatorHistory, "23547");
|
||||
|
||||
final List<HistoryState> states = calculatorHistory.getStates(false);
|
||||
final List<OldHistoryState> states = calculatorHistory.getStates(false);
|
||||
Assert.assertEquals(2, states.size());
|
||||
Assert.assertEquals("23547", states.get(1).getEditorState().getText());
|
||||
Assert.assertEquals("123+3", states.get(0).getEditorState().getText());
|
||||
}
|
||||
|
||||
private void addState(@Nonnull CalculatorHistory calculatorHistory, @Nonnull String text) {
|
||||
calculatorHistory.addState(HistoryState.create(EditorState.create(text, 3), DisplayState.empty()));
|
||||
calculatorHistory.addState(OldHistoryState.create(EditorState.create(text, 3), DisplayState.empty()));
|
||||
}
|
||||
}
|
||||
@ -135,13 +135,13 @@ public class HistoryUtilsTest {
|
||||
public void testToXml() throws Exception {
|
||||
final Date date = new Date(100000000);
|
||||
|
||||
HistoryHelper<HistoryState> history = SimpleHistoryHelper.newInstance();
|
||||
HistoryHelper<OldHistoryState> history = SimpleHistoryHelper.newInstance();
|
||||
|
||||
DisplayState calculatorDisplay = DisplayState.createError(JsclOperation.simplify, "Error", EditorState.NO_SEQUENCE);
|
||||
|
||||
EditorState calculatorEditor = EditorState.create("1+1", 3);
|
||||
|
||||
HistoryState state = HistoryState.create(calculatorEditor, calculatorDisplay);
|
||||
OldHistoryState state = OldHistoryState.create(calculatorEditor, calculatorDisplay);
|
||||
state.setTime(date.getTime());
|
||||
history.addState(state);
|
||||
|
||||
@ -156,7 +156,7 @@ public class HistoryUtilsTest {
|
||||
|
||||
calculatorEditor = EditorState.create("5/6", 2);
|
||||
|
||||
state = HistoryState.create(calculatorEditor, calculatorDisplay);
|
||||
state = OldHistoryState.create(calculatorEditor, calculatorDisplay);
|
||||
state.setSaved(true);
|
||||
state.setTime(date.getTime());
|
||||
history.addState(state);
|
||||
@ -165,7 +165,7 @@ public class HistoryUtilsTest {
|
||||
|
||||
calculatorEditor = EditorState.create("", 1);
|
||||
|
||||
state = HistoryState.create(calculatorEditor, calculatorDisplay);
|
||||
state = OldHistoryState.create(calculatorEditor, calculatorDisplay);
|
||||
state.setSaved(true);
|
||||
state.setTime(date.getTime());
|
||||
history.addState(state);
|
||||
@ -174,7 +174,7 @@ public class HistoryUtilsTest {
|
||||
|
||||
calculatorEditor = EditorState.create("4+5/35sin(41)+dfdsfsdfs", 0);
|
||||
|
||||
state = HistoryState.create(calculatorEditor, calculatorDisplay);
|
||||
state = OldHistoryState.create(calculatorEditor, calculatorDisplay);
|
||||
state.setSaved(true);
|
||||
state.setTime(date.getTime());
|
||||
history.addState(state);
|
||||
@ -182,28 +182,28 @@ public class HistoryUtilsTest {
|
||||
String xml = createHistory(history).toXml();
|
||||
assertEquals(toXml2, xml);
|
||||
|
||||
final HistoryHelper<HistoryState> historyFromXml = SimpleHistoryHelper.newInstance();
|
||||
final History actual = History.fromXml(xml);
|
||||
for (HistoryState historyState : actual.getItems()) {
|
||||
final HistoryHelper<OldHistoryState> historyFromXml = SimpleHistoryHelper.newInstance();
|
||||
final OldHistory actual = OldHistory.fromXml(xml);
|
||||
for (OldHistoryState historyState : actual.getItems()) {
|
||||
historyFromXml.addState(historyState);
|
||||
}
|
||||
|
||||
assertEquals(history.getStates().size(), historyFromXml.getStates().size());
|
||||
|
||||
for (HistoryState historyState : history.getStates()) {
|
||||
for (OldHistoryState historyState : history.getStates()) {
|
||||
historyState.setId(0);
|
||||
historyState.setSaved(true);
|
||||
}
|
||||
for (HistoryState historyState : historyFromXml.getStates()) {
|
||||
for (OldHistoryState historyState : historyFromXml.getStates()) {
|
||||
historyState.setId(0);
|
||||
historyState.setSaved(true);
|
||||
}
|
||||
Assert.assertTrue(Objects.areEqual(history.getStates(), historyFromXml.getStates(), new CollectionEqualizer<HistoryState>(null)));
|
||||
Assert.assertTrue(Objects.areEqual(history.getStates(), historyFromXml.getStates(), new CollectionEqualizer<OldHistoryState>(null)));
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
private History createHistory(HistoryHelper<HistoryState> history) {
|
||||
final History result = new History();
|
||||
private OldHistory createHistory(HistoryHelper<OldHistoryState> history) {
|
||||
final OldHistory result = new OldHistory();
|
||||
result.addAll(history.getStates());
|
||||
return result;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user