2019-09-27 17:05:34 +00:00
|
|
|
package eu.faircode.email;
|
|
|
|
|
2021-01-01 07:56:36 +00:00
|
|
|
/*
|
|
|
|
This file is part of FairEmail.
|
|
|
|
|
|
|
|
FairEmail is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
FairEmail is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with FairEmail. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
2022-01-01 08:46:36 +00:00
|
|
|
Copyright 2018-2022 by Marcel Bokhorst (M66B)
|
2021-01-01 07:56:36 +00:00
|
|
|
*/
|
|
|
|
|
2020-08-12 08:25:08 +00:00
|
|
|
import android.content.Context;
|
2020-06-28 21:36:31 +00:00
|
|
|
import android.content.DialogInterface;
|
2020-08-14 18:15:52 +00:00
|
|
|
import android.content.SharedPreferences;
|
2019-09-27 17:05:34 +00:00
|
|
|
import android.graphics.Typeface;
|
2020-08-12 06:18:39 +00:00
|
|
|
import android.os.Build;
|
2020-11-17 18:37:56 +00:00
|
|
|
import android.text.Editable;
|
2020-10-03 09:37:43 +00:00
|
|
|
import android.text.Layout;
|
2021-05-10 20:10:25 +00:00
|
|
|
import android.text.SpannableStringBuilder;
|
2019-09-27 17:05:34 +00:00
|
|
|
import android.text.Spanned;
|
2020-10-03 09:37:43 +00:00
|
|
|
import android.text.TextUtils;
|
|
|
|
import android.text.style.AlignmentSpan;
|
2021-07-04 11:17:15 +00:00
|
|
|
import android.text.style.BackgroundColorSpan;
|
2020-08-11 16:46:26 +00:00
|
|
|
import android.text.style.BulletSpan;
|
2020-11-17 19:22:34 +00:00
|
|
|
import android.text.style.CharacterStyle;
|
2019-09-27 17:05:34 +00:00
|
|
|
import android.text.style.ForegroundColorSpan;
|
2019-09-29 10:10:19 +00:00
|
|
|
import android.text.style.ImageSpan;
|
2020-11-17 18:37:56 +00:00
|
|
|
import android.text.style.ParagraphStyle;
|
2020-10-01 08:22:20 +00:00
|
|
|
import android.text.style.QuoteSpan;
|
2019-09-27 17:05:34 +00:00
|
|
|
import android.text.style.RelativeSizeSpan;
|
2020-10-01 08:31:58 +00:00
|
|
|
import android.text.style.StrikethroughSpan;
|
2019-09-27 17:05:34 +00:00
|
|
|
import android.text.style.StyleSpan;
|
2021-09-12 06:43:55 +00:00
|
|
|
import android.text.style.SuggestionSpan;
|
2020-06-28 16:39:27 +00:00
|
|
|
import android.text.style.TypefaceSpan;
|
2019-09-27 17:05:34 +00:00
|
|
|
import android.text.style.URLSpan;
|
|
|
|
import android.text.style.UnderlineSpan;
|
2020-10-03 12:17:13 +00:00
|
|
|
import android.util.Pair;
|
2020-06-28 15:18:42 +00:00
|
|
|
import android.view.MenuItem;
|
2020-08-12 08:25:08 +00:00
|
|
|
import android.view.SubMenu;
|
2020-06-28 15:18:42 +00:00
|
|
|
import android.view.View;
|
2019-09-27 17:05:34 +00:00
|
|
|
import android.widget.EditText;
|
|
|
|
|
2020-06-28 15:18:42 +00:00
|
|
|
import androidx.appcompat.widget.PopupMenu;
|
2021-06-01 11:34:57 +00:00
|
|
|
import androidx.core.content.res.ResourcesCompat;
|
2020-11-12 14:08:34 +00:00
|
|
|
import androidx.lifecycle.LifecycleOwner;
|
2020-08-14 18:15:52 +00:00
|
|
|
import androidx.preference.PreferenceManager;
|
2020-06-28 15:18:42 +00:00
|
|
|
|
2020-06-28 21:36:31 +00:00
|
|
|
import com.flask.colorpicker.ColorPickerView;
|
|
|
|
import com.flask.colorpicker.builder.ColorPickerClickListener;
|
|
|
|
import com.flask.colorpicker.builder.ColorPickerDialogBuilder;
|
|
|
|
|
2019-09-27 17:05:34 +00:00
|
|
|
import java.util.ArrayList;
|
2021-09-23 14:17:49 +00:00
|
|
|
import java.util.Arrays;
|
|
|
|
import java.util.Collections;
|
2021-05-30 16:15:50 +00:00
|
|
|
import java.util.HashMap;
|
2019-09-27 17:05:34 +00:00
|
|
|
import java.util.List;
|
2020-10-03 09:37:43 +00:00
|
|
|
import java.util.Locale;
|
2021-05-30 16:15:50 +00:00
|
|
|
import java.util.Map;
|
2019-09-27 17:05:34 +00:00
|
|
|
|
|
|
|
public class StyleHelper {
|
2021-09-23 14:17:49 +00:00
|
|
|
private static final List<Class> CLEAR_STYLES = Collections.unmodifiableList(Arrays.asList(
|
|
|
|
StyleSpan.class,
|
|
|
|
UnderlineSpan.class,
|
|
|
|
RelativeSizeSpan.class,
|
|
|
|
BackgroundColorSpan.class,
|
|
|
|
ForegroundColorSpan.class,
|
|
|
|
AlignmentSpan.class,
|
|
|
|
BulletSpan.class,
|
|
|
|
QuoteSpan.class, IndentSpan.class,
|
|
|
|
StrikethroughSpan.class,
|
|
|
|
URLSpan.class,
|
|
|
|
TypefaceSpan.class
|
|
|
|
));
|
|
|
|
|
2020-11-12 14:08:34 +00:00
|
|
|
static boolean apply(int action, LifecycleOwner owner, View anchor, EditText etBody, Object... args) {
|
2019-09-27 17:05:34 +00:00
|
|
|
Log.i("Style action=" + action);
|
|
|
|
|
|
|
|
try {
|
2021-05-06 05:58:04 +00:00
|
|
|
int _start = etBody.getSelectionStart();
|
|
|
|
int _end = etBody.getSelectionEnd();
|
|
|
|
|
|
|
|
if (_start < 0)
|
|
|
|
_start = 0;
|
|
|
|
if (_end < 0)
|
|
|
|
_end = 0;
|
|
|
|
|
|
|
|
if (_start > _end) {
|
|
|
|
int tmp = _start;
|
|
|
|
_start = _end;
|
|
|
|
_end = tmp;
|
2019-09-27 17:05:34 +00:00
|
|
|
}
|
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
final Editable edit = etBody.getText();
|
|
|
|
final int start = _start;
|
|
|
|
final int end = _end;
|
2019-09-27 17:05:34 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
if (action == R.id.menu_bold || action == R.id.menu_italic) {
|
2021-05-14 17:20:01 +00:00
|
|
|
String name = (action == R.id.menu_bold ? "bold" : "italic");
|
|
|
|
Log.breadcrumb("style", "action", name);
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
boolean has = false;
|
2021-05-14 17:20:01 +00:00
|
|
|
int style = (action == R.id.menu_bold ? Typeface.BOLD : Typeface.ITALIC);
|
2021-05-14 17:16:27 +00:00
|
|
|
StyleSpan[] spans = edit.getSpans(start, end, StyleSpan.class);
|
|
|
|
for (StyleSpan span : spans)
|
2021-02-05 10:15:02 +00:00
|
|
|
if (span.getStyle() == style) {
|
2021-05-14 06:49:26 +00:00
|
|
|
int s = edit.getSpanStart(span);
|
|
|
|
int e = edit.getSpanEnd(span);
|
|
|
|
int f = edit.getSpanFlags(span);
|
2021-05-06 05:58:04 +00:00
|
|
|
edit.removeSpan(span);
|
2021-06-12 18:19:24 +00:00
|
|
|
if (splitSpan(edit, start, end, s, e, f, true,
|
|
|
|
new StyleSpan(style), new StyleSpan(style)))
|
|
|
|
has = true;
|
2019-09-27 17:05:34 +00:00
|
|
|
}
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
if (!has)
|
2021-05-06 05:58:04 +00:00
|
|
|
edit.setSpan(new StyleSpan(style), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
2019-09-27 17:05:34 +00:00
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
etBody.setText(edit);
|
2021-02-05 10:15:02 +00:00
|
|
|
etBody.setSelection(start, end);
|
2019-09-27 17:05:34 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
return true;
|
|
|
|
} else if (action == R.id.menu_underline) {
|
2021-05-14 17:20:01 +00:00
|
|
|
Log.breadcrumb("style", "action", "underline");
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
boolean has = false;
|
2021-05-14 17:16:27 +00:00
|
|
|
UnderlineSpan[] spans = edit.getSpans(start, end, UnderlineSpan.class);
|
|
|
|
for (UnderlineSpan span : spans) {
|
2021-05-14 06:49:26 +00:00
|
|
|
int s = edit.getSpanStart(span);
|
|
|
|
int e = edit.getSpanEnd(span);
|
|
|
|
int f = edit.getSpanFlags(span);
|
2021-05-06 05:58:04 +00:00
|
|
|
edit.removeSpan(span);
|
2021-06-12 18:19:24 +00:00
|
|
|
if (splitSpan(edit, start, end, s, e, f, true,
|
|
|
|
new UnderlineSpan(), new UnderlineSpan()))
|
|
|
|
has = true;
|
2019-09-27 17:05:34 +00:00
|
|
|
}
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
if (!has)
|
2021-05-06 05:58:04 +00:00
|
|
|
edit.setSpan(new UnderlineSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
2021-02-05 10:15:02 +00:00
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
etBody.setText(edit);
|
2021-02-05 10:15:02 +00:00
|
|
|
etBody.setSelection(start, end);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
} else if (action == R.id.menu_style) {
|
2021-05-11 06:08:49 +00:00
|
|
|
final Context context = anchor.getContext();
|
|
|
|
PopupMenuLifecycle popupMenu = new PopupMenuLifecycle(context, owner, anchor);
|
2021-02-05 10:15:02 +00:00
|
|
|
popupMenu.inflate(R.menu.popup_style);
|
2021-05-11 06:08:49 +00:00
|
|
|
|
|
|
|
{
|
|
|
|
SubMenu smenu = popupMenu.getMenu().findItem(R.id.menu_style_size).getSubMenu();
|
|
|
|
smenu.clear();
|
|
|
|
int[] ids = new int[]{R.id.menu_style_size_small, R.id.menu_style_size_medium, R.id.menu_style_size_large};
|
|
|
|
int[] titles = new int[]{R.string.title_style_size_small, R.string.title_style_size_medium, R.string.title_style_size_large};
|
|
|
|
float[] sizes = new float[]{HtmlHelper.FONT_SMALL, 1.0f, HtmlHelper.FONT_LARGE};
|
|
|
|
for (int i = 0; i < ids.length; i++) {
|
2021-09-09 10:52:10 +00:00
|
|
|
SpannableStringBuilder ssb = new SpannableStringBuilderEx(context.getString(titles[i]));
|
2021-05-11 06:08:49 +00:00
|
|
|
ssb.setSpan(new RelativeSizeSpan(sizes[i]), 0, ssb.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
|
|
smenu.add(R.id.group_style_size, ids[i], i, ssb);
|
|
|
|
}
|
|
|
|
}
|
2021-02-05 10:15:02 +00:00
|
|
|
|
2021-05-10 20:10:25 +00:00
|
|
|
String[] fontNameNames = anchor.getResources().getStringArray(R.array.fontNameNames);
|
|
|
|
String[] fontNameValues = anchor.getResources().getStringArray(R.array.fontNameValues);
|
2021-02-05 10:15:02 +00:00
|
|
|
SubMenu smenu = popupMenu.getMenu().findItem(R.id.menu_style_font).getSubMenu();
|
2021-05-10 20:10:25 +00:00
|
|
|
for (int i = 0; i < fontNameNames.length; i++) {
|
2021-09-09 10:52:10 +00:00
|
|
|
SpannableStringBuilder ssb = new SpannableStringBuilderEx(fontNameNames[i]);
|
2021-06-01 11:34:57 +00:00
|
|
|
ssb.setSpan(getTypefaceSpan(fontNameValues[i], context), 0, ssb.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
2021-05-10 20:10:25 +00:00
|
|
|
smenu.add(R.id.group_style_font, i, 0, ssb);
|
|
|
|
}
|
|
|
|
smenu.add(R.id.group_style_font, fontNameNames.length, 0, R.string.title_style_font_default);
|
2021-02-05 10:15:02 +00:00
|
|
|
|
2021-05-06 06:22:04 +00:00
|
|
|
int level = -1;
|
|
|
|
BulletSpan[] spans = edit.getSpans(start, end, BulletSpan.class);
|
|
|
|
for (BulletSpan span : spans)
|
|
|
|
if (span instanceof NumberSpan)
|
|
|
|
level = ((NumberSpan) span).getLevel();
|
|
|
|
else if (span instanceof BulletSpanEx)
|
|
|
|
level = ((BulletSpanEx) span).getLevel();
|
2021-07-07 20:22:01 +00:00
|
|
|
|
2021-05-06 06:22:04 +00:00
|
|
|
popupMenu.getMenu().findItem(R.id.menu_style_list_increase).setVisible(level >= 0);
|
|
|
|
popupMenu.getMenu().findItem(R.id.menu_style_list_decrease).setVisible(level > 0);
|
|
|
|
|
2021-07-07 14:39:04 +00:00
|
|
|
IndentSpan[] indents = edit.getSpans(start, end, IndentSpan.class);
|
2021-07-08 07:53:55 +00:00
|
|
|
popupMenu.getMenu().findItem(R.id.menu_style_indentation_decrease).setEnabled(indents.length > 0);
|
2021-07-07 14:39:04 +00:00
|
|
|
|
2021-07-24 07:46:56 +00:00
|
|
|
popupMenu.getMenu().findItem(R.id.menu_style_code).setEnabled(BuildConfig.DEBUG);
|
|
|
|
|
2021-05-11 06:08:49 +00:00
|
|
|
popupMenu.insertIcons(context);
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
popupMenu.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
|
|
|
|
@Override
|
|
|
|
public boolean onMenuItemClick(MenuItem item) {
|
|
|
|
try {
|
|
|
|
int groupId = item.getGroupId();
|
2021-06-20 12:45:56 +00:00
|
|
|
int itemId = item.getItemId();
|
2021-02-05 10:15:02 +00:00
|
|
|
if (groupId == R.id.group_style_size) {
|
|
|
|
return setSize(item);
|
2021-07-04 11:17:15 +00:00
|
|
|
} else if (itemId == R.id.menu_style_background) {
|
|
|
|
return setBackground(item);
|
2021-06-20 12:45:56 +00:00
|
|
|
} else if (itemId == R.id.menu_style_color) {
|
2021-02-05 10:15:02 +00:00
|
|
|
return setColor(item);
|
2021-05-07 19:23:46 +00:00
|
|
|
} else if (groupId == R.id.group_style_font) {
|
|
|
|
return setFont(item);
|
2021-02-05 10:15:02 +00:00
|
|
|
} else if (groupId == R.id.group_style_align) {
|
|
|
|
return setAlignment(item);
|
|
|
|
} else if (groupId == R.id.group_style_list) {
|
2021-05-06 06:22:04 +00:00
|
|
|
if (item.getItemId() == R.id.menu_style_list_increase ||
|
|
|
|
item.getItemId() == R.id.menu_style_list_decrease)
|
|
|
|
return setListLevel(item);
|
|
|
|
else
|
|
|
|
return setList(item);
|
2021-02-05 10:15:02 +00:00
|
|
|
} else if (groupId == R.id.group_style_blockquote) {
|
|
|
|
return setBlockQuote(item);
|
2021-07-07 14:39:04 +00:00
|
|
|
} else if (groupId == R.id.group_style_indentation) {
|
|
|
|
return setIndentation(item);
|
2021-02-05 10:15:02 +00:00
|
|
|
} else if (groupId == R.id.group_style_strikethrough) {
|
|
|
|
return setStrikeThrough(item);
|
2021-07-24 07:46:56 +00:00
|
|
|
} else if (groupId == R.id.group_style_code) {
|
|
|
|
return setCode(item);
|
2021-02-05 10:15:02 +00:00
|
|
|
} else if (groupId == R.id.group_style_clear) {
|
|
|
|
return clear(item);
|
2020-06-28 21:36:31 +00:00
|
|
|
}
|
2021-02-05 10:15:02 +00:00
|
|
|
return false;
|
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
return false;
|
2020-06-28 21:36:31 +00:00
|
|
|
}
|
2021-02-05 10:15:02 +00:00
|
|
|
}
|
2020-06-28 16:39:27 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
private boolean setSize(MenuItem item) {
|
2021-05-14 17:20:01 +00:00
|
|
|
Log.breadcrumb("style", "action", "size");
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
Float size;
|
|
|
|
if (item.getItemId() == R.id.menu_style_size_small)
|
2021-07-24 07:46:56 +00:00
|
|
|
size = HtmlHelper.FONT_SMALL;
|
2021-02-05 10:15:02 +00:00
|
|
|
else if (item.getItemId() == R.id.menu_style_size_large)
|
2021-07-24 07:46:56 +00:00
|
|
|
size = HtmlHelper.FONT_LARGE;
|
2021-02-05 10:15:02 +00:00
|
|
|
else
|
|
|
|
size = null;
|
2019-09-27 17:05:34 +00:00
|
|
|
|
2021-07-24 07:46:56 +00:00
|
|
|
return _setSize(size);
|
|
|
|
}
|
|
|
|
|
|
|
|
private boolean _setSize(Float size) {
|
2021-05-14 06:49:26 +00:00
|
|
|
RelativeSizeSpan[] spans = edit.getSpans(start, end, RelativeSizeSpan.class);
|
|
|
|
for (RelativeSizeSpan span : spans) {
|
|
|
|
int s = edit.getSpanStart(span);
|
|
|
|
int e = edit.getSpanEnd(span);
|
|
|
|
int f = edit.getSpanFlags(span);
|
|
|
|
edit.removeSpan(span);
|
2021-05-14 10:04:08 +00:00
|
|
|
splitSpan(edit, start, end, s, e, f, false,
|
2021-05-14 06:49:26 +00:00
|
|
|
new RelativeSizeSpan(span.getSizeChange()),
|
|
|
|
new RelativeSizeSpan(span.getSizeChange()));
|
|
|
|
}
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
if (size != null)
|
2021-05-06 05:58:04 +00:00
|
|
|
edit.setSpan(new RelativeSizeSpan(size), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
2019-09-27 17:05:34 +00:00
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
etBody.setText(edit);
|
|
|
|
etBody.setSelection(start, end);
|
2019-09-27 17:05:34 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
return true;
|
|
|
|
}
|
2020-10-03 12:17:13 +00:00
|
|
|
|
2021-07-04 11:17:15 +00:00
|
|
|
private boolean setBackground(MenuItem item) {
|
|
|
|
Helper.hideKeyboard(etBody);
|
|
|
|
|
|
|
|
Context context = etBody.getContext();
|
|
|
|
int editTextColor = Helper.resolveColor(context, android.R.attr.editTextColor);
|
|
|
|
|
|
|
|
ColorPickerDialogBuilder builder = ColorPickerDialogBuilder
|
|
|
|
.with(context)
|
|
|
|
.setTitle(R.string.title_background)
|
|
|
|
.showColorEdit(true)
|
|
|
|
.setColorEditTextColor(editTextColor)
|
|
|
|
.wheelType(ColorPickerView.WHEEL_TYPE.FLOWER)
|
|
|
|
.density(6)
|
2021-07-05 14:55:31 +00:00
|
|
|
//.lightnessSliderOnly()
|
2021-07-04 11:17:15 +00:00
|
|
|
.setPositiveButton(android.R.string.ok, new ColorPickerClickListener() {
|
|
|
|
@Override
|
|
|
|
public void onClick(DialogInterface dialog, int selectedColor, Integer[] allColors) {
|
|
|
|
_setBackground(selectedColor);
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.setNegativeButton(R.string.title_reset, new DialogInterface.OnClickListener() {
|
|
|
|
@Override
|
|
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
|
|
_setBackground(null);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2021-07-15 12:28:34 +00:00
|
|
|
BackgroundColorSpan[] spans = edit.getSpans(start, end, BackgroundColorSpan.class);
|
|
|
|
if (spans != null && spans.length == 1)
|
|
|
|
builder.initialColor(spans[0].getBackgroundColor());
|
|
|
|
|
2021-07-04 11:17:15 +00:00
|
|
|
builder.build().show();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
private void _setBackground(Integer color) {
|
|
|
|
Log.breadcrumb("style", "action", "background");
|
|
|
|
|
|
|
|
BackgroundColorSpan spans[] = edit.getSpans(start, end, BackgroundColorSpan.class);
|
|
|
|
for (BackgroundColorSpan span : spans) {
|
|
|
|
int s = edit.getSpanStart(span);
|
|
|
|
int e = edit.getSpanEnd(span);
|
|
|
|
int f = edit.getSpanFlags(span);
|
|
|
|
edit.removeSpan(span);
|
|
|
|
splitSpan(edit, start, end, s, e, f, false,
|
|
|
|
new BackgroundColorSpan(span.getBackgroundColor()),
|
|
|
|
new BackgroundColorSpan(span.getBackgroundColor()));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (color != null)
|
|
|
|
edit.setSpan(new BackgroundColorSpan(color), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
|
|
|
|
|
|
etBody.setText(edit);
|
|
|
|
etBody.setSelection(start, end);
|
|
|
|
}
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
private boolean setColor(MenuItem item) {
|
2021-04-27 14:40:27 +00:00
|
|
|
Helper.hideKeyboard(etBody);
|
2021-02-05 10:15:02 +00:00
|
|
|
|
|
|
|
Context context = etBody.getContext();
|
|
|
|
int editTextColor = Helper.resolveColor(context, android.R.attr.editTextColor);
|
|
|
|
|
|
|
|
ColorPickerDialogBuilder builder = ColorPickerDialogBuilder
|
|
|
|
.with(context)
|
|
|
|
.setTitle(R.string.title_color)
|
|
|
|
.showColorEdit(true)
|
|
|
|
.setColorEditTextColor(editTextColor)
|
|
|
|
.wheelType(ColorPickerView.WHEEL_TYPE.FLOWER)
|
|
|
|
.density(6)
|
2021-07-05 14:55:31 +00:00
|
|
|
//.lightnessSliderOnly()
|
2021-02-05 10:15:02 +00:00
|
|
|
.setPositiveButton(android.R.string.ok, new ColorPickerClickListener() {
|
|
|
|
@Override
|
|
|
|
public void onClick(DialogInterface dialog, int selectedColor, Integer[] allColors) {
|
|
|
|
_setColor(selectedColor);
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.setNegativeButton(R.string.title_reset, new DialogInterface.OnClickListener() {
|
|
|
|
@Override
|
|
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
|
|
_setColor(null);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2021-07-15 12:28:34 +00:00
|
|
|
ForegroundColorSpan[] spans = edit.getSpans(start, end, ForegroundColorSpan.class);
|
|
|
|
if (spans != null && spans.length == 1)
|
|
|
|
builder.initialColor(spans[0].getForegroundColor());
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
builder.build().show();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2020-10-03 09:37:43 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
private void _setColor(Integer color) {
|
2021-05-14 17:20:01 +00:00
|
|
|
Log.breadcrumb("style", "action", "color");
|
|
|
|
|
2021-05-14 17:16:27 +00:00
|
|
|
ForegroundColorSpan spans[] = edit.getSpans(start, end, ForegroundColorSpan.class);
|
|
|
|
for (ForegroundColorSpan span : spans) {
|
2021-05-14 06:49:26 +00:00
|
|
|
int s = edit.getSpanStart(span);
|
|
|
|
int e = edit.getSpanEnd(span);
|
|
|
|
int f = edit.getSpanFlags(span);
|
2021-05-06 05:58:04 +00:00
|
|
|
edit.removeSpan(span);
|
2021-05-14 06:49:26 +00:00
|
|
|
splitSpan(edit, start, end, s, e, f, false,
|
|
|
|
new ForegroundColorSpan(span.getForegroundColor()),
|
|
|
|
new ForegroundColorSpan(span.getForegroundColor()));
|
|
|
|
}
|
2020-10-03 09:37:43 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
if (color != null)
|
2021-05-06 05:58:04 +00:00
|
|
|
edit.setSpan(new ForegroundColorSpan(color), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
2020-10-03 09:37:43 +00:00
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
etBody.setText(edit);
|
|
|
|
etBody.setSelection(start, end);
|
2021-02-05 10:15:02 +00:00
|
|
|
}
|
2020-10-03 09:37:43 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
private boolean setAlignment(MenuItem item) {
|
2021-05-14 17:20:01 +00:00
|
|
|
Log.breadcrumb("style", "action", "alignment");
|
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
Pair<Integer, Integer> paragraph = ensureParagraph(edit, start, end);
|
2021-07-06 17:25:00 +00:00
|
|
|
if (paragraph == null)
|
|
|
|
return false;
|
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
int s = paragraph.first;
|
|
|
|
int e = paragraph.second;
|
2021-02-05 10:15:02 +00:00
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
AlignmentSpan[] spans = edit.getSpans(s, e, AlignmentSpan.class);
|
2021-02-05 10:15:02 +00:00
|
|
|
for (AlignmentSpan span : spans)
|
2021-05-06 05:58:04 +00:00
|
|
|
edit.removeSpan(span);
|
2021-02-05 10:15:02 +00:00
|
|
|
|
|
|
|
Layout.Alignment alignment = null;
|
|
|
|
boolean ltr = (TextUtils.getLayoutDirectionFromLocale(Locale.getDefault()) == View.LAYOUT_DIRECTION_LTR);
|
|
|
|
int itemId = item.getItemId();
|
|
|
|
if (itemId == R.id.menu_style_align_start) {
|
|
|
|
alignment = (ltr ? Layout.Alignment.ALIGN_NORMAL : Layout.Alignment.ALIGN_OPPOSITE);
|
|
|
|
} else if (itemId == R.id.menu_style_align_center) {
|
|
|
|
alignment = Layout.Alignment.ALIGN_CENTER;
|
|
|
|
} else if (itemId == R.id.menu_style_align_end) {
|
|
|
|
alignment = (ltr ? Layout.Alignment.ALIGN_OPPOSITE : Layout.Alignment.ALIGN_NORMAL);
|
2020-10-03 09:37:43 +00:00
|
|
|
}
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
if (alignment != null)
|
2021-05-06 05:58:04 +00:00
|
|
|
edit.setSpan(new AlignmentSpan.Standard(alignment),
|
|
|
|
s, e, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE | Spanned.SPAN_PARAGRAPH);
|
2020-08-12 08:25:08 +00:00
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
etBody.setText(edit);
|
|
|
|
etBody.setSelection(s, e);
|
2020-08-14 18:32:05 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
return true;
|
|
|
|
}
|
2020-08-12 06:18:39 +00:00
|
|
|
|
2021-05-06 06:22:04 +00:00
|
|
|
private boolean setListLevel(MenuItem item) {
|
2021-05-14 17:20:01 +00:00
|
|
|
Log.breadcrumb("style", "action", "level");
|
|
|
|
|
2021-05-06 06:22:04 +00:00
|
|
|
Context context = etBody.getContext();
|
|
|
|
int add = (item.getItemId() == R.id.menu_style_list_increase ? 1 : -1);
|
|
|
|
|
|
|
|
boolean renum = false;
|
|
|
|
BulletSpan[] spans = edit.getSpans(start, end, BulletSpan.class);
|
|
|
|
for (BulletSpan span : spans)
|
|
|
|
if (span instanceof BulletSpanEx) {
|
|
|
|
BulletSpanEx bs = (BulletSpanEx) span;
|
|
|
|
bs.setLevel(bs.getLevel() + add);
|
|
|
|
} else if (span instanceof NumberSpan) {
|
|
|
|
renum = true;
|
|
|
|
NumberSpan ns = (NumberSpan) span;
|
|
|
|
ns.setLevel(ns.getLevel() + add);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (renum)
|
|
|
|
renumber(edit, false, context);
|
|
|
|
|
|
|
|
etBody.setText(edit);
|
|
|
|
etBody.setSelection(start, end);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
private boolean setList(MenuItem item) {
|
2021-05-14 17:20:01 +00:00
|
|
|
Log.breadcrumb("style", "action", "list");
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
Context context = etBody.getContext();
|
|
|
|
|
|
|
|
int colorAccent = Helper.resolveColor(context, R.attr.colorAccent);
|
2021-05-07 12:09:16 +00:00
|
|
|
int bulletGap = context.getResources().getDimensionPixelSize(R.dimen.bullet_gap_size);
|
|
|
|
int bulletRadius = context.getResources().getDimensionPixelSize(R.dimen.bullet_radius_size);
|
|
|
|
int bulletIndent = context.getResources().getDimensionPixelSize(R.dimen.bullet_indent_size);
|
2021-02-05 10:15:02 +00:00
|
|
|
|
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
|
|
|
|
int message_zoom = prefs.getInt("message_zoom", 100);
|
|
|
|
float textSize = Helper.getTextSize(context, 0) * message_zoom / 100f;
|
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
Pair<Integer, Integer> paragraph = ensureParagraph(edit, start, end);
|
2021-07-06 17:25:00 +00:00
|
|
|
if (paragraph == null)
|
|
|
|
return false;
|
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
int s = paragraph.first;
|
|
|
|
int e = paragraph.second;
|
2021-02-05 10:15:02 +00:00
|
|
|
|
|
|
|
// Remove existing bullets
|
2021-05-06 05:58:04 +00:00
|
|
|
BulletSpan[] spans = edit.getSpans(s, e, BulletSpan.class);
|
2021-02-05 10:15:02 +00:00
|
|
|
for (BulletSpan span : spans)
|
2021-05-06 05:58:04 +00:00
|
|
|
edit.removeSpan(span);
|
2021-02-05 10:15:02 +00:00
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
int i = s;
|
|
|
|
int j = s + 1;
|
2021-02-05 10:15:02 +00:00
|
|
|
int index = 1;
|
2021-05-06 05:58:04 +00:00
|
|
|
while (j < e) {
|
|
|
|
if (i > 0 && edit.charAt(i - 1) == '\n' && edit.charAt(j) == '\n') {
|
|
|
|
Log.i("Insert " + i + "..." + (j + 1) + " size=" + e);
|
2021-02-05 10:15:02 +00:00
|
|
|
if (item.getItemId() == R.id.menu_style_list_bullets)
|
|
|
|
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P)
|
2021-05-07 12:09:16 +00:00
|
|
|
edit.setSpan(new BulletSpanEx(bulletIndent, bulletGap, colorAccent, 0), i, j + 1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE | Spanned.SPAN_PARAGRAPH);
|
2020-08-12 06:18:39 +00:00
|
|
|
else
|
2021-05-07 12:09:16 +00:00
|
|
|
edit.setSpan(new BulletSpanEx(bulletIndent, bulletGap, colorAccent, bulletRadius, 0), i, j + 1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE | Spanned.SPAN_PARAGRAPH);
|
2021-05-06 18:46:50 +00:00
|
|
|
else
|
2021-05-07 12:09:16 +00:00
|
|
|
edit.setSpan(new NumberSpan(bulletIndent, bulletGap, colorAccent, textSize, 0, index++), i, j + 1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE | Spanned.SPAN_PARAGRAPH);
|
2020-08-12 06:18:39 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
i = j + 1;
|
2020-08-11 16:46:26 +00:00
|
|
|
}
|
2021-02-05 10:15:02 +00:00
|
|
|
j++;
|
2020-08-11 16:46:26 +00:00
|
|
|
}
|
|
|
|
|
2021-05-06 18:46:50 +00:00
|
|
|
renumber(edit, false, context);
|
2021-05-06 06:22:04 +00:00
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
etBody.setText(edit);
|
|
|
|
etBody.setSelection(s, e);
|
2020-06-28 21:36:31 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
return true;
|
|
|
|
}
|
2019-09-27 17:05:34 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
private boolean setFont(MenuItem item) {
|
2021-05-14 17:20:01 +00:00
|
|
|
Log.breadcrumb("style", "action", "font");
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
int id = item.getItemId();
|
|
|
|
String[] names = anchor.getResources().getStringArray(R.array.fontNameValues);
|
|
|
|
String face = (id < names.length ? names[id] : null);
|
2020-06-28 21:36:31 +00:00
|
|
|
|
2021-07-24 07:46:56 +00:00
|
|
|
return _setFont(face);
|
|
|
|
}
|
|
|
|
|
|
|
|
private boolean _setFont(String face) {
|
2021-05-14 06:49:26 +00:00
|
|
|
TypefaceSpan[] spans = edit.getSpans(start, end, TypefaceSpan.class);
|
|
|
|
for (TypefaceSpan span : spans) {
|
|
|
|
int s = edit.getSpanStart(span);
|
|
|
|
int e = edit.getSpanEnd(span);
|
|
|
|
int f = edit.getSpanFlags(span);
|
|
|
|
edit.removeSpan(span);
|
|
|
|
splitSpan(edit, start, end, s, e, f, false,
|
2021-06-01 11:34:57 +00:00
|
|
|
getTypefaceSpan(span.getFamily(), context),
|
|
|
|
getTypefaceSpan(span.getFamily(), context));
|
2021-05-14 06:49:26 +00:00
|
|
|
}
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
if (face != null)
|
2021-06-01 11:34:57 +00:00
|
|
|
edit.setSpan(getTypefaceSpan(face, context), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
2020-06-28 21:36:31 +00:00
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
etBody.setText(edit);
|
|
|
|
etBody.setSelection(start, end);
|
2020-10-01 08:22:20 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
return true;
|
|
|
|
}
|
2020-11-17 20:22:02 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
private boolean setBlockQuote(MenuItem item) {
|
2021-05-14 17:20:01 +00:00
|
|
|
Log.breadcrumb("style", "action", "quote");
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
Context context = etBody.getContext();
|
2020-10-01 08:22:20 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
int colorPrimary = Helper.resolveColor(context, R.attr.colorPrimary);
|
2021-07-05 04:53:21 +00:00
|
|
|
final int colorBlockquote = Helper.resolveColor(context, R.attr.colorBlockquote, colorPrimary);
|
2021-05-07 12:19:59 +00:00
|
|
|
int quoteGap = context.getResources().getDimensionPixelSize(R.dimen.quote_gap_size);
|
|
|
|
int quoteStripe = context.getResources().getDimensionPixelSize(R.dimen.quote_stripe_width);
|
2020-10-01 08:22:20 +00:00
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
Pair<Integer, Integer> paragraph = ensureParagraph(edit, start, end);
|
2021-07-06 17:25:00 +00:00
|
|
|
if (paragraph == null)
|
|
|
|
return false;
|
2020-10-01 08:22:20 +00:00
|
|
|
|
2021-07-07 14:39:04 +00:00
|
|
|
QuoteSpan[] quotes = edit.getSpans(paragraph.first, paragraph.second, QuoteSpan.class);
|
|
|
|
for (QuoteSpan quote : quotes)
|
|
|
|
edit.removeSpan(quote);
|
|
|
|
|
|
|
|
if (quotes.length == 1)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
IndentSpan[] indents = edit.getSpans(start, end, IndentSpan.class);
|
|
|
|
for (IndentSpan indent : indents)
|
|
|
|
edit.removeSpan(indent);
|
|
|
|
|
2021-07-06 17:23:03 +00:00
|
|
|
QuoteSpan q;
|
|
|
|
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P)
|
|
|
|
q = new QuoteSpan(colorBlockquote);
|
|
|
|
else
|
|
|
|
q = new QuoteSpan(colorBlockquote, quoteStripe, quoteGap);
|
|
|
|
edit.setSpan(q, paragraph.first, paragraph.second, Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
|
2020-10-01 08:31:58 +00:00
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
etBody.setText(edit);
|
2021-05-14 06:49:26 +00:00
|
|
|
etBody.setSelection(paragraph.first, paragraph.second);
|
2020-10-01 08:31:58 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
return true;
|
|
|
|
}
|
2020-10-01 08:31:58 +00:00
|
|
|
|
2021-07-07 14:39:04 +00:00
|
|
|
private boolean setIndentation(MenuItem item) {
|
|
|
|
Log.breadcrumb("style", "action", "indent");
|
|
|
|
|
|
|
|
Pair<Integer, Integer> paragraph = ensureParagraph(edit, start, end);
|
|
|
|
if (paragraph == null)
|
|
|
|
return false;
|
|
|
|
|
2021-07-08 05:28:46 +00:00
|
|
|
Context context = etBody.getContext();
|
|
|
|
int intentSize = context.getResources().getDimensionPixelSize(R.dimen.indent_size);
|
|
|
|
|
|
|
|
QuoteSpan[] quotes = edit.getSpans(start, end, QuoteSpan.class);
|
|
|
|
for (QuoteSpan quote : quotes)
|
|
|
|
edit.removeSpan(quote);
|
2021-07-07 14:39:04 +00:00
|
|
|
|
2021-07-08 05:28:46 +00:00
|
|
|
int prev = paragraph.first;
|
|
|
|
int next = paragraph.first;
|
|
|
|
while (next < paragraph.second) {
|
|
|
|
while (next < paragraph.second && edit.charAt(next) != '\n')
|
|
|
|
next++;
|
|
|
|
|
|
|
|
if (item.getItemId() == R.id.menu_style_indentation_decrease) {
|
|
|
|
IndentSpan[] indents = edit.getSpans(prev, prev, IndentSpan.class);
|
|
|
|
if (indents.length > 0)
|
|
|
|
edit.removeSpan(indents[0]);
|
|
|
|
} else {
|
|
|
|
IndentSpan is = new IndentSpan(intentSize);
|
2022-01-19 20:11:06 +00:00
|
|
|
edit.setSpan(is, prev, next + 1, Spanned.SPAN_INCLUSIVE_INCLUSIVE);
|
2021-07-08 05:28:46 +00:00
|
|
|
}
|
2021-07-07 14:39:04 +00:00
|
|
|
|
2021-07-08 05:28:46 +00:00
|
|
|
next++;
|
|
|
|
prev = next;
|
2021-07-07 14:39:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
etBody.setText(edit);
|
|
|
|
etBody.setSelection(paragraph.first, paragraph.second);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
private boolean setStrikeThrough(MenuItem item) {
|
2021-05-14 17:20:01 +00:00
|
|
|
Log.breadcrumb("style", "action", "strike");
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
boolean has = false;
|
2021-05-14 17:16:27 +00:00
|
|
|
StrikethroughSpan[] spans = edit.getSpans(start, end, StrikethroughSpan.class);
|
|
|
|
for (StrikethroughSpan span : spans) {
|
2021-05-14 06:49:26 +00:00
|
|
|
int s = edit.getSpanStart(span);
|
|
|
|
int e = edit.getSpanEnd(span);
|
|
|
|
int f = edit.getSpanFlags(span);
|
2021-05-06 05:58:04 +00:00
|
|
|
edit.removeSpan(span);
|
2021-06-12 18:19:24 +00:00
|
|
|
if (splitSpan(edit, start, end, s, e, f, true,
|
|
|
|
new StrikethroughSpan(), new StrikethroughSpan()))
|
|
|
|
has = true;
|
2020-10-01 08:31:58 +00:00
|
|
|
}
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
if (!has)
|
2021-05-06 05:58:04 +00:00
|
|
|
edit.setSpan(new StrikethroughSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
2020-11-17 20:55:02 +00:00
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
etBody.setText(edit);
|
|
|
|
etBody.setSelection(start, end);
|
2020-11-17 20:55:02 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
return true;
|
|
|
|
}
|
2020-11-17 19:22:34 +00:00
|
|
|
|
2021-07-24 07:46:56 +00:00
|
|
|
private boolean setCode(MenuItem item) {
|
|
|
|
_setSize(HtmlHelper.FONT_SMALL);
|
|
|
|
_setFont("monospace");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
private boolean clear(MenuItem item) {
|
2021-05-14 17:20:01 +00:00
|
|
|
Log.breadcrumb("style", "action", "clear");
|
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
int e = end;
|
2020-06-28 21:36:31 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
// Expand to paragraph (block quotes)
|
2021-05-06 05:58:04 +00:00
|
|
|
if (e + 1 < edit.length() && edit.charAt(e) == '\n')
|
|
|
|
e++;
|
2020-06-28 21:36:31 +00:00
|
|
|
|
2021-09-12 06:43:55 +00:00
|
|
|
for (Object span : edit.getSpans(start, e, Object.class)) {
|
2022-01-08 11:05:36 +00:00
|
|
|
boolean has = false;
|
|
|
|
for (Class cls : CLEAR_STYLES)
|
|
|
|
if (cls.isAssignableFrom(span.getClass())) {
|
|
|
|
has = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!has)
|
2021-09-12 06:43:55 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
int sstart = edit.getSpanStart(span);
|
|
|
|
int send = edit.getSpanEnd(span);
|
|
|
|
int flags = edit.getSpanFlags(span);
|
|
|
|
|
|
|
|
if (sstart < start && send > start)
|
|
|
|
setSpan(edit, span, sstart, start, flags, etBody.getContext());
|
|
|
|
if (sstart < end && send > end)
|
|
|
|
setSpan(edit, span, e, send, flags, etBody.getContext());
|
|
|
|
|
|
|
|
edit.removeSpan(span);
|
|
|
|
}
|
2019-09-27 17:05:34 +00:00
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
etBody.setText(edit);
|
|
|
|
etBody.setSelection(start, e);
|
2019-12-29 12:13:52 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
return true;
|
2019-09-27 17:05:34 +00:00
|
|
|
}
|
2021-02-05 10:15:02 +00:00
|
|
|
});
|
2019-09-27 17:05:34 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
popupMenu.show();
|
2019-12-29 12:13:52 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
return true;
|
|
|
|
} else if (action == R.id.menu_link) {
|
2021-05-14 17:20:01 +00:00
|
|
|
Log.breadcrumb("style", "action", "link");
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
String url = (String) args[0];
|
2019-09-27 17:05:34 +00:00
|
|
|
|
2021-05-30 16:15:50 +00:00
|
|
|
List<CharacterStyle> spans = new ArrayList<>();
|
|
|
|
Map<CharacterStyle, Pair<Integer, Integer>> ranges = new HashMap<>();
|
|
|
|
Map<CharacterStyle, Integer> flags = new HashMap<>();
|
|
|
|
for (CharacterStyle span : edit.getSpans(start, end, CharacterStyle.class)) {
|
|
|
|
if (!(span instanceof URLSpan)) {
|
2021-02-05 10:15:02 +00:00
|
|
|
spans.add(span);
|
2021-05-30 16:15:50 +00:00
|
|
|
ranges.put(span, new Pair<>(edit.getSpanStart(span), edit.getSpanEnd(span)));
|
|
|
|
flags.put(span, edit.getSpanFlags(span));
|
|
|
|
}
|
2021-05-06 05:58:04 +00:00
|
|
|
edit.removeSpan(span);
|
2021-02-05 10:15:02 +00:00
|
|
|
}
|
2019-09-27 17:05:34 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
if (url != null) {
|
2021-05-06 05:58:04 +00:00
|
|
|
int e = end;
|
2021-02-05 10:15:02 +00:00
|
|
|
if (start == end) {
|
|
|
|
etBody.getText().insert(start, url);
|
2021-05-06 05:58:04 +00:00
|
|
|
e += url.length();
|
2021-02-05 10:15:02 +00:00
|
|
|
}
|
2019-09-27 17:05:34 +00:00
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
edit.setSpan(new URLSpan(url), start, e, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
2019-09-27 17:05:34 +00:00
|
|
|
}
|
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
// Restore other spans
|
2021-05-30 16:15:50 +00:00
|
|
|
for (CharacterStyle span : spans)
|
|
|
|
edit.setSpan(span,
|
|
|
|
ranges.get(span).first,
|
|
|
|
ranges.get(span).second,
|
|
|
|
flags.get(span));
|
2019-09-29 10:10:19 +00:00
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
etBody.setText(edit);
|
2021-02-05 10:15:02 +00:00
|
|
|
etBody.setSelection(end, end);
|
2019-09-29 10:10:19 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
return true;
|
|
|
|
} else if (action == R.id.menu_clear) {
|
2021-05-14 17:20:01 +00:00
|
|
|
Log.breadcrumb("style", "action", "clear/all");
|
|
|
|
|
2021-09-12 06:43:55 +00:00
|
|
|
for (Object span : edit.getSpans(0, etBody.length(), Object.class)) {
|
2021-09-23 14:17:49 +00:00
|
|
|
if (!CLEAR_STYLES.contains(span.getClass()))
|
2021-09-12 06:43:55 +00:00
|
|
|
continue;
|
|
|
|
edit.removeSpan(span);
|
|
|
|
}
|
2021-02-05 10:15:02 +00:00
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
etBody.setText(edit);
|
2021-02-05 10:15:02 +00:00
|
|
|
etBody.setSelection(start, end);
|
2019-09-29 10:10:19 +00:00
|
|
|
|
2021-02-05 10:15:02 +00:00
|
|
|
return true;
|
2019-09-27 17:05:34 +00:00
|
|
|
}
|
2021-02-05 10:15:02 +00:00
|
|
|
return false;
|
2019-09-27 17:05:34 +00:00
|
|
|
} catch (Throwable ex) {
|
|
|
|
Log.e(ex);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2020-11-17 18:37:56 +00:00
|
|
|
|
2021-06-12 18:19:24 +00:00
|
|
|
static boolean splitSpan(Editable edit, int start, int end, int s, int e, int f, boolean extend, Object span1, Object span2) {
|
2021-05-14 17:20:01 +00:00
|
|
|
if (start < 0 || end < 0) {
|
|
|
|
Log.e(span1 + " invalid selection=" + start + "..." + end);
|
2021-06-12 18:19:24 +00:00
|
|
|
return false;
|
2021-05-14 17:20:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (s < 0 || e < 0) {
|
|
|
|
Log.e(span1 + " not attached=" + s + "..." + e);
|
2021-06-12 18:19:24 +00:00
|
|
|
return false;
|
2021-05-14 17:20:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (s > e) {
|
|
|
|
int tmp = s;
|
|
|
|
s = e;
|
|
|
|
e = tmp;
|
|
|
|
}
|
|
|
|
|
2021-05-14 06:49:26 +00:00
|
|
|
if (start < s && end > s && end < e) {
|
|
|
|
// overlap before
|
|
|
|
if (extend)
|
|
|
|
edit.setSpan(span1, start, e, f);
|
|
|
|
else
|
|
|
|
edit.setSpan(span1, end, e, f);
|
2021-06-12 18:19:24 +00:00
|
|
|
return true;
|
2021-05-14 06:49:26 +00:00
|
|
|
} else if (start < e && end > e && start > s) {
|
|
|
|
// overlap after
|
|
|
|
if (extend)
|
|
|
|
edit.setSpan(span1, s, end, f);
|
|
|
|
else
|
|
|
|
edit.setSpan(span1, s, start, f);
|
2021-06-12 18:19:24 +00:00
|
|
|
return true;
|
2021-05-14 06:49:26 +00:00
|
|
|
} else if (start < s && end > e) {
|
|
|
|
// overlap all
|
2021-06-12 18:19:24 +00:00
|
|
|
if (extend) {
|
2021-05-14 06:49:26 +00:00
|
|
|
edit.setSpan(span1, start, end, f);
|
2021-06-12 18:19:24 +00:00
|
|
|
return true;
|
|
|
|
}
|
2021-06-01 11:52:33 +00:00
|
|
|
} else if (start >= s && end <= e) {
|
2021-06-12 18:19:24 +00:00
|
|
|
if (start == s && end == e)
|
|
|
|
return true;
|
|
|
|
|
2021-05-14 06:49:26 +00:00
|
|
|
// overlap inner
|
2021-06-01 11:52:33 +00:00
|
|
|
if (s < start)
|
|
|
|
edit.setSpan(span1, s, start, f);
|
|
|
|
if (end < e)
|
|
|
|
edit.setSpan(span2, end, e, f);
|
2021-06-12 18:19:24 +00:00
|
|
|
if (s < start || end < e)
|
|
|
|
return true;
|
2021-05-14 06:49:26 +00:00
|
|
|
}
|
2021-06-12 18:19:24 +00:00
|
|
|
|
|
|
|
return false;
|
2021-05-14 06:49:26 +00:00
|
|
|
}
|
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
static void setSpan(Editable edit, Object span, int start, int end, int flags, Context context) {
|
2020-11-17 19:22:34 +00:00
|
|
|
if (span instanceof CharacterStyle)
|
2021-05-06 05:58:04 +00:00
|
|
|
edit.setSpan(CharacterStyle.wrap((CharacterStyle) span), start, end, flags);
|
2020-11-17 19:22:34 +00:00
|
|
|
else if (span instanceof QuoteSpan) {
|
2020-11-17 20:22:02 +00:00
|
|
|
ParagraphStyle ps = (ParagraphStyle) span;
|
2021-05-06 05:58:04 +00:00
|
|
|
Pair<Integer, Integer> p = ensureParagraph(edit, start, end);
|
2021-07-06 17:25:00 +00:00
|
|
|
if (p == null)
|
|
|
|
return;
|
2021-05-06 05:58:04 +00:00
|
|
|
edit.setSpan(clone(span, ps.getClass(), context), p.first, p.second, flags);
|
2020-11-17 20:22:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
static private Pair<Integer, Integer> ensureParagraph(Editable edit, int s, int e) {
|
2020-11-17 20:22:02 +00:00
|
|
|
int start = s;
|
|
|
|
int end = e;
|
|
|
|
|
|
|
|
// Expand selection at start
|
2021-05-06 05:58:04 +00:00
|
|
|
while (start > 0 && edit.charAt(start - 1) != '\n')
|
2020-11-17 20:22:02 +00:00
|
|
|
start--;
|
|
|
|
|
|
|
|
// Expand selection at end
|
2021-05-06 05:58:04 +00:00
|
|
|
while (end > 0 && end < edit.length() && edit.charAt(end - 1) != '\n')
|
2020-11-17 20:22:02 +00:00
|
|
|
end++;
|
|
|
|
|
|
|
|
// Nothing to do
|
|
|
|
if (start == end)
|
|
|
|
return null;
|
|
|
|
|
|
|
|
// Create paragraph at start
|
2021-05-06 05:58:04 +00:00
|
|
|
if (start == 0 && edit.charAt(start) != '\n') {
|
|
|
|
edit.insert(0, "\n");
|
2020-11-17 20:22:02 +00:00
|
|
|
start++;
|
|
|
|
end++;
|
2020-11-17 19:22:34 +00:00
|
|
|
}
|
2020-11-17 20:22:02 +00:00
|
|
|
|
|
|
|
// Create paragraph at end
|
2021-05-06 05:58:04 +00:00
|
|
|
if (end == edit.length() && edit.charAt(end - 1) != '\n') {
|
|
|
|
edit.append("\n");
|
2020-11-17 20:22:02 +00:00
|
|
|
end++;
|
|
|
|
}
|
|
|
|
|
2021-05-06 05:58:04 +00:00
|
|
|
if (end == edit.length())
|
|
|
|
edit.append("\n"); // workaround Android bug
|
2020-11-17 20:22:02 +00:00
|
|
|
|
2021-05-06 06:22:04 +00:00
|
|
|
return new Pair<>(start, end);
|
2020-11-17 19:22:34 +00:00
|
|
|
}
|
|
|
|
|
2020-11-17 18:37:56 +00:00
|
|
|
static <T extends ParagraphStyle> T clone(Object span, Class<T> type, Context context) {
|
|
|
|
if (QuoteSpan.class.isAssignableFrom(type)) {
|
|
|
|
QuoteSpan q = (QuoteSpan) span;
|
|
|
|
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P)
|
|
|
|
return (T) new QuoteSpan(q.getColor());
|
|
|
|
else
|
|
|
|
return (T) new QuoteSpan(q.getColor(), q.getStripeWidth(), q.getGapWidth());
|
|
|
|
} else if (NumberSpan.class.isAssignableFrom(type)) {
|
|
|
|
NumberSpan n = (NumberSpan) span;
|
2021-05-07 12:09:16 +00:00
|
|
|
int bulletGap = context.getResources().getDimensionPixelSize(R.dimen.bullet_gap_size);
|
|
|
|
int bulletIndent = context.getResources().getDimensionPixelSize(R.dimen.bullet_indent_size);
|
2020-11-17 18:37:56 +00:00
|
|
|
int colorAccent = Helper.resolveColor(context, R.attr.colorAccent);
|
2021-05-07 12:09:16 +00:00
|
|
|
return (T) new NumberSpan(bulletIndent, bulletGap, colorAccent, n.getTextSize(), n.getLevel(), n.getIndex() + 1);
|
2021-05-06 06:22:04 +00:00
|
|
|
} else if (BulletSpanEx.class.isAssignableFrom(type)) {
|
|
|
|
BulletSpanEx b = (BulletSpanEx) span;
|
2021-05-07 12:09:16 +00:00
|
|
|
int bulletIndent = context.getResources().getDimensionPixelSize(R.dimen.bullet_indent_size);
|
2020-11-17 18:37:56 +00:00
|
|
|
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) {
|
|
|
|
int colorAccent = Helper.resolveColor(context, R.attr.colorAccent);
|
2021-05-07 12:09:16 +00:00
|
|
|
int bulletGap = context.getResources().getDimensionPixelSize(R.dimen.bullet_gap_size);
|
|
|
|
return (T) new BulletSpanEx(bulletIndent, bulletGap, colorAccent, b.getLevel());
|
2020-11-17 18:37:56 +00:00
|
|
|
} else
|
2021-05-07 12:09:16 +00:00
|
|
|
return (T) new BulletSpanEx(bulletIndent, b.getGapWidth(), b.getColor(), b.getBulletRadius(), b.getLevel());
|
2020-11-17 18:37:56 +00:00
|
|
|
|
|
|
|
} else
|
|
|
|
throw new IllegalArgumentException(type.getName());
|
|
|
|
}
|
|
|
|
|
|
|
|
static void renumber(Editable text, boolean clean, Context context) {
|
2021-05-07 12:09:16 +00:00
|
|
|
int bulletGap = context.getResources().getDimensionPixelSize(R.dimen.bullet_gap_size);
|
|
|
|
int bulletIndent = context.getResources().getDimensionPixelSize(R.dimen.bullet_indent_size);
|
2020-11-17 18:37:56 +00:00
|
|
|
int colorAccent = Helper.resolveColor(context, R.attr.colorAccent);
|
|
|
|
|
|
|
|
Log.i("Renumber clean=" + clean + " text=" + text);
|
|
|
|
|
|
|
|
int next;
|
|
|
|
int pos = -1;
|
2021-05-06 06:22:04 +00:00
|
|
|
List<Integer> levels = new ArrayList<>();
|
2020-11-17 18:37:56 +00:00
|
|
|
for (int i = 0; i < text.length(); i = next) {
|
|
|
|
next = text.nextSpanTransition(i, text.length(), NumberSpan.class);
|
|
|
|
Log.i("Bullet span next=" + next);
|
|
|
|
|
|
|
|
BulletSpan[] spans = text.getSpans(i, next, BulletSpan.class);
|
|
|
|
for (BulletSpan span : spans) {
|
|
|
|
int start = text.getSpanStart(span);
|
|
|
|
int end = text.getSpanEnd(span);
|
|
|
|
int flags = text.getSpanFlags(span);
|
|
|
|
Log.i("Bullet span " + start + "..." + end);
|
|
|
|
|
|
|
|
if (clean && start == end) {
|
|
|
|
text.removeSpan(span);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2021-05-06 06:22:04 +00:00
|
|
|
int level;
|
|
|
|
if (span instanceof NumberSpan)
|
|
|
|
level = ((NumberSpan) span).getLevel();
|
|
|
|
else if (span instanceof BulletSpanEx)
|
|
|
|
level = ((BulletSpanEx) span).getLevel();
|
|
|
|
else
|
|
|
|
level = 0;
|
|
|
|
|
|
|
|
if (start != pos)
|
|
|
|
levels.clear();
|
|
|
|
while (levels.size() > level + 1)
|
|
|
|
levels.remove(levels.size() - 1);
|
|
|
|
if (levels.size() == level + 1 && !(span instanceof NumberSpan))
|
2021-05-06 18:46:50 +00:00
|
|
|
levels.remove(level);
|
2021-05-06 06:22:04 +00:00
|
|
|
while (levels.size() < level + 1)
|
|
|
|
levels.add(0);
|
|
|
|
|
|
|
|
int index = levels.get(level) + 1;
|
|
|
|
levels.remove(level);
|
|
|
|
levels.add(level, index);
|
2020-11-17 18:37:56 +00:00
|
|
|
|
2021-05-06 06:22:04 +00:00
|
|
|
if (span instanceof NumberSpan) {
|
2020-11-17 18:37:56 +00:00
|
|
|
NumberSpan ns = (NumberSpan) span;
|
|
|
|
if (index != ns.getIndex()) {
|
|
|
|
text.removeSpan(span);
|
2021-05-06 06:22:04 +00:00
|
|
|
// Text size needs measuring
|
2021-05-07 12:09:16 +00:00
|
|
|
NumberSpan clone = new NumberSpan(bulletIndent, bulletGap, colorAccent, ns.getTextSize(), level, index);
|
2020-11-17 18:37:56 +00:00
|
|
|
text.setSpan(clone, start, end, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
pos = end;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-06-01 11:34:57 +00:00
|
|
|
static TypefaceSpan getTypefaceSpan(String family, Context context) {
|
2021-06-05 16:12:22 +00:00
|
|
|
String faces = family.toLowerCase(Locale.ROOT);
|
|
|
|
if (faces.contains("comic sans"))
|
|
|
|
family = "comic sans ms, sans-serif";
|
|
|
|
return new CustomTypefaceSpan(family, getTypeface(family, context));
|
2021-06-01 12:46:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static Typeface getTypeface(String family, Context context) {
|
2021-06-05 16:12:22 +00:00
|
|
|
String faces = family.toLowerCase(Locale.ROOT);
|
2021-06-05 18:47:05 +00:00
|
|
|
|
|
|
|
if (faces.equals("fairemail"))
|
|
|
|
return ResourcesCompat.getFont(context, R.font.fantasy);
|
|
|
|
|
|
|
|
if (faces.contains("comic sans"))
|
|
|
|
return ResourcesCompat.getFont(context, R.font.opendyslexic);
|
|
|
|
|
2021-06-05 16:12:22 +00:00
|
|
|
for (String face : faces.split(",")) {
|
|
|
|
face = face.trim().replace("\"", "");
|
2021-06-05 18:47:05 +00:00
|
|
|
Typeface tf = Typeface.create(face, Typeface.NORMAL);
|
|
|
|
if (!tf.equals(Typeface.DEFAULT))
|
|
|
|
return tf;
|
2021-06-05 16:12:22 +00:00
|
|
|
}
|
2021-06-05 18:47:05 +00:00
|
|
|
return Typeface.DEFAULT;
|
2021-06-01 11:34:57 +00:00
|
|
|
}
|
|
|
|
|
2020-11-17 18:37:56 +00:00
|
|
|
//TextUtils.dumpSpans(text, new LogPrinter(android.util.Log.INFO, "FairEmail"), "afterTextChanged ");
|
2019-09-27 17:05:34 +00:00
|
|
|
}
|