mirror of https://github.com/M66B/FairEmail.git
1468 lines
65 KiB
Java
1468 lines
65 KiB
Java
package eu.faircode.email;
|
|
|
|
/*
|
|
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/>.
|
|
|
|
Copyright 2018-2022 by Marcel Bokhorst (M66B)
|
|
*/
|
|
|
|
import android.content.Context;
|
|
import android.content.DialogInterface;
|
|
import android.content.Intent;
|
|
import android.content.SharedPreferences;
|
|
import android.graphics.Bitmap;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Color;
|
|
import android.graphics.Typeface;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.os.Build;
|
|
import android.os.Bundle;
|
|
import android.text.Editable;
|
|
import android.text.Layout;
|
|
import android.text.NoCopySpan;
|
|
import android.text.Spannable;
|
|
import android.text.SpannableStringBuilder;
|
|
import android.text.Spanned;
|
|
import android.text.TextPaint;
|
|
import android.text.TextUtils;
|
|
import android.text.TextWatcher;
|
|
import android.text.style.AlignmentSpan;
|
|
import android.text.style.BackgroundColorSpan;
|
|
import android.text.style.BulletSpan;
|
|
import android.text.style.CharacterStyle;
|
|
import android.text.style.ForegroundColorSpan;
|
|
import android.text.style.ParagraphStyle;
|
|
import android.text.style.QuoteSpan;
|
|
import android.text.style.RelativeSizeSpan;
|
|
import android.text.style.StrikethroughSpan;
|
|
import android.text.style.StyleSpan;
|
|
import android.text.style.TypefaceSpan;
|
|
import android.text.style.URLSpan;
|
|
import android.text.style.UnderlineSpan;
|
|
import android.util.Base64;
|
|
import android.util.Pair;
|
|
import android.view.LayoutInflater;
|
|
import android.view.MenuItem;
|
|
import android.view.SubMenu;
|
|
import android.view.View;
|
|
import android.view.WindowManager;
|
|
import android.widget.Button;
|
|
import android.widget.EditText;
|
|
import android.widget.TextView;
|
|
import android.widget.Toast;
|
|
|
|
import androidx.annotation.NonNull;
|
|
import androidx.appcompat.app.AlertDialog;
|
|
import androidx.appcompat.widget.PopupMenu;
|
|
import androidx.core.content.ContextCompat;
|
|
import androidx.core.content.res.ResourcesCompat;
|
|
import androidx.lifecycle.LifecycleOwner;
|
|
import androidx.preference.PreferenceManager;
|
|
|
|
import com.flask.colorpicker.ColorPickerView;
|
|
import com.flask.colorpicker.builder.ColorPickerClickListener;
|
|
import com.flask.colorpicker.builder.ColorPickerDialogBuilder;
|
|
import com.google.android.material.textfield.TextInputLayout;
|
|
|
|
import org.jsoup.nodes.Document;
|
|
import org.jsoup.nodes.Element;
|
|
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.security.SecureRandom;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
|
|
import javax.crypto.Cipher;
|
|
import javax.crypto.SecretKey;
|
|
import javax.crypto.SecretKeyFactory;
|
|
import javax.crypto.spec.GCMParameterSpec;
|
|
import javax.crypto.spec.PBEKeySpec;
|
|
|
|
public class StyleHelper {
|
|
private static final int MAX_PROTECTED_TEXT = 1500;
|
|
private static final String DECRYPT_URL = "https://fairemail.net/decrypt/";
|
|
|
|
private static final List<Class> CLEAR_STYLES = Collections.unmodifiableList(Arrays.asList(
|
|
StyleSpan.class,
|
|
UnderlineSpan.class,
|
|
RelativeSizeSpan.class,
|
|
BackgroundColorSpan.class,
|
|
ForegroundColorSpan.class,
|
|
AlignmentSpan.class,
|
|
BulletSpanEx.class, NumberSpan.class,
|
|
QuoteSpan.class, IndentSpan.class,
|
|
SubscriptSpanEx.class, SuperscriptSpanEx.class,
|
|
StrikethroughSpan.class,
|
|
URLSpan.class,
|
|
TypefaceSpan.class, CustomTypefaceSpan.class,
|
|
MarkSpan.class,
|
|
InsertedSpan.class
|
|
));
|
|
|
|
static boolean apply(int action, LifecycleOwner owner, View anchor, EditText etBody, Object... args) {
|
|
Log.i("Style action=" + action);
|
|
|
|
try {
|
|
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;
|
|
}
|
|
|
|
final Editable edit = etBody.getText();
|
|
final int start = _start;
|
|
final int end = _end;
|
|
|
|
if (action == R.id.menu_bold || action == R.id.menu_italic) {
|
|
String name = (action == R.id.menu_bold ? "bold" : "italic");
|
|
Log.breadcrumb("style", "action", name);
|
|
|
|
boolean has = false;
|
|
int style = (action == R.id.menu_bold ? Typeface.BOLD : Typeface.ITALIC);
|
|
StyleSpan[] spans = edit.getSpans(start, end, StyleSpan.class);
|
|
for (StyleSpan span : spans)
|
|
if (span.getStyle() == style) {
|
|
int s = edit.getSpanStart(span);
|
|
int e = edit.getSpanEnd(span);
|
|
int f = edit.getSpanFlags(span);
|
|
edit.removeSpan(span);
|
|
if (splitSpan(edit, start, end, s, e, f, true,
|
|
new StyleSpan(style), new StyleSpan(style)))
|
|
has = true;
|
|
}
|
|
|
|
if (!has)
|
|
edit.setSpan(new StyleSpan(style), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(start, end);
|
|
|
|
return true;
|
|
} else if (action == R.id.menu_underline) {
|
|
Log.breadcrumb("style", "action", "underline");
|
|
|
|
boolean has = false;
|
|
UnderlineSpan[] spans = edit.getSpans(start, end, UnderlineSpan.class);
|
|
for (UnderlineSpan span : spans) {
|
|
int s = edit.getSpanStart(span);
|
|
int e = edit.getSpanEnd(span);
|
|
int f = edit.getSpanFlags(span);
|
|
edit.removeSpan(span);
|
|
if (splitSpan(edit, start, end, s, e, f, true,
|
|
new UnderlineSpan(), new UnderlineSpan()))
|
|
has = true;
|
|
}
|
|
|
|
if (!has)
|
|
edit.setSpan(new UnderlineSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(start, end);
|
|
|
|
return true;
|
|
} else if (action == R.id.menu_style) {
|
|
final Context context = anchor.getContext();
|
|
PopupMenuLifecycle popupMenu = new PopupMenuLifecycle(context, owner, anchor);
|
|
popupMenu.inflate(R.menu.popup_style);
|
|
|
|
{
|
|
SubMenu smenu = popupMenu.getMenu().findItem(R.id.menu_style_size).getSubMenu();
|
|
smenu.clear();
|
|
int[] ids = new int[]{
|
|
R.id.menu_style_size_xsmall,
|
|
R.id.menu_style_size_small,
|
|
R.id.menu_style_size_medium,
|
|
R.id.menu_style_size_large,
|
|
R.id.menu_style_size_xlarge
|
|
};
|
|
int[] titles = new int[]{
|
|
R.string.title_style_size_xsmall,
|
|
R.string.title_style_size_small,
|
|
R.string.title_style_size_medium,
|
|
R.string.title_style_size_large,
|
|
R.string.title_style_size_xlarge};
|
|
float[] sizes = new float[]{
|
|
HtmlHelper.FONT_XSMALL,
|
|
HtmlHelper.FONT_SMALL,
|
|
1.0f,
|
|
HtmlHelper.FONT_LARGE,
|
|
HtmlHelper.FONT_XLARGE};
|
|
for (int i = 0; i < ids.length; i++) {
|
|
SpannableStringBuilder ssb = new SpannableStringBuilderEx(context.getString(titles[i]));
|
|
ssb.setSpan(new RelativeSizeSpan(sizes[i]), 0, ssb.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
smenu.add(R.id.group_style_size, ids[i], i, ssb);
|
|
}
|
|
}
|
|
|
|
List<FontDescriptor> fonts = getFonts(anchor.getContext(), false);
|
|
SubMenu smenu = popupMenu.getMenu().findItem(R.id.menu_style_font).getSubMenu();
|
|
for (int i = 0; i < fonts.size(); i++) {
|
|
FontDescriptor font = fonts.get(i);
|
|
SpannableStringBuilder ssb = new SpannableStringBuilderEx(font.toString());
|
|
ssb.setSpan(getTypefaceSpan(font.type, context), 0, ssb.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
smenu.add(font.custom ? R.id.group_style_font_custom : R.id.group_style_font_standard, i, 0, ssb)
|
|
.setIntent(new Intent().putExtra("face", font.type));
|
|
}
|
|
smenu.add(R.id.group_style_font_standard, fonts.size(), 0, R.string.title_style_font_default)
|
|
.setIntent(new Intent());
|
|
|
|
Integer maxLevel = getMaxListLevel(edit, start, end);
|
|
IndentSpan[] indents = edit.getSpans(start, end, IndentSpan.class);
|
|
|
|
popupMenu.getMenu().findItem(R.id.menu_style_list_bullets).setEnabled(indents.length == 0);
|
|
popupMenu.getMenu().findItem(R.id.menu_style_list_numbered).setEnabled(indents.length == 0);
|
|
popupMenu.getMenu().findItem(R.id.menu_style_list_increase).setEnabled(indents.length == 0 && maxLevel != null);
|
|
popupMenu.getMenu().findItem(R.id.menu_style_list_decrease).setEnabled(indents.length == 0 && maxLevel != null && maxLevel > 0);
|
|
|
|
popupMenu.getMenu().findItem(R.id.menu_style_indentation_increase).setEnabled(maxLevel == null);
|
|
popupMenu.getMenu().findItem(R.id.menu_style_indentation_decrease).setEnabled(indents.length > 0);
|
|
|
|
popupMenu.getMenu().findItem(R.id.menu_style_password).setVisible(!BuildConfig.PLAY_STORE_RELEASE);
|
|
popupMenu.getMenu().findItem(R.id.menu_style_code).setEnabled(BuildConfig.DEBUG);
|
|
|
|
popupMenu.insertIcons(context);
|
|
|
|
popupMenu.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
|
|
@Override
|
|
public boolean onMenuItemClick(MenuItem item) {
|
|
try {
|
|
int groupId = item.getGroupId();
|
|
int itemId = item.getItemId();
|
|
if (groupId == R.id.group_style_size) {
|
|
return setSize(item);
|
|
} else if (itemId == R.id.menu_style_background) {
|
|
return setBackground(item);
|
|
} else if (itemId == R.id.menu_style_color) {
|
|
return setColor(item);
|
|
} else if (groupId == R.id.group_style_font_standard ||
|
|
groupId == R.id.group_style_font_custom) {
|
|
return setFont(item);
|
|
} else if (groupId == R.id.group_style_align) {
|
|
return setAlignment(item.getItemId(), etBody, start, end, true);
|
|
} else if (groupId == R.id.group_style_list) {
|
|
if (item.getItemId() == R.id.menu_style_list_increase ||
|
|
item.getItemId() == R.id.menu_style_list_decrease)
|
|
return setListLevel(item.getItemId(), etBody, start, end, true);
|
|
else
|
|
return setList(item.getItemId(), etBody, start, end, true);
|
|
} else if (groupId == R.id.group_style_indentation) {
|
|
return setIndentation(item.getItemId(), etBody, start, end, true);
|
|
} else if (groupId == R.id.group_style_blockquote) {
|
|
return setBlockQuote(etBody, start, end, true);
|
|
} else if (groupId == R.id.group_style_mark) {
|
|
return setMark(item);
|
|
} else if (groupId == R.id.group_style_subscript) {
|
|
return setSubscript(item);
|
|
} else if (groupId == R.id.group_style_superscript) {
|
|
return setSuperscript(item);
|
|
} else if (groupId == R.id.group_style_strikethrough) {
|
|
return setStrikeThrough(item);
|
|
} else if (groupId == R.id.group_style_password) {
|
|
return setPassword(item);
|
|
} else if (groupId == R.id.group_style_code) {
|
|
return setCode(item);
|
|
} else if (groupId == R.id.group_style_clear) {
|
|
return clear(item);
|
|
}
|
|
return false;
|
|
} catch (Throwable ex) {
|
|
Log.e(ex);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private boolean setSize(MenuItem item) {
|
|
Log.breadcrumb("style", "action", "size");
|
|
|
|
Float size;
|
|
if (item.getItemId() == R.id.menu_style_size_xsmall)
|
|
size = HtmlHelper.FONT_XSMALL;
|
|
else if (item.getItemId() == R.id.menu_style_size_small)
|
|
size = HtmlHelper.FONT_SMALL;
|
|
else if (item.getItemId() == R.id.menu_style_size_large)
|
|
size = HtmlHelper.FONT_LARGE;
|
|
else if (item.getItemId() == R.id.menu_style_size_xlarge)
|
|
size = HtmlHelper.FONT_XLARGE;
|
|
else
|
|
size = null;
|
|
|
|
return _setSize(size);
|
|
}
|
|
|
|
private boolean _setSize(Float size) {
|
|
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);
|
|
splitSpan(edit, start, end, s, e, f, false,
|
|
new RelativeSizeSpan(span.getSizeChange()),
|
|
new RelativeSizeSpan(span.getSizeChange()));
|
|
}
|
|
|
|
if (size != null)
|
|
edit.setSpan(new RelativeSizeSpan(size), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(start, end);
|
|
|
|
return true;
|
|
}
|
|
|
|
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)
|
|
//.lightnessSliderOnly()
|
|
.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);
|
|
}
|
|
});
|
|
|
|
BackgroundColorSpan[] spans = edit.getSpans(start, end, BackgroundColorSpan.class);
|
|
if (spans != null && spans.length == 1)
|
|
builder.initialColor(spans[0].getBackgroundColor());
|
|
|
|
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);
|
|
}
|
|
|
|
private boolean setColor(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_color)
|
|
.showColorEdit(true)
|
|
.setColorEditTextColor(editTextColor)
|
|
.wheelType(ColorPickerView.WHEEL_TYPE.FLOWER)
|
|
.density(6)
|
|
//.lightnessSliderOnly()
|
|
.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);
|
|
}
|
|
});
|
|
|
|
ForegroundColorSpan[] spans = edit.getSpans(start, end, ForegroundColorSpan.class);
|
|
if (spans != null && spans.length == 1)
|
|
builder.initialColor(spans[0].getForegroundColor());
|
|
|
|
builder.build().show();
|
|
|
|
return true;
|
|
}
|
|
|
|
private void _setColor(Integer color) {
|
|
Log.breadcrumb("style", "action", "color");
|
|
|
|
ForegroundColorSpan spans[] = edit.getSpans(start, end, ForegroundColorSpan.class);
|
|
for (ForegroundColorSpan 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 ForegroundColorSpan(span.getForegroundColor()),
|
|
new ForegroundColorSpan(span.getForegroundColor()));
|
|
}
|
|
|
|
if (color != null)
|
|
edit.setSpan(new ForegroundColorSpan(color), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(start, end);
|
|
}
|
|
|
|
private boolean setFont(MenuItem item) {
|
|
Log.breadcrumb("style", "action", "font");
|
|
return _setFont(item.getIntent().getStringExtra("face"));
|
|
}
|
|
|
|
private boolean _setFont(String face) {
|
|
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,
|
|
getTypefaceSpan(span.getFamily(), context),
|
|
getTypefaceSpan(span.getFamily(), context));
|
|
}
|
|
|
|
if (face != null)
|
|
edit.setSpan(getTypefaceSpan(face, context), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(start, end);
|
|
|
|
return true;
|
|
}
|
|
|
|
private boolean setMark(MenuItem item) {
|
|
Log.breadcrumb("style", "action", "strike");
|
|
|
|
Context context = etBody.getContext();
|
|
|
|
boolean has = false;
|
|
MarkSpan[] spans = edit.getSpans(start, end, MarkSpan.class);
|
|
for (MarkSpan span : spans) {
|
|
int s = edit.getSpanStart(span);
|
|
int e = edit.getSpanEnd(span);
|
|
int f = edit.getSpanFlags(span);
|
|
edit.removeSpan(span);
|
|
if (splitSpan(edit, start, end, s, e, f, true,
|
|
new MarkSpan(), new MarkSpan()))
|
|
has = true;
|
|
}
|
|
|
|
if (!has)
|
|
edit.setSpan(new MarkSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(end);
|
|
|
|
return true;
|
|
}
|
|
|
|
private boolean setSubscript(MenuItem item) {
|
|
Log.breadcrumb("style", "action", "subscript");
|
|
|
|
boolean has = false;
|
|
SubscriptSpanEx[] spans = edit.getSpans(start, end, SubscriptSpanEx.class);
|
|
for (SubscriptSpanEx span : spans) {
|
|
int s = edit.getSpanStart(span);
|
|
int e = edit.getSpanEnd(span);
|
|
int f = edit.getSpanFlags(span);
|
|
edit.removeSpan(span);
|
|
if (splitSpan(edit, start, end, s, e, f, true,
|
|
new SubscriptSpanEx(), new SubscriptSpanEx()))
|
|
has = true;
|
|
}
|
|
|
|
if (!has)
|
|
edit.setSpan(new SubscriptSpanEx(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(start, end);
|
|
|
|
return true;
|
|
}
|
|
|
|
private boolean setSuperscript(MenuItem item) {
|
|
Log.breadcrumb("style", "action", "superscript");
|
|
|
|
boolean has = false;
|
|
SuperscriptSpanEx[] spans = edit.getSpans(start, end, SuperscriptSpanEx.class);
|
|
for (SuperscriptSpanEx span : spans) {
|
|
int s = edit.getSpanStart(span);
|
|
int e = edit.getSpanEnd(span);
|
|
int f = edit.getSpanFlags(span);
|
|
edit.removeSpan(span);
|
|
if (splitSpan(edit, start, end, s, e, f, true,
|
|
new SuperscriptSpanEx(), new SuperscriptSpanEx()))
|
|
has = true;
|
|
}
|
|
|
|
if (!has) {
|
|
edit.setSpan(new SuperscriptSpanEx(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
edit.setSpan(new RelativeSizeSpan(HtmlHelper.FONT_SMALL), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
}
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(start, end);
|
|
|
|
return true;
|
|
}
|
|
|
|
private boolean setStrikeThrough(MenuItem item) {
|
|
Log.breadcrumb("style", "action", "strike");
|
|
|
|
boolean has = false;
|
|
StrikethroughSpan[] spans = edit.getSpans(start, end, StrikethroughSpan.class);
|
|
for (StrikethroughSpan span : spans) {
|
|
int s = edit.getSpanStart(span);
|
|
int e = edit.getSpanEnd(span);
|
|
int f = edit.getSpanFlags(span);
|
|
edit.removeSpan(span);
|
|
if (splitSpan(edit, start, end, s, e, f, true,
|
|
new StrikethroughSpan(), new StrikethroughSpan()))
|
|
has = true;
|
|
}
|
|
|
|
if (!has)
|
|
edit.setSpan(new StrikethroughSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(start, end);
|
|
|
|
return true;
|
|
}
|
|
|
|
private boolean setPassword(MenuItem item) {
|
|
if (!ActivityBilling.isPro(context)) {
|
|
context.startActivity(new Intent(context, ActivityBilling.class));
|
|
return true;
|
|
}
|
|
|
|
boolean toolong = false;
|
|
if (end - start > MAX_PROTECTED_TEXT) {
|
|
toolong = true;
|
|
} else {
|
|
String html = getProtectedContent((Spanned) edit.subSequence(start, end));
|
|
if (html.length() > MAX_PROTECTED_TEXT)
|
|
toolong = true;
|
|
}
|
|
if (toolong) {
|
|
ToastEx.makeText(context, R.string.title_style_protect_size, Toast.LENGTH_LONG).show();
|
|
return true;
|
|
}
|
|
|
|
View dview = LayoutInflater.from(context).inflate(R.layout.dialog_password_protect, null);
|
|
TextInputLayout tilPassword1 = dview.findViewById(R.id.tilPassword1);
|
|
TextInputLayout tilPassword2 = dview.findViewById(R.id.tilPassword2);
|
|
Button btnInfo = dview.findViewById(R.id.btnInfo);
|
|
|
|
btnInfo.setOnClickListener(new View.OnClickListener() {
|
|
@Override
|
|
public void onClick(View v) {
|
|
Helper.viewFAQ(v.getContext(), 184);
|
|
}
|
|
});
|
|
|
|
AlertDialog dialog = new AlertDialog.Builder(context)
|
|
.setView(dview)
|
|
.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
|
|
@Override
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
int start = etBody.getSelectionStart();
|
|
int end = etBody.getSelectionEnd();
|
|
boolean selection = (start >= 0 && start < end);
|
|
if (selection) {
|
|
Bundle args = new Bundle();
|
|
args.putCharSequence("text", edit.subSequence(start, end));
|
|
args.putString("password", tilPassword1.getEditText().getText().toString());
|
|
args.putInt("start", start);
|
|
args.putInt("end", end);
|
|
|
|
new SimpleTask<String>() {
|
|
@Override
|
|
protected String onExecute(Context context, Bundle args) throws Throwable {
|
|
Spanned text = (Spanned) args.getCharSequence("text");
|
|
String password = args.getString("password");
|
|
|
|
String html = getProtectedContent(text);
|
|
if (html.length() > MAX_PROTECTED_TEXT)
|
|
throw new IllegalArgumentException(context.getString(R.string.title_style_protect_size));
|
|
|
|
SecureRandom random = new SecureRandom();
|
|
|
|
byte[] salt = new byte[16]; // 128 bits
|
|
random.nextBytes(salt);
|
|
|
|
byte[] iv = new byte[12]; // 96 bites
|
|
random.nextBytes(iv);
|
|
|
|
// Iterations = 120,000; Keylength = 256 bits = 32 bytes
|
|
PBEKeySpec spec = new PBEKeySpec(password.toCharArray(), salt, 120000, 256);
|
|
|
|
SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA512");
|
|
SecretKey key = skf.generateSecret(spec);
|
|
|
|
// Authentication tag length = 128 bits = 16 bytes
|
|
GCMParameterSpec parameterSpec = new GCMParameterSpec(128, iv);
|
|
|
|
final Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
|
|
cipher.init(Cipher.ENCRYPT_MODE, key, parameterSpec);
|
|
|
|
byte[] cipherText = cipher.doFinal(html.getBytes(StandardCharsets.UTF_8));
|
|
|
|
ByteBuffer out = ByteBuffer.allocate(1 + salt.length + iv.length + cipherText.length);
|
|
out.put((byte) 1); // version
|
|
out.put(salt);
|
|
out.put(iv);
|
|
out.put(cipherText);
|
|
|
|
String fragment = Base64.encodeToString(out.array(), Base64.URL_SAFE | Base64.NO_WRAP);
|
|
String url = DECRYPT_URL + "#" + fragment;
|
|
|
|
return url;
|
|
}
|
|
|
|
@Override
|
|
protected void onExecuted(Bundle args, String url) {
|
|
if (etBody.getSelectionStart() != start ||
|
|
etBody.getSelectionEnd() != end)
|
|
return;
|
|
|
|
String title = context.getString(R.string.title_decrypt);
|
|
edit.delete(start, end);
|
|
edit.insert(start, title);
|
|
edit.setSpan(new URLSpan(url), start, start + title.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
etBody.setSelection(start + title.length());
|
|
}
|
|
|
|
@Override
|
|
protected void onException(Bundle args, Throwable ex) {
|
|
Log.e(ex);
|
|
ToastEx.makeText(context, ex.toString(), Toast.LENGTH_LONG).show();
|
|
}
|
|
}.execute(context, owner, args, "protect");
|
|
}
|
|
}
|
|
})
|
|
.setNegativeButton(android.R.string.cancel, null)
|
|
.create();
|
|
|
|
dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
|
|
// WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
|
|
dialog.show();
|
|
|
|
Button btnOk = dialog.getButton(AlertDialog.BUTTON_POSITIVE);
|
|
|
|
TextWatcher w = new TextWatcher() {
|
|
@Override
|
|
public void beforeTextChanged(CharSequence s, int start, int count, int after) {
|
|
// Do nothing
|
|
}
|
|
|
|
@Override
|
|
public void onTextChanged(CharSequence s, int start, int before, int count) {
|
|
// Do nothing
|
|
}
|
|
|
|
@Override
|
|
public void afterTextChanged(Editable s) {
|
|
String p1 = tilPassword1.getEditText().getText().toString();
|
|
String p2 = tilPassword2.getEditText().getText().toString();
|
|
btnOk.setEnabled(!TextUtils.isEmpty(p1) && p1.equals(p2));
|
|
tilPassword2.setHint(!TextUtils.isEmpty(p2) && !p2.equals(p1)
|
|
? R.string.title_setup_password_different
|
|
: R.string.title_setup_password_repeat);
|
|
}
|
|
};
|
|
|
|
tilPassword1.getEditText().addTextChangedListener(w);
|
|
tilPassword2.getEditText().addTextChangedListener(w);
|
|
w.afterTextChanged(null);
|
|
|
|
return true;
|
|
}
|
|
|
|
private String getProtectedContent(Spanned text) {
|
|
Drawable d = ContextCompat.getDrawable(context, R.drawable.twotone_image_24);
|
|
d.setTint(Color.GRAY);
|
|
|
|
Bitmap bm = Bitmap.createBitmap(24, 24, Bitmap.Config.ARGB_8888);
|
|
Canvas c = new Canvas(bm);
|
|
d.setBounds(0, 0, c.getWidth(), c.getHeight());
|
|
d.draw(c);
|
|
|
|
ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
|
bm.compress(Bitmap.CompressFormat.PNG, 100, bos);
|
|
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("data:image/png;base64,");
|
|
sb.append(Base64.encodeToString(bos.toByteArray(), Base64.NO_WRAP));
|
|
|
|
String html = HtmlHelper.toHtml(text, context);
|
|
Document doc = JsoupEx.parse(html);
|
|
for (Element img : doc.select("img"))
|
|
img.attr("src", sb.toString());
|
|
|
|
return doc.body().html();
|
|
}
|
|
|
|
private boolean setCode(MenuItem item) {
|
|
Log.breadcrumb("style", "action", "code");
|
|
_setSize(HtmlHelper.FONT_SMALL);
|
|
_setFont("monospace");
|
|
return true;
|
|
}
|
|
|
|
private boolean clear(MenuItem item) {
|
|
Log.breadcrumb("style", "action", "clear");
|
|
|
|
int e = end;
|
|
|
|
// Expand to paragraph (block quotes)
|
|
if (e + 1 < edit.length() && edit.charAt(e) == '\n')
|
|
e++;
|
|
|
|
for (Object span : edit.getSpans(start, e, Object.class)) {
|
|
boolean has = false;
|
|
for (Class cls : CLEAR_STYLES)
|
|
if (cls.isAssignableFrom(span.getClass())) {
|
|
has = true;
|
|
break;
|
|
}
|
|
if (!has)
|
|
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);
|
|
}
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(start, e);
|
|
|
|
return true;
|
|
}
|
|
});
|
|
|
|
popupMenu.show();
|
|
|
|
return true;
|
|
} else if (action == R.id.menu_link) {
|
|
Log.breadcrumb("style", "action", "link");
|
|
|
|
String url = (String) args[0];
|
|
String title = (String) args[1];
|
|
|
|
URLSpan[] spans = edit.getSpans(start, end, URLSpan.class);
|
|
for (URLSpan span : spans)
|
|
edit.removeSpan(span);
|
|
|
|
if (!TextUtils.isEmpty(url)) {
|
|
if (TextUtils.isEmpty(title))
|
|
title = url;
|
|
|
|
if (start == end)
|
|
edit.insert(start, title);
|
|
else if (!title.equals(edit.subSequence(start, end).toString()))
|
|
edit.replace(start, end, title);
|
|
|
|
edit.setSpan(new URLSpan(url), start, start + title.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
}
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(start + title.length());
|
|
|
|
return true;
|
|
} else if (action == R.id.menu_clear) {
|
|
Log.breadcrumb("style", "action", "clear/all");
|
|
|
|
for (Object span : edit.getSpans(0, etBody.length(), Object.class)) {
|
|
if (!CLEAR_STYLES.contains(span.getClass()))
|
|
continue;
|
|
edit.removeSpan(span);
|
|
}
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(start, end);
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
} catch (Throwable ex) {
|
|
Log.e(ex);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static boolean setAlignment(int itemId, EditText etBody, int start, int end, boolean select) {
|
|
Log.breadcrumb("style", "action", "alignment");
|
|
|
|
Editable edit = etBody.getText();
|
|
Pair<Integer, Integer> paragraph = ensureParagraph(edit, start, end);
|
|
if (paragraph == null)
|
|
return false;
|
|
|
|
int s = paragraph.first;
|
|
int e = paragraph.second;
|
|
|
|
AlignmentSpan[] spans = edit.getSpans(s, e, AlignmentSpan.class);
|
|
for (AlignmentSpan span : spans)
|
|
edit.removeSpan(span);
|
|
|
|
Layout.Alignment alignment = null;
|
|
boolean ltr = (TextUtils.getLayoutDirectionFromLocale(Locale.getDefault()) == View.LAYOUT_DIRECTION_LTR);
|
|
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);
|
|
}
|
|
|
|
if (alignment != null)
|
|
edit.setSpan(new AlignmentSpan.Standard(alignment),
|
|
s, e, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE | Spanned.SPAN_PARAGRAPH);
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(select ? s : e, e);
|
|
|
|
return true;
|
|
}
|
|
|
|
static boolean setListLevel(int itemId, EditText etBody, int start, int end, boolean select) {
|
|
Log.breadcrumb("style", "action", "level");
|
|
|
|
Context context = etBody.getContext();
|
|
Editable edit = etBody.getText();
|
|
int add = (itemId == 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(Math.max(0, bs.getLevel() + add));
|
|
} else if (span instanceof NumberSpan) {
|
|
renum = true;
|
|
NumberSpan ns = (NumberSpan) span;
|
|
ns.setLevel(Math.max(0, ns.getLevel() + add));
|
|
}
|
|
|
|
if (renum)
|
|
renumber(edit, false, context);
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(select ? start : end, end);
|
|
|
|
return true;
|
|
}
|
|
|
|
static boolean setList(int itemId, EditText etBody, int start, int end, boolean select) {
|
|
Log.breadcrumb("style", "action", "list");
|
|
|
|
Context context = etBody.getContext();
|
|
Editable edit = etBody.getText();
|
|
|
|
int colorAccent = Helper.resolveColor(context, R.attr.colorAccent);
|
|
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);
|
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
|
|
int message_zoom = prefs.getInt("message_zoom", 100);
|
|
float textSize = Helper.getTextSize(context, 0) * message_zoom / 100f;
|
|
|
|
Pair<Integer, Integer> paragraph = ensureParagraph(edit, start, end);
|
|
if (paragraph == null)
|
|
return false;
|
|
|
|
int s = paragraph.first;
|
|
int e = paragraph.second;
|
|
|
|
// Remove existing bullets
|
|
BulletSpan[] spans = edit.getSpans(s, e, BulletSpan.class);
|
|
for (BulletSpan span : spans)
|
|
edit.removeSpan(span);
|
|
|
|
int i = s;
|
|
int j = s + 1;
|
|
int index = 1;
|
|
while (j < e) {
|
|
if (i > 0 && edit.charAt(i - 1) == '\n' && edit.charAt(j) == '\n') {
|
|
Log.i("Insert " + i + "..." + (j + 1) + " size=" + e);
|
|
if (itemId == R.id.menu_style_list_bullets)
|
|
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P)
|
|
edit.setSpan(new BulletSpanEx(bulletIndent, bulletGap, colorAccent, 0), i, j + 1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE | Spanned.SPAN_PARAGRAPH);
|
|
else
|
|
edit.setSpan(new BulletSpanEx(bulletIndent, bulletGap, colorAccent, bulletRadius, 0), i, j + 1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE | Spanned.SPAN_PARAGRAPH);
|
|
else
|
|
edit.setSpan(new NumberSpan(bulletIndent, bulletGap, colorAccent, textSize, 0, index++), i, j + 1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE | Spanned.SPAN_PARAGRAPH);
|
|
|
|
i = j + 1;
|
|
}
|
|
j++;
|
|
}
|
|
|
|
renumber(edit, false, context);
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(select ? s : e, e);
|
|
|
|
return true;
|
|
}
|
|
|
|
static boolean setIndentation(int itemId, EditText etBody, int start, int end, boolean select) {
|
|
Log.breadcrumb("style", "action", "indent");
|
|
|
|
Editable edit = etBody.getText();
|
|
Pair<Integer, Integer> paragraph = ensureParagraph(edit, start, end);
|
|
if (paragraph == null)
|
|
return false;
|
|
|
|
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);
|
|
|
|
int prev = paragraph.first;
|
|
int next = paragraph.first;
|
|
while (next < paragraph.second) {
|
|
while (next < paragraph.second && edit.charAt(next) != '\n')
|
|
next++;
|
|
|
|
if (itemId == 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);
|
|
edit.setSpan(is, prev, next + 1, Spanned.SPAN_INCLUSIVE_INCLUSIVE);
|
|
}
|
|
|
|
next++;
|
|
prev = next;
|
|
}
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(select ? paragraph.first : paragraph.second, paragraph.second);
|
|
|
|
return true;
|
|
}
|
|
|
|
static boolean setBlockQuote(EditText etBody, int start, int end, boolean select) {
|
|
Log.breadcrumb("style", "action", "quote");
|
|
|
|
Context context = etBody.getContext();
|
|
Editable edit = etBody.getText();
|
|
|
|
int colorPrimary = Helper.resolveColor(context, R.attr.colorPrimary);
|
|
final int colorBlockquote = Helper.resolveColor(context, R.attr.colorBlockquote, colorPrimary);
|
|
int quoteGap = context.getResources().getDimensionPixelSize(R.dimen.quote_gap_size);
|
|
int quoteStripe = context.getResources().getDimensionPixelSize(R.dimen.quote_stripe_width);
|
|
|
|
Pair<Integer, Integer> paragraph = ensureParagraph(edit, start, end);
|
|
if (paragraph == null)
|
|
return false;
|
|
|
|
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);
|
|
|
|
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);
|
|
|
|
etBody.setText(edit);
|
|
etBody.setSelection(select ? paragraph.first : paragraph.second, paragraph.second);
|
|
|
|
return true;
|
|
}
|
|
|
|
static boolean splitSpan(Editable edit, int start, int end, int s, int e, int f, boolean extend, Object span1, Object span2) {
|
|
if (start < 0 || end < 0) {
|
|
Log.e(span1 + " invalid selection=" + start + "..." + end);
|
|
return false;
|
|
}
|
|
|
|
if (s < 0 || e < 0) {
|
|
Log.e(span1 + " not attached=" + s + "..." + e);
|
|
return false;
|
|
}
|
|
|
|
if (s > e) {
|
|
int tmp = s;
|
|
s = e;
|
|
e = tmp;
|
|
}
|
|
|
|
if (start < s && end > s && end < e) {
|
|
// overlap before
|
|
if (extend)
|
|
edit.setSpan(span1, start, e, f);
|
|
else
|
|
edit.setSpan(span1, end, e, f);
|
|
return true;
|
|
} 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);
|
|
return true;
|
|
} else if (start < s && end > e) {
|
|
// overlap all
|
|
if (extend) {
|
|
edit.setSpan(span1, start, end, f);
|
|
return true;
|
|
}
|
|
} else if (start >= s && end <= e) {
|
|
if (start == s && end == e)
|
|
return true;
|
|
|
|
// overlap inner
|
|
if (s < start)
|
|
edit.setSpan(span1, s, start, f);
|
|
if (end < e)
|
|
edit.setSpan(span2, end, e, f);
|
|
if (s < start || end < e)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static void setSpan(Editable edit, Object span, int start, int end, int flags, Context context) {
|
|
if (span instanceof CharacterStyle)
|
|
edit.setSpan(CharacterStyle.wrap((CharacterStyle) span), start, end, flags);
|
|
else if (span instanceof QuoteSpan) {
|
|
ParagraphStyle ps = (ParagraphStyle) span;
|
|
Pair<Integer, Integer> p = ensureParagraph(edit, start, end);
|
|
if (p == null)
|
|
return;
|
|
edit.setSpan(clone(span, ps.getClass(), context), p.first, p.second, flags);
|
|
}
|
|
}
|
|
|
|
static private Pair<Integer, Integer> ensureParagraph(Editable edit, int s, int e) {
|
|
int start = s;
|
|
int end = e;
|
|
|
|
// Expand selection at start
|
|
while (start > 0 && edit.charAt(start - 1) != '\n')
|
|
start--;
|
|
|
|
// Expand selection at end
|
|
while (end > 0 && end < edit.length() && edit.charAt(end - 1) != '\n')
|
|
end++;
|
|
|
|
// Nothing to do
|
|
if (start == end)
|
|
return null;
|
|
|
|
// Create paragraph at start
|
|
if (start == 0 && edit.charAt(start) != '\n') {
|
|
edit.insert(0, "\n");
|
|
start++;
|
|
end++;
|
|
}
|
|
|
|
// Create paragraph at end
|
|
if (end == edit.length() && edit.charAt(end - 1) != '\n') {
|
|
edit.append("\n");
|
|
end++;
|
|
}
|
|
|
|
if (end == edit.length())
|
|
edit.append("\n"); // workaround Android bug
|
|
|
|
return new Pair<>(start, end);
|
|
}
|
|
|
|
public static Pair<Integer, Integer> getParagraph(TextView tvBody) {
|
|
return getParagraph(tvBody, false);
|
|
}
|
|
|
|
public static Pair<Integer, Integer> getParagraph(TextView tvBody, boolean block) {
|
|
int start = tvBody.getSelectionStart();
|
|
int end = tvBody.getSelectionEnd();
|
|
Spannable edit = (Spannable) tvBody.getText();
|
|
|
|
if (start < 0 || end < 0)
|
|
return null;
|
|
|
|
if (start > end) {
|
|
int tmp = start;
|
|
start = end;
|
|
end = tmp;
|
|
}
|
|
|
|
// Expand selection at start
|
|
while (start > 0 &&
|
|
(edit.charAt(start - 1) != '\n' ||
|
|
(block && start - 1 > 0 && edit.charAt(start - 2) != '\n')))
|
|
start--;
|
|
|
|
if (start == end && end < edit.length())
|
|
end++;
|
|
|
|
// Expand selection at end
|
|
while (end > 0 && end < edit.length() &&
|
|
(edit.charAt(end - 1) != '\n' ||
|
|
(block && end - 1 > 0 && edit.charAt(end - 2) != '\n')))
|
|
end++;
|
|
|
|
// Trim start
|
|
while (start < edit.length() - 1 && edit.charAt(start) == '\n')
|
|
start++;
|
|
|
|
// Trim end
|
|
while (end > 0 && edit.charAt(end - 1) == '\n')
|
|
end--;
|
|
|
|
if (start < end)
|
|
return new Pair(start, end);
|
|
|
|
return null;
|
|
}
|
|
|
|
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;
|
|
int bulletGap = context.getResources().getDimensionPixelSize(R.dimen.bullet_gap_size);
|
|
int bulletIndent = context.getResources().getDimensionPixelSize(R.dimen.bullet_indent_size);
|
|
int colorAccent = Helper.resolveColor(context, R.attr.colorAccent);
|
|
return (T) new NumberSpan(bulletIndent, bulletGap, colorAccent, n.getTextSize(), n.getLevel(), n.getIndex() + 1);
|
|
} else if (BulletSpanEx.class.isAssignableFrom(type)) {
|
|
BulletSpanEx b = (BulletSpanEx) span;
|
|
int bulletIndent = context.getResources().getDimensionPixelSize(R.dimen.bullet_indent_size);
|
|
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) {
|
|
int colorAccent = Helper.resolveColor(context, R.attr.colorAccent);
|
|
int bulletGap = context.getResources().getDimensionPixelSize(R.dimen.bullet_gap_size);
|
|
return (T) new BulletSpanEx(bulletIndent, bulletGap, colorAccent, b.getLevel());
|
|
} else
|
|
return (T) new BulletSpanEx(bulletIndent, b.getGapWidth(), b.getColor(), b.getBulletRadius(), b.getLevel());
|
|
|
|
} else
|
|
throw new IllegalArgumentException(type.getName());
|
|
}
|
|
|
|
static Integer getMaxListLevel(Editable edit, int start, int end) {
|
|
Integer maxLevel = null;
|
|
BulletSpan[] bullets = edit.getSpans(start, end, BulletSpan.class);
|
|
for (BulletSpan span : bullets) {
|
|
Integer level = null;
|
|
if (span instanceof NumberSpan)
|
|
level = ((NumberSpan) span).getLevel();
|
|
else if (span instanceof BulletSpanEx)
|
|
level = ((BulletSpanEx) span).getLevel();
|
|
if (level != null && (maxLevel == null || level > maxLevel))
|
|
maxLevel = level;
|
|
}
|
|
return maxLevel;
|
|
}
|
|
|
|
static void renumber(Editable text, boolean clean, Context context) {
|
|
int bulletGap = context.getResources().getDimensionPixelSize(R.dimen.bullet_gap_size);
|
|
int bulletIndent = context.getResources().getDimensionPixelSize(R.dimen.bullet_indent_size);
|
|
int colorAccent = Helper.resolveColor(context, R.attr.colorAccent);
|
|
|
|
Log.i("Renumber clean=" + clean + " text=" + text);
|
|
|
|
int next;
|
|
int pos = -1;
|
|
List<Integer> levels = new ArrayList<>();
|
|
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;
|
|
}
|
|
|
|
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))
|
|
levels.remove(level);
|
|
while (levels.size() < level + 1)
|
|
levels.add(0);
|
|
|
|
int index = levels.get(level) + 1;
|
|
levels.remove(level);
|
|
levels.add(level, index);
|
|
|
|
if (span instanceof NumberSpan) {
|
|
NumberSpan ns = (NumberSpan) span;
|
|
if (index != ns.getIndex()) {
|
|
text.removeSpan(span);
|
|
// Text size needs measuring
|
|
NumberSpan clone = new NumberSpan(bulletIndent, bulletGap, colorAccent, ns.getTextSize(), level, index);
|
|
text.setSpan(clone, start, end, flags);
|
|
}
|
|
|
|
pos = end;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void markAsInserted(Editable text, int start, int end) {
|
|
for (InsertedSpan span : text.getSpans(0, text.length(), InsertedSpan.class))
|
|
text.removeSpan(span);
|
|
if (start >= 0 && start < end && end <= text.length())
|
|
text.setSpan(new InsertedSpan(), start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
|
|
}
|
|
|
|
static class InsertedSpan implements NoCopySpan {
|
|
}
|
|
|
|
static class MarkSpan extends BackgroundColorSpan {
|
|
public MarkSpan() {
|
|
super(Color.YELLOW);
|
|
}
|
|
|
|
@Override
|
|
public void updateDrawState(@NonNull TextPaint textPaint) {
|
|
super.updateDrawState(textPaint);
|
|
textPaint.setColor(Color.BLACK);
|
|
}
|
|
}
|
|
|
|
static String getFamily(String family) {
|
|
// https://web.mit.edu/jmorzins/www/fonts.html
|
|
// https://en.wikipedia.org/wiki/Croscore_fonts
|
|
// https://developer.mozilla.org/en-US/docs/Web/CSS/font-family
|
|
// TODO: Microsoft: Georgia (Serif), Tahoma (Sans-serif), Trebuchet MS (Sans-serif)
|
|
String faces = family.toLowerCase(Locale.ROOT);
|
|
if (faces.contains("montserrat"))
|
|
return "Montserrat, Gotham, \"Proxima Nova\", sans-serif";
|
|
if (faces.contains("arimo"))
|
|
return "Arimo, Arial, Verdana, Helvetica, \"Helvetica Neue\", sans-serif";
|
|
if (faces.contains("tinos"))
|
|
return "Tinos, \"Times New Roman\", Times, serif";
|
|
if (faces.contains("cousine"))
|
|
return "Cousine, \"Courier New\", Courier, monospace";
|
|
if (faces.contains("lato"))
|
|
return "Lato, Carlito, Calibri, sans-serif";
|
|
if (faces.contains("caladea"))
|
|
return "Caladea, Cambo, Cambria, serif";
|
|
if (faces.contains("comic sans"))
|
|
return "OpenDyslexic, \"Comic Sans\", \"Comic Sans MS\", sans-serif";
|
|
return family;
|
|
}
|
|
|
|
static TypefaceSpan getTypefaceSpan(String family, Context context) {
|
|
family = getFamily(family);
|
|
return new CustomTypefaceSpan(family, getTypeface(family, context));
|
|
}
|
|
|
|
static Typeface getTypeface(String family, Context context) {
|
|
if (TextUtils.isEmpty(family))
|
|
return Typeface.DEFAULT;
|
|
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
|
|
boolean bundled_fonts = prefs.getBoolean("bundled_fonts", true);
|
|
|
|
List<String> faces = new ArrayList<>();
|
|
for (String face : family.split(","))
|
|
faces.add(face
|
|
.trim()
|
|
.toLowerCase(Locale.ROOT)
|
|
.replace("'", "")
|
|
.replace("\"", ""));
|
|
|
|
if (faces.contains("fairemail"))
|
|
return ResourcesCompat.getFont(context.getApplicationContext(), R.font.fantasy);
|
|
|
|
if (bundled_fonts) {
|
|
if (faces.contains("montserrat") ||
|
|
faces.contains("gotham") ||
|
|
faces.contains("proxima nova"))
|
|
return ResourcesCompat.getFont(context.getApplicationContext(), R.font.montserrat);
|
|
|
|
if (faces.contains("arimo") ||
|
|
faces.contains("arial") ||
|
|
faces.contains("verdana") ||
|
|
faces.contains("helvetica") ||
|
|
faces.contains("helvetica neue"))
|
|
return ResourcesCompat.getFont(context.getApplicationContext(), R.font.arimo);
|
|
|
|
if (faces.contains("tinos") ||
|
|
faces.contains("times") ||
|
|
faces.contains("times new roman"))
|
|
return ResourcesCompat.getFont(context.getApplicationContext(), R.font.tinos);
|
|
|
|
if (faces.contains("cousine") ||
|
|
faces.contains("courier") ||
|
|
faces.contains("courier new"))
|
|
return ResourcesCompat.getFont(context.getApplicationContext(), R.font.cousine);
|
|
|
|
if (faces.contains("lato") ||
|
|
faces.contains("carlito") ||
|
|
faces.contains("calibri"))
|
|
return ResourcesCompat.getFont(context.getApplicationContext(), R.font.lato);
|
|
|
|
if (faces.contains("caladea") ||
|
|
faces.contains("cambo") ||
|
|
faces.contains("cambria"))
|
|
return ResourcesCompat.getFont(context.getApplicationContext(), R.font.caladea);
|
|
|
|
if (faces.contains("opendyslexic") ||
|
|
faces.contains("comic sans") ||
|
|
faces.contains("comic sans ms"))
|
|
return ResourcesCompat.getFont(context.getApplicationContext(), R.font.opendyslexic);
|
|
}
|
|
|
|
for (String face : faces) {
|
|
Typeface tf = Typeface.create(face, Typeface.NORMAL);
|
|
if (!tf.equals(Typeface.DEFAULT))
|
|
return tf;
|
|
}
|
|
|
|
return Typeface.DEFAULT;
|
|
}
|
|
|
|
public static List<FontDescriptor> getFonts(Context context) {
|
|
return getFonts(context, true);
|
|
}
|
|
|
|
public static List<FontDescriptor> getFonts(Context context, boolean all) {
|
|
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
|
|
boolean bundled_fonts = prefs.getBoolean("bundled_fonts", true);
|
|
|
|
List<FontDescriptor> result = new ArrayList<>();
|
|
String[] fontNameNames = context.getResources().getStringArray(R.array.fontNameNames);
|
|
String[] fontNameValues = context.getResources().getStringArray(R.array.fontNameValues);
|
|
for (int i = 0; i < fontNameNames.length; i++)
|
|
result.add(new FontDescriptor(fontNameValues[i], fontNameNames[i]));
|
|
|
|
// https://en.wikipedia.org/wiki/Croscore_fonts
|
|
if (all || bundled_fonts) {
|
|
result.add(new FontDescriptor("arimo", "Arimo (Arial, Verdana)", true));
|
|
result.add(new FontDescriptor("tinos", "Tinos (Times New Roman)", true));
|
|
result.add(new FontDescriptor("cousine", "Cousine (Courier New)", true));
|
|
result.add(new FontDescriptor("lato", "Lato (Calibri)", true));
|
|
result.add(new FontDescriptor("caladea", "Caladea (Cambria)", true));
|
|
|
|
if (BuildConfig.DEBUG) {
|
|
result.add(new FontDescriptor("montserrat", "Montserrat", true));
|
|
}
|
|
|
|
result.add(new FontDescriptor("comic sans", "OpenDyslexic", true));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public static class FontDescriptor {
|
|
@NonNull
|
|
public String type;
|
|
@NonNull
|
|
public String name;
|
|
public boolean custom;
|
|
|
|
FontDescriptor(String type, String name) {
|
|
this(type, name, false);
|
|
}
|
|
|
|
FontDescriptor(String type, String name, boolean custom) {
|
|
this.type = type;
|
|
this.name = name;
|
|
this.custom = custom;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return name;
|
|
}
|
|
}
|
|
|
|
//TextUtils.dumpSpans(text, new LogPrinter(android.util.Log.INFO, "FairEmail"), "afterTextChanged ");
|
|
}
|