/*
|
* Copyright (C) 2016 The Android Open Source Project
|
*
|
* 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.
|
*/
|
|
// TODO: Copy & more general paste in formula? Note that this requires
|
// great care: Currently the text version of a displayed formula
|
// is not directly useful for re-evaluating the formula later, since
|
// it contains ellipses representing subexpressions evaluated with
|
// a different degree mode. Rather than supporting copy from the
|
// formula window, we may eventually want to support generation of a
|
// more useful text version in a separate window. It's not clear
|
// this is worth the added (code and user) complexity.
|
|
package com.android.calculator2;
|
|
import android.animation.Animator;
|
import android.animation.Animator.AnimatorListener;
|
import android.animation.AnimatorListenerAdapter;
|
import android.animation.AnimatorSet;
|
import android.animation.ObjectAnimator;
|
import android.animation.PropertyValuesHolder;
|
import android.app.ActionBar;
|
import android.app.Activity;
|
import android.app.Fragment;
|
import android.app.FragmentManager;
|
import android.app.FragmentTransaction;
|
import android.content.ClipData;
|
import android.content.DialogInterface;
|
import android.content.Intent;
|
import android.content.res.Resources;
|
import android.graphics.Color;
|
import android.graphics.Rect;
|
import android.net.Uri;
|
import android.os.Bundle;
|
import androidx.annotation.NonNull;
|
import androidx.annotation.StringRes;
|
import androidx.core.content.ContextCompat;
|
import androidx.viewpager.widget.ViewPager;
|
import android.text.Editable;
|
import android.text.SpannableStringBuilder;
|
import android.text.Spanned;
|
import android.text.TextUtils;
|
import android.text.TextWatcher;
|
import android.text.style.ForegroundColorSpan;
|
import android.util.Log;
|
import android.util.Property;
|
import android.view.ActionMode;
|
import android.view.KeyCharacterMap;
|
import android.view.KeyEvent;
|
import android.view.Menu;
|
import android.view.MenuItem;
|
import android.view.MotionEvent;
|
import android.view.View;
|
import android.view.View.OnLongClickListener;
|
import android.view.ViewAnimationUtils;
|
import android.view.ViewGroupOverlay;
|
import android.view.ViewTreeObserver;
|
import android.view.animation.AccelerateDecelerateInterpolator;
|
import android.widget.HorizontalScrollView;
|
import android.widget.TextView;
|
import android.widget.Toolbar;
|
|
import com.android.calculator2.CalculatorFormula.OnTextSizeChangeListener;
|
|
import java.io.ByteArrayInputStream;
|
import java.io.ByteArrayOutputStream;
|
import java.io.IOException;
|
import java.io.ObjectInput;
|
import java.io.ObjectInputStream;
|
import java.io.ObjectOutput;
|
import java.io.ObjectOutputStream;
|
import java.text.DecimalFormatSymbols;
|
|
import static com.android.calculator2.CalculatorFormula.OnFormulaContextMenuClickListener;
|
|
public class Calculator extends Activity
|
implements OnTextSizeChangeListener, OnLongClickListener,
|
AlertDialogFragment.OnClickListener, Evaluator.EvaluationListener /* for main result */,
|
DragLayout.CloseCallback, DragLayout.DragCallback {
|
|
private static final String TAG = "Calculator";
|
/**
|
* Constant for an invalid resource id.
|
*/
|
public static final int INVALID_RES_ID = -1;
|
|
private enum CalculatorState {
|
INPUT, // Result and formula both visible, no evaluation requested,
|
// Though result may be visible on bottom line.
|
EVALUATE, // Both visible, evaluation requested, evaluation/animation incomplete.
|
// Not used for instant result evaluation.
|
INIT, // Very temporary state used as alternative to EVALUATE
|
// during reinitialization. Do not animate on completion.
|
INIT_FOR_RESULT, // Identical to INIT, but evaluation is known to terminate
|
// with result, and current expression has been copied to history.
|
ANIMATE, // Result computed, animation to enlarge result window in progress.
|
RESULT, // Result displayed, formula invisible.
|
// If we are in RESULT state, the formula was evaluated without
|
// error to initial precision.
|
// The current formula is now also the last history entry.
|
ERROR // Error displayed: Formula visible, result shows error message.
|
// Display similar to INPUT state.
|
}
|
// Normal transition sequence is
|
// INPUT -> EVALUATE -> ANIMATE -> RESULT (or ERROR) -> INPUT
|
// A RESULT -> ERROR transition is possible in rare corner cases, in which
|
// a higher precision evaluation exposes an error. This is possible, since we
|
// initially evaluate assuming we were given a well-defined problem. If we
|
// were actually asked to compute sqrt(<extremely tiny negative number>) we produce 0
|
// unless we are asked for enough precision that we can distinguish the argument from zero.
|
// ERROR and RESULT are translated to INIT or INIT_FOR_RESULT state if the application
|
// is restarted in that state. This leads us to recompute and redisplay the result
|
// ASAP. We avoid saving the ANIMATE state or activating history in that state.
|
// In INIT_FOR_RESULT, and RESULT state, a copy of the current
|
// expression has been saved in the history db; in the other non-ANIMATE states,
|
// it has not.
|
// TODO: Possibly save a bit more information, e.g. its initial display string
|
// or most significant digit position, to speed up restart.
|
|
private final Property<TextView, Integer> TEXT_COLOR =
|
new Property<TextView, Integer>(Integer.class, "textColor") {
|
@Override
|
public Integer get(TextView textView) {
|
return textView.getCurrentTextColor();
|
}
|
|
@Override
|
public void set(TextView textView, Integer textColor) {
|
textView.setTextColor(textColor);
|
}
|
};
|
|
private static final String NAME = "Calculator";
|
private static final String KEY_DISPLAY_STATE = NAME + "_display_state";
|
private static final String KEY_UNPROCESSED_CHARS = NAME + "_unprocessed_chars";
|
/**
|
* Associated value is a byte array holding the evaluator state.
|
*/
|
private static final String KEY_EVAL_STATE = NAME + "_eval_state";
|
private static final String KEY_INVERSE_MODE = NAME + "_inverse_mode";
|
/**
|
* Associated value is an boolean holding the visibility state of the toolbar.
|
*/
|
private static final String KEY_SHOW_TOOLBAR = NAME + "_show_toolbar";
|
|
private final ViewTreeObserver.OnPreDrawListener mPreDrawListener =
|
new ViewTreeObserver.OnPreDrawListener() {
|
@Override
|
public boolean onPreDraw() {
|
mFormulaContainer.scrollTo(mFormulaText.getRight(), 0);
|
final ViewTreeObserver observer = mFormulaContainer.getViewTreeObserver();
|
if (observer.isAlive()) {
|
observer.removeOnPreDrawListener(this);
|
}
|
return false;
|
}
|
};
|
|
private final Evaluator.Callback mEvaluatorCallback = new Evaluator.Callback() {
|
@Override
|
public void onMemoryStateChanged() {
|
mFormulaText.onMemoryStateChanged();
|
}
|
|
@Override
|
public void showMessageDialog(@StringRes int title, @StringRes int message,
|
@StringRes int positiveButtonLabel, String tag) {
|
AlertDialogFragment.showMessageDialog(Calculator.this, title, message,
|
positiveButtonLabel, tag);
|
|
}
|
};
|
|
private final OnDisplayMemoryOperationsListener mOnDisplayMemoryOperationsListener =
|
new OnDisplayMemoryOperationsListener() {
|
@Override
|
public boolean shouldDisplayMemory() {
|
return mEvaluator.getMemoryIndex() != 0;
|
}
|
};
|
|
private final OnFormulaContextMenuClickListener mOnFormulaContextMenuClickListener =
|
new OnFormulaContextMenuClickListener() {
|
@Override
|
public boolean onPaste(ClipData clip) {
|
final ClipData.Item item = clip.getItemCount() == 0 ? null : clip.getItemAt(0);
|
if (item == null) {
|
// nothing to paste, bail early...
|
return false;
|
}
|
|
// Check if the item is a previously copied result, otherwise paste as raw text.
|
final Uri uri = item.getUri();
|
if (uri != null && mEvaluator.isLastSaved(uri)) {
|
clearIfNotInputState();
|
mEvaluator.appendExpr(mEvaluator.getSavedIndex());
|
redisplayAfterFormulaChange();
|
} else {
|
addChars(item.coerceToText(Calculator.this).toString(), false);
|
}
|
return true;
|
}
|
|
@Override
|
public void onMemoryRecall() {
|
clearIfNotInputState();
|
long memoryIndex = mEvaluator.getMemoryIndex();
|
if (memoryIndex != 0) {
|
mEvaluator.appendExpr(mEvaluator.getMemoryIndex());
|
redisplayAfterFormulaChange();
|
}
|
}
|
};
|
|
|
private final TextWatcher mFormulaTextWatcher = new TextWatcher() {
|
@Override
|
public void beforeTextChanged(CharSequence charSequence, int start, int count, int after) {
|
}
|
|
@Override
|
public void onTextChanged(CharSequence charSequence, int start, int count, int after) {
|
}
|
|
@Override
|
public void afterTextChanged(Editable editable) {
|
final ViewTreeObserver observer = mFormulaContainer.getViewTreeObserver();
|
if (observer.isAlive()) {
|
observer.removeOnPreDrawListener(mPreDrawListener);
|
observer.addOnPreDrawListener(mPreDrawListener);
|
}
|
}
|
};
|
|
private CalculatorState mCurrentState;
|
private Evaluator mEvaluator;
|
|
private CalculatorDisplay mDisplayView;
|
private TextView mModeView;
|
private CalculatorFormula mFormulaText;
|
private CalculatorResult mResultText;
|
private HorizontalScrollView mFormulaContainer;
|
private DragLayout mDragLayout;
|
|
private ViewPager mPadViewPager;
|
private View mDeleteButton;
|
private View mClearButton;
|
private View mEqualButton;
|
private View mMainCalculator;
|
|
private TextView mInverseToggle;
|
private TextView mModeToggle;
|
|
private View[] mInvertibleButtons;
|
private View[] mInverseButtons;
|
|
private View mCurrentButton;
|
private Animator mCurrentAnimator;
|
|
// Characters that were recently entered at the end of the display that have not yet
|
// been added to the underlying expression.
|
private String mUnprocessedChars = null;
|
|
// Color to highlight unprocessed characters from physical keyboard.
|
// TODO: should probably match this to the error color?
|
private ForegroundColorSpan mUnprocessedColorSpan = new ForegroundColorSpan(Color.RED);
|
|
// Whether the display is one line.
|
private boolean mIsOneLine;
|
|
/**
|
* Map the old saved state to a new state reflecting requested result reevaluation.
|
*/
|
private CalculatorState mapFromSaved(CalculatorState savedState) {
|
switch (savedState) {
|
case RESULT:
|
case INIT_FOR_RESULT:
|
// Evaluation is expected to terminate normally.
|
return CalculatorState.INIT_FOR_RESULT;
|
case ERROR:
|
case INIT:
|
return CalculatorState.INIT;
|
case EVALUATE:
|
case INPUT:
|
return savedState;
|
default: // Includes ANIMATE state.
|
throw new AssertionError("Impossible saved state");
|
}
|
}
|
|
/**
|
* Restore Evaluator state and mCurrentState from savedInstanceState.
|
* Return true if the toolbar should be visible.
|
*/
|
private void restoreInstanceState(Bundle savedInstanceState) {
|
final CalculatorState savedState = CalculatorState.values()[
|
savedInstanceState.getInt(KEY_DISPLAY_STATE,
|
CalculatorState.INPUT.ordinal())];
|
setState(savedState);
|
CharSequence unprocessed = savedInstanceState.getCharSequence(KEY_UNPROCESSED_CHARS);
|
if (unprocessed != null) {
|
mUnprocessedChars = unprocessed.toString();
|
}
|
byte[] state = savedInstanceState.getByteArray(KEY_EVAL_STATE);
|
if (state != null) {
|
try (ObjectInput in = new ObjectInputStream(new ByteArrayInputStream(state))) {
|
mEvaluator.restoreInstanceState(in);
|
} catch (Throwable ignored) {
|
// When in doubt, revert to clean state
|
mCurrentState = CalculatorState.INPUT;
|
mEvaluator.clearMain();
|
}
|
}
|
if (savedInstanceState.getBoolean(KEY_SHOW_TOOLBAR, true)) {
|
showAndMaybeHideToolbar();
|
} else {
|
mDisplayView.hideToolbar();
|
}
|
onInverseToggled(savedInstanceState.getBoolean(KEY_INVERSE_MODE));
|
// TODO: We're currently not saving and restoring scroll position.
|
// We probably should. Details may require care to deal with:
|
// - new display size
|
// - slow recomputation if we've scrolled far.
|
}
|
|
private void restoreDisplay() {
|
onModeChanged(mEvaluator.getDegreeMode(Evaluator.MAIN_INDEX));
|
if (mCurrentState != CalculatorState.RESULT
|
&& mCurrentState != CalculatorState.INIT_FOR_RESULT) {
|
redisplayFormula();
|
}
|
if (mCurrentState == CalculatorState.INPUT) {
|
// This resultText will explicitly call evaluateAndNotify when ready.
|
mResultText.setShouldEvaluateResult(CalculatorResult.SHOULD_EVALUATE, this);
|
} else {
|
// Just reevaluate.
|
setState(mapFromSaved(mCurrentState));
|
// Request evaluation when we know display width.
|
mResultText.setShouldEvaluateResult(CalculatorResult.SHOULD_REQUIRE, this);
|
}
|
}
|
|
@Override
|
protected void onCreate(Bundle savedInstanceState) {
|
super.onCreate(savedInstanceState);
|
|
setContentView(R.layout.activity_calculator_main);
|
setActionBar((Toolbar) findViewById(R.id.toolbar));
|
|
// Hide all default options in the ActionBar.
|
getActionBar().setDisplayOptions(0);
|
|
// Ensure the toolbar stays visible while the options menu is displayed.
|
getActionBar().addOnMenuVisibilityListener(new ActionBar.OnMenuVisibilityListener() {
|
@Override
|
public void onMenuVisibilityChanged(boolean isVisible) {
|
mDisplayView.setForceToolbarVisible(isVisible);
|
}
|
});
|
|
mMainCalculator = findViewById(R.id.main_calculator);
|
mDisplayView = (CalculatorDisplay) findViewById(R.id.display);
|
mModeView = (TextView) findViewById(R.id.mode);
|
mFormulaText = (CalculatorFormula) findViewById(R.id.formula);
|
mResultText = (CalculatorResult) findViewById(R.id.result);
|
mFormulaContainer = (HorizontalScrollView) findViewById(R.id.formula_container);
|
mEvaluator = Evaluator.getInstance(this);
|
mEvaluator.setCallback(mEvaluatorCallback);
|
mResultText.setEvaluator(mEvaluator, Evaluator.MAIN_INDEX);
|
KeyMaps.setActivity(this);
|
|
mPadViewPager = (ViewPager) findViewById(R.id.pad_pager);
|
mDeleteButton = findViewById(R.id.del);
|
mClearButton = findViewById(R.id.clr);
|
final View numberPad = findViewById(R.id.pad_numeric);
|
mEqualButton = numberPad.findViewById(R.id.eq);
|
if (mEqualButton == null || mEqualButton.getVisibility() != View.VISIBLE) {
|
mEqualButton = findViewById(R.id.pad_operator).findViewById(R.id.eq);
|
}
|
final TextView decimalPointButton = (TextView) numberPad.findViewById(R.id.dec_point);
|
decimalPointButton.setText(getDecimalSeparator());
|
|
mInverseToggle = (TextView) findViewById(R.id.toggle_inv);
|
mModeToggle = (TextView) findViewById(R.id.toggle_mode);
|
|
mIsOneLine = mResultText.getVisibility() == View.INVISIBLE;
|
|
mInvertibleButtons = new View[] {
|
findViewById(R.id.fun_sin),
|
findViewById(R.id.fun_cos),
|
findViewById(R.id.fun_tan),
|
findViewById(R.id.fun_ln),
|
findViewById(R.id.fun_log),
|
findViewById(R.id.op_sqrt)
|
};
|
mInverseButtons = new View[] {
|
findViewById(R.id.fun_arcsin),
|
findViewById(R.id.fun_arccos),
|
findViewById(R.id.fun_arctan),
|
findViewById(R.id.fun_exp),
|
findViewById(R.id.fun_10pow),
|
findViewById(R.id.op_sqr)
|
};
|
|
mDragLayout = (DragLayout) findViewById(R.id.drag_layout);
|
mDragLayout.removeDragCallback(this);
|
mDragLayout.addDragCallback(this);
|
mDragLayout.setCloseCallback(this);
|
|
mFormulaText.setOnContextMenuClickListener(mOnFormulaContextMenuClickListener);
|
mFormulaText.setOnDisplayMemoryOperationsListener(mOnDisplayMemoryOperationsListener);
|
|
mFormulaText.setOnTextSizeChangeListener(this);
|
mFormulaText.addTextChangedListener(mFormulaTextWatcher);
|
mDeleteButton.setOnLongClickListener(this);
|
|
if (savedInstanceState != null) {
|
restoreInstanceState(savedInstanceState);
|
} else {
|
mCurrentState = CalculatorState.INPUT;
|
mEvaluator.clearMain();
|
showAndMaybeHideToolbar();
|
onInverseToggled(false);
|
}
|
restoreDisplay();
|
}
|
|
@Override
|
protected void onResume() {
|
super.onResume();
|
if (mDisplayView.isToolbarVisible()) {
|
showAndMaybeHideToolbar();
|
}
|
// If HistoryFragment is showing, hide the main Calculator elements from accessibility.
|
// This is because Talkback does not use visibility as a cue for RelativeLayout elements,
|
// and RelativeLayout is the base class of DragLayout.
|
// If we did not do this, it would be possible to traverse to main Calculator elements from
|
// HistoryFragment.
|
mMainCalculator.setImportantForAccessibility(
|
mDragLayout.isOpen() ? View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
|
: View.IMPORTANT_FOR_ACCESSIBILITY_AUTO);
|
}
|
|
@Override
|
protected void onSaveInstanceState(@NonNull Bundle outState) {
|
mEvaluator.cancelAll(true);
|
// If there's an animation in progress, cancel it first to ensure our state is up-to-date.
|
if (mCurrentAnimator != null) {
|
mCurrentAnimator.cancel();
|
}
|
|
super.onSaveInstanceState(outState);
|
outState.putInt(KEY_DISPLAY_STATE, mCurrentState.ordinal());
|
outState.putCharSequence(KEY_UNPROCESSED_CHARS, mUnprocessedChars);
|
ByteArrayOutputStream byteArrayStream = new ByteArrayOutputStream();
|
try (ObjectOutput out = new ObjectOutputStream(byteArrayStream)) {
|
mEvaluator.saveInstanceState(out);
|
} catch (IOException e) {
|
// Impossible; No IO involved.
|
throw new AssertionError("Impossible IO exception", e);
|
}
|
outState.putByteArray(KEY_EVAL_STATE, byteArrayStream.toByteArray());
|
outState.putBoolean(KEY_INVERSE_MODE, mInverseToggle.isSelected());
|
outState.putBoolean(KEY_SHOW_TOOLBAR, mDisplayView.isToolbarVisible());
|
// We must wait for asynchronous writes to complete, since outState may contain
|
// references to expressions being written.
|
mEvaluator.waitForWrites();
|
}
|
|
// Set the state, updating delete label and display colors.
|
// This restores display positions on moving to INPUT.
|
// But movement/animation for moving to RESULT has already been done.
|
private void setState(CalculatorState state) {
|
if (mCurrentState != state) {
|
if (state == CalculatorState.INPUT) {
|
// We'll explicitly request evaluation from now on.
|
mResultText.setShouldEvaluateResult(CalculatorResult.SHOULD_NOT_EVALUATE, null);
|
restoreDisplayPositions();
|
}
|
mCurrentState = state;
|
|
if (mCurrentState == CalculatorState.RESULT) {
|
// No longer do this for ERROR; allow mistakes to be corrected.
|
mDeleteButton.setVisibility(View.GONE);
|
mClearButton.setVisibility(View.VISIBLE);
|
} else {
|
mDeleteButton.setVisibility(View.VISIBLE);
|
mClearButton.setVisibility(View.GONE);
|
}
|
|
if (mIsOneLine) {
|
if (mCurrentState == CalculatorState.RESULT
|
|| mCurrentState == CalculatorState.EVALUATE
|
|| mCurrentState == CalculatorState.ANIMATE) {
|
mFormulaText.setVisibility(View.VISIBLE);
|
mResultText.setVisibility(View.VISIBLE);
|
} else if (mCurrentState == CalculatorState.ERROR) {
|
mFormulaText.setVisibility(View.INVISIBLE);
|
mResultText.setVisibility(View.VISIBLE);
|
} else {
|
mFormulaText.setVisibility(View.VISIBLE);
|
mResultText.setVisibility(View.INVISIBLE);
|
}
|
}
|
|
if (mCurrentState == CalculatorState.ERROR) {
|
final int errorColor =
|
ContextCompat.getColor(this, R.color.calculator_error_color);
|
mFormulaText.setTextColor(errorColor);
|
mResultText.setTextColor(errorColor);
|
getWindow().setStatusBarColor(errorColor);
|
} else if (mCurrentState != CalculatorState.RESULT) {
|
mFormulaText.setTextColor(
|
ContextCompat.getColor(this, R.color.display_formula_text_color));
|
mResultText.setTextColor(
|
ContextCompat.getColor(this, R.color.display_result_text_color));
|
getWindow().setStatusBarColor(
|
ContextCompat.getColor(this, R.color.calculator_statusbar_color));
|
}
|
|
invalidateOptionsMenu();
|
}
|
}
|
|
public boolean isResultLayout() {
|
// Note that ERROR has INPUT, not RESULT layout.
|
return mCurrentState == CalculatorState.INIT_FOR_RESULT
|
|| mCurrentState == CalculatorState.RESULT;
|
}
|
|
public boolean isOneLine() {
|
return mIsOneLine;
|
}
|
|
@Override
|
protected void onDestroy() {
|
mDragLayout.removeDragCallback(this);
|
super.onDestroy();
|
}
|
|
/**
|
* Destroy the evaluator and close the underlying database.
|
*/
|
public void destroyEvaluator() {
|
mEvaluator.destroyEvaluator();
|
}
|
|
@Override
|
public void onActionModeStarted(ActionMode mode) {
|
super.onActionModeStarted(mode);
|
if (mode.getTag() == CalculatorFormula.TAG_ACTION_MODE) {
|
mFormulaContainer.scrollTo(mFormulaText.getRight(), 0);
|
}
|
}
|
|
/**
|
* Stop any active ActionMode or ContextMenu for copy/paste actions.
|
* Return true if there was one.
|
*/
|
private boolean stopActionModeOrContextMenu() {
|
return mResultText.stopActionModeOrContextMenu()
|
|| mFormulaText.stopActionModeOrContextMenu();
|
}
|
|
@Override
|
public void onUserInteraction() {
|
super.onUserInteraction();
|
|
// If there's an animation in progress, end it immediately, so the user interaction can
|
// be handled.
|
if (mCurrentAnimator != null) {
|
mCurrentAnimator.end();
|
}
|
}
|
|
@Override
|
public boolean dispatchTouchEvent(MotionEvent e) {
|
if (e.getActionMasked() == MotionEvent.ACTION_DOWN) {
|
stopActionModeOrContextMenu();
|
|
final HistoryFragment historyFragment = getHistoryFragment();
|
if (mDragLayout.isOpen() && historyFragment != null) {
|
historyFragment.stopActionModeOrContextMenu();
|
}
|
}
|
return super.dispatchTouchEvent(e);
|
}
|
|
@Override
|
public void onBackPressed() {
|
if (!stopActionModeOrContextMenu()) {
|
final HistoryFragment historyFragment = getHistoryFragment();
|
if (mDragLayout.isOpen() && historyFragment != null) {
|
if (!historyFragment.stopActionModeOrContextMenu()) {
|
removeHistoryFragment();
|
}
|
return;
|
}
|
if (mPadViewPager != null && mPadViewPager.getCurrentItem() != 0) {
|
// Select the previous pad.
|
mPadViewPager.setCurrentItem(mPadViewPager.getCurrentItem() - 1);
|
} else {
|
// If the user is currently looking at the first pad (or the pad is not paged),
|
// allow the system to handle the Back button.
|
super.onBackPressed();
|
}
|
}
|
}
|
|
@Override
|
public boolean onKeyUp(int keyCode, KeyEvent event) {
|
// Allow the system to handle special key codes (e.g. "BACK" or "DPAD").
|
switch (keyCode) {
|
case KeyEvent.KEYCODE_BACK:
|
case KeyEvent.KEYCODE_ESCAPE:
|
case KeyEvent.KEYCODE_DPAD_UP:
|
case KeyEvent.KEYCODE_DPAD_DOWN:
|
case KeyEvent.KEYCODE_DPAD_LEFT:
|
case KeyEvent.KEYCODE_DPAD_RIGHT:
|
return super.onKeyUp(keyCode, event);
|
}
|
|
// Stop the action mode or context menu if it's showing.
|
stopActionModeOrContextMenu();
|
|
// Always cancel unrequested in-progress evaluation of the main expression, so that
|
// we don't have to worry about subsequent asynchronous completion.
|
// Requested in-progress evaluations are handled below.
|
cancelUnrequested();
|
|
switch (keyCode) {
|
case KeyEvent.KEYCODE_NUMPAD_ENTER:
|
case KeyEvent.KEYCODE_ENTER:
|
case KeyEvent.KEYCODE_DPAD_CENTER:
|
mCurrentButton = mEqualButton;
|
onEquals();
|
return true;
|
case KeyEvent.KEYCODE_DEL:
|
mCurrentButton = mDeleteButton;
|
onDelete();
|
return true;
|
case KeyEvent.KEYCODE_CLEAR:
|
mCurrentButton = mClearButton;
|
onClear();
|
return true;
|
default:
|
cancelIfEvaluating(false);
|
final int raw = event.getKeyCharacterMap().get(keyCode, event.getMetaState());
|
if ((raw & KeyCharacterMap.COMBINING_ACCENT) != 0) {
|
return true; // discard
|
}
|
// Try to discard non-printing characters and the like.
|
// The user will have to explicitly delete other junk that gets past us.
|
if (Character.isIdentifierIgnorable(raw) || Character.isWhitespace(raw)) {
|
return true;
|
}
|
char c = (char) raw;
|
if (c == '=') {
|
mCurrentButton = mEqualButton;
|
onEquals();
|
} else {
|
addChars(String.valueOf(c), true);
|
redisplayAfterFormulaChange();
|
}
|
return true;
|
}
|
}
|
|
/**
|
* Invoked whenever the inverse button is toggled to update the UI.
|
*
|
* @param showInverse {@code true} if inverse functions should be shown
|
*/
|
private void onInverseToggled(boolean showInverse) {
|
mInverseToggle.setSelected(showInverse);
|
if (showInverse) {
|
mInverseToggle.setContentDescription(getString(R.string.desc_inv_on));
|
for (View invertibleButton : mInvertibleButtons) {
|
invertibleButton.setVisibility(View.GONE);
|
}
|
for (View inverseButton : mInverseButtons) {
|
inverseButton.setVisibility(View.VISIBLE);
|
}
|
} else {
|
mInverseToggle.setContentDescription(getString(R.string.desc_inv_off));
|
for (View invertibleButton : mInvertibleButtons) {
|
invertibleButton.setVisibility(View.VISIBLE);
|
}
|
for (View inverseButton : mInverseButtons) {
|
inverseButton.setVisibility(View.GONE);
|
}
|
}
|
}
|
|
/**
|
* Invoked whenever the deg/rad mode may have changed to update the UI. Note that the mode has
|
* not necessarily actually changed where this is invoked.
|
*
|
* @param degreeMode {@code true} if in degree mode
|
*/
|
private void onModeChanged(boolean degreeMode) {
|
if (degreeMode) {
|
mModeView.setText(R.string.mode_deg);
|
mModeView.setContentDescription(getString(R.string.desc_mode_deg));
|
|
mModeToggle.setText(R.string.mode_rad);
|
mModeToggle.setContentDescription(getString(R.string.desc_switch_rad));
|
} else {
|
mModeView.setText(R.string.mode_rad);
|
mModeView.setContentDescription(getString(R.string.desc_mode_rad));
|
|
mModeToggle.setText(R.string.mode_deg);
|
mModeToggle.setContentDescription(getString(R.string.desc_switch_deg));
|
}
|
}
|
|
private void removeHistoryFragment() {
|
final FragmentManager manager = getFragmentManager();
|
if (manager != null && !manager.isDestroyed()) {
|
manager.popBackStack(HistoryFragment.TAG, FragmentManager.POP_BACK_STACK_INCLUSIVE);
|
}
|
|
// When HistoryFragment is hidden, the main Calculator is important for accessibility again.
|
mMainCalculator.setImportantForAccessibility(View.IMPORTANT_FOR_ACCESSIBILITY_AUTO);
|
}
|
|
/**
|
* Switch to INPUT from RESULT state in response to input of the specified button_id.
|
* View.NO_ID is treated as an incomplete function id.
|
*/
|
private void switchToInput(int button_id) {
|
if (KeyMaps.isBinary(button_id) || KeyMaps.isSuffix(button_id)) {
|
mEvaluator.collapse(mEvaluator.getMaxIndex() /* Most recent history entry */);
|
} else {
|
announceClearedForAccessibility();
|
mEvaluator.clearMain();
|
}
|
setState(CalculatorState.INPUT);
|
}
|
|
// Add the given button id to input expression.
|
// If appropriate, clear the expression before doing so.
|
private void addKeyToExpr(int id) {
|
if (mCurrentState == CalculatorState.ERROR) {
|
setState(CalculatorState.INPUT);
|
} else if (mCurrentState == CalculatorState.RESULT) {
|
switchToInput(id);
|
}
|
if (!mEvaluator.append(id)) {
|
// TODO: Some user visible feedback?
|
}
|
}
|
|
/**
|
* Add the given button id to input expression, assuming it was explicitly
|
* typed/touched.
|
* We perform slightly more aggressive correction than in pasted expressions.
|
*/
|
private void addExplicitKeyToExpr(int id) {
|
if (mCurrentState == CalculatorState.INPUT && id == R.id.op_sub) {
|
mEvaluator.getExpr(Evaluator.MAIN_INDEX).removeTrailingAdditiveOperators();
|
}
|
addKeyToExpr(id);
|
}
|
|
public void evaluateInstantIfNecessary() {
|
if (mCurrentState == CalculatorState.INPUT
|
&& mEvaluator.getExpr(Evaluator.MAIN_INDEX).hasInterestingOps()) {
|
mEvaluator.evaluateAndNotify(Evaluator.MAIN_INDEX, this, mResultText);
|
}
|
}
|
|
private void redisplayAfterFormulaChange() {
|
// TODO: Could do this more incrementally.
|
redisplayFormula();
|
setState(CalculatorState.INPUT);
|
mResultText.clear();
|
if (haveUnprocessed()) {
|
// Force reevaluation when text is deleted, even if expression is unchanged.
|
mEvaluator.touch();
|
} else {
|
evaluateInstantIfNecessary();
|
}
|
}
|
|
/**
|
* Show the toolbar.
|
* Automatically hide it again if it's not relevant to current formula.
|
*/
|
private void showAndMaybeHideToolbar() {
|
final boolean shouldBeVisible =
|
mCurrentState == CalculatorState.INPUT && mEvaluator.hasTrigFuncs();
|
mDisplayView.showToolbar(!shouldBeVisible);
|
}
|
|
/**
|
* Display or hide the toolbar depending on calculator state.
|
*/
|
private void showOrHideToolbar() {
|
final boolean shouldBeVisible =
|
mCurrentState == CalculatorState.INPUT && mEvaluator.hasTrigFuncs();
|
if (shouldBeVisible) {
|
mDisplayView.showToolbar(false);
|
} else {
|
mDisplayView.hideToolbar();
|
}
|
}
|
|
public void onButtonClick(View view) {
|
// Any animation is ended before we get here.
|
mCurrentButton = view;
|
stopActionModeOrContextMenu();
|
|
// See onKey above for the rationale behind some of the behavior below:
|
cancelUnrequested();
|
|
final int id = view.getId();
|
switch (id) {
|
case R.id.eq:
|
onEquals();
|
break;
|
case R.id.del:
|
onDelete();
|
break;
|
case R.id.clr:
|
onClear();
|
return; // Toolbar visibility adjusted at end of animation.
|
case R.id.toggle_inv:
|
final boolean selected = !mInverseToggle.isSelected();
|
mInverseToggle.setSelected(selected);
|
onInverseToggled(selected);
|
if (mCurrentState == CalculatorState.RESULT) {
|
mResultText.redisplay(); // In case we cancelled reevaluation.
|
}
|
break;
|
case R.id.toggle_mode:
|
cancelIfEvaluating(false);
|
final boolean mode = !mEvaluator.getDegreeMode(Evaluator.MAIN_INDEX);
|
if (mCurrentState == CalculatorState.RESULT
|
&& mEvaluator.getExpr(Evaluator.MAIN_INDEX).hasTrigFuncs()) {
|
// Capture current result evaluated in old mode.
|
mEvaluator.collapse(mEvaluator.getMaxIndex());
|
redisplayFormula();
|
}
|
// In input mode, we reinterpret already entered trig functions.
|
mEvaluator.setDegreeMode(mode);
|
onModeChanged(mode);
|
// Show the toolbar to highlight the mode change.
|
showAndMaybeHideToolbar();
|
setState(CalculatorState.INPUT);
|
mResultText.clear();
|
if (!haveUnprocessed()) {
|
evaluateInstantIfNecessary();
|
}
|
return;
|
case R.id.op_add:
|
//when sd card exist "custom_cases.xml", open test mode, check if Calculator's display TEST_MODE_KEY, then startup DragonFire application.
|
String str = mFormulaText.getText().toString();
|
if (TestModeManager.start(view.getContext(), str)) {
|
onClear();
|
break;
|
}
|
default:
|
cancelIfEvaluating(false);
|
if (haveUnprocessed()) {
|
// For consistency, append as uninterpreted characters.
|
// This may actually be useful for a left parenthesis.
|
addChars(KeyMaps.toString(this, id), true);
|
} else {
|
addExplicitKeyToExpr(id);
|
redisplayAfterFormulaChange();
|
}
|
break;
|
}
|
showOrHideToolbar();
|
}
|
|
void redisplayFormula() {
|
SpannableStringBuilder formula
|
= mEvaluator.getExpr(Evaluator.MAIN_INDEX).toSpannableStringBuilder(this);
|
if (mUnprocessedChars != null) {
|
// Add and highlight characters we couldn't process.
|
formula.append(mUnprocessedChars, mUnprocessedColorSpan,
|
Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
}
|
mFormulaText.changeTextTo(formula);
|
mFormulaText.setContentDescription(TextUtils.isEmpty(formula)
|
? getString(R.string.desc_formula) : null);
|
}
|
|
@Override
|
public boolean onLongClick(View view) {
|
mCurrentButton = view;
|
|
if (view.getId() == R.id.del) {
|
onClear();
|
return true;
|
}
|
return false;
|
}
|
|
// Initial evaluation completed successfully. Initiate display.
|
public void onEvaluate(long index, int initDisplayPrec, int msd, int leastDigPos,
|
String truncatedWholeNumber) {
|
if (index != Evaluator.MAIN_INDEX) {
|
throw new AssertionError("Unexpected evaluation result index\n");
|
}
|
|
// Invalidate any options that may depend on the current result.
|
invalidateOptionsMenu();
|
|
mResultText.onEvaluate(index, initDisplayPrec, msd, leastDigPos, truncatedWholeNumber);
|
if (mCurrentState != CalculatorState.INPUT) {
|
// In EVALUATE, INIT, RESULT, or INIT_FOR_RESULT state.
|
onResult(mCurrentState == CalculatorState.EVALUATE /* animate */,
|
mCurrentState == CalculatorState.INIT_FOR_RESULT
|
|| mCurrentState == CalculatorState.RESULT /* previously preserved */);
|
}
|
}
|
|
// Reset state to reflect evaluator cancellation. Invoked by evaluator.
|
public void onCancelled(long index) {
|
// Index is Evaluator.MAIN_INDEX. We should be in EVALUATE state.
|
setState(CalculatorState.INPUT);
|
mResultText.onCancelled(index);
|
}
|
|
// Reevaluation completed; ask result to redisplay current value.
|
public void onReevaluate(long index) {
|
// Index is Evaluator.MAIN_INDEX.
|
mResultText.onReevaluate(index);
|
}
|
|
@Override
|
public void onTextSizeChanged(final TextView textView, float oldSize) {
|
if (mCurrentState != CalculatorState.INPUT) {
|
// Only animate text changes that occur from user input.
|
return;
|
}
|
|
// Calculate the values needed to perform the scale and translation animations,
|
// maintaining the same apparent baseline for the displayed text.
|
final float textScale = oldSize / textView.getTextSize();
|
final float translationX = (1.0f - textScale) *
|
(textView.getWidth() / 2.0f - textView.getPaddingEnd());
|
final float translationY = (1.0f - textScale) *
|
(textView.getHeight() / 2.0f - textView.getPaddingBottom());
|
|
final AnimatorSet animatorSet = new AnimatorSet();
|
animatorSet.playTogether(
|
ObjectAnimator.ofFloat(textView, View.SCALE_X, textScale, 1.0f),
|
ObjectAnimator.ofFloat(textView, View.SCALE_Y, textScale, 1.0f),
|
ObjectAnimator.ofFloat(textView, View.TRANSLATION_X, translationX, 0.0f),
|
ObjectAnimator.ofFloat(textView, View.TRANSLATION_Y, translationY, 0.0f));
|
animatorSet.setDuration(getResources().getInteger(android.R.integer.config_mediumAnimTime));
|
animatorSet.setInterpolator(new AccelerateDecelerateInterpolator());
|
animatorSet.start();
|
}
|
|
/**
|
* Cancel any in-progress explicitly requested evaluations.
|
* @param quiet suppress pop-up message. Explicit evaluation can change the expression
|
value, and certainly changes the display, so it seems reasonable to warn.
|
* @return true if there was such an evaluation
|
*/
|
private boolean cancelIfEvaluating(boolean quiet) {
|
if (mCurrentState == CalculatorState.EVALUATE) {
|
mEvaluator.cancel(Evaluator.MAIN_INDEX, quiet);
|
return true;
|
} else {
|
return false;
|
}
|
}
|
|
|
private void cancelUnrequested() {
|
if (mCurrentState == CalculatorState.INPUT) {
|
mEvaluator.cancel(Evaluator.MAIN_INDEX, true);
|
}
|
}
|
|
private boolean haveUnprocessed() {
|
return mUnprocessedChars != null && !mUnprocessedChars.isEmpty();
|
}
|
|
private void onEquals() {
|
// Ignore if in non-INPUT state, or if there are no operators.
|
if (mCurrentState == CalculatorState.INPUT) {
|
if (haveUnprocessed()) {
|
setState(CalculatorState.EVALUATE);
|
onError(Evaluator.MAIN_INDEX, R.string.error_syntax);
|
} else if (mEvaluator.getExpr(Evaluator.MAIN_INDEX).hasInterestingOps()) {
|
setState(CalculatorState.EVALUATE);
|
mEvaluator.requireResult(Evaluator.MAIN_INDEX, this, mResultText);
|
}
|
}
|
}
|
|
private void onDelete() {
|
// Delete works like backspace; remove the last character or operator from the expression.
|
// Note that we handle keyboard delete exactly like the delete button. For
|
// example the delete button can be used to delete a character from an incomplete
|
// function name typed on a physical keyboard.
|
// This should be impossible in RESULT state.
|
// If there is an in-progress explicit evaluation, just cancel it and return.
|
if (cancelIfEvaluating(false)) return;
|
setState(CalculatorState.INPUT);
|
if (haveUnprocessed()) {
|
mUnprocessedChars = mUnprocessedChars.substring(0, mUnprocessedChars.length() - 1);
|
} else {
|
mEvaluator.delete();
|
}
|
if (mEvaluator.getExpr(Evaluator.MAIN_INDEX).isEmpty() && !haveUnprocessed()) {
|
// Resulting formula won't be announced, since it's empty.
|
announceClearedForAccessibility();
|
}
|
redisplayAfterFormulaChange();
|
}
|
|
private void reveal(View sourceView, int colorRes, AnimatorListener listener) {
|
final ViewGroupOverlay groupOverlay =
|
(ViewGroupOverlay) getWindow().getDecorView().getOverlay();
|
|
final Rect displayRect = new Rect();
|
mDisplayView.getGlobalVisibleRect(displayRect);
|
|
// Make reveal cover the display and status bar.
|
final View revealView = new View(this);
|
revealView.setBottom(displayRect.bottom);
|
revealView.setLeft(displayRect.left);
|
revealView.setRight(displayRect.right);
|
revealView.setBackgroundColor(ContextCompat.getColor(this, colorRes));
|
groupOverlay.add(revealView);
|
|
final int[] clearLocation = new int[2];
|
sourceView.getLocationInWindow(clearLocation);
|
clearLocation[0] += sourceView.getWidth() / 2;
|
clearLocation[1] += sourceView.getHeight() / 2;
|
|
final int revealCenterX = clearLocation[0] - revealView.getLeft();
|
final int revealCenterY = clearLocation[1] - revealView.getTop();
|
|
final double x1_2 = Math.pow(revealView.getLeft() - revealCenterX, 2);
|
final double x2_2 = Math.pow(revealView.getRight() - revealCenterX, 2);
|
final double y_2 = Math.pow(revealView.getTop() - revealCenterY, 2);
|
final float revealRadius = (float) Math.max(Math.sqrt(x1_2 + y_2), Math.sqrt(x2_2 + y_2));
|
|
final Animator revealAnimator =
|
ViewAnimationUtils.createCircularReveal(revealView,
|
revealCenterX, revealCenterY, 0.0f, revealRadius);
|
revealAnimator.setDuration(
|
getResources().getInteger(android.R.integer.config_longAnimTime));
|
revealAnimator.addListener(listener);
|
|
final Animator alphaAnimator = ObjectAnimator.ofFloat(revealView, View.ALPHA, 0.0f);
|
alphaAnimator.setDuration(
|
getResources().getInteger(android.R.integer.config_mediumAnimTime));
|
|
final AnimatorSet animatorSet = new AnimatorSet();
|
animatorSet.play(revealAnimator).before(alphaAnimator);
|
animatorSet.setInterpolator(new AccelerateDecelerateInterpolator());
|
animatorSet.addListener(new AnimatorListenerAdapter() {
|
@Override
|
public void onAnimationEnd(Animator animator) {
|
groupOverlay.remove(revealView);
|
mCurrentAnimator = null;
|
}
|
});
|
|
mCurrentAnimator = animatorSet;
|
animatorSet.start();
|
}
|
|
private void announceClearedForAccessibility() {
|
mResultText.announceForAccessibility(getResources().getString(R.string.cleared));
|
}
|
|
public void onClearAnimationEnd() {
|
mUnprocessedChars = null;
|
mResultText.clear();
|
mEvaluator.clearMain();
|
setState(CalculatorState.INPUT);
|
redisplayFormula();
|
}
|
|
private void onClear() {
|
if (mEvaluator.getExpr(Evaluator.MAIN_INDEX).isEmpty() && !haveUnprocessed()) {
|
return;
|
}
|
cancelIfEvaluating(true);
|
announceClearedForAccessibility();
|
reveal(mCurrentButton, R.color.calculator_primary_color, new AnimatorListenerAdapter() {
|
@Override
|
public void onAnimationEnd(Animator animation) {
|
onClearAnimationEnd();
|
showOrHideToolbar();
|
}
|
});
|
}
|
|
// Evaluation encountered en error. Display the error.
|
@Override
|
public void onError(final long index, final int errorResourceId) {
|
if (index != Evaluator.MAIN_INDEX) {
|
throw new AssertionError("Unexpected error source");
|
}
|
if (mCurrentState == CalculatorState.EVALUATE) {
|
setState(CalculatorState.ANIMATE);
|
mResultText.announceForAccessibility(getResources().getString(errorResourceId));
|
reveal(mCurrentButton, R.color.calculator_error_color,
|
new AnimatorListenerAdapter() {
|
@Override
|
public void onAnimationEnd(Animator animation) {
|
setState(CalculatorState.ERROR);
|
mResultText.onError(index, errorResourceId);
|
}
|
});
|
} else if (mCurrentState == CalculatorState.INIT
|
|| mCurrentState == CalculatorState.INIT_FOR_RESULT /* very unlikely */) {
|
setState(CalculatorState.ERROR);
|
mResultText.onError(index, errorResourceId);
|
} else {
|
mResultText.clear();
|
}
|
}
|
|
// Animate movement of result into the top formula slot.
|
// Result window now remains translated in the top slot while the result is displayed.
|
// (We convert it back to formula use only when the user provides new input.)
|
// Historical note: In the Lollipop version, this invisibly and instantaneously moved
|
// formula and result displays back at the end of the animation. We no longer do that,
|
// so that we can continue to properly support scrolling of the result.
|
// We assume the result already contains the text to be expanded.
|
private void onResult(boolean animate, boolean resultWasPreserved) {
|
// Calculate the textSize that would be used to display the result in the formula.
|
// For scrollable results just use the minimum textSize to maximize the number of digits
|
// that are visible on screen.
|
float textSize = mFormulaText.getMinimumTextSize();
|
if (!mResultText.isScrollable()) {
|
textSize = mFormulaText.getVariableTextSize(mResultText.getText().toString());
|
}
|
|
// Scale the result to match the calculated textSize, minimizing the jump-cut transition
|
// when a result is reused in a subsequent expression.
|
final float resultScale = textSize / mResultText.getTextSize();
|
|
// Set the result's pivot to match its gravity.
|
mResultText.setPivotX(mResultText.getWidth() - mResultText.getPaddingRight());
|
mResultText.setPivotY(mResultText.getHeight() - mResultText.getPaddingBottom());
|
|
// Calculate the necessary translations so the result takes the place of the formula and
|
// the formula moves off the top of the screen.
|
final float resultTranslationY = (mFormulaContainer.getBottom() - mResultText.getBottom())
|
- (mFormulaText.getPaddingBottom() - mResultText.getPaddingBottom());
|
float formulaTranslationY = -mFormulaContainer.getBottom();
|
if (mIsOneLine) {
|
// Position the result text.
|
mResultText.setY(mResultText.getBottom());
|
formulaTranslationY = -(findViewById(R.id.toolbar).getBottom()
|
+ mFormulaContainer.getBottom());
|
}
|
|
// Change the result's textColor to match the formula.
|
final int formulaTextColor = mFormulaText.getCurrentTextColor();
|
|
if (resultWasPreserved) {
|
// Result was previously addded to history.
|
mEvaluator.represerve();
|
} else {
|
// Add current result to history.
|
mEvaluator.preserve(Evaluator.MAIN_INDEX, true);
|
}
|
|
if (animate) {
|
mResultText.announceForAccessibility(getResources().getString(R.string.desc_eq));
|
mResultText.announceForAccessibility(mResultText.getText());
|
setState(CalculatorState.ANIMATE);
|
final AnimatorSet animatorSet = new AnimatorSet();
|
animatorSet.playTogether(
|
ObjectAnimator.ofPropertyValuesHolder(mResultText,
|
PropertyValuesHolder.ofFloat(View.SCALE_X, resultScale),
|
PropertyValuesHolder.ofFloat(View.SCALE_Y, resultScale),
|
PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, resultTranslationY)),
|
ObjectAnimator.ofArgb(mResultText, TEXT_COLOR, formulaTextColor),
|
ObjectAnimator.ofFloat(mFormulaContainer, View.TRANSLATION_Y,
|
formulaTranslationY));
|
animatorSet.setDuration(getResources().getInteger(
|
android.R.integer.config_longAnimTime));
|
animatorSet.addListener(new AnimatorListenerAdapter() {
|
@Override
|
public void onAnimationEnd(Animator animation) {
|
setState(CalculatorState.RESULT);
|
mCurrentAnimator = null;
|
}
|
});
|
|
mCurrentAnimator = animatorSet;
|
animatorSet.start();
|
} else /* No animation desired; get there fast when restarting */ {
|
mResultText.setScaleX(resultScale);
|
mResultText.setScaleY(resultScale);
|
mResultText.setTranslationY(resultTranslationY);
|
mResultText.setTextColor(formulaTextColor);
|
mFormulaContainer.setTranslationY(formulaTranslationY);
|
setState(CalculatorState.RESULT);
|
}
|
}
|
|
// Restore positions of the formula and result displays back to their original,
|
// pre-animation state.
|
private void restoreDisplayPositions() {
|
// Clear result.
|
mResultText.setText("");
|
// Reset all of the values modified during the animation.
|
mResultText.setScaleX(1.0f);
|
mResultText.setScaleY(1.0f);
|
mResultText.setTranslationX(0.0f);
|
mResultText.setTranslationY(0.0f);
|
mFormulaContainer.setTranslationY(0.0f);
|
|
mFormulaText.requestFocus();
|
}
|
|
@Override
|
public void onClick(AlertDialogFragment fragment, int which) {
|
if (which == DialogInterface.BUTTON_POSITIVE) {
|
if (HistoryFragment.CLEAR_DIALOG_TAG.equals(fragment.getTag())) {
|
// TODO: Try to preserve the current, saved, and memory expressions. How should we
|
// handle expressions to which they refer?
|
mEvaluator.clearEverything();
|
// TODO: It's not clear what we should really do here. This is an initial hack.
|
// May want to make onClearAnimationEnd() private if/when we fix this.
|
onClearAnimationEnd();
|
mEvaluatorCallback.onMemoryStateChanged();
|
onBackPressed();
|
} else if (Evaluator.TIMEOUT_DIALOG_TAG.equals(fragment.getTag())) {
|
// Timeout extension request.
|
mEvaluator.setLongTimeout();
|
} else {
|
Log.e(TAG, "Unknown AlertDialogFragment click:" + fragment.getTag());
|
}
|
}
|
}
|
|
@Override
|
public boolean onCreateOptionsMenu(Menu menu) {
|
super.onCreateOptionsMenu(menu);
|
|
getMenuInflater().inflate(R.menu.activity_calculator, menu);
|
return true;
|
}
|
|
@Override
|
public boolean onPrepareOptionsMenu(Menu menu) {
|
super.onPrepareOptionsMenu(menu);
|
|
// Show the leading option when displaying a result.
|
menu.findItem(R.id.menu_leading).setVisible(mCurrentState == CalculatorState.RESULT);
|
|
// Show the fraction option when displaying a rational result.
|
boolean visible = mCurrentState == CalculatorState.RESULT;
|
final UnifiedReal mainResult = mEvaluator.getResult(Evaluator.MAIN_INDEX);
|
// mainResult should never be null, but it happens. Check as a workaround to protect
|
// against crashes until we find the root cause (b/34763650).
|
visible &= mainResult != null && mainResult.exactlyDisplayable();
|
menu.findItem(R.id.menu_fraction).setVisible(visible);
|
|
return true;
|
}
|
|
@Override
|
public boolean onOptionsItemSelected(MenuItem item) {
|
switch (item.getItemId()) {
|
case R.id.menu_history:
|
showHistoryFragment();
|
return true;
|
case R.id.menu_leading:
|
displayFull();
|
return true;
|
case R.id.menu_fraction:
|
displayFraction();
|
return true;
|
case R.id.menu_licenses:
|
startActivity(new Intent(this, Licenses.class));
|
return true;
|
default:
|
return super.onOptionsItemSelected(item);
|
}
|
}
|
|
/* Begin override CloseCallback method. */
|
|
@Override
|
public void onClose() {
|
removeHistoryFragment();
|
}
|
|
/* End override CloseCallback method. */
|
|
/* Begin override DragCallback methods */
|
|
public void onStartDraggingOpen() {
|
mDisplayView.hideToolbar();
|
showHistoryFragment();
|
}
|
|
@Override
|
public void onInstanceStateRestored(boolean isOpen) {
|
}
|
|
@Override
|
public void whileDragging(float yFraction) {
|
}
|
|
@Override
|
public boolean shouldCaptureView(View view, int x, int y) {
|
return view.getId() == R.id.history_frame
|
&& (mDragLayout.isMoving() || mDragLayout.isViewUnder(view, x, y));
|
}
|
|
@Override
|
public int getDisplayHeight() {
|
return mDisplayView.getMeasuredHeight();
|
}
|
|
/* End override DragCallback methods */
|
|
/**
|
* Change evaluation state to one that's friendly to the history fragment.
|
* Return false if that was not easily possible.
|
*/
|
private boolean prepareForHistory() {
|
if (mCurrentState == CalculatorState.ANIMATE) {
|
// End the current animation and signal that preparation has failed.
|
// onUserInteraction is unreliable and onAnimationEnd() is asynchronous, so we
|
// aren't guaranteed to be out of the ANIMATE state by the time prepareForHistory is
|
// called.
|
if (mCurrentAnimator != null) {
|
mCurrentAnimator.end();
|
}
|
return false;
|
} else if (mCurrentState == CalculatorState.EVALUATE) {
|
// Cancel current evaluation
|
cancelIfEvaluating(true /* quiet */ );
|
setState(CalculatorState.INPUT);
|
return true;
|
} else if (mCurrentState == CalculatorState.INIT) {
|
// Easiest to just refuse. Otherwise we can see a state change
|
// while in history mode, which causes all sorts of problems.
|
// TODO: Consider other alternatives. If we're just doing the decimal conversion
|
// at the end of an evaluation, we could treat this as RESULT state.
|
return false;
|
}
|
// We should be in INPUT, INIT_FOR_RESULT, RESULT, or ERROR state.
|
return true;
|
}
|
|
private HistoryFragment getHistoryFragment() {
|
final FragmentManager manager = getFragmentManager();
|
if (manager == null || manager.isDestroyed()) {
|
return null;
|
}
|
final Fragment fragment = manager.findFragmentByTag(HistoryFragment.TAG);
|
return fragment == null || fragment.isRemoving() ? null : (HistoryFragment) fragment;
|
}
|
|
private void showHistoryFragment() {
|
if (getHistoryFragment() != null) {
|
// If the fragment already exists, do nothing.
|
return;
|
}
|
|
final FragmentManager manager = getFragmentManager();
|
if (manager == null || manager.isDestroyed() || !prepareForHistory()) {
|
// If the history fragment can not be shown, close the draglayout.
|
mDragLayout.setClosed();
|
return;
|
}
|
|
stopActionModeOrContextMenu();
|
manager.beginTransaction()
|
.replace(R.id.history_frame, new HistoryFragment(), HistoryFragment.TAG)
|
.setTransition(FragmentTransaction.TRANSIT_NONE)
|
.addToBackStack(HistoryFragment.TAG)
|
.commit();
|
|
// When HistoryFragment is visible, hide all descendants of the main Calculator view.
|
mMainCalculator.setImportantForAccessibility(
|
View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS);
|
// TODO: pass current scroll position of result
|
}
|
|
private void displayMessage(String title, String message) {
|
AlertDialogFragment.showMessageDialog(this, title, message, null, null /* tag */);
|
}
|
|
private void displayFraction() {
|
UnifiedReal result = mEvaluator.getResult(Evaluator.MAIN_INDEX);
|
displayMessage(getString(R.string.menu_fraction),
|
KeyMaps.translateResult(result.toNiceString()));
|
}
|
|
// Display full result to currently evaluated precision
|
private void displayFull() {
|
Resources res = getResources();
|
String msg = mResultText.getFullText(true /* withSeparators */) + " ";
|
if (mResultText.fullTextIsExact()) {
|
msg += res.getString(R.string.exact);
|
} else {
|
msg += res.getString(R.string.approximate);
|
}
|
displayMessage(getString(R.string.menu_leading), msg);
|
}
|
|
/**
|
* Add input characters to the end of the expression.
|
* Map them to the appropriate button pushes when possible. Leftover characters
|
* are added to mUnprocessedChars, which is presumed to immediately precede the newly
|
* added characters.
|
* @param moreChars characters to be added
|
* @param explicit these characters were explicitly typed by the user, not pasted
|
*/
|
private void addChars(String moreChars, boolean explicit) {
|
if (mUnprocessedChars != null) {
|
moreChars = mUnprocessedChars + moreChars;
|
}
|
int current = 0;
|
int len = moreChars.length();
|
boolean lastWasDigit = false;
|
if (mCurrentState == CalculatorState.RESULT && len != 0) {
|
// Clear display immediately for incomplete function name.
|
switchToInput(KeyMaps.keyForChar(moreChars.charAt(current)));
|
}
|
char groupingSeparator = KeyMaps.translateResult(",").charAt(0);
|
while (current < len) {
|
char c = moreChars.charAt(current);
|
if (Character.isSpaceChar(c) || c == groupingSeparator) {
|
++current;
|
continue;
|
}
|
int k = KeyMaps.keyForChar(c);
|
if (!explicit) {
|
int expEnd;
|
if (lastWasDigit && current !=
|
(expEnd = Evaluator.exponentEnd(moreChars, current))) {
|
// Process scientific notation with 'E' when pasting, in spite of ambiguity
|
// with base of natural log.
|
// Otherwise the 10^x key is the user's friend.
|
mEvaluator.addExponent(moreChars, current, expEnd);
|
current = expEnd;
|
lastWasDigit = false;
|
continue;
|
} else {
|
boolean isDigit = KeyMaps.digVal(k) != KeyMaps.NOT_DIGIT;
|
if (current == 0 && (isDigit || k == R.id.dec_point)
|
&& mEvaluator.getExpr(Evaluator.MAIN_INDEX).hasTrailingConstant()) {
|
// Refuse to concatenate pasted content to trailing constant.
|
// This makes pasting of calculator results more consistent, whether or
|
// not the old calculator instance is still around.
|
addKeyToExpr(R.id.op_mul);
|
}
|
lastWasDigit = (isDigit || lastWasDigit && k == R.id.dec_point);
|
}
|
}
|
if (k != View.NO_ID) {
|
mCurrentButton = findViewById(k);
|
if (explicit) {
|
addExplicitKeyToExpr(k);
|
} else {
|
addKeyToExpr(k);
|
}
|
if (Character.isSurrogate(c)) {
|
current += 2;
|
} else {
|
++current;
|
}
|
continue;
|
}
|
int f = KeyMaps.funForString(moreChars, current);
|
if (f != View.NO_ID) {
|
mCurrentButton = findViewById(f);
|
if (explicit) {
|
addExplicitKeyToExpr(f);
|
} else {
|
addKeyToExpr(f);
|
}
|
if (f == R.id.op_sqrt) {
|
// Square root entered as function; don't lose the parenthesis.
|
addKeyToExpr(R.id.lparen);
|
}
|
current = moreChars.indexOf('(', current) + 1;
|
continue;
|
}
|
// There are characters left, but we can't convert them to button presses.
|
mUnprocessedChars = moreChars.substring(current);
|
redisplayAfterFormulaChange();
|
showOrHideToolbar();
|
return;
|
}
|
mUnprocessedChars = null;
|
redisplayAfterFormulaChange();
|
showOrHideToolbar();
|
}
|
|
private void clearIfNotInputState() {
|
if (mCurrentState == CalculatorState.ERROR
|
|| mCurrentState == CalculatorState.RESULT) {
|
setState(CalculatorState.INPUT);
|
mEvaluator.clearMain();
|
}
|
}
|
|
/**
|
* Since we only support LTR format, using the RTL comma does not make sense.
|
*/
|
private String getDecimalSeparator() {
|
final char defaultSeparator = DecimalFormatSymbols.getInstance().getDecimalSeparator();
|
final char rtlComma = '\u066b';
|
return defaultSeparator == rtlComma ? "," : String.valueOf(defaultSeparator);
|
}
|
|
/**
|
* Clean up animation for context menu.
|
*/
|
@Override
|
public void onContextMenuClosed(Menu menu) {
|
stopActionModeOrContextMenu();
|
}
|
|
public interface OnDisplayMemoryOperationsListener {
|
boolean shouldDisplayMemory();
|
}
|
}
|
