| package org.wordpress.android.editor; |
| |
| import android.app.AlertDialog; |
| import android.content.Context; |
| import android.content.DialogInterface; |
| import android.content.Intent; |
| import android.content.res.Configuration; |
| import android.graphics.Bitmap; |
| import android.graphics.BitmapFactory; |
| import android.graphics.Typeface; |
| import android.net.Uri; |
| import android.os.AsyncTask; |
| import android.os.Bundle; |
| import android.os.Parcelable; |
| import android.support.v7.app.ActionBar; |
| import android.support.v7.app.AppCompatActivity; |
| import android.text.Editable; |
| import android.text.Layout; |
| import android.text.Selection; |
| import android.text.Spannable; |
| import android.text.Spanned; |
| import android.text.TextUtils; |
| import android.text.TextWatcher; |
| import android.text.method.ArrowKeyMovementMethod; |
| import android.text.style.AlignmentSpan; |
| import android.text.style.QuoteSpan; |
| import android.text.style.StrikethroughSpan; |
| import android.text.style.StyleSpan; |
| import android.text.style.URLSpan; |
| import android.view.KeyEvent; |
| import android.view.LayoutInflater; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.ViewTreeObserver; |
| import android.view.WindowManager; |
| import android.view.animation.AlphaAnimation; |
| import android.view.animation.Animation; |
| import android.view.inputmethod.EditorInfo; |
| import android.view.inputmethod.InputMethodManager; |
| import android.webkit.URLUtil; |
| import android.widget.ArrayAdapter; |
| import android.widget.Button; |
| import android.widget.CheckBox; |
| import android.widget.CompoundButton; |
| import android.widget.EditText; |
| import android.widget.LinearLayout; |
| import android.widget.SeekBar; |
| import android.widget.Spinner; |
| import android.widget.TextView; |
| import android.widget.ToggleButton; |
| |
| import com.android.volley.VolleyError; |
| import com.android.volley.toolbox.ImageLoader; |
| |
| import org.wordpress.android.editor.legacy.EditLinkActivity; |
| import org.wordpress.android.editor.legacy.WPEditImageSpan; |
| import org.wordpress.android.util.AppLog; |
| import org.wordpress.android.util.AppLog.T; |
| import org.wordpress.android.util.DisplayUtils; |
| import org.wordpress.android.util.ImageUtils; |
| import org.wordpress.android.util.MediaUtils; |
| import org.wordpress.android.util.ToastUtils; |
| import org.wordpress.android.util.ToastUtils.Duration; |
| import org.wordpress.android.util.helpers.MediaFile; |
| import org.wordpress.android.util.helpers.MediaGallery; |
| import org.wordpress.android.util.helpers.MediaGalleryImageSpan; |
| import org.wordpress.android.util.helpers.WPImageSpan; |
| import org.wordpress.android.util.helpers.WPUnderlineSpan; |
| import org.wordpress.android.util.widgets.WPEditText; |
| |
| import java.util.Locale; |
| |
| public class LegacyEditorFragment extends EditorFragmentAbstract implements TextWatcher, |
| WPEditText.OnSelectionChangedListener, View.OnTouchListener { |
| public static final int ACTIVITY_REQUEST_CODE_CREATE_LINK = 4; |
| public static final String ACTION_MEDIA_GALLERY_TOUCHED = "MEDIA_GALLERY_TOUCHED"; |
| public static final String EXTRA_MEDIA_GALLERY = "EXTRA_MEDIA_GALLERY"; |
| |
| private static final int MIN_THUMBNAIL_WIDTH = 200; |
| private static final int CONTENT_ANIMATION_DURATION = 250; |
| private static final String KEY_IMAGE_SPANS = "image-spans"; |
| private static final String KEY_START = "start"; |
| private static final String KEY_END = "end"; |
| private static final String KEY_CONTENT = "content"; |
| private static final String TAG_FORMAT_BAR_BUTTON_STRONG = "strong"; |
| private static final String TAG_FORMAT_BAR_BUTTON_EM = "em"; |
| private static final String TAG_FORMAT_BAR_BUTTON_UNDERLINE = "u"; |
| private static final String TAG_FORMAT_BAR_BUTTON_STRIKE = "strike"; |
| private static final String TAG_FORMAT_BAR_BUTTON_QUOTE = "blockquote"; |
| |
| private View mRootView; |
| private WPEditText mContentEditText; |
| private EditText mTitleEditText; |
| private ToggleButton mBoldToggleButton, mEmToggleButton, mBquoteToggleButton; |
| private ToggleButton mUnderlineToggleButton, mStrikeToggleButton; |
| private LinearLayout mFormatBar, mPostContentLinearLayout, mPostSettingsLinearLayout; |
| private Button mAddPictureButton; |
| private boolean mIsBackspace; |
| private boolean mScrollDetected; |
| private boolean mIsLocalDraft; |
| |
| private int mStyleStart, mSelectionStart, mSelectionEnd, mFullViewBottom; |
| private int mLastPosition = -1; |
| private CharSequence mTitle; |
| private CharSequence mContent; |
| |
| private float mLastYPos = 0; |
| |
| @Override |
| public boolean onBackPressed() { |
| // leave full screen mode back button is pressed |
| if (getActionBar() != null && !getActionBar().isShowing()) { |
| setContentEditingModeVisible(false); |
| return true; |
| } |
| return false; |
| } |
| |
| @Override |
| public CharSequence getTitle() { |
| if (mTitleEditText != null) { |
| return mTitleEditText.getText().toString(); |
| } |
| return mTitle; |
| } |
| |
| @Override |
| public CharSequence getContent() { |
| if (mContentEditText != null) { |
| return mContentEditText.getText().toString(); |
| } |
| return mContent; |
| } |
| |
| @Override |
| public void setTitle(CharSequence text) { |
| mTitle = text; |
| if (mTitleEditText != null) { |
| mTitleEditText.setText(text); |
| } else { |
| // TODO |
| } |
| } |
| |
| @Override |
| public void setContent(CharSequence text) { |
| mContent = text; |
| if (mContentEditText != null) { |
| mContentEditText.setText(text); |
| mContentEditText.setSelection(mSelectionStart, mSelectionEnd); |
| } else { |
| // TODO |
| } |
| } |
| |
| @Override |
| public Spanned getSpannedContent() { |
| return mContentEditText.getText(); |
| } |
| |
| public void setLocalDraft(boolean isLocalDraft) { |
| mIsLocalDraft = isLocalDraft; |
| } |
| |
| @Override |
| public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { |
| final ViewGroup rootView = (ViewGroup) inflater.inflate(R.layout.fragment_edit_post_content, container, false); |
| |
| mFormatBar = (LinearLayout) rootView.findViewById(R.id.format_bar); |
| mTitleEditText = (EditText) rootView.findViewById(R.id.post_title); |
| mTitleEditText.setText(mTitle); |
| mTitleEditText.setOnEditorActionListener(new TextView.OnEditorActionListener() { |
| @Override |
| public boolean onEditorAction(TextView v, int actionId, KeyEvent event) { |
| // Go to full screen editor when 'next' button is tapped on soft keyboard |
| ActionBar actionBar = getActionBar(); |
| if (actionId == EditorInfo.IME_ACTION_NEXT && actionBar != null && actionBar.isShowing()) { |
| setContentEditingModeVisible(true); |
| } |
| return false; |
| } |
| }); |
| |
| mContentEditText = (WPEditText) rootView.findViewById(R.id.post_content); |
| mContentEditText.setText(mContent); |
| |
| mPostContentLinearLayout = (LinearLayout) rootView.findViewById(R.id.post_content_wrapper); |
| mPostSettingsLinearLayout = (LinearLayout) rootView.findViewById(R.id.post_settings_wrapper); |
| Button postSettingsButton = (Button) rootView.findViewById(R.id.post_settings_button); |
| postSettingsButton.setOnClickListener(new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| mEditorFragmentListener.onSettingsClicked(); |
| } |
| }); |
| mBoldToggleButton = (ToggleButton) rootView.findViewById(R.id.bold); |
| mEmToggleButton = (ToggleButton) rootView.findViewById(R.id.em); |
| mBquoteToggleButton = (ToggleButton) rootView.findViewById(R.id.bquote); |
| mUnderlineToggleButton = (ToggleButton) rootView.findViewById(R.id.underline); |
| mStrikeToggleButton = (ToggleButton) rootView.findViewById(R.id.strike); |
| mAddPictureButton = (Button) rootView.findViewById(R.id.addPictureButton); |
| Button linkButton = (Button) rootView.findViewById(R.id.link); |
| Button moreButton = (Button) rootView.findViewById(R.id.more); |
| |
| registerForContextMenu(mAddPictureButton); |
| mContentEditText = (WPEditText) rootView.findViewById(R.id.post_content); |
| mContentEditText.setOnSelectionChangedListener(this); |
| mContentEditText.setOnTouchListener(this); |
| mContentEditText.addTextChangedListener(this); |
| mContentEditText.setOnEditTextImeBackListener(new WPEditText.EditTextImeBackListener() { |
| @Override |
| public void onImeBack(WPEditText ctrl, String text) { |
| // Go back to regular editor if IME keyboard is dismissed |
| // Bottom comparison is there to ensure that the keyboard is actually showing |
| ActionBar actionBar = getActionBar(); |
| if (mRootView.getBottom() < mFullViewBottom && actionBar != null && !actionBar.isShowing()) { |
| setContentEditingModeVisible(false); |
| } |
| } |
| }); |
| mAddPictureButton.setOnClickListener(mFormatBarButtonClickListener); |
| mBoldToggleButton.setOnClickListener(mFormatBarButtonClickListener); |
| linkButton.setOnClickListener(mFormatBarButtonClickListener); |
| mEmToggleButton.setOnClickListener(mFormatBarButtonClickListener); |
| mUnderlineToggleButton.setOnClickListener(mFormatBarButtonClickListener); |
| mStrikeToggleButton.setOnClickListener(mFormatBarButtonClickListener); |
| mBquoteToggleButton.setOnClickListener(mFormatBarButtonClickListener); |
| moreButton.setOnClickListener(mFormatBarButtonClickListener); |
| mEditorFragmentListener.onEditorFragmentInitialized(); |
| |
| if (savedInstanceState != null) { |
| Parcelable[] spans = savedInstanceState.getParcelableArray(KEY_IMAGE_SPANS); |
| |
| mContent = savedInstanceState.getString(KEY_CONTENT, ""); |
| mContentEditText.setText(mContent); |
| mContentEditText.setSelection(savedInstanceState.getInt(KEY_START, 0), |
| savedInstanceState.getInt(KEY_END, 0)); |
| |
| if (spans != null && spans.length > 0) { |
| for (Parcelable s : spans) { |
| WPImageSpan editSpan = (WPImageSpan)s; |
| addMediaFile(editSpan.getMediaFile(), editSpan.getMediaFile().getFilePath(), |
| mImageLoader, editSpan.getStartPosition(), editSpan.getEndPosition()); |
| } |
| } |
| } |
| |
| return rootView; |
| } |
| |
| @Override |
| public void onViewCreated(View view, Bundle savedInstanceState) { |
| super.onViewCreated(view, savedInstanceState); |
| mRootView = view; |
| mRootView.getViewTreeObserver().addOnGlobalLayoutListener(mGlobalLayoutListener); |
| } |
| |
| private ViewTreeObserver.OnGlobalLayoutListener mGlobalLayoutListener = new ViewTreeObserver.OnGlobalLayoutListener() { |
| public void onGlobalLayout() { |
| mRootView.getViewTreeObserver().removeGlobalOnLayoutListener(this); |
| mFullViewBottom = mRootView.getBottom(); |
| } |
| }; |
| |
| private ActionBar getActionBar() { |
| if (!isAdded()) { |
| return null; |
| } |
| if (getActivity() instanceof AppCompatActivity) { |
| return ((AppCompatActivity) getActivity()).getSupportActionBar(); |
| } else { |
| return null; |
| } |
| } |
| |
| public void setContentEditingModeVisible(boolean isVisible) { |
| if (!isAdded()) { |
| return; |
| } |
| ActionBar actionBar = getActionBar(); |
| if (isVisible) { |
| Animation fadeAnimation = new AlphaAnimation(1, 0); |
| fadeAnimation.setDuration(CONTENT_ANIMATION_DURATION); |
| fadeAnimation.setAnimationListener(new Animation.AnimationListener() { |
| @Override |
| public void onAnimationStart(Animation animation) { |
| mTitleEditText.setVisibility(View.GONE); |
| } |
| |
| @Override |
| public void onAnimationEnd(Animation animation) { |
| mPostSettingsLinearLayout.setVisibility(View.GONE); |
| mFormatBar.setVisibility(View.VISIBLE); |
| } |
| |
| @Override |
| public void onAnimationRepeat(Animation animation) { |
| } |
| }); |
| |
| mPostContentLinearLayout.startAnimation(fadeAnimation); |
| if (actionBar != null) { |
| actionBar.hide(); |
| } |
| } else { |
| mTitleEditText.setVisibility(View.VISIBLE); |
| mFormatBar.setVisibility(View.GONE); |
| Animation fadeAnimation = new AlphaAnimation(0, 1); |
| fadeAnimation.setDuration(CONTENT_ANIMATION_DURATION); |
| fadeAnimation.setAnimationListener(new Animation.AnimationListener() { |
| @Override |
| public void onAnimationStart(Animation animation) { |
| } |
| |
| @Override |
| public void onAnimationEnd(Animation animation) { |
| mPostSettingsLinearLayout.setVisibility(View.VISIBLE); |
| } |
| |
| @Override |
| public void onAnimationRepeat(Animation animation) { |
| } |
| }); |
| mPostContentLinearLayout.startAnimation(fadeAnimation); |
| getActivity().invalidateOptionsMenu(); |
| if (actionBar != null) { |
| actionBar.show(); |
| } |
| } |
| } |
| |
| @Override |
| public void onActivityResult(int requestCode, int resultCode, Intent data) { |
| super.onActivityResult(requestCode, resultCode, data); |
| |
| if (requestCode == LegacyEditorFragment.ACTIVITY_REQUEST_CODE_CREATE_LINK && data != null) { |
| Bundle extras = data.getExtras(); |
| if (extras == null) { |
| return; |
| } |
| String linkURL = extras.getString("linkURL"); |
| String linkText = extras.getString("linkText"); |
| createLinkFromSelection(linkURL, linkText); |
| } |
| } |
| |
| public boolean hasEmptyContentFields() { |
| return TextUtils.isEmpty(mTitleEditText.getText()) && TextUtils.isEmpty(mContentEditText.getText()); |
| } |
| |
| @Override |
| public void onConfigurationChanged(Configuration newConfig) { |
| super.onConfigurationChanged(newConfig); |
| mFullViewBottom = mRootView.getBottom(); |
| } |
| |
| private void createLinkFromSelection(String linkURL, String linkText) { |
| try { |
| if (linkURL != null && !linkURL.equals("http://") && !linkURL.equals("")) { |
| if (mSelectionStart > mSelectionEnd) { |
| int temp = mSelectionEnd; |
| mSelectionEnd = mSelectionStart; |
| mSelectionStart = temp; |
| } |
| Editable editable = mContentEditText.getText(); |
| if (editable == null) { |
| return; |
| } |
| if (mIsLocalDraft) { |
| if (linkText == null) { |
| if (mSelectionStart < mSelectionEnd) { |
| editable.delete(mSelectionStart, mSelectionEnd); |
| } |
| editable.insert(mSelectionStart, linkURL); |
| editable.setSpan(new URLSpan(linkURL), mSelectionStart, mSelectionStart + linkURL.length(), |
| Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); |
| mContentEditText.setSelection(mSelectionStart + linkURL.length()); |
| } else { |
| if (mSelectionStart < mSelectionEnd) { |
| editable.delete(mSelectionStart, mSelectionEnd); |
| } |
| editable.insert(mSelectionStart, linkText); |
| editable.setSpan(new URLSpan(linkURL), mSelectionStart, mSelectionStart + linkText.length(), |
| Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); |
| mContentEditText.setSelection(mSelectionStart + linkText.length()); |
| } |
| } else { |
| if (linkText == null) { |
| if (mSelectionStart < mSelectionEnd) { |
| editable.delete(mSelectionStart, mSelectionEnd); |
| } |
| String urlHTML = "<a href=\"" + linkURL + "\">" + linkURL + "</a>"; |
| editable.insert(mSelectionStart, urlHTML); |
| mContentEditText.setSelection(mSelectionStart + urlHTML.length()); |
| } else { |
| if (mSelectionStart < mSelectionEnd) { |
| editable.delete(mSelectionStart, mSelectionEnd); |
| } |
| String urlHTML = "<a href=\"" + linkURL + "\">" + linkText + "</a>"; |
| editable.insert(mSelectionStart, urlHTML); |
| mContentEditText.setSelection(mSelectionStart + urlHTML.length()); |
| } |
| } |
| } |
| } catch (RuntimeException e) { |
| AppLog.e(T.POSTS, e); |
| } |
| } |
| |
| /** |
| * Formatting bar |
| */ |
| private View.OnClickListener mFormatBarButtonClickListener = new View.OnClickListener() { |
| @Override |
| public void onClick(View v) { |
| int id = v.getId(); |
| if (id == R.id.bold) { |
| mEditorFragmentListener.onTrackableEvent(TrackableEvent.BOLD_BUTTON_TAPPED); |
| onFormatButtonClick(mBoldToggleButton, TAG_FORMAT_BAR_BUTTON_STRONG); |
| } else if (id == R.id.em) { |
| mEditorFragmentListener.onTrackableEvent(TrackableEvent.ITALIC_BUTTON_TAPPED); |
| onFormatButtonClick(mEmToggleButton, TAG_FORMAT_BAR_BUTTON_EM); |
| } else if (id == R.id.underline) { |
| mEditorFragmentListener.onTrackableEvent(TrackableEvent.UNDERLINE_BUTTON_TAPPED); |
| onFormatButtonClick(mUnderlineToggleButton, TAG_FORMAT_BAR_BUTTON_UNDERLINE); |
| } else if (id == R.id.strike) { |
| mEditorFragmentListener.onTrackableEvent(TrackableEvent.STRIKETHROUGH_BUTTON_TAPPED); |
| onFormatButtonClick(mStrikeToggleButton, TAG_FORMAT_BAR_BUTTON_STRIKE); |
| } else if (id == R.id.bquote) { |
| mEditorFragmentListener.onTrackableEvent(TrackableEvent.BLOCKQUOTE_BUTTON_TAPPED); |
| onFormatButtonClick(mBquoteToggleButton, TAG_FORMAT_BAR_BUTTON_QUOTE); |
| } else if (id == R.id.more) { |
| mEditorFragmentListener.onTrackableEvent(TrackableEvent.MORE_BUTTON_TAPPED); |
| mSelectionEnd = mContentEditText.getSelectionEnd(); |
| Editable str = mContentEditText.getText(); |
| if (str != null) { |
| if (mSelectionEnd > str.length()) |
| mSelectionEnd = str.length(); |
| str.insert(mSelectionEnd, "\n<!--more-->\n"); |
| } |
| } else if (id == R.id.link) { |
| mEditorFragmentListener.onTrackableEvent(TrackableEvent.LINK_BUTTON_TAPPED); |
| mSelectionStart = mContentEditText.getSelectionStart(); |
| mStyleStart = mSelectionStart; |
| mSelectionEnd = mContentEditText.getSelectionEnd(); |
| if (mSelectionStart > mSelectionEnd) { |
| int temp = mSelectionEnd; |
| mSelectionEnd = mSelectionStart; |
| mSelectionStart = temp; |
| } |
| Intent i = new Intent(getActivity(), EditLinkActivity.class); |
| if (mSelectionEnd > mSelectionStart) { |
| if (mContentEditText.getText() != null) { |
| String selectedText = mContentEditText.getText().subSequence(mSelectionStart, mSelectionEnd).toString(); |
| i.putExtra("selectedText", selectedText); |
| } |
| } |
| startActivityForResult(i, ACTIVITY_REQUEST_CODE_CREATE_LINK); |
| } else if (id == R.id.addPictureButton) { |
| mEditorFragmentListener.onTrackableEvent(TrackableEvent.MEDIA_BUTTON_TAPPED); |
| mEditorFragmentListener.onAddMediaClicked(); |
| if (isAdded()) { |
| getActivity().openContextMenu(mAddPictureButton); |
| } |
| } |
| } |
| }; |
| |
| private WPEditImageSpan createWPEditImageSpanLocal(Context context, MediaFile mediaFile) { |
| if (context == null || mediaFile == null || mediaFile.getFilePath() == null) { |
| return null; |
| } |
| Uri imageUri = Uri.parse(mediaFile.getFilePath()); |
| Bitmap thumbnailBitmap; |
| if (MediaUtils.isVideo(imageUri.toString())) { |
| thumbnailBitmap = BitmapFactory.decodeResource(context.getResources(), R.drawable.media_movieclip); |
| } else { |
| thumbnailBitmap = ImageUtils.getWPImageSpanThumbnailFromFilePath(context, imageUri.getEncodedPath(), |
| ImageUtils.getMaximumThumbnailWidthForEditor(context)); |
| if (thumbnailBitmap == null) { |
| // Use a placeholder in case thumbnail can't be decoded (OOM for instance) |
| thumbnailBitmap = BitmapFactory.decodeResource(context.getResources(), |
| R.drawable.legacy_dashicon_format_image_big_grey); |
| } |
| } |
| WPEditImageSpan imageSpan = new WPEditImageSpan(context, thumbnailBitmap, imageUri); |
| mediaFile.setWidth(MediaUtils.getMaximumImageWidth(context, imageUri, mBlogSettingMaxImageWidth)); |
| imageSpan.setMediaFile(mediaFile); |
| return imageSpan; |
| } |
| |
| private WPEditImageSpan createWPEditImageSpanRemote(Context context, MediaFile mediaFile) { |
| if (context == null || mediaFile == null || mediaFile.getFileURL() == null) { |
| return null; |
| } |
| int drawable = mediaFile.isVideo() ? R.drawable.media_movieclip : R.drawable.legacy_dashicon_format_image_big_grey; |
| Uri uri = Uri.parse(mediaFile.getFileURL()); |
| WPEditImageSpan imageSpan = new WPEditImageSpan(context, drawable, uri); |
| imageSpan.setMediaFile(mediaFile); |
| return imageSpan; |
| } |
| |
| private WPEditImageSpan createWPEditImageSpan(Context context, MediaFile mediaFile) { |
| if (!URLUtil.isNetworkUrl(mediaFile.getFileURL())) { |
| return createWPEditImageSpanLocal(context, mediaFile); |
| } else { |
| return createWPEditImageSpanRemote(context, mediaFile); |
| } |
| } |
| |
| /** |
| * Applies formatting to selected text, or marks the entry for a new text style |
| * at the current cursor position |
| * @param toggleButton button from formatting bar |
| * @param tag HTML tag name for text style |
| */ |
| private void onFormatButtonClick(ToggleButton toggleButton, String tag) { |
| Spannable s = mContentEditText.getText(); |
| if (s == null) |
| return; |
| int selectionStart = mContentEditText.getSelectionStart(); |
| mStyleStart = selectionStart; |
| int selectionEnd = mContentEditText.getSelectionEnd(); |
| |
| if (selectionStart > selectionEnd) { |
| int temp = selectionEnd; |
| selectionEnd = selectionStart; |
| selectionStart = temp; |
| } |
| |
| Class styleClass = null; |
| if (tag.equals(TAG_FORMAT_BAR_BUTTON_STRONG) || tag.equals(TAG_FORMAT_BAR_BUTTON_EM)) |
| styleClass = StyleSpan.class; |
| else if (tag.equals(TAG_FORMAT_BAR_BUTTON_UNDERLINE)) |
| styleClass = WPUnderlineSpan.class; |
| else if (tag.equals(TAG_FORMAT_BAR_BUTTON_STRIKE)) |
| styleClass = StrikethroughSpan.class; |
| else if (tag.equals(TAG_FORMAT_BAR_BUTTON_QUOTE)) |
| styleClass = QuoteSpan.class; |
| |
| if (styleClass == null) |
| return; |
| |
| Object[] allSpans = s.getSpans(selectionStart, selectionEnd, styleClass); |
| boolean textIsSelected = selectionEnd > selectionStart; |
| if (mIsLocalDraft) { |
| // Local drafts can use the rich text editor. Yay! |
| boolean shouldAddSpan = true; |
| for (Object span : allSpans) { |
| if (span instanceof StyleSpan) { |
| StyleSpan styleSpan = (StyleSpan)span; |
| if ((styleSpan.getStyle() == Typeface.BOLD && !tag.equals(TAG_FORMAT_BAR_BUTTON_STRONG)) |
| || (styleSpan.getStyle() == Typeface.ITALIC && !tag.equals(TAG_FORMAT_BAR_BUTTON_EM))) { |
| continue; |
| } |
| } |
| if (!toggleButton.isChecked() && textIsSelected) { |
| // If span exists and text is selected, remove the span |
| s.removeSpan(span); |
| shouldAddSpan = false; |
| break; |
| } else if (!toggleButton.isChecked()) { |
| // Remove span at cursor point if button isn't checked |
| Object[] spans = s.getSpans(mStyleStart - 1, mStyleStart, styleClass); |
| for (Object removeSpan : spans) { |
| selectionStart = s.getSpanStart(removeSpan); |
| selectionEnd = s.getSpanEnd(removeSpan); |
| s.removeSpan(removeSpan); |
| } |
| } |
| } |
| |
| if (shouldAddSpan) { |
| if (tag.equals(TAG_FORMAT_BAR_BUTTON_STRONG)) { |
| s.setSpan(new StyleSpan(android.graphics.Typeface.BOLD), selectionStart, selectionEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); |
| } else if (tag.equals(TAG_FORMAT_BAR_BUTTON_EM)) { |
| s.setSpan(new StyleSpan(android.graphics.Typeface.ITALIC), selectionStart, selectionEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); |
| } else { |
| try { |
| s.setSpan(styleClass.newInstance(), selectionStart, selectionEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); |
| } catch (java.lang.InstantiationException e) { |
| AppLog.e(T.POSTS, e); |
| } catch (IllegalAccessException e) { |
| AppLog.e(T.POSTS, e); |
| } |
| } |
| } |
| } else { |
| // Add HTML tags when editing an existing post |
| String startTag = "<" + tag + ">"; |
| String endTag = "</" + tag + ">"; |
| Editable content = mContentEditText.getText(); |
| if (textIsSelected) { |
| content.insert(selectionStart, startTag); |
| content.insert(selectionEnd + startTag.length(), endTag); |
| toggleButton.setChecked(false); |
| mContentEditText.setSelection(selectionEnd + startTag.length() + endTag.length()); |
| } else if (toggleButton.isChecked()) { |
| content.insert(selectionStart, startTag); |
| mContentEditText.setSelection(selectionEnd + startTag.length()); |
| } else if (!toggleButton.isChecked()) { |
| content.insert(selectionEnd, endTag); |
| mContentEditText.setSelection(selectionEnd + endTag.length()); |
| } |
| } |
| } |
| |
| /** |
| * Rich Text Editor |
| */ |
| public void showImageSettings(final View alertView, final EditText titleText, |
| final EditText caption, final EditText imageWidthText, |
| final CheckBox featuredCheckBox, final CheckBox featuredInPostCheckBox, |
| final int maxWidth, final Spinner alignmentSpinner, final WPImageSpan imageSpan) { |
| AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); |
| builder.setTitle(getString(R.string.image_settings)); |
| builder.setView(alertView); |
| builder.setPositiveButton(getString(android.R.string.ok), new DialogInterface.OnClickListener() { |
| public void onClick(DialogInterface dialog, int whichButton) { |
| String title = (titleText.getText() != null) ? titleText.getText().toString() : ""; |
| MediaFile mediaFile = imageSpan.getMediaFile(); |
| if (mediaFile == null) { |
| return; |
| } |
| mediaFile.setTitle(title); |
| mediaFile.setHorizontalAlignment(alignmentSpinner.getSelectedItemPosition()); |
| mediaFile.setWidth(getEditTextIntegerClamped(imageWidthText, 10, maxWidth)); |
| String captionText = (caption.getText() != null) ? caption.getText().toString() : ""; |
| mediaFile.setCaption(captionText); |
| mediaFile.setFeatured(featuredCheckBox.isChecked()); |
| if (featuredCheckBox.isChecked()) { |
| // remove featured flag from all other images |
| Spannable contentSpannable = mContentEditText.getText(); |
| WPImageSpan[] imageSpans = |
| contentSpannable.getSpans(0, contentSpannable.length(), WPImageSpan.class); |
| if (imageSpans.length > 1) { |
| for (WPImageSpan postImageSpan : imageSpans) { |
| if (postImageSpan != imageSpan) { |
| MediaFile postMediaFile = postImageSpan.getMediaFile(); |
| postMediaFile.setFeatured(false); |
| postMediaFile.setFeaturedInPost(false); |
| // TODO: remove this |
| mEditorFragmentListener.saveMediaFile(postMediaFile); |
| } |
| } |
| } |
| } |
| mediaFile.setFeaturedInPost(featuredInPostCheckBox.isChecked()); |
| // TODO: remove this |
| mEditorFragmentListener.saveMediaFile(mediaFile); |
| } |
| }); |
| builder.setNegativeButton(getString(android.R.string.cancel), new DialogInterface.OnClickListener() { |
| public void onClick(DialogInterface dialog, int whichButton) { |
| dialog.dismiss(); |
| } |
| }); |
| AlertDialog alertDialog = builder.create(); |
| alertDialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN); |
| alertDialog.show(); |
| } |
| |
| @Override |
| public boolean onTouch(View v, MotionEvent event) { |
| float pos = event.getY(); |
| |
| if (event.getAction() == 0) |
| mLastYPos = pos; |
| |
| if (event.getAction() > 1) { |
| int scrollThreshold = DisplayUtils.dpToPx(getActivity(), 2); |
| if (((mLastYPos - pos) > scrollThreshold) || ((pos - mLastYPos) > scrollThreshold)) |
| mScrollDetected = true; |
| } |
| |
| mLastYPos = pos; |
| |
| if (event.getAction() == MotionEvent.ACTION_UP) { |
| ActionBar actionBar = getActionBar(); |
| if (actionBar != null && actionBar.isShowing()) { |
| setContentEditingModeVisible(true); |
| return false; |
| } |
| } |
| |
| if (event.getAction() == MotionEvent.ACTION_UP && !mScrollDetected) { |
| Layout layout = ((TextView) v).getLayout(); |
| int x = (int) event.getX(); |
| int y = (int) event.getY(); |
| |
| x += v.getScrollX(); |
| y += v.getScrollY(); |
| if (layout != null) { |
| int line = layout.getLineForVertical(y); |
| int charPosition = layout.getOffsetForHorizontal(line, x); |
| |
| Spannable spannable = mContentEditText.getText(); |
| if (spannable == null) { |
| return false; |
| } |
| // check if image span was tapped |
| WPImageSpan[] imageSpans = spannable.getSpans(charPosition, charPosition, WPImageSpan.class); |
| |
| if (imageSpans.length != 0) { |
| final WPImageSpan imageSpan = imageSpans[0]; |
| MediaFile mediaFile = imageSpan.getMediaFile(); |
| if (mediaFile == null) |
| return false; |
| if (!mediaFile.isVideo()) { |
| LayoutInflater factory = LayoutInflater.from(getActivity()); |
| final View alertView = factory.inflate(R.layout.alert_image_options, null); |
| if (alertView == null) |
| return false; |
| final EditText imageWidthText = (EditText) alertView.findViewById(R.id.imageWidthText); |
| final EditText titleText = (EditText) alertView.findViewById(R.id.title); |
| final EditText caption = (EditText) alertView.findViewById(R.id.caption); |
| final CheckBox featuredCheckBox = (CheckBox) alertView.findViewById(R.id.featuredImage); |
| final CheckBox featuredInPostCheckBox = (CheckBox) alertView.findViewById(R.id.featuredInPost); |
| |
| // show featured image checkboxes if supported |
| if (mFeaturedImageSupported) { |
| featuredCheckBox.setVisibility(View.VISIBLE); |
| featuredInPostCheckBox.setVisibility(View.VISIBLE); |
| } |
| |
| featuredCheckBox.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() { |
| @Override |
| public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { |
| if (isChecked) { |
| featuredInPostCheckBox.setVisibility(View.VISIBLE); |
| } else { |
| featuredInPostCheckBox.setVisibility(View.GONE); |
| } |
| |
| } |
| }); |
| |
| final SeekBar seekBar = (SeekBar) alertView.findViewById(R.id.imageWidth); |
| final Spinner alignmentSpinner = (Spinner) alertView.findViewById(R.id.alignment_spinner); |
| ArrayAdapter<CharSequence> adapter = |
| ArrayAdapter.createFromResource(getActivity(), R.array.alignment_array, |
| android.R.layout.simple_spinner_item); |
| adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); |
| alignmentSpinner.setAdapter(adapter); |
| |
| seekBar.setProgress(mediaFile.getWidth()); |
| titleText.setText(mediaFile.getTitle()); |
| caption.setText(mediaFile.getCaption()); |
| featuredCheckBox.setChecked(mediaFile.isFeatured()); |
| |
| if (mediaFile.isFeatured()) { |
| featuredInPostCheckBox.setVisibility(View.VISIBLE); |
| } else { |
| featuredInPostCheckBox.setVisibility(View.GONE); |
| } |
| |
| featuredInPostCheckBox.setChecked(mediaFile.isFeaturedInPost()); |
| |
| alignmentSpinner.setSelection(mediaFile.getHorizontalAlignment(), true); |
| |
| final int maxWidth = MediaUtils.getMaximumImageWidth(getActivity(), |
| imageSpan.getImageSource(), mBlogSettingMaxImageWidth); |
| seekBar.setMax(maxWidth / 10); |
| imageWidthText.setText(String.format(Locale.US, "%dpx", maxWidth)); |
| if (mediaFile.getWidth() != 0) { |
| seekBar.setProgress(mediaFile.getWidth() / 10); |
| } |
| seekBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() { |
| @Override |
| public void onStopTrackingTouch(SeekBar seekBar) { |
| } |
| |
| @Override |
| public void onStartTrackingTouch(SeekBar seekBar) { |
| } |
| |
| @Override |
| public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) { |
| if (progress == 0) { |
| progress = 1; |
| } |
| imageWidthText.setText(String.format(Locale.US, "%dpx", progress * 10)); |
| } |
| }); |
| |
| imageWidthText.setOnFocusChangeListener(new View.OnFocusChangeListener() { |
| @Override |
| public void onFocusChange(View v, boolean hasFocus) { |
| if (hasFocus) { |
| imageWidthText.setText(""); |
| } |
| } |
| }); |
| |
| imageWidthText.setOnEditorActionListener(new TextView.OnEditorActionListener() { |
| @Override |
| public boolean onEditorAction(TextView v, int actionId, KeyEvent event) { |
| int width = getEditTextIntegerClamped(imageWidthText, 10, maxWidth); |
| seekBar.setProgress(width / 10); |
| imageWidthText.setSelection((String.valueOf(width).length())); |
| |
| InputMethodManager imm = (InputMethodManager) getActivity() |
| .getSystemService(Context.INPUT_METHOD_SERVICE); |
| imm.hideSoftInputFromWindow(imageWidthText.getWindowToken(), |
| InputMethodManager.RESULT_UNCHANGED_SHOWN); |
| |
| return true; |
| } |
| }); |
| |
| showImageSettings(alertView, titleText, caption, imageWidthText, featuredCheckBox, |
| featuredInPostCheckBox, maxWidth, alignmentSpinner, imageSpan); |
| mScrollDetected = false; |
| return true; |
| } |
| |
| } else { |
| mContentEditText.setMovementMethod(ArrowKeyMovementMethod.getInstance()); |
| int selectionStart = mContentEditText.getSelectionStart(); |
| if (selectionStart >= 0 && mContentEditText.getSelectionEnd() >= selectionStart) |
| mContentEditText.setSelection(selectionStart, mContentEditText.getSelectionEnd()); |
| } |
| |
| // get media gallery spans |
| MediaGalleryImageSpan[] gallerySpans = spannable.getSpans(charPosition, charPosition, MediaGalleryImageSpan.class); |
| if (gallerySpans.length > 0) { |
| final MediaGalleryImageSpan gallerySpan = gallerySpans[0]; |
| Intent intent = new Intent(ACTION_MEDIA_GALLERY_TOUCHED); |
| intent.putExtra(EXTRA_MEDIA_GALLERY, gallerySpan.getMediaGallery()); |
| getActivity().sendBroadcast(intent); |
| } |
| } |
| } else if (event.getAction() == 1) { |
| mScrollDetected = false; |
| } |
| return false; |
| } |
| |
| @Override |
| public void afterTextChanged(Editable s) { |
| int position = Selection.getSelectionStart(mContentEditText.getText()); |
| if ((mIsBackspace && position != 1) || mLastPosition == position || !mIsLocalDraft) |
| return; |
| |
| if (position < 0) { |
| position = 0; |
| } |
| mLastPosition = position; |
| if (position > 0) { |
| if (mStyleStart > position) { |
| mStyleStart = position - 1; |
| } |
| |
| boolean shouldBold = mBoldToggleButton.isChecked(); |
| boolean shouldEm = mEmToggleButton.isChecked(); |
| boolean shouldUnderline = mUnderlineToggleButton.isChecked(); |
| boolean shouldStrike = mStrikeToggleButton.isChecked(); |
| boolean shouldQuote = mBquoteToggleButton.isChecked(); |
| |
| Object[] allSpans = s.getSpans(mStyleStart, position, Object.class); |
| for (Object span : allSpans) { |
| if (span instanceof StyleSpan) { |
| StyleSpan styleSpan = (StyleSpan) span; |
| if (styleSpan.getStyle() == Typeface.BOLD) |
| shouldBold = false; |
| else if (styleSpan.getStyle() == Typeface.ITALIC) |
| shouldEm = false; |
| } else if (span instanceof WPUnderlineSpan) { |
| shouldUnderline = false; |
| } else if (span instanceof StrikethroughSpan) { |
| shouldStrike = false; |
| } else if (span instanceof QuoteSpan) { |
| shouldQuote = false; |
| } |
| } |
| |
| if (shouldBold) |
| s.setSpan(new StyleSpan(android.graphics.Typeface.BOLD), mStyleStart, position, Spannable.SPAN_INCLUSIVE_INCLUSIVE); |
| if (shouldEm) |
| s.setSpan(new StyleSpan(android.graphics.Typeface.ITALIC), mStyleStart, position, Spannable.SPAN_INCLUSIVE_INCLUSIVE); |
| if (shouldUnderline) |
| s.setSpan(new WPUnderlineSpan(), mStyleStart, position, Spannable.SPAN_INCLUSIVE_INCLUSIVE); |
| if (shouldStrike) |
| s.setSpan(new StrikethroughSpan(), mStyleStart, position, Spannable.SPAN_INCLUSIVE_INCLUSIVE); |
| if (shouldQuote) |
| s.setSpan(new QuoteSpan(), mStyleStart, position, Spannable.SPAN_INCLUSIVE_INCLUSIVE); |
| } |
| } |
| |
| @Override |
| public void beforeTextChanged(CharSequence s, int start, int count, int after) { |
| mIsBackspace = (count - after == 1) || (s.length() == 0); |
| } |
| |
| @Override |
| public void onTextChanged(CharSequence s, int start, int before, int count) { |
| } |
| |
| @Override |
| public void onSelectionChanged() { |
| if (!mIsLocalDraft) { |
| return; |
| } |
| |
| final Spannable s = mContentEditText.getText(); |
| if (s == null) |
| return; |
| // set toggle buttons if cursor is inside of a matching span |
| mStyleStart = mContentEditText.getSelectionStart(); |
| Object[] spans = s.getSpans(mContentEditText.getSelectionStart(), mContentEditText.getSelectionStart(), Object.class); |
| |
| mBoldToggleButton.setChecked(false); |
| mEmToggleButton.setChecked(false); |
| mBquoteToggleButton.setChecked(false); |
| mUnderlineToggleButton.setChecked(false); |
| mStrikeToggleButton.setChecked(false); |
| for (Object span : spans) { |
| if (span instanceof StyleSpan) { |
| StyleSpan ss = (StyleSpan) span; |
| if (ss.getStyle() == android.graphics.Typeface.BOLD) { |
| mBoldToggleButton.setChecked(true); |
| } |
| if (ss.getStyle() == android.graphics.Typeface.ITALIC) { |
| mEmToggleButton.setChecked(true); |
| } |
| } |
| if (span instanceof QuoteSpan) { |
| mBquoteToggleButton.setChecked(true); |
| } |
| if (span instanceof WPUnderlineSpan) { |
| mUnderlineToggleButton.setChecked(true); |
| } |
| if (span instanceof StrikethroughSpan) { |
| mStrikeToggleButton.setChecked(true); |
| } |
| } |
| } |
| |
| private int getEditTextIntegerClamped(EditText editText, int min, int max) { |
| int width = 10; |
| try { |
| if (editText.getText() != null) |
| width = Integer.parseInt(editText.getText().toString().replace("px", "")); |
| } catch (NumberFormatException e) { |
| AppLog.e(T.POSTS, e); |
| } |
| width = Math.min(max, Math.max(width, min)); |
| return width; |
| } |
| |
| private void loadWPImageSpanThumbnail(MediaFile mediaFile, String imageURL, ImageLoader imageLoader) { |
| if (mediaFile == null || imageURL == null) { |
| return; |
| } |
| final String mediaId = mediaFile.getMediaId(); |
| if (mediaId == null) { |
| return; |
| } |
| |
| final int maxThumbWidth = ImageUtils.getMaximumThumbnailWidthForEditor(getActivity()); |
| |
| imageLoader.get(imageURL, new ImageLoader.ImageListener() { |
| @Override |
| public void onErrorResponse(VolleyError arg0) { |
| } |
| |
| @Override |
| public void onResponse(ImageLoader.ImageContainer container, boolean arg1) { |
| Bitmap downloadedBitmap = container.getBitmap(); |
| if (downloadedBitmap == null) { |
| // no bitmap downloaded from the server. |
| return; |
| } |
| |
| if (downloadedBitmap.getWidth() < MIN_THUMBNAIL_WIDTH) { |
| // Picture is too small. Show the placeholder in this case. |
| return; |
| } |
| |
| Bitmap resizedBitmap; |
| // resize the downloaded bitmap |
| resizedBitmap = ImageUtils.getScaledBitmapAtLongestSide(downloadedBitmap, maxThumbWidth); |
| |
| if (resizedBitmap == null) { |
| return; |
| } |
| |
| final EditText editText = mContentEditText; |
| Editable s = editText.getText(); |
| if (s == null) { |
| return; |
| } |
| WPImageSpan[] spans = s.getSpans(0, s.length(), WPImageSpan.class); |
| if (spans.length != 0 && getActivity() != null) { |
| for (WPImageSpan is : spans) { |
| MediaFile mediaFile = is.getMediaFile(); |
| if (mediaFile == null) { |
| continue; |
| } |
| if (mediaId.equals(mediaFile.getMediaId()) && !is.isNetworkImageLoaded()) { |
| // replace the existing span with a new one with the correct image, re-add |
| // it to the same position. |
| int spanStart = is.getStartPosition(); |
| int spanEnd = is.getEndPosition(); |
| WPEditImageSpan imageSpan = new WPEditImageSpan(getActivity(), resizedBitmap, |
| is.getImageSource()); |
| imageSpan.setMediaFile(is.getMediaFile()); |
| imageSpan.setNetworkImageLoaded(true); |
| imageSpan.setPosition(spanStart, spanEnd); |
| s.removeSpan(is); |
| s.setSpan(imageSpan, spanStart, spanEnd + 1, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); |
| break; |
| } |
| } |
| } |
| } |
| }, 0, 0); |
| } |
| |
| @Override |
| public void onSaveInstanceState(Bundle outState) { |
| super.onSaveInstanceState(outState); |
| |
| WPImageSpan[] spans = mContentEditText.getText().getSpans(0, mContentEditText.getText().length(), WPEditImageSpan.class); |
| |
| if (spans != null && spans.length > 0) { |
| outState.putParcelableArray(KEY_IMAGE_SPANS, spans); |
| } |
| |
| outState.putInt(KEY_START, mContentEditText.getSelectionStart()); |
| outState.putInt(KEY_END, mContentEditText.getSelectionEnd()); |
| outState.putString(KEY_CONTENT, mContentEditText.getText().toString()); |
| } |
| |
| private class AddMediaFileTask extends AsyncTask<Void, Void, WPEditImageSpan> { |
| private MediaFile mMediaFile; |
| private String mImageUrl; |
| private ImageLoader mImageLoader; |
| private int mStart; |
| private int mEnd; |
| |
| public AddMediaFileTask(MediaFile mediaFile, String imageUrl, ImageLoader imageLoader, int start, int end) { |
| mMediaFile = mediaFile; |
| mImageUrl = imageUrl; |
| mImageLoader = imageLoader; |
| mStart = start; |
| mEnd = end; |
| } |
| |
| protected WPEditImageSpan doInBackground(Void... voids) { |
| mMediaFile.setFileURL(mImageUrl); |
| mMediaFile.setFilePath(mImageUrl); |
| WPEditImageSpan imageSpan = createWPEditImageSpan(getActivity(), mMediaFile); |
| mEditorFragmentListener.saveMediaFile(mMediaFile); |
| return imageSpan; |
| } |
| |
| protected void onPostExecute(WPEditImageSpan imageSpan) { |
| if (imageSpan == null) { |
| if (isAdded()) { |
| ToastUtils.showToast(getActivity(), R.string.alert_error_adding_media, Duration.LONG); |
| } |
| return ; |
| } |
| // Insert the WPImageSpan in the content field |
| int selectionStart = mStart; |
| int selectionEnd = mEnd; |
| |
| if (selectionStart > selectionEnd) { |
| int temp = selectionEnd; |
| selectionEnd = selectionStart; |
| selectionStart = temp; |
| } |
| |
| imageSpan.setPosition(selectionStart, selectionEnd); |
| |
| int line, column = 0; |
| if (mContentEditText.getLayout() != null) { |
| line = mContentEditText.getLayout().getLineForOffset(selectionStart); |
| column = selectionStart - mContentEditText.getLayout().getLineStart(line); |
| } |
| |
| Editable s = mContentEditText.getText(); |
| if (s == null) { |
| return; |
| } |
| |
| WPImageSpan[] imageSpans = s.getSpans(selectionStart, selectionEnd, WPImageSpan.class); |
| if (imageSpans.length != 0) { |
| // insert a few line breaks if the cursor is already on an image |
| s.insert(selectionEnd, "\n\n"); |
| selectionStart = selectionStart + 2; |
| selectionEnd = selectionEnd + 2; |
| } else if (column != 0) { |
| // insert one line break if the cursor is not at the first column |
| s.insert(selectionEnd, "\n"); |
| selectionStart = selectionStart + 1; |
| selectionEnd = selectionEnd + 1; |
| } |
| |
| s.insert(selectionStart, " "); |
| s.setSpan(imageSpan, selectionStart, selectionEnd + 1, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); |
| AlignmentSpan.Standard as = new AlignmentSpan.Standard(Layout.Alignment.ALIGN_CENTER); |
| s.setSpan(as, selectionStart, selectionEnd + 1, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); |
| s.insert(selectionEnd + 1, "\n\n"); |
| |
| // Fetch and replace the WPImageSpan if it's a remote media |
| if (mImageLoader != null && URLUtil.isNetworkUrl(mImageUrl)) { |
| loadWPImageSpanThumbnail(mMediaFile, mImageUrl, mImageLoader); |
| } |
| } |
| } |
| |
| public void addMediaFile(final MediaFile mediaFile, final String imageUrl, final ImageLoader imageLoader, |
| final int start, final int end) { |
| AddMediaFileTask addMediaFileTask = new AddMediaFileTask(mediaFile, imageUrl, imageLoader, start, end); |
| addMediaFileTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR); |
| } |
| |
| @Override |
| public void appendMediaFile(final MediaFile mediaFile, final String imageUrl, final ImageLoader imageLoader) { |
| addMediaFile(mediaFile, imageUrl, imageLoader, mContentEditText.getSelectionStart(), mContentEditText.getSelectionEnd()); |
| } |
| |
| @Override |
| public void appendGallery(MediaGallery mediaGallery) { |
| Editable editableText = mContentEditText.getText(); |
| if (editableText == null) { |
| return; |
| } |
| |
| int selectionStart = mContentEditText.getSelectionStart(); |
| int selectionEnd = mContentEditText.getSelectionEnd(); |
| |
| if (selectionStart > selectionEnd) { |
| int temp = selectionEnd; |
| selectionEnd = selectionStart; |
| selectionStart = temp; |
| } |
| |
| int line, column = 0; |
| if (mContentEditText.getLayout() != null) { |
| line = mContentEditText.getLayout().getLineForOffset(selectionStart); |
| column = mContentEditText.getSelectionStart() - mContentEditText.getLayout().getLineStart(line); |
| } |
| |
| if (column != 0) { |
| // insert one line break if the cursor is not at the first column |
| editableText.insert(selectionEnd, "\n"); |
| selectionStart = selectionStart + 1; |
| selectionEnd = selectionEnd + 1; |
| } |
| |
| editableText.insert(selectionStart, " "); |
| MediaGalleryImageSpan is = new MediaGalleryImageSpan(getActivity(), mediaGallery, |
| R.drawable.legacy_icon_mediagallery_placeholder); |
| editableText.setSpan(is, selectionStart, selectionEnd + 1, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); |
| AlignmentSpan.Standard as = new AlignmentSpan.Standard(Layout.Alignment.ALIGN_CENTER); |
| editableText.setSpan(as, selectionStart, selectionEnd + 1, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); |
| editableText.insert(selectionEnd + 1, "\n\n"); |
| } |
| |
| @Override |
| public void setUrlForVideoPressId(String videoPressId, String url, String posterUrl) { |
| |
| } |
| |
| @Override |
| public boolean isUploadingMedia() { |
| return false; |
| } |
| |
| @Override |
| public boolean hasFailedMediaUploads() { |
| return false; |
| } |
| |
| @Override |
| public void removeAllFailedMediaUploads() {} |
| |
| @Override |
| public void setTitlePlaceholder(CharSequence text) { |
| } |
| |
| @Override |
| public void setContentPlaceholder(CharSequence text) { |
| } |
| |
| @Override |
| public boolean isActionInProgress() { |
| return false; |
| } |
| } |
