/*
* Copyright (C) 2010 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.
*/
package com.android.ex.editstyledtext;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import com.android.ex.editstyledtext.EditStyledText.EditModeActions.EditModeActionBase;
import com.android.ex.editstyledtext.EditStyledText.EditStyledTextSpans.HorizontalLineSpan;
import com.android.ex.editstyledtext.EditStyledText.EditStyledTextSpans.MarqueeSpan;
import com.android.ex.editstyledtext.EditStyledText.EditStyledTextSpans.RescalableImageSpan;
import android.R;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnCancelListener;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Rect;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.ShapeDrawable;
import android.graphics.drawable.shapes.RectShape;
import android.net.Uri;
import android.os.Bundle;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.ResultReceiver;
import android.text.ClipboardManager;
import android.text.Editable;
import android.text.Html;
import android.text.Layout;
import android.text.NoCopySpan;
import android.text.NoCopySpan.Concrete;
import android.text.Selection;
import android.text.Spannable;
import android.text.SpannableStringBuilder;
import android.text.Spanned;
import android.text.TextPaint;
import android.text.Html.ImageGetter;
import android.text.Html.TagHandler;
import android.text.method.ArrowKeyMovementMethod;
import android.text.style.AbsoluteSizeSpan;
import android.text.style.AlignmentSpan;
import android.text.style.BackgroundColorSpan;
import android.text.style.CharacterStyle;
import android.text.style.DynamicDrawableSpan;
import android.text.style.ForegroundColorSpan;
import android.text.style.ImageSpan;
import android.text.style.ParagraphStyle;
import android.text.style.QuoteSpan;
import android.text.style.UnderlineSpan;
import android.util.AttributeSet;
import android.util.Log;
import android.view.ContextMenu;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.View;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputConnection;
import android.view.inputmethod.InputConnectionWrapper;
import android.view.inputmethod.InputMethodManager;
import android.widget.Button;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.TextView;
/**
* EditStyledText extends EditText for managing the flow and status to edit the styled text. This
* manages the states and flows of editing, supports inserting image, import/export HTML.
*/
public class EditStyledText extends EditText {
private static final String TAG = "EditStyledText";
/**
* DBG should be false at checking in.
*/
private static final boolean DBG = true;
/**
* Modes of editing actions.
*/
/** The mode that no editing action is done. */
public static final int MODE_NOTHING = 0;
/** The mode of copy. */
public static final int MODE_COPY = 1;
/** The mode of paste. */
public static final int MODE_PASTE = 2;
/** The mode of changing size. */
public static final int MODE_SIZE = 3;
/** The mode of changing color. */
public static final int MODE_COLOR = 4;
/** The mode of selection. */
public static final int MODE_SELECT = 5;
/** The mode of changing alignment. */
public static final int MODE_ALIGN = 6;
/** The mode of changing cut. */
public static final int MODE_CUT = 7;
public static final int MODE_TELOP = 8;
public static final int MODE_SWING = 9;
public static final int MODE_MARQUEE = 10;
public static final int MODE_SELECTALL = 11;
public static final int MODE_HORIZONTALLINE = 12;
public static final int MODE_STOP_SELECT = 13;
public static final int MODE_CLEARSTYLES = 14;
public static final int MODE_IMAGE = 15;
public static final int MODE_BGCOLOR = 16;
public static final int MODE_PREVIEW = 17;
public static final int MODE_CANCEL = 18;
public static final int MODE_TEXTVIEWFUNCTION = 19;
public static final int MODE_START_EDIT = 20;
public static final int MODE_END_EDIT = 21;
public static final int MODE_RESET = 22;
public static final int MODE_SHOW_MENU = 23;
/**
* States of selection.
*/
/** The state that selection isn't started. */
public static final int STATE_SELECT_OFF = 0;
/** The state that selection is started. */
public static final int STATE_SELECT_ON = 1;
/** The state that selection is done, but not fixed. */
public static final int STATE_SELECTED = 2;
/** The state that selection is done and not fixed. */
public static final int STATE_SELECT_FIX = 3;
/**
* Help message strings.
*/
public static final int HINT_MSG_NULL = 0;
public static final int HINT_MSG_COPY_BUF_BLANK = 1;
public static final int HINT_MSG_SELECT_START = 2;
public static final int HINT_MSG_SELECT_END = 3;
public static final int HINT_MSG_PUSH_COMPETE = 4;
public static final int HINT_MSG_BIG_SIZE_ERROR = 5;
public static final int HINT_MSG_END_PREVIEW = 6;
public static final int HINT_MSG_END_COMPOSE = 7;
/**
* Fixed Values.
*/
public static final int DEFAULT_TRANSPARENT_COLOR = 0x00FFFFFF;
public static final int DEFAULT_FOREGROUND_COLOR = 0xFF000000;
public static final char ZEROWIDTHCHAR = '\u2060';
public static final char IMAGECHAR = '\uFFFC';
private static final int ID_SELECT_ALL = android.R.id.selectAll;
private static final int ID_START_SELECTING_TEXT = android.R.id.startSelectingText;
private static final int ID_STOP_SELECTING_TEXT = android.R.id.stopSelectingText;
private static final int ID_PASTE = android.R.id.paste;
private static final int ID_COPY = android.R.id.copy;
private static final int ID_CUT = android.R.id.cut;
private static final int ID_HORIZONTALLINE = 0x00FFFF01;
private static final int ID_CLEARSTYLES = 0x00FFFF02;
private static final int ID_SHOWEDIT = 0x00FFFF03;
private static final int ID_HIDEEDIT = 0x00FFFF04;
private static final int MAXIMAGEWIDTHDIP = 300;
/**
* Strings for context menu. TODO: Extract the strings to strings.xml.
*/
private static CharSequence STR_HORIZONTALLINE;
private static CharSequence STR_CLEARSTYLES;
private static CharSequence STR_PASTE;
private float mPaddingScale = 0;
private ArrayList<EditStyledTextNotifier> mESTNotifiers;
private Drawable mDefaultBackground;
// EditStyledTextEditorManager manages the flow and status of each function of StyledText.
private EditorManager mManager;
private InputConnection mInputConnection;
private StyledTextConverter mConverter;
private StyledTextDialog mDialog;
private static final Concrete SELECTING = new NoCopySpan.Concrete();
private static final int PRESSED = Spannable.SPAN_MARK_MARK | (1 << Spannable.SPAN_USER_SHIFT);
/**
* EditStyledText extends EditText for managing flow of each editing action.
*/
public EditStyledText(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
init();
}
public EditStyledText(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
public EditStyledText(Context context) {
super(context);
init();
}
@Override
public boolean onTouchEvent(MotionEvent event) {
boolean superResult;
if (event.getAction() == MotionEvent.ACTION_UP) {
cancelLongPress();
boolean editting = isEditting();
// If View is touched but not in Edit Mode, starts Edit Mode.
if (!editting) {
onStartEdit();
}
int oldSelStart = Selection.getSelectionStart(getText());
int oldSelEnd = Selection.getSelectionEnd(getText());
superResult = super.onTouchEvent(event);
if (isFocused()) {
// If selection is started, don't open soft key by
// touching.
if (getSelectState() == STATE_SELECT_OFF) {
if (editting) {
mManager.showSoftKey(Selection.getSelectionStart(getText()),
Selection.getSelectionEnd(getText()));
} else {
mManager.showSoftKey(oldSelStart, oldSelEnd);
}
}
}
mManager.onCursorMoved();
mManager.unsetTextComposingMask();
} else {
superResult = super.onTouchEvent(event);
}
sendOnTouchEvent(event);
return superResult;
}
@Override
public Parcelable onSaveInstanceState() {
Parcelable superState = super.onSaveInstanceState();
SavedStyledTextState ss = new SavedStyledTextState(superState);
ss.mBackgroundColor = mManager.getBackgroundColor();
return ss;
}
@Override
public void onRestoreInstanceState(Parcelable state) {
if (!(state instanceof SavedStyledTextState)) {
super.onRestoreInstanceState(state);
return;
}
SavedStyledTextState ss = (SavedStyledTextState) state;
super.onRestoreInstanceState(ss.getSuperState());
setBackgroundColor(ss.mBackgroundColor);
}
@Override
protected void drawableStateChanged() {
super.drawableStateChanged();
if (mManager != null) {
mManager.onRefreshStyles();
}
}
@Override
public boolean onTextContextMenuItem(int id) {
boolean selection = getSelectionStart() != getSelectionEnd();
switch (id) {
case ID_SELECT_ALL:
onStartSelectAll();
return true;
case ID_START_SELECTING_TEXT:
onStartSelect();
mManager.blockSoftKey();
break;
case ID_STOP_SELECTING_TEXT:
onFixSelectedItem();
break;
case ID_PASTE:
onStartPaste();
return true;
case ID_COPY:
if (selection) {
onStartCopy();
} else {
mManager.onStartSelectAll(false);
onStartCopy();
}
return true;
case ID_CUT:
if (selection) {
onStartCut();
} else {
mManager.onStartSelectAll(false);
onStartCut();
}
return true;
case ID_HORIZONTALLINE:
onInsertHorizontalLine();
return true;
case ID_CLEARSTYLES:
onClearStyles();
return true;
case ID_SHOWEDIT:
onStartEdit();
return true;
case ID_HIDEEDIT:
onEndEdit();
return true;
}
return super.onTextContextMenuItem(id);
}
@Override
protected void onCreateContextMenu(ContextMenu menu) {
super.onCreateContextMenu(menu);
MenuHandler handler = new MenuHandler();
if (STR_HORIZONTALLINE != null) {
menu.add(0, ID_HORIZONTALLINE, 0, STR_HORIZONTALLINE).setOnMenuItemClickListener(
handler);
}
if (isStyledText() && STR_CLEARSTYLES != null) {
menu.add(0, ID_CLEARSTYLES, 0, STR_CLEARSTYLES)
.setOnMenuItemClickListener(handler);
}
if (mManager.canPaste()) {
menu.add(0, ID_PASTE, 0, STR_PASTE)
.setOnMenuItemClickListener(handler).setAlphabeticShortcut('v');
}
}
@Override
protected void onTextChanged(CharSequence text, int start, int before, int after) {
// onTextChanged will be called super's constructor.
if (mManager != null) {
mManager.updateSpanNextToCursor(getText(), start, before, after);
mManager.updateSpanPreviousFromCursor(getText(), start, before, after);
if (after > before) {
mManager.setTextComposingMask(start, start + after);
} else if (before < after) {
mManager.unsetTextComposingMask();
}
if (mManager.isWaitInput()) {
if (after > before) {
mManager.onCursorMoved();
onFixSelectedItem();
} else if (after < before) {
mManager.onAction(MODE_RESET);
}
}
}
super.onTextChanged(text, start, before, after);
}
@Override
public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
mInputConnection =
new StyledTextInputConnection(super.onCreateInputConnection(outAttrs), this);
return mInputConnection;
}
@Override
protected void onFocusChanged(boolean focused, int direction, Rect previouslyFocusedRect) {
super.onFocusChanged(focused, direction, previouslyFocusedRect);
if (focused) {
onStartEdit();
} else if (!isButtonsFocused()) {
onEndEdit();
}
}
/**
* Initialize members.
*/
private void init() {
mConverter = new StyledTextConverter(this, new StyledTextHtmlStandard());
mDialog = new StyledTextDialog(this);
mManager = new EditorManager(this, mDialog);
setMovementMethod(new StyledTextArrowKeyMethod(mManager));
mDefaultBackground = getBackground();
requestFocus();
}
public interface StyledTextHtmlConverter {
public String toHtml(Spanned text);
public String toHtml(Spanned text, boolean escapeNonAsciiChar);
public String toHtml(Spanned text, boolean escapeNonAsciiChar, int width, float scale);
public Spanned fromHtml(String string);
public Spanned fromHtml(String source, ImageGetter imageGetter, TagHandler tagHandler);
}
public void setStyledTextHtmlConverter(StyledTextHtmlConverter html) {
mConverter.setStyledTextHtmlConverter(html);
}
/**
* EditStyledTextInterface provides functions for notifying messages to calling class.
*/
public interface EditStyledTextNotifier {
public void sendHintMsg(int msgId);
public void onStateChanged(int mode, int state);
public boolean sendOnTouchEvent(MotionEvent event);
public boolean isButtonsFocused();
public boolean showPreview();
public void cancelViewManager();
public boolean showInsertImageSelectAlertDialog();
public boolean showMenuAlertDialog();
}
/**
* Add Notifier.
*/
public void addEditStyledTextListener(EditStyledTextNotifier estInterface) {
if (mESTNotifiers == null) {
mESTNotifiers = new ArrayList<EditStyledTextNotifier>();
}
mESTNotifiers.add(estInterface);
}
/**
* Remove Notifier.
*/
public void removeEditStyledTextListener(EditStyledTextNotifier estInterface) {
if (mESTNotifiers != null) {
int i = mESTNotifiers.indexOf(estInterface);
if (i > 0) {
mESTNotifiers.remove(i);
}
}
}
private void sendOnTouchEvent(MotionEvent event) {
if (mESTNotifiers != null) {
for (EditStyledTextNotifier notifier : mESTNotifiers) {
notifier.sendOnTouchEvent(event);
}
}
}
public boolean isButtonsFocused() {
boolean retval = false;
if (mESTNotifiers != null) {
for (EditStyledTextNotifier notifier : mESTNotifiers) {
retval |= notifier.isButtonsFocused();
}
}
return retval;
}
private void showPreview() {
if (mESTNotifiers != null) {
for (EditStyledTextNotifier notifier : mESTNotifiers) {
if (notifier.showPreview()) {
break;
}
}
}
}
private void cancelViewManagers() {
if (mESTNotifiers != null) {
for (EditStyledTextNotifier notifier : mESTNotifiers) {
notifier.cancelViewManager();
}
}
}
private void showInsertImageSelectAlertDialog() {
if (mESTNotifiers != null) {
for (EditStyledTextNotifier notifier : mESTNotifiers) {
if (notifier.showInsertImageSelectAlertDialog()) {
break;
}
}
}
}
private void showMenuAlertDialog() {
if (mESTNotifiers != null) {
for (EditStyledTextNotifier notifier : mESTNotifiers) {
if (notifier.showMenuAlertDialog()) {
break;
}
}
}
}
/**
* Notify hint messages what action is expected to calling class.
*
* @param msgId Id of the hint message.
*/
private void sendHintMessage(int msgId) {
if (mESTNotifiers != null) {
for (EditStyledTextNotifier notifier : mESTNotifiers) {
notifier.sendHintMsg(msgId);
}
}
}
/**
* Notify the event that the mode and state are changed.
*
* @param mode Mode of the editing action.
* @param state Mode of the selection state.
*/
private void notifyStateChanged(int mode, int state) {
if (mESTNotifiers != null) {
for (EditStyledTextNotifier notifier : mESTNotifiers) {
notifier.onStateChanged(mode, state);
}
}
}
/** Start to edit styled text */
public void onStartEdit() {
mManager.onAction(MODE_START_EDIT);
}
/** End of editing styled text */
public void onEndEdit() {
mManager.onAction(MODE_END_EDIT);
}
public void onResetEdit() {
mManager.onAction(MODE_RESET);
}
/** Start to copy styled text */
public void onStartCopy() {
mManager.onAction(MODE_COPY);
}
/** Start to cut styled text */
public void onStartCut() {
mManager.onAction(MODE_CUT);
}
/** Start to paste styled text */
public void onStartPaste() {
mManager.onAction(MODE_PASTE);
}
/** Start to change size */
public void onStartSize() {
mManager.onAction(MODE_SIZE);
}
/** Start to change color */
public void onStartColor() {
mManager.onAction(MODE_COLOR);
}
/** Start to change background color */
public void onStartBackgroundColor() {
mManager.onAction(MODE_BGCOLOR);
}
/** Start to change Alignment */
public void onStartAlign() {
mManager.onAction(MODE_ALIGN);
}
public void onStartTelop() {
mManager.onAction(MODE_TELOP);
}
public void onStartSwing() {
mManager.onAction(MODE_SWING);
}
public void onStartMarquee() {
mManager.onAction(MODE_MARQUEE);
}
/** Start to select a text */
public void onStartSelect() {
mManager.onStartSelect(true);
}
/** Start to select all characters */
public void onStartSelectAll() {
mManager.onStartSelectAll(true);
}
public void onStartShowPreview() {
mManager.onAction(MODE_PREVIEW);
}
public void onStartShowMenuAlertDialog() {
mManager.onStartShowMenuAlertDialog();
}
public void onStartAction(int mode, boolean notifyStateChanged) {
mManager.onAction(mode, notifyStateChanged);
}
/** Fix selection */
public void onFixSelectedItem() {
mManager.onFixSelectedItem();
}
public void onInsertImage() {
mManager.onAction(MODE_IMAGE);
}
/**
* InsertImage to TextView by using URI
*
* @param uri URI of the iamge inserted to TextView.
*/
public void onInsertImage(Uri uri) {
mManager.onInsertImage(uri);
}
/**
* InsertImage to TextView by using resource ID
*
* @param resId Resource ID of the iamge inserted to TextView.
*/
public void onInsertImage(int resId) {
mManager.onInsertImage(resId);
}
public void onInsertHorizontalLine() {
mManager.onAction(MODE_HORIZONTALLINE);
}
public void onClearStyles() {
mManager.onClearStyles();
}
public void onBlockSoftKey() {
mManager.blockSoftKey();
}
public void onUnblockSoftKey() {
mManager.unblockSoftKey();
}
public void onCancelViewManagers() {
mManager.onCancelViewManagers();
}
private void onRefreshStyles() {
mManager.onRefreshStyles();
}
private void onRefreshZeoWidthChar() {
mManager.onRefreshZeoWidthChar();
}
/**
* Set Size of the Item.
*
* @param size The size of the Item.
*/
public void setItemSize(int size) {
mManager.setItemSize(size, true);
}
/**
* Set Color of the Item.
*
* @param color The color of the Item.
*/
public void setItemColor(int color) {
mManager.setItemColor(color, true);
}
/**
* Set Alignment of the Item.
*
* @param align The color of the Item.
*/
public void setAlignment(Layout.Alignment align) {
mManager.setAlignment(align);
}
/**
* Set Background color of View.
*
* @param color The background color of view.
*/
@Override
public void setBackgroundColor(int color) {
if (color != DEFAULT_TRANSPARENT_COLOR) {
super.setBackgroundColor(color);
} else {
setBackgroundDrawable(mDefaultBackground);
}
mManager.setBackgroundColor(color);
onRefreshStyles();
}
public void setMarquee(int marquee) {
mManager.setMarquee(marquee);
}
/**
* Set html to EditStyledText.
*
* @param html The html to be set.
*/
public void setHtml(String html) {
mConverter.SetHtml(html);
}
/**
* Set Builder for AlertDialog.
*
* @param builder Builder for opening Alert Dialog.
*/
public void setBuilder(Builder builder) {
mDialog.setBuilder(builder);
}
/**
* Set Parameters for ColorAlertDialog.
*
* @param colortitle Title for Alert Dialog.
* @param colornames List of name of selecting color.
* @param colorints List of int of color.
*/
public void setColorAlertParams(CharSequence colortitle, CharSequence[] colornames,
CharSequence[] colorints, CharSequence transparent) {
mDialog.setColorAlertParams(colortitle, colornames, colorints, transparent);
}
/**
* Set Parameters for SizeAlertDialog.
*
* @param sizetitle Title for Alert Dialog.
* @param sizenames List of name of selecting size.
* @param sizedisplayints List of int of size displayed in TextView.
* @param sizesendints List of int of size exported to HTML.
*/
public void setSizeAlertParams(CharSequence sizetitle, CharSequence[] sizenames,
CharSequence[] sizedisplayints, CharSequence[] sizesendints) {
mDialog.setSizeAlertParams(sizetitle, sizenames, sizedisplayints, sizesendints);
}
public void setAlignAlertParams(CharSequence aligntitle, CharSequence[] alignnames) {
mDialog.setAlignAlertParams(aligntitle, alignnames);
}
public void setMarqueeAlertParams(CharSequence marqueetitle, CharSequence[] marqueenames) {
mDialog.setMarqueeAlertParams(marqueetitle, marqueenames);
}
public void setContextMenuStrings(CharSequence horizontalline, CharSequence clearstyles,
CharSequence paste) {
STR_HORIZONTALLINE = horizontalline;
STR_CLEARSTYLES = clearstyles;
STR_PASTE = paste;
}
/**
* Check whether editing is started or not.
*
* @return Whether editing is started or not.
*/
public boolean isEditting() {
return mManager.isEditting();
}
/**
* Check whether styled text or not.
*
* @return Whether styled text or not.
*/
public boolean isStyledText() {
return mManager.isStyledText();
}
/**
* Check whether SoftKey is Blocked or not.
*
* @return whether SoftKey is Blocked or not.
*/
public boolean isSoftKeyBlocked() {
return mManager.isSoftKeyBlocked();
}
/**
* Get the mode of the action.
*
* @return The mode of the action.
*/
public int getEditMode() {
return mManager.getEditMode();
}
/**
* Get the state of the selection.
*
* @return The state of the selection.
*/
public int getSelectState() {
return mManager.getSelectState();
}
/**
* Get the state of the selection.
*
* @return The state of the selection.
*/
public String getHtml() {
return mConverter.getHtml(true);
}
public String getHtml(boolean escapeFlag) {
return mConverter.getHtml(escapeFlag);
}
/**
* Get the state of the selection.
*
* @param uris The array of used uris.
* @return The state of the selection.
*/
public String getHtml(ArrayList<Uri> uris, boolean escapeFlag) {
mConverter.getUriArray(uris, getText());
return mConverter.getHtml(escapeFlag);
}
public String getPreviewHtml() {
return mConverter.getPreviewHtml();
}
/**
* Get Background color of View.
*
* @return The background color of View.
*/
public int getBackgroundColor() {
return mManager.getBackgroundColor();
}
public EditorManager getEditStyledTextManager() {
return mManager;
}
/**
* Get Foreground color of View.
*
* @return The background color of View.
*/
public int getForegroundColor(int pos) {
if (pos < 0 || pos > getText().length()) {
return DEFAULT_FOREGROUND_COLOR;
} else {
ForegroundColorSpan[] spans =
getText().getSpans(pos, pos, ForegroundColorSpan.class);
if (spans.length > 0) {
return spans[0].getForegroundColor();
} else {
return DEFAULT_FOREGROUND_COLOR;
}
}
}
private void finishComposingText() {
if (mInputConnection != null && !mManager.mTextIsFinishedFlag) {
mInputConnection.finishComposingText();
mManager.mTextIsFinishedFlag = true;
}
}
private float getPaddingScale() {
if (mPaddingScale <= 0) {
mPaddingScale = getContext().getResources().getDisplayMetrics().density;
}
return mPaddingScale;
}
/** Convert pixcel to DIP */
private int dipToPx(int dip) {
if (mPaddingScale <= 0) {
mPaddingScale = getContext().getResources().getDisplayMetrics().density;
}
return (int) ((float) dip * getPaddingScale() + 0.5);
}
private int getMaxImageWidthDip() {
return MAXIMAGEWIDTHDIP;
}
private int getMaxImageWidthPx() {
return dipToPx(MAXIMAGEWIDTHDIP);
}
public void addAction(int mode, EditModeActionBase action) {
mManager.addAction(mode, action);
}
public void addInputExtra(boolean create, String extra) {
Bundle bundle = super.getInputExtras(create);
if (bundle != null) {
bundle.putBoolean(extra, true);
}
}
private static void startSelecting(View view, Spannable content) {
content.setSpan(SELECTING, 0, 0, PRESSED);
}
private static void stopSelecting(View view, Spannable content) {
content.removeSpan(SELECTING);
}
/**
* EditorManager manages the flow and status of editing actions.
*/
private class EditorManager {
static final private String LOG_TAG = "EditStyledText.EditorManager";
private boolean mEditFlag = false;
private boolean mSoftKeyBlockFlag = false;
private boolean mKeepNonLineSpan = false;
private boolean mWaitInputFlag = false;
private boolean mTextIsFinishedFlag = false;
private int mMode = MODE_NOTHING;
private int mState = STATE_SELECT_OFF;
private int mCurStart = 0;
private int mCurEnd = 0;
private int mColorWaitInput = DEFAULT_TRANSPARENT_COLOR;
private int mSizeWaitInput = 0;
private int mBackgroundColor = DEFAULT_TRANSPARENT_COLOR;
private BackgroundColorSpan mComposingTextMask;
private EditStyledText mEST;
private EditModeActions mActions;
private SoftKeyReceiver mSkr;
private SpannableStringBuilder mCopyBuffer;
EditorManager(EditStyledText est, StyledTextDialog dialog) {
mEST = est;
mActions = new EditModeActions(mEST, this, dialog);
mSkr = new SoftKeyReceiver(mEST);
}
public void addAction(int mode, EditModeActionBase action) {
mActions.addAction(mode, action);
}
public void onAction(int mode) {
onAction(mode, true);
}
public void onAction(int mode, boolean notifyStateChanged) {
mActions.onAction(mode);
if (notifyStateChanged) {
mEST.notifyStateChanged(mMode, mState);
}
}
private void startEdit() {
resetEdit();
showSoftKey();
}
public void onStartSelect(boolean notifyStateChanged) {
if (DBG) {
Log.d(LOG_TAG, "--- onClickSelect");
}
mMode = MODE_SELECT;
if (mState == STATE_SELECT_OFF) {
mActions.onSelectAction();
} else {
unsetSelect();
mActions.onSelectAction();
}
if (notifyStateChanged) {
mEST.notifyStateChanged(mMode, mState);
}
}
public void onCursorMoved() {
if (DBG) {
Log.d(LOG_TAG, "--- onClickView");
}
if (mState == STATE_SELECT_ON || mState == STATE_SELECTED) {
mActions.onSelectAction();
mEST.notifyStateChanged(mMode, mState);
}
}
public void onStartSelectAll(boolean notifyStateChanged) {
if (DBG) {
Log.d(LOG_TAG, "--- onClickSelectAll");
}
handleSelectAll();
if (notifyStateChanged) {
mEST.notifyStateChanged(mMode, mState);
}
}
public void onStartShowMenuAlertDialog() {
mActions.onAction(MODE_SHOW_MENU);
// don't call notify state changed because it have to continue
// to the next action.
// mEST.notifyStateChanged(mMode, mState);
}
public void onFixSelectedItem() {
if (DBG) {
Log.d(LOG_TAG, "--- onFixSelectedItem");
}
fixSelectionAndDoNextAction();
mEST.notifyStateChanged(mMode, mState);
}
public void onInsertImage(Uri uri) {
mActions.onAction(MODE_IMAGE, uri);
mEST.notifyStateChanged(mMode, mState);
}
public void onInsertImage(int resId) {
mActions.onAction(MODE_IMAGE, resId);
mEST.notifyStateChanged(mMode, mState);
}
private void insertImageFromUri(Uri uri) {
insertImageSpan(new EditStyledTextSpans.RescalableImageSpan(mEST.getContext(),
uri, mEST.getMaxImageWidthPx()), mEST.getSelectionStart());
}
private void insertImageFromResId(int resId) {
insertImageSpan(new EditStyledTextSpans.RescalableImageSpan(mEST.getContext(),
resId, mEST.getMaxImageWidthDip()), mEST.getSelectionStart());
}
private void insertHorizontalLine() {
if (DBG) {
Log.d(LOG_TAG, "--- onInsertHorizontalLine:");
}
int curpos = mEST.getSelectionStart();
if (curpos > 0 && mEST.getText().charAt(curpos - 1) != '\n') {
mEST.getText().insert(curpos++, "\n");
}
insertImageSpan(
new HorizontalLineSpan(0xFF000000, mEST.getWidth(), mEST.getText()),
curpos++);
mEST.getText().insert(curpos++, "\n");
mEST.setSelection(curpos);
mEST.notifyStateChanged(mMode, mState);
}
private void clearStyles(CharSequence txt) {
if (DBG) {
Log.d("EditStyledText", "--- onClearStyles");
}
int len = txt.length();
if (txt instanceof Editable) {
Editable editable = (Editable) txt;
Object[] styles = editable.getSpans(0, len, Object.class);
for (Object style : styles) {
if (style instanceof ParagraphStyle || style instanceof QuoteSpan
|| style instanceof CharacterStyle
&& !(style instanceof UnderlineSpan)) {
if (style instanceof ImageSpan || style instanceof HorizontalLineSpan) {
int start = editable.getSpanStart(style);
int end = editable.getSpanEnd(style);
editable.replace(start, end, "");
}
editable.removeSpan(style);
}
}
}
}
public void onClearStyles() {
mActions.onAction(MODE_CLEARSTYLES);
}
public void onCancelViewManagers() {
mActions.onAction(MODE_CANCEL);
}
private void clearStyles() {
if (DBG) {
Log.d(LOG_TAG, "--- onClearStyles");
}
clearStyles(mEST.getText());
mEST.setBackgroundDrawable(mEST.mDefaultBackground);
mBackgroundColor = DEFAULT_TRANSPARENT_COLOR;
onRefreshZeoWidthChar();
}
public void onRefreshZeoWidthChar() {
Editable txt = mEST.getText();
for (int i = 0; i < txt.length(); i++) {
if (txt.charAt(i) == ZEROWIDTHCHAR) {
txt.replace(i, i + 1, "");
i--;
}
}
}
public void onRefreshStyles() {
if (DBG) {
Log.d(LOG_TAG, "--- onRefreshStyles");
}
Editable txt = mEST.getText();
int len = txt.length();
int width = mEST.getWidth();
HorizontalLineSpan[] lines = txt.getSpans(0, len, HorizontalLineSpan.class);
for (HorizontalLineSpan line : lines) {
line.resetWidth(width);
}
MarqueeSpan[] marquees = txt.getSpans(0, len, MarqueeSpan.class);
for (MarqueeSpan marquee : marquees) {
marquee.resetColor(mEST.getBackgroundColor());
}
if (lines.length > 0) {
// This is hack, bad needed for renewing View
// by inserting new line.
txt.replace(0, 1, "" + txt.charAt(0));
}
}
public void setBackgroundColor(int color) {
mBackgroundColor = color;
}
public void setItemSize(int size, boolean reset) {
if (DBG) {
Log.d(LOG_TAG, "--- setItemSize");
}
if (isWaitingNextAction()) {
mSizeWaitInput = size;
} else if (mState == STATE_SELECTED || mState == STATE_SELECT_FIX) {
if (size > 0) {
changeSizeSelectedText(size);
}
if (reset) {
resetEdit();
}
}
}
public void setItemColor(int color, boolean reset) {
if (DBG) {
Log.d(LOG_TAG, "--- setItemColor");
}
if (isWaitingNextAction()) {
mColorWaitInput = color;
} else if (mState == STATE_SELECTED || mState == STATE_SELECT_FIX) {
if (color != DEFAULT_TRANSPARENT_COLOR) {
changeColorSelectedText(color);
}
if (reset) {
resetEdit();
}
}
}
public void setAlignment(Layout.Alignment align) {
if (mState == STATE_SELECTED || mState == STATE_SELECT_FIX) {
changeAlign(align);
resetEdit();
}
}
public void setTelop() {
if (mState == STATE_SELECTED || mState == STATE_SELECT_FIX) {
addTelop();
resetEdit();
}
}
public void setSwing() {
if (mState == STATE_SELECTED || mState == STATE_SELECT_FIX) {
addSwing();
resetEdit();
}
}
public void setMarquee(int marquee) {
if (mState == STATE_SELECTED || mState == STATE_SELECT_FIX) {
addMarquee(marquee);
resetEdit();
}
}
public void setTextComposingMask(int start, int end) {
if (DBG) {
Log.d(TAG, "--- setTextComposingMask:" + start + "," + end);
}
int min = Math.min(start, end);
int max = Math.max(start, end);
int foregroundColor;
if (isWaitInput() && mColorWaitInput != DEFAULT_TRANSPARENT_COLOR) {
foregroundColor = mColorWaitInput;
} else {
foregroundColor = mEST.getForegroundColor(min);
}
int backgroundColor = mEST.getBackgroundColor();
if (DBG) {
Log.d(TAG,
"--- fg:" + Integer.toHexString(foregroundColor) + ",bg:"
+ Integer.toHexString(backgroundColor) + "," + isWaitInput()
+ "," + "," + mMode);
}
if (foregroundColor == backgroundColor) {
int maskColor = 0x80000000 | ~(backgroundColor | 0xFF000000);
if (mComposingTextMask == null
|| mComposingTextMask.getBackgroundColor() != maskColor) {
mComposingTextMask = new BackgroundColorSpan(maskColor);
}
mEST.getText().setSpan(mComposingTextMask, min, max,
Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
}
}
private void setEditMode(int mode) {
mMode = mode;
}
private void setSelectState(int state) {
mState = state;
}
public void unsetTextComposingMask() {
if (DBG) {
Log.d(TAG, "--- unsetTextComposingMask");
}
if (mComposingTextMask != null) {
mEST.getText().removeSpan(mComposingTextMask);
mComposingTextMask = null;
}
}
public boolean isEditting() {
return mEditFlag;
}
/* If the style of the span is added, add check case for that style */
public boolean isStyledText() {
Editable txt = mEST.getText();
int len = txt.length();
if (txt.getSpans(0, len, ParagraphStyle.class).length > 0
|| txt.getSpans(0, len, QuoteSpan.class).length > 0
|| txt.getSpans(0, len, CharacterStyle.class).length > 0
|| mBackgroundColor != DEFAULT_TRANSPARENT_COLOR) {
return true;
}
return false;
}
public boolean isSoftKeyBlocked() {
return mSoftKeyBlockFlag;
}
public boolean isWaitInput() {
return mWaitInputFlag;
}
public int getBackgroundColor() {
return mBackgroundColor;
}
public int getEditMode() {
return mMode;
}
public int getSelectState() {
return mState;
}
public int getSelectionStart() {
return mCurStart;
}
public int getSelectionEnd() {
return mCurEnd;
}
public int getSizeWaitInput() {
return mSizeWaitInput;
}
public int getColorWaitInput() {
return mColorWaitInput;
}
private void setInternalSelection(int curStart, int curEnd) {
mCurStart = curStart;
mCurEnd = curEnd;
}
public void
updateSpanPreviousFromCursor(Editable txt, int start, int before, int after) {
if (DBG) {
Log.d(LOG_TAG, "updateSpanPrevious:" + start + "," + before + "," + after);
}
int end = start + after;
int min = Math.min(start, end);
int max = Math.max(start, end);
Object[] spansBefore = txt.getSpans(min, min, Object.class);
for (Object span : spansBefore) {
if (span instanceof ForegroundColorSpan || span instanceof AbsoluteSizeSpan
|| span instanceof MarqueeSpan || span instanceof AlignmentSpan) {
int spanstart = txt.getSpanStart(span);
int spanend = txt.getSpanEnd(span);
if (DBG) {
Log.d(LOG_TAG, "spantype:" + span.getClass() + "," + spanstart);
}
int tempmax = max;
if (span instanceof MarqueeSpan || span instanceof AlignmentSpan) {
// Line Span
tempmax = findLineEnd(mEST.getText(), max);
} else {
if (mKeepNonLineSpan) {
tempmax = spanend;
}
}
if (spanend < tempmax) {
if (DBG) {
Log.d(LOG_TAG, "updateSpanPrevious: extend span");
}
txt.setSpan(span, spanstart, tempmax,
Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
}
} else if (span instanceof HorizontalLineSpan) {
int spanstart = txt.getSpanStart(span);
int spanend = txt.getSpanEnd(span);
if (before > after) {
// When text is deleted just after horizontalLineSpan, horizontalLineSpan
// has to be deleted, because the charactor just after horizontalLineSpan
// is '\n'.
txt.replace(spanstart, spanend, "");
txt.removeSpan(span);
} else {
// When text is added just after horizontalLineSpan add '\n' just after
// horizontalLineSpan.
if (spanend == end && end < txt.length()
&& mEST.getText().charAt(end) != '\n') {
mEST.getText().insert(end, "\n");
}
}
}
}
}
public void updateSpanNextToCursor(Editable txt, int start, int before, int after) {
if (DBG) {
Log.d(LOG_TAG, "updateSpanNext:" + start + "," + before + "," + after);
}
int end = start + after;
int min = Math.min(start, end);
int max = Math.max(start, end);
Object[] spansAfter = txt.getSpans(max, max, Object.class);
for (Object span : spansAfter) {
if (span instanceof MarqueeSpan || span instanceof AlignmentSpan) {
int spanstart = txt.getSpanStart(span);
int spanend = txt.getSpanEnd(span);
if (DBG) {
Log.d(LOG_TAG, "spantype:" + span.getClass() + "," + spanend);
}
int tempmin = min;
if (span instanceof MarqueeSpan || span instanceof AlignmentSpan) {
tempmin = findLineStart(mEST.getText(), min);
}
if (tempmin < spanstart && before > after) {
txt.removeSpan(span);
} else if (spanstart > min) {
txt.setSpan(span, min, spanend, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
}
} else if (span instanceof HorizontalLineSpan) {
int spanstart = txt.getSpanStart(span);
// Whene text is changed just before horizontalLineSpan and there is no '\n'
// just before horizontalLineSpan add '\n'
if (spanstart == end && end > 0 && mEST.getText().charAt(end - 1) != '\n') {
mEST.getText().insert(end, "\n");
mEST.setSelection(end);
}
}
}
}
/** canPaste returns true only if ClipboardManager doen't contain text. */
public boolean canPaste() {
return (mCopyBuffer != null && mCopyBuffer.length() > 0 && removeImageChar(
mCopyBuffer).length() == 0);
}
private void endEdit() {
if (DBG) {
Log.d(LOG_TAG, "--- handleCancel");
}
mMode = MODE_NOTHING;
mState = STATE_SELECT_OFF;
mEditFlag = false;
mColorWaitInput = DEFAULT_TRANSPARENT_COLOR;
mSizeWaitInput = 0;
mWaitInputFlag = false;
mSoftKeyBlockFlag = false;
mKeepNonLineSpan = false;
mTextIsFinishedFlag = false;
unsetSelect();
mEST.setOnClickListener(null);
unblockSoftKey();
}
private void fixSelectionAndDoNextAction() {
if (DBG) {
Log.d(LOG_TAG, "--- handleComplete:" + mCurStart + "," + mCurEnd);
}
if (!mEditFlag) {
return;
}
if (mCurStart == mCurEnd) {
if (DBG) {
Log.d(LOG_TAG, "--- cancel handle complete:" + mCurStart);
}
resetEdit();
return;
}
if (mState == STATE_SELECTED) {
mState = STATE_SELECT_FIX;
}
// When the complete button is clicked, this should do action.
mActions.doNext(mMode);
//MetaKeyKeyListener.stopSelecting(mEST, mEST.getText());
stopSelecting(mEST, mEST.getText());
}
// Remove obj character for DynamicDrawableSpan from clipboard.
private SpannableStringBuilder removeImageChar(SpannableStringBuilder text) {
SpannableStringBuilder buf = new SpannableStringBuilder(text);
DynamicDrawableSpan[] styles =
buf.getSpans(0, buf.length(), DynamicDrawableSpan.class);
for (DynamicDrawableSpan style : styles) {
if (style instanceof HorizontalLineSpan
|| style instanceof RescalableImageSpan) {
int start = buf.getSpanStart(style);
int end = buf.getSpanEnd(style);
buf.replace(start, end, "");
}
}
return buf;
}
private void copyToClipBoard() {
int min = Math.min(getSelectionStart(), getSelectionEnd());
int max = Math.max(getSelectionStart(), getSelectionEnd());
mCopyBuffer = (SpannableStringBuilder) mEST.getText().subSequence(min, max);
SpannableStringBuilder clipboardtxt = removeImageChar(mCopyBuffer);
ClipboardManager clip =
(ClipboardManager) getContext()
.getSystemService(Context.CLIPBOARD_SERVICE);
clip.setText(clipboardtxt);
if (DBG) {
dumpSpannableString(clipboardtxt);
dumpSpannableString(mCopyBuffer);
}
}
private void cutToClipBoard() {
copyToClipBoard();
int min = Math.min(getSelectionStart(), getSelectionEnd());
int max = Math.max(getSelectionStart(), getSelectionEnd());
mEST.getText().delete(min, max);
}
private boolean isClipBoardChanged(CharSequence clipboardText) {
if (DBG) {
Log.d(TAG, "--- isClipBoardChanged:" + clipboardText);
}
if (mCopyBuffer == null) {
return true;
}
int len = clipboardText.length();
CharSequence removedClipBoard = removeImageChar(mCopyBuffer);
if (DBG) {
Log.d(TAG, "--- clipBoard:" + len + "," + removedClipBoard + clipboardText);
}
if (len != removedClipBoard.length()) {
return true;
}
for (int i = 0; i < len; ++i) {
if (clipboardText.charAt(i) != removedClipBoard.charAt(i)) {
return true;
}
}
return false;
}
private void pasteFromClipboard() {
int min = Math.min(mEST.getSelectionStart(), mEST.getSelectionEnd());
int max = Math.max(mEST.getSelectionStart(), mEST.getSelectionEnd());
// TODO: Find more smart way to set Span to Clipboard.
Selection.setSelection(mEST.getText(), max);
ClipboardManager clip =
(ClipboardManager) getContext()
.getSystemService(Context.CLIPBOARD_SERVICE);
mKeepNonLineSpan = true;
mEST.getText().replace(min, max, clip.getText());
if (!isClipBoardChanged(clip.getText())) {
if (DBG) {
Log.d(TAG, "--- handlePaste: startPasteImage");
}
DynamicDrawableSpan[] styles =
mCopyBuffer.getSpans(0, mCopyBuffer.length(),
DynamicDrawableSpan.class);
for (DynamicDrawableSpan style : styles) {
int start = mCopyBuffer.getSpanStart(style);
if (style instanceof HorizontalLineSpan) {
insertImageSpan(new HorizontalLineSpan(0xFF000000, mEST.getWidth(),
mEST.getText()), min + start);
} else if (style instanceof RescalableImageSpan) {
insertImageSpan(
new RescalableImageSpan(mEST.getContext(),
((RescalableImageSpan) style).getContentUri(),
mEST.getMaxImageWidthPx()), min + start);
}
}
}
}
private void handleSelectAll() {
if (!mEditFlag) {
return;
}
mActions.onAction(MODE_SELECTALL);
}
private void selectAll() {
Selection.selectAll(mEST.getText());
mCurStart = mEST.getSelectionStart();
mCurEnd = mEST.getSelectionEnd();
mMode = MODE_SELECT;
mState = STATE_SELECT_FIX;
}
private void resetEdit() {
endEdit();
mEditFlag = true;
mEST.notifyStateChanged(mMode, mState);
}
private void setSelection() {
if (DBG) {
Log.d(LOG_TAG, "--- onSelect:" + mCurStart + "," + mCurEnd);
}
if (mCurStart >= 0 && mCurStart <= mEST.getText().length() && mCurEnd >= 0
&& mCurEnd <= mEST.getText().length()) {
if (mCurStart < mCurEnd) {
mEST.setSelection(mCurStart, mCurEnd);
mState = STATE_SELECTED;
} else if (mCurStart > mCurEnd) {
mEST.setSelection(mCurEnd, mCurStart);
mState = STATE_SELECTED;
} else {
mState = STATE_SELECT_ON;
}
} else {
Log.e(LOG_TAG, "Select is on, but cursor positions are illigal.:"
+ mEST.getText().length() + "," + mCurStart + "," + mCurEnd);
}
}
private void unsetSelect() {
if (DBG) {
Log.d(LOG_TAG, "--- offSelect");
}
//MetaKeyKeyListener.stopSelecting(mEST, mEST.getText());
stopSelecting(mEST, mEST.getText());
int currpos = mEST.getSelectionStart();
mEST.setSelection(currpos, currpos);
mState = STATE_SELECT_OFF;
}
private void setSelectStartPos() {
if (DBG) {
Log.d(LOG_TAG, "--- setSelectStartPos");
}
mCurStart = mEST.getSelectionStart();
mState = STATE_SELECT_ON;
}
private void setSelectEndPos() {
if (mEST.getSelectionEnd() == mCurStart) {
setEndPos(mEST.getSelectionStart());
} else {
setEndPos(mEST.getSelectionEnd());
}
}
public void setEndPos(int pos) {
if (DBG) {
Log.d(LOG_TAG, "--- setSelectedEndPos:" + pos);
}
mCurEnd = pos;
setSelection();
}
private boolean isWaitingNextAction() {
if (DBG) {
Log.d(LOG_TAG, "--- waitingNext:" + mCurStart + "," + mCurEnd + "," + mState);
}
if (mCurStart == mCurEnd && mState == STATE_SELECT_FIX) {
waitSelection();
return true;
} else {
resumeSelection();
return false;
}
}
private void waitSelection() {
if (DBG) {
Log.d(LOG_TAG, "--- waitSelection");
}
mWaitInputFlag = true;
if (mCurStart == mCurEnd) {
mState = STATE_SELECT_ON;
} else {
mState = STATE_SELECTED;
}
//MetaKeyKeyListener.startSelecting(mEST, mEST.getText());
startSelecting(mEST, mEST.getText());
}
private void resumeSelection() {
if (DBG) {
Log.d(LOG_TAG, "--- resumeSelection");
}
mWaitInputFlag = false;
mState = STATE_SELECT_FIX;
//MetaKeyKeyListener.stopSelecting(mEST, mEST.getText());
stopSelecting(mEST, mEST.getText());
}
private boolean isTextSelected() {
return (mState == STATE_SELECTED || mState == STATE_SELECT_FIX);
}
private void setStyledTextSpan(Object span, int start, int end) {
if (DBG) {
Log.d(LOG_TAG, "--- setStyledTextSpan:" + mMode + "," + start + "," + end);
}
int min = Math.min(start, end);
int max = Math.max(start, end);
mEST.getText().setSpan(span, min, max, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
Selection.setSelection(mEST.getText(), max);
}
private void setLineStyledTextSpan(Object span) {
int min = Math.min(mCurStart, mCurEnd);
int max = Math.max(mCurStart, mCurEnd);
int current = mEST.getSelectionStart();
int start = findLineStart(mEST.getText(), min);
int end = findLineEnd(mEST.getText(), max);
if (start == end) {
mEST.getText().insert(end, "\n");
setStyledTextSpan(span, start, end + 1);
} else {
setStyledTextSpan(span, start, end);
}
Selection.setSelection(mEST.getText(), current);
}
private void changeSizeSelectedText(int size) {
if (mCurStart != mCurEnd) {
setStyledTextSpan(new AbsoluteSizeSpan(size), mCurStart, mCurEnd);
} else {
Log.e(LOG_TAG, "---changeSize: Size of the span is zero");
}
}
private void changeColorSelectedText(int color) {
if (mCurStart != mCurEnd) {
setStyledTextSpan(new ForegroundColorSpan(color), mCurStart, mCurEnd);
} else {
Log.e(LOG_TAG, "---changeColor: Size of the span is zero");
}
}
private void changeAlign(Layout.Alignment align) {
setLineStyledTextSpan(new AlignmentSpan.Standard(align));
}
private void addTelop() {
addMarquee(MarqueeSpan.ALTERNATE);
}
private void addSwing() {
addMarquee(MarqueeSpan.SCROLL);
}
private void addMarquee(int marquee) {
if (DBG) {
Log.d(LOG_TAG, "--- addMarquee:" + marquee);
}
setLineStyledTextSpan(new MarqueeSpan(marquee, mEST.getBackgroundColor()));
}
private void insertImageSpan(DynamicDrawableSpan span, int curpos) {
if (DBG) {
Log.d(LOG_TAG, "--- insertImageSpan:");
}
if (span != null && span.getDrawable() != null) {
mEST.getText().insert(curpos, "" + IMAGECHAR);
mEST.getText().setSpan(span, curpos, curpos + 1,
Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
mEST.notifyStateChanged(mMode, mState);
} else {
Log.e(LOG_TAG, "--- insertImageSpan: null span was inserted");
mEST.sendHintMessage(HINT_MSG_BIG_SIZE_ERROR);
}
}
private int findLineStart(Editable text, int current) {
int pos = current;
for (; pos > 0; pos--) {
if (text.charAt(pos - 1) == '\n') {
break;
}
}
if (DBG) {
Log.d(LOG_TAG, "--- findLineStart:" + current + "," + text.length() + ","
+ pos);
}
return pos;
}
private int findLineEnd(Editable text, int current) {
int pos = current;
for (; pos < text.length(); pos++) {
if (text.charAt(pos) == '\n') {
pos++;
break;
}
}
if (DBG) {
Log.d(LOG_TAG, "--- findLineEnd:" + current + "," + text.length() + "," + pos);
}
return pos;
}
// Only for debug.
private void dumpSpannableString(CharSequence txt) {
if (txt instanceof Spannable) {
Spannable spannable = (Spannable) txt;
int len = spannable.length();
if (DBG) {
Log.d(TAG, "--- dumpSpannableString, txt:" + spannable + ", len:" + len);
}
Object[] styles = spannable.getSpans(0, len, Object.class);
for (Object style : styles) {
if (DBG) {
Log.d(TAG,
"--- dumpSpannableString, class:" + style + ","
+ spannable.getSpanStart(style) + ","
+ spannable.getSpanEnd(style) + ","
+ spannable.getSpanFlags(style));
}
}
}
}
public void showSoftKey() {
showSoftKey(mEST.getSelectionStart(), mEST.getSelectionEnd());
}
public void showSoftKey(int oldSelStart, int oldSelEnd) {
if (DBG) {
Log.d(LOG_TAG, "--- showsoftkey");
}
if (!mEST.isFocused() || isSoftKeyBlocked()) {
return;
}
mSkr.mNewStart = Selection.getSelectionStart(mEST.getText());
mSkr.mNewEnd = Selection.getSelectionEnd(mEST.getText());
InputMethodManager imm =
(InputMethodManager) getContext().getSystemService(
Context.INPUT_METHOD_SERVICE);
if (imm.showSoftInput(mEST, 0, mSkr) && mSkr != null) {
Selection.setSelection(getText(), oldSelStart, oldSelEnd);
}
}
public void hideSoftKey() {
if (DBG) {
Log.d(LOG_TAG, "--- hidesoftkey");
}
if (!mEST.isFocused()) {
return;
}
mSkr.mNewStart = Selection.getSelectionStart(mEST.getText());
mSkr.mNewEnd = Selection.getSelectionEnd(mEST.getText());
InputMethodManager imm =
(InputMethodManager) mEST.getContext().getSystemService(
Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(mEST.getWindowToken(), 0, mSkr);
}
public void blockSoftKey() {
if (DBG) {
Log.d(LOG_TAG, "--- blockSoftKey:");
}
hideSoftKey();
mSoftKeyBlockFlag = true;
}
public void unblockSoftKey() {
if (DBG) {
Log.d(LOG_TAG, "--- unblockSoftKey:");
}
mSoftKeyBlockFlag = false;
}
}
private class StyledTextHtmlStandard implements StyledTextHtmlConverter {
public String toHtml(Spanned text) {
return Html.toHtml(text);
}
public String toHtml(Spanned text, boolean escapeNonAsciiChar) {
return Html.toHtml(text);
}
public String toHtml(Spanned text, boolean escapeNonAsciiChar, int width, float scale) {
return Html.toHtml(text);
}
public Spanned fromHtml(String source) {
return Html.fromHtml(source);
}
public Spanned fromHtml(String source, ImageGetter imageGetter, TagHandler tagHandler) {
return Html.fromHtml(source, imageGetter, tagHandler);
}
}
private class StyledTextConverter {
private EditStyledText mEST;
private StyledTextHtmlConverter mHtml;
public StyledTextConverter(EditStyledText est, StyledTextHtmlConverter html) {
mEST = est;
mHtml = html;
}
public void setStyledTextHtmlConverter(StyledTextHtmlConverter html) {
mHtml = html;
}
public String getHtml(boolean escapeFlag) {
mEST.clearComposingText();
mEST.onRefreshZeoWidthChar();
String htmlBody = mHtml.toHtml(mEST.getText(), escapeFlag);
if (DBG) {
Log.d(TAG, "--- getHtml:" + htmlBody);
}
return htmlBody;
}
public String getPreviewHtml() {
mEST.clearComposingText();
mEST.onRefreshZeoWidthChar();
String html =
mHtml.toHtml(mEST.getText(), true, getMaxImageWidthDip(),
getPaddingScale());
int bgColor = mEST.getBackgroundColor();
html =
String.format("<body bgcolor=\"#%02X%02X%02X\">%s</body>",
Color.red(bgColor), Color.green(bgColor), Color.blue(bgColor),
html);
if (DBG) {
Log.d(TAG, "--- getPreviewHtml:" + html + "," + mEST.getWidth());
}
return html;
}
public void getUriArray(ArrayList<Uri> uris, Editable text) {
uris.clear();
if (DBG) {
Log.d(TAG, "--- getUriArray:");
}
int len = text.length();
int next;
for (int i = 0; i < text.length(); i = next) {
next = text.nextSpanTransition(i, len, ImageSpan.class);
ImageSpan[] images = text.getSpans(i, next, ImageSpan.class);
for (int j = 0; j < images.length; j++) {
if (DBG) {
Log.d(TAG, "--- getUriArray: foundArray" + images[j].getSource());
}
uris.add(Uri.parse(images[j].getSource()));
}
}
}
public void SetHtml(String html) {
final Spanned spanned = mHtml.fromHtml(html, new Html.ImageGetter() {
public Drawable getDrawable(String src) {
Log.d(TAG, "--- sethtml: src=" + src);
if (src.startsWith("content://")) {
Uri uri = Uri.parse(src);
try {
Drawable drawable = null;
Bitmap bitmap = null;
System.gc();
InputStream is =
mEST.getContext().getContentResolver().openInputStream(uri);
BitmapFactory.Options opt = new BitmapFactory.Options();
opt.inJustDecodeBounds = true;
BitmapFactory.decodeStream(is, null, opt);
is.close();
is = mEST.getContext().getContentResolver().openInputStream(uri);
int width, height;
width = opt.outWidth;
height = opt.outHeight;
if (opt.outWidth > getMaxImageWidthPx()) {
width = getMaxImageWidthPx();
height = height * getMaxImageWidthPx() / opt.outWidth;
Rect padding = new Rect(0, 0, width, height);
bitmap = BitmapFactory.decodeStream(is, padding, null);
} else {
bitmap = BitmapFactory.decodeStream(is);
}
drawable = new BitmapDrawable(
mEST.getContext().getResources(), bitmap);
drawable.setBounds(0, 0, width, height);
is.close();
return drawable;
} catch (Exception e) {
Log.e(TAG, "--- set html: Failed to loaded content " + uri, e);
return null;
} catch (OutOfMemoryError e) {
Log.e(TAG, "OutOfMemoryError");
mEST.setHint(HINT_MSG_BIG_SIZE_ERROR);
return null;
}
}
return null;
}
}, null);
mEST.setText(spanned);
}
}
private static class SoftKeyReceiver extends ResultReceiver {
int mNewStart;
int mNewEnd;
EditStyledText mEST;
SoftKeyReceiver(EditStyledText est) {
super(est.getHandler());
mEST = est;
}
@Override
protected void onReceiveResult(int resultCode, Bundle resultData) {
if (resultCode != InputMethodManager.RESULT_SHOWN) {
Selection.setSelection(mEST.getText(), mNewStart, mNewEnd);
}
}
}
public static class SavedStyledTextState extends BaseSavedState {
public int mBackgroundColor;
SavedStyledTextState(Parcelable superState) {
super(superState);
}
@Override
public void writeToParcel(Parcel out, int flags) {
super.writeToParcel(out, flags);
out.writeInt(mBackgroundColor);
}
@Override
public String toString() {
return "EditStyledText.SavedState{"
+ Integer.toHexString(System.identityHashCode(this)) + " bgcolor="
+ mBackgroundColor + "}";
}
}
private static class StyledTextDialog {
private static final int TYPE_FOREGROUND = 0;
private static final int TYPE_BACKGROUND = 1;
private Builder mBuilder;
private AlertDialog mAlertDialog;
private CharSequence mColorTitle;
private CharSequence mSizeTitle;
private CharSequence mAlignTitle;
private CharSequence mMarqueeTitle;
private CharSequence[] mColorNames;
private CharSequence[] mColorInts;
private CharSequence[] mSizeNames;
private CharSequence[] mSizeDisplayInts;
private CharSequence[] mSizeSendInts;
private CharSequence[] mAlignNames;
private CharSequence[] mMarqueeNames;
private CharSequence mColorDefaultMessage;
private EditStyledText mEST;
public StyledTextDialog(EditStyledText est) {
mEST = est;
}
public void setBuilder(Builder builder) {
mBuilder = builder;
}
public void setColorAlertParams(CharSequence colortitle, CharSequence[] colornames,
CharSequence[] colorInts, CharSequence defaultColorMessage) {
mColorTitle = colortitle;
mColorNames = colornames;
mColorInts = colorInts;
mColorDefaultMessage = defaultColorMessage;
}
public void setSizeAlertParams(CharSequence sizetitle, CharSequence[] sizenames,
CharSequence[] sizedisplayints, CharSequence[] sizesendints) {
mSizeTitle = sizetitle;
mSizeNames = sizenames;
mSizeDisplayInts = sizedisplayints;
mSizeSendInts = sizesendints;
}
public void setAlignAlertParams(CharSequence aligntitle, CharSequence[] alignnames) {
mAlignTitle = aligntitle;
mAlignNames = alignnames;
}
public void setMarqueeAlertParams(CharSequence marqueetitle,
CharSequence[] marqueenames) {
mMarqueeTitle = marqueetitle;
mMarqueeNames = marqueenames;
}
private boolean checkColorAlertParams() {
if (DBG) {
Log.d(TAG, "--- checkParams");
}
if (mBuilder == null) {
Log.e(TAG, "--- builder is null.");
return false;
} else if (mColorTitle == null || mColorNames == null || mColorInts == null) {
Log.e(TAG, "--- color alert params are null.");
return false;
} else if (mColorNames.length != mColorInts.length) {
Log.e(TAG, "--- the length of color alert params are " + "different.");
return false;
}
return true;
}
private boolean checkSizeAlertParams() {
if (DBG) {
Log.d(TAG, "--- checkParams");
}
if (mBuilder == null) {
Log.e(TAG, "--- builder is null.");
return false;
} else if (mSizeTitle == null || mSizeNames == null || mSizeDisplayInts == null
|| mSizeSendInts == null) {
Log.e(TAG, "--- size alert params are null.");
return false;
} else if (mSizeNames.length != mSizeDisplayInts.length
&& mSizeSendInts.length != mSizeDisplayInts.length) {
Log.e(TAG, "--- the length of size alert params are " + "different.");
return false;
}
return true;
}
private boolean checkAlignAlertParams() {
if (DBG) {
Log.d(TAG, "--- checkAlignAlertParams");
}
if (mBuilder == null) {
Log.e(TAG, "--- builder is null.");
return false;
} else if (mAlignTitle == null) {
Log.e(TAG, "--- align alert params are null.");
return false;
}
return true;
}
private boolean checkMarqueeAlertParams() {
if (DBG) {
Log.d(TAG, "--- checkMarqueeAlertParams");
}
if (mBuilder == null) {
Log.e(TAG, "--- builder is null.");
return false;
} else if (mMarqueeTitle == null) {
Log.e(TAG, "--- Marquee alert params are null.");
return false;
}
return true;
}
private void buildDialogue(CharSequence title, CharSequence[] names,
DialogInterface.OnClickListener l) {
mBuilder.setTitle(title);
mBuilder.setIcon(0);
mBuilder.setPositiveButton(null, null);
mBuilder.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
mEST.onStartEdit();
}
});
mBuilder.setItems(names, l);
mBuilder.setView(null);
mBuilder.setCancelable(true);
mBuilder.setOnCancelListener(new OnCancelListener() {
public void onCancel(DialogInterface arg0) {
if (DBG) {
Log.d(TAG, "--- oncancel");
}
mEST.onStartEdit();
}
});
mBuilder.show();
}
private void buildAndShowColorDialogue(int type, CharSequence title, int[] colors) {
final int HORIZONTAL_ELEMENT_NUM = 5;
final int BUTTON_SIZE = mEST.dipToPx(50);
final int BUTTON_MERGIN = mEST.dipToPx(2);
final int BUTTON_PADDING = mEST.dipToPx(15);
mBuilder.setTitle(title);
mBuilder.setIcon(0);
mBuilder.setPositiveButton(null, null);
mBuilder.setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
mEST.onStartEdit();
}
});
mBuilder.setItems(null, null);
LinearLayout verticalLayout = new LinearLayout(mEST.getContext());
verticalLayout.setOrientation(LinearLayout.VERTICAL);
verticalLayout.setGravity(Gravity.CENTER_HORIZONTAL);
verticalLayout.setPadding(BUTTON_PADDING, BUTTON_PADDING, BUTTON_PADDING,
BUTTON_PADDING);
LinearLayout horizontalLayout = null;
for (int i = 0; i < colors.length; i++) {
if (i % HORIZONTAL_ELEMENT_NUM == 0) {
horizontalLayout = new LinearLayout(mEST.getContext());
verticalLayout.addView(horizontalLayout);
}
Button button = new Button(mEST.getContext());
button.setHeight(BUTTON_SIZE);
button.setWidth(BUTTON_SIZE);
ColorPaletteDrawable cp =
new ColorPaletteDrawable(colors[i], BUTTON_SIZE, BUTTON_SIZE,
BUTTON_MERGIN);
button.setBackgroundDrawable(cp);
button.setDrawingCacheBackgroundColor(colors[i]);
if (type == TYPE_FOREGROUND) {
button.setOnClickListener(new View.OnClickListener() {
public void onClick(View view) {
mEST.setItemColor(view.getDrawingCacheBackgroundColor());
if (mAlertDialog != null) {
mAlertDialog.setView(null);
mAlertDialog.dismiss();
mAlertDialog = null;
} else {
Log.e(TAG,
"--- buildAndShowColorDialogue: can't find alertDialog");
}
}
});
} else if (type == TYPE_BACKGROUND) {
button.setOnClickListener(new View.OnClickListener() {
public void onClick(View view) {
mEST.setBackgroundColor(view.getDrawingCacheBackgroundColor());
if (mAlertDialog != null) {
mAlertDialog.setView(null);
mAlertDialog.dismiss();
mAlertDialog = null;
} else {
Log.e(TAG,
"--- buildAndShowColorDialogue: can't find alertDialog");
}
}
});
}
horizontalLayout.addView(button);
}
if (type == TYPE_BACKGROUND) {
mBuilder.setPositiveButton(mColorDefaultMessage,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
mEST.setBackgroundColor(DEFAULT_TRANSPARENT_COLOR);
}
});
} else if (type == TYPE_FOREGROUND) {
mBuilder.setPositiveButton(mColorDefaultMessage,
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
mEST.setItemColor(DEFAULT_FOREGROUND_COLOR);
}
});
}
mBuilder.setView(verticalLayout);
mBuilder.setCancelable(true);
mBuilder.setOnCancelListener(new OnCancelListener() {
public void onCancel(DialogInterface arg0) {
mEST.onStartEdit();
}
});
mAlertDialog = mBuilder.show();
}
private void onShowForegroundColorAlertDialog() {
if (DBG) {
Log.d(TAG, "--- onShowForegroundColorAlertDialog");
}
if (!checkColorAlertParams()) {
return;
}
int[] colorints = new int[mColorInts.length];
for (int i = 0; i < colorints.length; i++) {
colorints[i] = Integer.parseInt((String) mColorInts[i], 16) - 0x01000000;
}
buildAndShowColorDialogue(TYPE_FOREGROUND, mColorTitle, colorints);
}
private void onShowBackgroundColorAlertDialog() {
if (DBG) {
Log.d(TAG, "--- onShowBackgroundColorAlertDialog");
}
if (!checkColorAlertParams()) {
return;
}
int[] colorInts = new int[mColorInts.length];
for (int i = 0; i < colorInts.length; i++) {
colorInts[i] = Integer.parseInt((String) mColorInts[i], 16) - 0x01000000;
}
buildAndShowColorDialogue(TYPE_BACKGROUND, mColorTitle, colorInts);
}
private void onShowSizeAlertDialog() {
if (DBG) {
Log.d(TAG, "--- onShowSizeAlertDialog");
}
if (!checkSizeAlertParams()) {
return;
}
buildDialogue(mSizeTitle, mSizeNames, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
Log.d(TAG, "mBuilder.onclick:" + which);
int size =
mEST.dipToPx(Integer.parseInt((String) mSizeDisplayInts[which]));
mEST.setItemSize(size);
}
});
}
private void onShowAlignAlertDialog() {
if (DBG) {
Log.d(TAG, "--- onShowAlignAlertDialog");
}
if (!checkAlignAlertParams()) {
return;
}
buildDialogue(mAlignTitle, mAlignNames, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
Layout.Alignment align = Layout.Alignment.ALIGN_NORMAL;
switch (which) {
case 0:
align = Layout.Alignment.ALIGN_NORMAL;
break;
case 1:
align = Layout.Alignment.ALIGN_CENTER;
break;
case 2:
align = Layout.Alignment.ALIGN_OPPOSITE;
break;
default:
Log.e(TAG, "--- onShowAlignAlertDialog: got illigal align.");
break;
}
mEST.setAlignment(align);
}
});
}
private void onShowMarqueeAlertDialog() {
if (DBG) {
Log.d(TAG, "--- onShowMarqueeAlertDialog");
}
if (!checkMarqueeAlertParams()) {
return;
}
buildDialogue(mMarqueeTitle, mMarqueeNames, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
if (DBG) {
Log.d(TAG, "mBuilder.onclick:" + which);
}
mEST.setMarquee(which);
}
});
}
}
private class MenuHandler implements MenuItem.OnMenuItemClickListener {
public boolean onMenuItemClick(MenuItem item) {
return onTextContextMenuItem(item.getItemId());
}
}
private static class StyledTextArrowKeyMethod extends ArrowKeyMovementMethod {
EditorManager mManager;
String LOG_TAG = "StyledTextArrowKeyMethod";
StyledTextArrowKeyMethod(EditorManager manager) {
super();
mManager = manager;
}
@Override
public boolean
onKeyDown(TextView widget, Spannable buffer, int keyCode, KeyEvent event) {
if (DBG) {
Log.d(LOG_TAG, "---onkeydown:" + keyCode);
}
mManager.unsetTextComposingMask();
if (mManager.getSelectState() == STATE_SELECT_ON
|| mManager.getSelectState() == STATE_SELECTED) {
return executeDown(widget, buffer, keyCode);
} else {
return super.onKeyDown(widget, buffer, keyCode, event);
}
}
private int getEndPos(TextView widget) {
int end;
if (widget.getSelectionStart() == mManager.getSelectionStart()) {
end = widget.getSelectionEnd();
} else {
end = widget.getSelectionStart();
}
return end;
}
protected boolean up(TextView widget, Spannable buffer) {
if (DBG) {
Log.d(LOG_TAG, "--- up:");
}
Layout layout = widget.getLayout();
int end = getEndPos(widget);
int line = layout.getLineForOffset(end);
if (line > 0) {
int to;
if (layout.getParagraphDirection(line) == layout
.getParagraphDirection(line - 1)) {
float h = layout.getPrimaryHorizontal(end);
to = layout.getOffsetForHorizontal(line - 1, h);
} else {
to = layout.getLineStart(line - 1);
}
mManager.setEndPos(to);
mManager.onCursorMoved();
}
return true;
}
protected boolean down(TextView widget, Spannable buffer) {
if (DBG) {
Log.d(LOG_TAG, "--- down:");
}
Layout layout = widget.getLayout();
int end = getEndPos(widget);
int line = layout.getLineForOffset(end);
if (line < layout.getLineCount() - 1) {
int to;
if (layout.getParagraphDirection(line) == layout
.getParagraphDirection(line + 1)) {
float h = layout.getPrimaryHorizontal(end);
to = layout.getOffsetForHorizontal(line + 1, h);
} else {
to = layout.getLineStart(line + 1);
}
mManager.setEndPos(to);
mManager.onCursorMoved();
}
return true;
}
protected boolean left(TextView widget, Spannable buffer) {
if (DBG) {
Log.d(LOG_TAG, "--- left:");
}
Layout layout = widget.getLayout();
int to = layout.getOffsetToLeftOf(getEndPos(widget));
mManager.setEndPos(to);
mManager.onCursorMoved();
return true;
}
protected boolean right(TextView widget, Spannable buffer) {
if (DBG) {
Log.d(LOG_TAG, "--- right:");
}
Layout layout = widget.getLayout();
int to = layout.getOffsetToRightOf(getEndPos(widget));
mManager.setEndPos(to);
mManager.onCursorMoved();
return true;
}
private boolean executeDown(TextView widget, Spannable buffer, int keyCode) {
if (DBG) {
Log.d(LOG_TAG, "--- executeDown: " + keyCode);
}
boolean handled = false;
switch (keyCode) {
case KeyEvent.KEYCODE_DPAD_UP:
handled |= up(widget, buffer);
break;
case KeyEvent.KEYCODE_DPAD_DOWN:
handled |= down(widget, buffer);
break;
case KeyEvent.KEYCODE_DPAD_LEFT:
handled |= left(widget, buffer);
break;
case KeyEvent.KEYCODE_DPAD_RIGHT:
handled |= right(widget, buffer);
break;
case KeyEvent.KEYCODE_DPAD_CENTER:
mManager.onFixSelectedItem();
handled = true;
break;
}
return handled;
}
}
public static class StyledTextInputConnection extends InputConnectionWrapper {
EditStyledText mEST;
public StyledTextInputConnection(InputConnection target, EditStyledText est) {
super(target, true);
mEST = est;
}
@Override
public boolean commitText(CharSequence text, int newCursorPosition) {
if (DBG) {
Log.d(TAG, "--- commitText:");
}
mEST.mManager.unsetTextComposingMask();
return super.commitText(text, newCursorPosition);
}
@Override
public boolean finishComposingText() {
if (DBG) {
Log.d(TAG, "--- finishcomposing:");
}
if (!mEST.isSoftKeyBlocked() && !mEST.isButtonsFocused() && !mEST.isEditting()) {
// TODO onEndEdit isn't called temporally .
mEST.onEndEdit();
}
return super.finishComposingText();
}
}
public static class EditStyledTextSpans {
private static final String LOG_TAG = "EditStyledTextSpan";
public static class HorizontalLineSpan extends DynamicDrawableSpan {
HorizontalLineDrawable mDrawable;
public HorizontalLineSpan(int color, int width, Spannable spannable) {
super(ALIGN_BOTTOM);
mDrawable = new HorizontalLineDrawable(color, width, spannable);
}
@Override
public Drawable getDrawable() {
return mDrawable;
}
public void resetWidth(int width) {
mDrawable.renewBounds(width);
}
public int getColor() {
return mDrawable.getPaint().getColor();
}
}
public static class MarqueeSpan extends CharacterStyle {
public static final int SCROLL = 0;
public static final int ALTERNATE = 1;
public static final int NOTHING = 2;
private int mType;
private int mMarqueeColor;
public MarqueeSpan(int type, int bgc) {
mType = type;
checkType(type);
mMarqueeColor = getMarqueeColor(type, bgc);
}
public MarqueeSpan(int type) {
this(type, EditStyledText.DEFAULT_TRANSPARENT_COLOR);
}
public int getType() {
return mType;
}
public void resetColor(int bgc) {
mMarqueeColor = getMarqueeColor(mType, bgc);
}
private int getMarqueeColor(int type, int bgc) {
int THRESHOLD = 128;
int a = Color.alpha(bgc);
int r = Color.red(bgc);
int g = Color.green(bgc);
int b = Color.blue(bgc);
if (a == 0) {
a = 0x80;
}
switch (type) {
case SCROLL:
if (r > THRESHOLD) {
r = r / 2;
} else {
r = (0XFF - r) / 2;
}
break;
case ALTERNATE:
if (g > THRESHOLD) {
g = g / 2;
} else {
g = (0XFF - g) / 2;
}
break;
case NOTHING:
return DEFAULT_TRANSPARENT_COLOR;
default:
Log.e(TAG, "--- getMarqueeColor: got illigal marquee ID.");
return DEFAULT_TRANSPARENT_COLOR;
}
return Color.argb(a, r, g, b);
}
private boolean checkType(int type) {
if (type == SCROLL || type == ALTERNATE) {
return true;
} else {
Log.e(LOG_TAG, "--- Invalid type of MarqueeSpan");
return false;
}
}
@Override
public void updateDrawState(TextPaint tp) {
tp.bgColor = mMarqueeColor;
}
}
public static class RescalableImageSpan extends ImageSpan {
Uri mContentUri;
private Drawable mDrawable;
private Context mContext;
public int mIntrinsicWidth = -1;
public int mIntrinsicHeight = -1;
private final int MAXWIDTH;
public RescalableImageSpan(Context context, Uri uri, int maxwidth) {
super(context, uri);
mContext = context;
mContentUri = uri;
MAXWIDTH = maxwidth;
}
public RescalableImageSpan(Context context, int resourceId, int maxwidth) {
super(context, resourceId);
mContext = context;
MAXWIDTH = maxwidth;
}
@Override
public Drawable getDrawable() {
if (mDrawable != null) {
return mDrawable;
} else if (mContentUri != null) {
Bitmap bitmap = null;
System.gc();
try {
InputStream is =
mContext.getContentResolver().openInputStream(mContentUri);
BitmapFactory.Options opt = new BitmapFactory.Options();
opt.inJustDecodeBounds = true;
BitmapFactory.decodeStream(is, null, opt);
is.close();
is = mContext.getContentResolver().openInputStream(mContentUri);
int width, height;
width = opt.outWidth;
height = opt.outHeight;
mIntrinsicWidth = width;
mIntrinsicHeight = height;
if (opt.outWidth > MAXWIDTH) {
width = MAXWIDTH;
height = height * MAXWIDTH / opt.outWidth;
Rect padding = new Rect(0, 0, width, height);
bitmap = BitmapFactory.decodeStream(is, padding, null);
} else {
bitmap = BitmapFactory.decodeStream(is);
}
mDrawable = new BitmapDrawable(mContext.getResources(), bitmap);
mDrawable.setBounds(0, 0, width, height);
is.close();
} catch (Exception e) {
Log.e(LOG_TAG, "Failed to loaded content " + mContentUri, e);
return null;
} catch (OutOfMemoryError e) {
Log.e(LOG_TAG, "OutOfMemoryError");
return null;
}
} else {
mDrawable = super.getDrawable();
rescaleBigImage(mDrawable);
mIntrinsicWidth = mDrawable.getIntrinsicWidth();
mIntrinsicHeight = mDrawable.getIntrinsicHeight();
}
return mDrawable;
}
public boolean isOverSize() {
return (getDrawable().getIntrinsicWidth() > MAXWIDTH);
}
public Uri getContentUri() {
return mContentUri;
}
private void rescaleBigImage(Drawable image) {
if (DBG) {
Log.d(LOG_TAG, "--- rescaleBigImage:");
}
if (MAXWIDTH < 0) {
return;
}
int image_width = image.getIntrinsicWidth();
int image_height = image.getIntrinsicHeight();
if (DBG) {
Log.d(LOG_TAG, "--- rescaleBigImage:" + image_width + "," + image_height
+ "," + MAXWIDTH);
}
if (image_width > MAXWIDTH) {
image_width = MAXWIDTH;
image_height = image_height * MAXWIDTH / image_width;
}
image.setBounds(0, 0, image_width, image_height);
}
}
public static class HorizontalLineDrawable extends ShapeDrawable {
private Spannable mSpannable;
private int mWidth;
private static boolean DBG_HL = false;
public HorizontalLineDrawable(int color, int width, Spannable spannable) {
super(new RectShape());
mSpannable = spannable;
mWidth = width;
renewColor(color);
renewBounds(width);
}
@Override
public void draw(Canvas canvas) {
renewColor();
Rect rect = new Rect(0, 9, mWidth, 11);
canvas.drawRect(rect, getPaint());
}
public void renewBounds(int width) {
int MARGIN = 20;
int HEIGHT = 20;
if (DBG_HL) {
Log.d(LOG_TAG, "--- renewBounds:" + width);
}
if (width > MARGIN) {
width -= MARGIN;
}
mWidth = width;
setBounds(0, 0, width, HEIGHT);
}
private void renewColor(int color) {
if (DBG_HL) {
Log.d(LOG_TAG, "--- renewColor:" + color);
}
getPaint().setColor(color);
}
private void renewColor() {
HorizontalLineSpan parent = getParentSpan();
Spannable text = mSpannable;
int start = text.getSpanStart(parent);
int end = text.getSpanEnd(parent);
ForegroundColorSpan[] spans =
text.getSpans(start, end, ForegroundColorSpan.class);
if (DBG_HL) {
Log.d(LOG_TAG, "--- renewColor:" + spans.length);
}
if (spans.length > 0) {
renewColor(spans[spans.length - 1].getForegroundColor());
}
}
private HorizontalLineSpan getParentSpan() {
Spannable text = mSpannable;
HorizontalLineSpan[] images =
text.getSpans(0, text.length(), HorizontalLineSpan.class);
if (images.length > 0) {
for (HorizontalLineSpan image : images) {
if (image.getDrawable() == this) {
return image;
}
}
}
Log.e(LOG_TAG, "---renewBounds: Couldn't find");
return null;
}
}
}
public static class ColorPaletteDrawable extends ShapeDrawable {
private Rect mRect;
public ColorPaletteDrawable(int color, int width, int height, int mergin) {
super(new RectShape());
mRect = new Rect(mergin, mergin, width - mergin, height - mergin);
getPaint().setColor(color);
}
@Override
public void draw(Canvas canvas) {
canvas.drawRect(mRect, getPaint());
}
}
public class EditModeActions {
private static final String TAG = "EditModeActions";
private static final boolean DBG = true;
private EditStyledText mEST;
private EditorManager mManager;
private StyledTextDialog mDialog;
private int mMode = EditStyledText.MODE_NOTHING;
private HashMap<Integer, EditModeActionBase> mActionMap =
new HashMap<Integer, EditModeActionBase>();
private NothingAction mNothingAction = new NothingAction();
private CopyAction mCopyAction = new CopyAction();
private PasteAction mPasteAction = new PasteAction();
private SelectAction mSelectAction = new SelectAction();
private CutAction mCutAction = new CutAction();
private SelectAllAction mSelectAllAction = new SelectAllAction();
private HorizontalLineAction mHorizontalLineAction = new HorizontalLineAction();
private StopSelectionAction mStopSelectionAction = new StopSelectionAction();
private ClearStylesAction mClearStylesAction = new ClearStylesAction();
private ImageAction mImageAction = new ImageAction();
private BackgroundColorAction mBackgroundColorAction = new BackgroundColorAction();
private PreviewAction mPreviewAction = new PreviewAction();
private CancelAction mCancelEditAction = new CancelAction();
private TextViewAction mTextViewAction = new TextViewAction();
private StartEditAction mStartEditAction = new StartEditAction();
private EndEditAction mEndEditAction = new EndEditAction();
private ResetAction mResetAction = new ResetAction();
private ShowMenuAction mShowMenuAction = new ShowMenuAction();
private AlignAction mAlignAction = new AlignAction();
private TelopAction mTelopAction = new TelopAction();
private SwingAction mSwingAction = new SwingAction();
private MarqueeDialogAction mMarqueeDialogAction = new MarqueeDialogAction();
private ColorAction mColorAction = new ColorAction();
private SizeAction mSizeAction = new SizeAction();
EditModeActions(EditStyledText est, EditorManager manager, StyledTextDialog dialog) {
mEST = est;
mManager = manager;
mDialog = dialog;
mActionMap.put(EditStyledText.MODE_NOTHING, mNothingAction);
mActionMap.put(EditStyledText.MODE_COPY, mCopyAction);
mActionMap.put(EditStyledText.MODE_PASTE, mPasteAction);
mActionMap.put(EditStyledText.MODE_SELECT, mSelectAction);
mActionMap.put(EditStyledText.MODE_CUT, mCutAction);
mActionMap.put(EditStyledText.MODE_SELECTALL, mSelectAllAction);
mActionMap.put(EditStyledText.MODE_HORIZONTALLINE, mHorizontalLineAction);
mActionMap.put(EditStyledText.MODE_STOP_SELECT, mStopSelectionAction);
mActionMap.put(EditStyledText.MODE_CLEARSTYLES, mClearStylesAction);
mActionMap.put(EditStyledText.MODE_IMAGE, mImageAction);
mActionMap.put(EditStyledText.MODE_BGCOLOR, mBackgroundColorAction);
mActionMap.put(EditStyledText.MODE_PREVIEW, mPreviewAction);
mActionMap.put(EditStyledText.MODE_CANCEL, mCancelEditAction);
mActionMap.put(EditStyledText.MODE_TEXTVIEWFUNCTION, mTextViewAction);
mActionMap.put(EditStyledText.MODE_START_EDIT, mStartEditAction);
mActionMap.put(EditStyledText.MODE_END_EDIT, mEndEditAction);
mActionMap.put(EditStyledText.MODE_RESET, mResetAction);
mActionMap.put(EditStyledText.MODE_SHOW_MENU, mShowMenuAction);
mActionMap.put(EditStyledText.MODE_ALIGN, mAlignAction);
mActionMap.put(EditStyledText.MODE_TELOP, mTelopAction);
mActionMap.put(EditStyledText.MODE_SWING, mSwingAction);
mActionMap.put(EditStyledText.MODE_MARQUEE, mMarqueeDialogAction);
mActionMap.put(EditStyledText.MODE_COLOR, mColorAction);
mActionMap.put(EditStyledText.MODE_SIZE, mSizeAction);
}
public void addAction(int modeId, EditModeActionBase action) {
mActionMap.put(modeId, action);
}
public void onAction(int newMode, Object[] params) {
getAction(newMode).addParams(params);
mMode = newMode;
doNext(newMode);
}
public void onAction(int newMode, Object param) {
onAction(newMode, new Object[] { param });
}
public void onAction(int newMode) {
onAction(newMode, null);
}
public void onSelectAction() {
doNext(EditStyledText.MODE_SELECT);
}
private EditModeActionBase getAction(int mode) {
if (mActionMap.containsKey(mode)) {
return mActionMap.get(mode);
}
return null;
}
public boolean doNext() {
return doNext(mMode);
}
public boolean doNext(int mode) {
if (DBG) {
Log.d(TAG, "--- do the next action: " + mode + "," + mManager.getSelectState());
}
EditModeActionBase action = getAction(mode);
if (action == null) {
Log.e(TAG, "--- invalid action error.");
return false;
}
switch (mManager.getSelectState()) {
case EditStyledText.STATE_SELECT_OFF:
return action.doNotSelected();
case EditStyledText.STATE_SELECT_ON:
return action.doStartPosIsSelected();
case EditStyledText.STATE_SELECTED:
return action.doEndPosIsSelected();
case EditStyledText.STATE_SELECT_FIX:
if (mManager.isWaitInput()) {
return action.doSelectionIsFixedAndWaitingInput();
} else {
return action.doSelectionIsFixed();
}
default:
return false;
}
}
public class EditModeActionBase {
private Object[] mParams;
protected boolean canOverWrap() {
return false;
}
protected boolean canSelect() {
return false;
}
protected boolean canWaitInput() {
return false;
}
protected boolean needSelection() {
return false;
}
protected boolean isLine() {
return false;
}
protected boolean doNotSelected() {
return false;
}
protected boolean doStartPosIsSelected() {
return doNotSelected();
}
protected boolean doEndPosIsSelected() {
return doStartPosIsSelected();
}
protected boolean doSelectionIsFixed() {
return doEndPosIsSelected();
}
protected boolean doSelectionIsFixedAndWaitingInput() {
return doEndPosIsSelected();
}
protected boolean fixSelection() {
mEST.finishComposingText();
mManager.setSelectState(EditStyledText.STATE_SELECT_FIX);
return true;
}
protected void addParams(Object[] o) {
mParams = o;
}
protected Object getParam(int num) {
if (mParams == null || num > mParams.length) {
if (DBG) {
Log.d(TAG, "--- Number of the parameter is out of bound.");
}
return null;
} else {
return mParams[num];
}
}
}
public class NothingAction extends EditModeActionBase {
}
public class TextViewActionBase extends EditModeActionBase {
@Override
protected boolean doNotSelected() {
if (mManager.getEditMode() == EditStyledText.MODE_NOTHING
|| mManager.getEditMode() == EditStyledText.MODE_SELECT) {
mManager.setEditMode(mMode);
onSelectAction();
return true;
}
return false;
}
@Override
protected boolean doEndPosIsSelected() {
if (mManager.getEditMode() == EditStyledText.MODE_NOTHING
|| mManager.getEditMode() == EditStyledText.MODE_SELECT) {
mManager.setEditMode(mMode);
fixSelection();
doNext();
return true;
} else if (mManager.getEditMode() != mMode) {
mManager.resetEdit();
mManager.setEditMode(mMode);
doNext();
return true;
}
return false;
}
}
public class TextViewAction extends TextViewActionBase {
@Override
protected boolean doEndPosIsSelected() {
if (super.doEndPosIsSelected()) {
return true;
}
Object param = getParam(0);
if (param != null && param instanceof Integer) {
mEST.onTextContextMenuItem((Integer) param);
}
mManager.resetEdit();
return true;
}
}
public class CopyAction extends TextViewActionBase {
@Override
protected boolean doEndPosIsSelected() {
if (super.doEndPosIsSelected()) {
return true;
}
mManager.copyToClipBoard();
mManager.resetEdit();
return true;
}
}
public class CutAction extends TextViewActionBase {
@Override
protected boolean doEndPosIsSelected() {
if (super.doEndPosIsSelected()) {
return true;
}
mManager.cutToClipBoard();
mManager.resetEdit();
return true;
}
}
public class SelectAction extends EditModeActionBase {
@Override
protected boolean doNotSelected() {
if (mManager.isTextSelected()) {
Log.e(TAG, "Selection is off, but selected");
}
mManager.setSelectStartPos();
mEST.sendHintMessage(EditStyledText.HINT_MSG_SELECT_END);
return true;
}
@Override
protected boolean doStartPosIsSelected() {
if (mManager.isTextSelected()) {
Log.e(TAG, "Selection now start, but selected");
}
mManager.setSelectEndPos();
mEST.sendHintMessage(EditStyledText.HINT_MSG_PUSH_COMPETE);
if (mManager.getEditMode() != EditStyledText.MODE_SELECT) {
doNext(mManager.getEditMode()); // doNextHandle needs edit mode in editor.
}
return true;
}
@Override
protected boolean doSelectionIsFixed() {
return false;
}
}
public class PasteAction extends EditModeActionBase {
@Override
protected boolean doNotSelected() {
mManager.pasteFromClipboard();
mManager.resetEdit();
return true;
}
}
public class SelectAllAction extends EditModeActionBase {
@Override
protected boolean doNotSelected() {
mManager.selectAll();
return true;
}
}
public class HorizontalLineAction extends EditModeActionBase {
@Override
protected boolean doNotSelected() {
mManager.insertHorizontalLine();
return true;
}
}
public class ClearStylesAction extends EditModeActionBase {
@Override
protected boolean doNotSelected() {
mManager.clearStyles();
return true;
}
}
public class StopSelectionAction extends EditModeActionBase {
@Override
protected boolean doNotSelected() {
mManager.fixSelectionAndDoNextAction();
return true;
}
}
public class CancelAction extends EditModeActionBase {
@Override
protected boolean doNotSelected() {
mEST.cancelViewManagers();
return true;
}
}
public class ImageAction extends EditModeActionBase {
@Override
protected boolean doNotSelected() {
Object param = getParam(0);
if (param != null) {
if (param instanceof Uri) {
mManager.insertImageFromUri((Uri) param);
} else if (param instanceof Integer) {
mManager.insertImageFromResId((Integer) param);
}
} else {
mEST.showInsertImageSelectAlertDialog();
}
return true;
}
}
public class BackgroundColorAction extends EditModeActionBase {
@Override
protected boolean doNotSelected() {
mDialog.onShowBackgroundColorAlertDialog();
return true;
}
}
public class PreviewAction extends EditModeActionBase {
@Override
protected boolean doNotSelected() {
mEST.showPreview();
return true;
}
}
public class StartEditAction extends EditModeActionBase {
@Override
protected boolean doNotSelected() {
mManager.startEdit();
return true;
}
}
public class EndEditAction extends EditModeActionBase {
@Override
protected boolean doNotSelected() {
mManager.endEdit();
return true;
}
}
public class ResetAction extends EditModeActionBase {
@Override
protected boolean doNotSelected() {
mManager.resetEdit();
return true;
}
}
public class ShowMenuAction extends EditModeActionBase {
@Override
protected boolean doNotSelected() {
mEST.showMenuAlertDialog();
return true;
}
}
public class SetSpanActionBase extends EditModeActionBase {
@Override
protected boolean doNotSelected() {
if (mManager.getEditMode() == EditStyledText.MODE_NOTHING
|| mManager.getEditMode() == EditStyledText.MODE_SELECT) {
mManager.setEditMode(mMode);
mManager.setInternalSelection(mEST.getSelectionStart(),
mEST.getSelectionEnd());
fixSelection();
doNext();
return true;
} else if (mManager.getEditMode() != mMode) {
Log.d(TAG, "--- setspanactionbase" + mManager.getEditMode() + "," + mMode);
if (!mManager.isWaitInput()) {
mManager.resetEdit();
mManager.setEditMode(mMode);
} else {
mManager.setEditMode(EditStyledText.MODE_NOTHING);
mManager.setSelectState(EditStyledText.STATE_SELECT_OFF);
}
doNext();
return true;
}
return false;
}
@Override
protected boolean doStartPosIsSelected() {
if (mManager.getEditMode() == EditStyledText.MODE_NOTHING
|| mManager.getEditMode() == EditStyledText.MODE_SELECT) {
mManager.setEditMode(mMode);
onSelectAction();
return true;
}
return doNotSelected();
}
@Override
protected boolean doEndPosIsSelected() {
if (mManager.getEditMode() == EditStyledText.MODE_NOTHING
|| mManager.getEditMode() == EditStyledText.MODE_SELECT) {
mManager.setEditMode(mMode);
fixSelection();
doNext();
return true;
}
return doStartPosIsSelected();
}
@Override
protected boolean doSelectionIsFixed() {
if (doEndPosIsSelected()) {
return true;
}
mEST.sendHintMessage(EditStyledText.HINT_MSG_NULL);
return false;
}
}
public class AlignAction extends SetSpanActionBase {
@Override
protected boolean doSelectionIsFixed() {
if (super.doSelectionIsFixed()) {
return true;
}
mDialog.onShowAlignAlertDialog();
return true;
}
}
public class TelopAction extends SetSpanActionBase {
@Override
protected boolean doSelectionIsFixed() {
if (super.doSelectionIsFixed()) {
return true;
}
mManager.setTelop();
return true;
}
}
public class SwingAction extends SetSpanActionBase {
@Override
protected boolean doSelectionIsFixed() {
if (super.doSelectionIsFixed()) {
return true;
}
mManager.setSwing();
return true;
}
}
public class MarqueeDialogAction extends SetSpanActionBase {
@Override
protected boolean doSelectionIsFixed() {
if (super.doSelectionIsFixed()) {
return true;
}
mDialog.onShowMarqueeAlertDialog();
return true;
}
}
public class ColorAction extends SetSpanActionBase {
@Override
protected boolean doSelectionIsFixed() {
if (super.doSelectionIsFixed()) {
return true;
}
mDialog.onShowForegroundColorAlertDialog();
return true;
}
@Override
protected boolean doSelectionIsFixedAndWaitingInput() {
if (super.doSelectionIsFixedAndWaitingInput()) {
return true;
}
int size = mManager.getSizeWaitInput();
mManager.setItemColor(mManager.getColorWaitInput(), false);
// selection was resumed
if (!mManager.isWaitInput()) {
mManager.setItemSize(size, false);
mManager.resetEdit();
} else {
fixSelection();
mDialog.onShowForegroundColorAlertDialog();
}
return true;
}
}
public class SizeAction extends SetSpanActionBase {
@Override
protected boolean doSelectionIsFixed() {
if (super.doSelectionIsFixed()) {
return true;
}
mDialog.onShowSizeAlertDialog();
return true;
}
@Override
protected boolean doSelectionIsFixedAndWaitingInput() {
if (super.doSelectionIsFixedAndWaitingInput()) {
return true;
}
int color = mManager.getColorWaitInput();
mManager.setItemSize(mManager.getSizeWaitInput(), false);
if (!mManager.isWaitInput()) {
mManager.setItemColor(color, false);
mManager.resetEdit();
} else {
fixSelection();
mDialog.onShowSizeAlertDialog();
}
return true;
}
}
}
}
|
