精华内容
下载资源
问答
  • Word 2013允许用户为选择的文字...1、在文档中选择需要设置格式的文字,在“字体”组中单击“字体”按钮打开“字体”对话框,单击“文字效果”按钮,如图1所示。图1 单击“文字效果”按钮2、打开“设置文本效果格式...

    Word 2013允许用户为选择的文字设置包括阴影、映像和三维格式在内的多种特效,这些文字特效可以通过“设置文本效果格式”对话框来进行设置,下面介绍在Word2013文档中通过设置文本效果格式来为文字添加特殊效果的具体操作方法。

    1、在文档中选择需要设置格式的文字,在“字体”组中单击“字体”按钮打开“字体”对话框,单击“文字效果”按钮,如图1所示。

    cecbc4d84ddff00f5a1258c1be463c20.png

    图1 单击“文字效果”按钮

    2、打开“设置文本效果格式”对话框,首先设置文字的填充效果。选择“渐变填充”单选按钮对文字进行渐变填充,在“预设渐变”下拉列表中选择预设的渐变样式并应用到文字,如图2所示。完成设置后单击“确定”按钮关闭对话框,文字即被应用渐变效果,如图3所示。

    d077c7b1589b75a17300cddf9b2b079c.png

    图2 选择预设渐变样式

    8038bfa0e1e6072b1b32d272cc869911.png

    图3 文字应用渐变样式后的效果

    3、在“文本边框”栏中选择“实线”单选按钮为文字添加实线边框线效果,将边框线的颜色设置为黑色,如图4所示。设置完后单击“确定”按钮关闭对话框,文本的效果如图5所示。

    ff5e592d393429b54c5690bc9b8208b1.png

    图4 设置文本边框线

    4a8942b1b4d1c19a8f4db6857f605205.png

    图5 完成边框线设置后的文字效果

    4、单击“文本效果”按钮,在打开的面板的“阴影”栏中选择预设阴影效果,如图6所示。单击“确定”按钮关闭对话框后,文字获得阴影效果,如图7所示。

    ffa25447f72ddf2d4731cb0fb7476c07.png

    图6 选择阴影效果

    18ad6143670d19a58e9e6d5af00dfff8.png

    图7 完成阴影效果设置后的文字效果

    更多相关阅读

    展开全文
  • 一些文字特效的参数,可快速上手。exe的压缩文件,可以参照里面的设置参数快速制作特效文字
  • 看了一篇博客,学到了一些关于文字颜色与样式的知识,有所启发,所以写了一个工具类方便对TextView中文字样式进行设置(或拼接不同样式的文字)。由于使用的是SpannableStringBuilder,所以类名为SpanUtil,知识点...

    看了一篇博客,学到了一些关于文字颜色与样式的知识,有所启发,所以写了一个工具类方便对TextView中文字样式进行设置(或拼接不同样式的文字)。

    由于使用的是SpannableStringBuilder,所以类名为SpanUtil,

    知识点来自CSDN博客:http://blog.csdn.net/u012422440/article/details/52133037

    先看效果图吧!!!


    对照一下使用代码:
    SpanUtil.create()
            .addSection("这是") //添加一个字符串
            .addForeColorSection("红色", Color.RED) //添加前景色为红色的文字
            .addSection("字体,这是") //添加普通字符串
            .addForeColorSection("蓝色", Color.rgb(0x00, 0x00, 0xff)) //添加前景色为蓝色的文字
            .addSection("字体,这是")
            .addForeColorSection("绿色", 0xff00ff00) //添加前景色为绿色的文字
            .addSection("字体。")
            .setForeColor("这是", 0x90900090,false, SpanUtil.Which.ALL)//将所有"这是"渲染为紫色(0x90900090)
            .removeSpans("这是", 2) //移除下标2后第一个"这是"的Span样式
            .setForeColor("字体", Color.MAGENTA) //渲染最后一个"字体"的字体颜色为Color.MAGENTA
            //.clearSpans() //清除所有格式
            //.setAlign(Layout.Alignment.ALIGN_CENTER, 0, 1)//设置文字对齐方式
            //.addImage(R.mipmap.ic_launcher) //文字后添加图片
            .insertImage(this,R.mipmap.ic_launcher,3) //文字中插入图片
            .addStyleSection("加粗倾斜", Typeface.BOLD_ITALIC)
            .setForeColor("加粗倾斜",0xff6090f0)
            .showIn(mTvPackage); //显示到控件TextView中
    
    SpanUtil.create()
            .addSection("这是前景色") //添加普通字符串
            .setForeColor("前景色", Color.RED) //为"前景色"设置前景色
            .setForeColor(Color.BLUE,0,2) //为前两个字符设置前景色
            .addSection(",这是")
            .addBackColorSection("背景色",Color.MAGENTA) //添加带背景色的文字片段
            .addSection(",这是删除线")
            .setStrikethrough("删除线") //为文字片段"删除线"设置删除线
            .setForeColor("删除线",Color.LTGRAY) //设置文字颜色(前景色)
            .addSection(",市场价:")
            .addForeColorSection("¥29.99",Color.GRAY)  //添加带前景色的文字片段
            .setAbsSize("¥29.99",38) //设置绝对字体
            .setRelSize(".99",0.6f) //设置相对字体
            .setStrikethrough("¥29.99") //设置删除线
            .addSection(",本店:")
            .addForeColorSection("¥39.99",Color.RED)
            .setAbsSize("¥39.99",28)
            .setRelSize(".99",0.6f)
            .showIn(mTipView);
    
    SpanUtil.create().addSection("2")
            .addSuperSection("10") //添加上标
            .setRelSize("10",0.6f)
            .addSection(" = 1024,")
            .addSection("42 = 16")
            .setAsSuperscript("2") //设置为上标
            .setRelSize("2",0.6f)
            .showIn(mSectionView);
    SpannableStringBuilder使用其实很简单,最重要的方法是setSpan(),基本使用见博客:
    为方便使用,所以封装了SpanUtil,
    接下来就是工具类SpanUtil的代码(直接复制就可以使用,看似很长,其实都只是辛苦活,没什么技术含量):
    import android.content.Context;
    import android.graphics.MaskFilter;
    import android.support.annotation.NonNull;
    import android.text.Layout;
    import android.text.SpannableStringBuilder;
    import android.text.Spanned;
    import android.text.style.AbsoluteSizeSpan;
    import android.text.style.AlignmentSpan;
    import android.text.style.BackgroundColorSpan;
    import android.text.style.ForegroundColorSpan;
    import android.text.style.ImageSpan;
    import android.text.style.MaskFilterSpan;
    import android.text.style.RelativeSizeSpan;
    import android.text.style.StrikethroughSpan;
    import android.text.style.StyleSpan;
    import android.text.style.SubscriptSpan;
    import android.text.style.SuperscriptSpan;
    import android.text.style.TypefaceSpan;
    import android.text.style.URLSpan;
    import android.text.style.UnderlineSpan;
    import android.widget.TextView;
    
    /**
     * 类名: SpanUtil
     * 知识点来自CSDN博客:http://blog.csdn.net/u012422440/article/details/52133037
     * 
    
     * Description: 使TextView显示不同(颜色、大小)文字的工具类
     * 使用的关键类:
     * SpannableStringBuilder:使用setSpan(span, start, end, flag);来设置文字的Span格式
     * ForegroundColorSpan:前景色
     * BackgroundColorSpan:背景色
     * SubscriptSpan:下标
     * SuperscriptSpan:上标
     * UnderlineSpan:下划线
     * StrikethroughSpan:删除线
     * AbsoluteSizeSpan:绝对字体大小
     * RelativeSizeSpan:相对字体大小
     * URLSpan:Url
     * StyleSpan:加粗、倾斜、正常
     * TypefaceSpan:三种字体:"monospace", "serif", and "sans-serif"
     * MaskFilterSpan:BlurMaskFilter、EmbossMaskFilter
     * 
    
    
     * Android Span 框架涉及的类遵循一下四个定义规则:(ctrl + H 查看层级结构(Android Studio),上面XxxSpan是这四个类或接口的部分子类或实现类)
     * 如果一个Span影响字符层次上的文字格式,那么它继承CharacterStyle类。
     * 如果一个Span影响段落层次上的文字格式,那么它实现ParagraphStyle接口。
     * 如果一个Span修改字符层次上的文字外观,那么它实现UpdateAppearance接口。
     * 如果一个Span修改字符层次上的度量或者尺寸,那么它实现UpdateLayout接口。
     * 虽然有以上四个规则,但是我们自定义Span时并不需要直接继承或者实现这些类或者接口,而是实现其他更加具体的类。
     * 
    
    
     * 
    
    
     * 知识点来自CSDN博客:http://blog.csdn.net/u012422440/article/details/52133037
     * 
    
    
     * 这里作一个封装方便使用:前景色、背景色、下划线、删除线、上标、下标、相对字体大小、绝对字体大小等,移除或清空格式。
     * 使用如下:
     * 
    
     SpanUtil.create()
             .addSection("这是") //添加一个字符串
             .addForeColorSection("红色", Color.RED) //添加前景色为红色的文字
             .addSection("字体,这是") //添加普通字符串
             .addForeColorSection("蓝色", Color.rgb(0x00, 0x00, 0xff)) //添加前景色为蓝色的文字
             .addSection("字体,这是")
             .addForeColorSection("绿色", 0xff00ff00) //添加前景色为绿色的文字
             .addSection("字体。")
             .setForeColor("这是", 0x90900090,false, SpanUtil.Which.ALL)//将所有"这是"渲染为紫色(0x90900090)
             .removeSpans("这是", 2) //移除下标2后第一个"这是"的Span样式
             .setForeColor("字体", Color.MAGENTA) //渲染最后一个"字体"的字体颜色为Color.MAGENTA
             //.clearSpans() //清除所有格式
             //.setAlign(Layout.Alignment.ALIGN_CENTER, 0, 1)//设置文字对齐方式
             //.addImage(R.mipmap.ic_launcher) //文字后添加图片
             .insertImage(this,R.mipmap.ic_launcher,3) //文字中插入图片
             .addStyleSection("加粗倾斜", Typeface.BOLD_ITALIC)
             .setForeColor("加粗倾斜",0xff6090f0)
             .showIn(mTvPackage); //显示到控件TextView中
    
     SpanUtil.create()
             .addSection("这是前景色") //添加普通字符串
             .setForeColor("前景色", Color.RED) //为"前景色"设置前景色
             .setForeColor(Color.BLUE,0,2) //为前两个字符设置前景色
             .addSection(",这是")
             .addBackColorSection("背景色",Color.MAGENTA) //添加带背景色的文字片段
             .addSection(",这是删除线")
             .setStrikethrough("删除线") //为文字片段"删除线"设置删除线
             .setForeColor("删除线",Color.LTGRAY) //设置文字颜色(前景色)
             .addSection(",市场价:")
             .addForeColorSection("¥29.99",Color.GRAY)  //添加带前景色的文字片段
             .setAbsSize("¥29.99",38) //设置绝对字体
             .setRelSize(".99",0.6f) //设置相对字体
             .setStrikethrough("¥29.99") //设置删除线
             .addSection(",本店:")
             .addForeColorSection("¥39.99",Color.RED)
             .setAbsSize("¥39.99",28)
             .setRelSize(".99",0.6f)
             .showIn(mTipView);
    
     SpanUtil.create().addSection("2")
             .addSuperSection("10") //添加上标
             .setRelSize("10",0.6f)
             .addSection(" = 1024,")
             .addSection("42 = 16")
             .setAsSuperscript("2") //设置为上标
             .setRelSize("2",0.6f)
             .showIn(mSectionView);
     * 
    
     * Create by wangzhengyang on 2017/2/22.
     */
    
    public final class SpanUtil {
    
        public static SpanBuilder create() {
            return new SpanBuilder();
        }
    
        public static class SpanBuilder {
    
            private SpannableStringBuilder spanStrBuilder;
    
            public SpanBuilder() {
                spanStrBuilder = new SpannableStringBuilder("");
            }
    
            /**
             * 添加文字片段
             */
            public SpanBuilder addSection(CharSequence section) {
                spanStrBuilder.append(section);
                return this;
            }
    
            /**
             * 添加字体片段
             *
             * @param section 要添加的文字
             * @param span
             * @param flag    可以是
             *                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE 不包含section前后文字,最常用
             *                Spanned.SPAN_INCLUSIVE_EXCLUSIVE 包含section前面文字
             *                Spanned.SPAN_EXCLUSIVE_INCLUSIVE 包含section后面文字
             *                Spanned.SPAN_INCLUSIVE_INCLUSIVE 包含section前后文字
             *                ……
             * @return SpanBuilder
             */
            public SpanBuilder addCertainSection(String section, Object span, int flag) {
                int start = spanStrBuilder.length();
                spanStrBuilder.append(section);
                int end = spanStrBuilder.length();
                spanStrBuilder.setSpan(span, start, end, flag);
                return this;
            }
    
            /**
             * 添加带前景色的文字片段
             */
            public SpanBuilder addForeColorSection(String section, int color) {
                return addCertainSection(section, new ForegroundColorSpan(color), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加带背景色的文字片段
             */
            public SpanBuilder addBackColorSection(String section, int color) {
                return addCertainSection(section, new BackgroundColorSpan(color), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加下标
             */
            public SpanBuilder addSubSection(String section) {
                return addCertainSection(section, new SubscriptSpan(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加上标
             */
            public SpanBuilder addSuperSection(String section) {
                return addCertainSection(section, new SuperscriptSpan(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加下划线片段
             */
            public SpanBuilder addUnderlineSection(String section) {
                return addCertainSection(section, new UnderlineSpan(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加删除线片段
             */
            public SpanBuilder addStrickoutSection(String section) {
                return addCertainSection(section, new StrikethroughSpan(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加绝对大小字体片段
             */
            public SpanBuilder addAbsSizeSection(String section, int size) {
                return addCertainSection(section, new AbsoluteSizeSpan(size), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加相对大小字体片段
             */
            public SpanBuilder addRelSizeSection(String section, float proportion) {
                return addCertainSection(section, new RelativeSizeSpan(proportion), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加url字体片段
             */
            public SpanBuilder addURLSection(String section, String url) {
                return addCertainSection(section, new URLSpan(url), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加某种风格(Style)的文字片段
             *
             * @param section
             * @param style   TypeFace.BOLD  加粗
             *                TypeFace.BOLD_ITALIC  加粗倾斜
             *                TypeFace.ITALIC  倾斜
             *                TypeFace.NORMAL  正常
             * @return
             */
            public SpanBuilder addStyleSection(String section, int style) {
                return addCertainSection(section, new StyleSpan(style), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加某种字体的文字片段
             *
             * @param section
             * @param family  The font family for this typeface.  Examples include
             *                "monospace", "serif", and "sans-serif".
             */
            public SpanBuilder addTypefaceSection(String section, String family) {
                return addCertainSection(section, new TypefaceSpan(family), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加带Mask的文字片段
             *
             * @param maskFilter BlurMaskFilter、EmbossMaskFilter
             *                   例://Blur a character
             *                   new BlurMaskFilter(density*2, BlurMaskFilter.Blur.NORMAL);
             *                   //Emboss a character
             *                   new EmbossMaskFilter(new float[] { 1, 1, 1 }, 0.4f, 6, 3.5f);
             * @return
             */
            public SpanBuilder addMaskSection(String section, MaskFilter maskFilter) {
                return addCertainSection(section, new MaskFilterSpan(maskFilter), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            private SpanBuilder onDecor(String section, boolean ignoreCase, @NonNull Which which, DecorCallback decorCallback) {
                String baseStr = getString();
                if (ignoreCase) {
                    section = section.toUpperCase();
                    baseStr = baseStr.toUpperCase();
                }
                int start = 0;
                switch (which) {
                    case FIRST:
                        start = baseStr.indexOf(section);
                        if (start == -1) break;
                        decorCallback.decor(start, start + section.length());
                        break;
                    case LAST:
                        start = baseStr.lastIndexOf(section);
                        if (start == -1) break;
                        decorCallback.decor(start, start + section.length());
                        break;
                    case ALL:
                        while (true) {
                            start = baseStr.indexOf(section, start);
                            if (start == -1) break;
                            decorCallback.decor(start, start + section.length());
                            start += section.length();
                        }
                        break;
                }
                return this;
            }
    
    
            private interface DecorCallback {
                void decor(int start, int end);
            }
    
            /**
             * 加上前景色
             *
             * @param ignoreCase boolean,true区分大小写;false,不区分大小写
             */
            public SpanBuilder setForeColor(final String section, final int color, boolean ignoreCase, @NonNull Which which) {
    
                return onDecor(section, ignoreCase, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setForeColor(color, start, end);
                    }
                });
            }
    
    
            /**
             * 给最后该片段(section)加上前景色,不区分大小写
             */
            public SpanBuilder setForeColor(String section, int color) {
                return setForeColor(section, color, true, Which.LAST);
            }
    
            /**
             * 整体加上前景色
             */
            public SpanBuilder setForeColor(int color) {
                return setForeColor(color, 0, spanStrBuilder.length());
            }
    
            /**
             * 加上前景色
             */
            public SpanBuilder setForeColor(int color, int start, int end) {
                spanStrBuilder.setSpan(new ForegroundColorSpan(color), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 加上背景色
             */
            public SpanBuilder setBackColor(String section, final int color, boolean ignoreCase, @NonNull Which which) {
    
                return onDecor(section, ignoreCase, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setBackColor(color, start, end);
                    }
                });
            }
    
            /**
             * 给最后一个该片段(section)加上背景色,不区分大小写
             */
            public SpanBuilder setBackColor(String section, int color) {
                return setBackColor(section, color, true, Which.LAST);
            }
    
            /**
             * 整体加上背景色
             */
            public SpanBuilder setBackColor(int color) {
                return setBackColor(color, 0, spanStrBuilder.length());
            }
    
            /**
             * 加上背景色
             */
            public SpanBuilder setBackColor(int color, int start, int end) {
                spanStrBuilder.setSpan(new BackgroundColorSpan(color), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 设置为下标
             */
            public SpanBuilder setAsSubscript(@NonNull String section, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setAsSubscript(start, end);
                    }
                });
            }
    
            /**
             * 给最后一个该片段(section)设置为下标
             */
            public SpanBuilder setAsSubscript(String section) {
                return setAsSubscript(section, Which.LAST);
            }
    
            /**
             * 整体设置为下标
             */
            public SpanBuilder setAsSubscript() {
                return setAsSubscript(0, spanStrBuilder.length());
            }
    
            /**
             * 设置为下标
             */
            public SpanBuilder setAsSubscript(int start, int end) {
                spanStrBuilder.setSpan(new SubscriptSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 设置为上标
             */
            public SpanBuilder setAsSuperscript(String section, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setAsSuperscript(start, end);
                    }
                });
            }
    
            /**
             * 给最后一个该片段(section)设置为上标
             */
            public SpanBuilder setAsSuperscript(String section) {
                return setAsSuperscript(section, Which.LAST);
            }
    
            /**
             * 整体设置为上标
             */
            public SpanBuilder setAsSuperscript() {
                return setAsSuperscript(0, spanStrBuilder.length());
            }
    
            /**
             * 设置为上标
             */
            public SpanBuilder setAsSuperscript(int start, int end) {
                spanStrBuilder.setSpan(new SuperscriptSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 给片段设置下划线
             */
            public SpanBuilder setUnderline(String section, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setUnderline(start, end);
                    }
                });
            }
    
            /**
             * 给最后一个该片段(section)设置下划线
             */
            public SpanBuilder setUnderline(String section) {
                return setUnderline(section, Which.LAST);
            }
    
            /**
             * 给所有文字设置下划线
             */
            public SpanBuilder setUnderline() {
                return setUnderline(0, spanStrBuilder.length());
            }
    
            /**
             * 给片段设置下划线
             */
            public SpanBuilder setUnderline(int start, int end) {
                spanStrBuilder.setSpan(new UnderlineSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 给片段添加删除线
             */
            public SpanBuilder setStrikethrough(String section, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setStrikethrough(start, end);
                    }
                });
            }
    
            /**
             * 给最后一个该片段(section)添加删除线
             */
            public SpanBuilder setStrikethrough(String section) {
                return setStrikethrough(section, Which.LAST);
            }
    
            /**
             * 给所有文字添加删除线
             */
            public SpanBuilder setStrikethrough() {
                return setStrikethrough(0, spanStrBuilder.length());
            }
    
            /**
             * 给片段添加删除线
             */
            public SpanBuilder setStrikethrough(int start, int end) {
                spanStrBuilder.setSpan(new StrikethroughSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 给片段的字体设置绝对大小
             */
            public SpanBuilder setAbsSize(String section, final int size, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setAbsSize(size, start, end);
                    }
                });
            }
    
            /**
             * 给最后一个该片段(section)设置绝对大小
             */
            public SpanBuilder setAbsSize(String section, int size) {
                return setAbsSize(section, size, Which.LAST);
            }
    
            /**
             * 给所有文字设置绝对大小
             */
            public SpanBuilder setAbsSize(int size) {
                return setAbsSize(size, 0, spanStrBuilder.length());
            }
    
            /**
             * 给片段的字体设置绝对大小
             */
            public SpanBuilder setAbsSize(int size, int start, int end) {
                spanStrBuilder.setSpan(new AbsoluteSizeSpan(size), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 给片段的字体设置相对大小
             */
            public SpanBuilder setRelSize(String section, final float proportion, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setRelSize(proportion, start, end);
                    }
                });
            }
    
            /**
             * 给最后一个该片段的字体设置相对大小
             */
            public SpanBuilder setRelSize(String section, float proportion) {
                return setRelSize(section, proportion, Which.LAST);
            }
    
            /**
             * 给片段的字体设置相对大小
             */
            public SpanBuilder setRelSize(float proportion) {
                return setRelSize(proportion, 0, spanStrBuilder.length());
            }
    
            /**
             * 给片段的字体设置相对大小
             */
            public SpanBuilder setRelSize(float proportion, int start, int end) {
                spanStrBuilder.setSpan(new RelativeSizeSpan(proportion), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 转为url字体片段
             */
            public SpanBuilder setAsURL(String section, final String url, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setAsUrl(url, start, end);
                    }
                });
            }
    
            /**
             * 整体转为url字体片段
             */
            public SpanBuilder setAsUrl(String url) {
                return setAsUrl(url, 0, spanStrBuilder.length());
            }
    
            /**
             * 转为url字体片段
             */
            public SpanBuilder setAsUrl(String url, int start, int end) {
                spanStrBuilder.setSpan(new URLSpan(url), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 设置字体风格(粗、斜、正常)
             */
            public SpanBuilder setStyle(String section, final int style, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setStyle(style, start, end);
                    }
                });
            }
    
    
            /**
             * 给最后一个片段(section)设置字体风格(粗、斜、正常)
             */
            public SpanBuilder setStyle(String section, int style) {
                return setStyle(section, style, Which.LAST);
            }
    
            /**
             * 整体设置字体风格(粗、斜、正常)
             */
            public SpanBuilder setStyle(int style) {
                return setStyle(style, 0, spanStrBuilder.length());
            }
    
            /**
             * 设置字体风格(粗、斜、正常)
             */
            public SpanBuilder setStyle(int style, int start, int end) {
                spanStrBuilder.setSpan(new StyleSpan(style), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 设置字体
             *
             * @param family "monospace", "serif", and "sans-serif"
             * @param which  SpanUtil.Which.FIRST、SpanUtil.Which.LAST、SpanUtil.Which.ALL
             */
            public SpanBuilder setTypeface(String section, final String family, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setTypeface(family, start, end);
                    }
                });
            }
    
            /**
             * 给最后一个该片段(section)设置字体
             */
            public SpanBuilder setTypeface(String section, String family) {
                return setTypeface(section, family, Which.LAST);
            }
    
            /**
             * 整体设置字体
             */
            public SpanBuilder setTypeface(String family) {
                return setTypeface(family, 0, spanStrBuilder.length());
            }
    
            /**
             * 设置字体
             */
            public SpanBuilder setTypeface(String family, int start, int end) {
                spanStrBuilder.setSpan(new TypefaceSpan(family), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 设置Mask
             *
             * @param maskFilter BlurMaskFilter、EmbossMaskFilter
             *                   例://Blur((使…)变模糊) a character
             *                   new BlurMaskFilter(density*2, BlurMaskFilter.Blur.NORMAL);
             *                   //Emboss a character
             *                   new EmbossMaskFilter(new float[] { 1, 1, 1 }, 0.4f, 6, 3.5f);
             */
            public SpanBuilder setMask(String section, final MaskFilter maskFilter, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setMask(maskFilter, start, end);
                    }
                });
            }
    
            /**
             * 为最后一个该片段(section)设置Mask
             *
             * @param maskFilter BlurMaskFilter、EmbossMaskFilter
             *                   例://Blur a character
             *                   new BlurMaskFilter(density*2, BlurMaskFilter.Blur.NORMAL);
             *                   //Emboss a character
             *                   new EmbossMaskFilter(new float[] { 1, 1, 1 }, 0.4f, 6, 3.5f);
             */
            public SpanBuilder setMask(String section, MaskFilter maskFilter) {
                return setMask(section, maskFilter, Which.LAST);
            }
    
            /**
             * 为整体设置Mask
             *
             * @param maskFilter BlurMaskFilter、EmbossMaskFilter
             *                   例://Blur a character
             *                   new BlurMaskFilter(density*2, BlurMaskFilter.Blur.NORMAL);
             *                   //Emboss a character
             *                   new EmbossMaskFilter(new float[] { 1, 1, 1 }, 0.4f, 6, 3.5f);
             */
            public SpanBuilder setMask(MaskFilter maskFilter) {
                return setMask(maskFilter, 0, spanStrBuilder.length());
            }
    
            /**
             * 设置Mask
             *
             * @param maskFilter BlurMaskFilter、EmbossMaskFilter
             *                   例://Blur a character
             *                   new BlurMaskFilter(density*2, BlurMaskFilter.Blur.NORMAL);
             *                   //Emboss a character
             *                   new EmbossMaskFilter(new float[] { 1, 1, 1 }, 0.4f, 6, 3.5f);
             * @param start      开始位置
             * @param end        截止位置
             */
            public SpanBuilder setMask(MaskFilter maskFilter, int start, int end) {
                spanStrBuilder.setSpan(new MaskFilterSpan(maskFilter), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 设置对齐方式
             *
             * @param alignment Layout.Alignment.ALIGN_CENTER 居中
             *                  Layout.Alignment.ALIGN_NORMAL 正常(左对齐)
             *                  Layout.Alignment.ALIGN_OPPOSITE 反向(右对齐)
             * @param start     开始位置
             * @param end       截止位置
             */
            public SpanBuilder setAlign(Layout.Alignment alignment, int start, int end) {
                spanStrBuilder.setSpan(new AlignmentSpan.Standard(alignment), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 文字后添加图片
             *
             * @param resId
             * @return
             */
            public SpanBuilder addImage(Context context, int resId) {
                insertImage(context, resId, spanStrBuilder.length());
                return this;
            }
    
            /**
             * 文字中某位置(where)插入图片
             *
             * @param resId 图片资源Id
             * @param where 插入位置:占一个字的位置,整体索引增加一个
             * @return
             */
            public SpanBuilder insertImage(Context context, int resId, int where) {
                spanStrBuilder.insert(where, " ");
                spanStrBuilder.setSpan(new ImageSpan(context, resId), where, where + 1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 清除格式
             */
            public SpanBuilder clearSpans() {
                spanStrBuilder.clearSpans();
                return this;
            }
    
            /**
             * 移除格式
             */
            public SpanBuilder removeSpans(@NonNull String section, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        removeSpans(start, end);
                    }
                });
            }
    
            /**
             * 移除最后一个该片段(section)的格式
             */
            public SpanBuilder removeSpans(@NonNull String section) {
                return removeSpans(section, Which.LAST);
            }
    
            /**
             * 移除格式,从某一个下标开始
             */
            public SpanBuilder removeSpans(@NonNull String section, int fromIndex) {
                String baseStr = getString();
                fromIndex = baseStr.indexOf(section, fromIndex);
                removeSpans(fromIndex, fromIndex + section.length());
                return this;
            }
    
            /**
             * 移除格式
             *
             * @param start 开始位置
             * @param end   结束位置
             * @return this
             */
            public SpanBuilder removeSpans(int start, int end) {
                Object[] spans = spanStrBuilder.getSpans(start, end, Object.class);
                for (Object span : spans) {
                    spanStrBuilder.removeSpan(span);
                }
                return this;
            }
    
            /**
             * 获得当前SpanStringBuilder实例
             */
            public SpannableStringBuilder getSpanStrBuilder() {
                return spanStrBuilder;
            }
    
            /**
             * 获得当前SpanStringBuilder中的字符串
             */
            public String getString() {
                return spanStrBuilder.toString();
            }
    
            /**
             * 显示到控件
             *
             * @param textView
             */
            public void showIn(TextView textView) {
                textView.setText(spanStrBuilder);
                spanStrBuilder.clearSpans();
                spanStrBuilder.clear();
                spanStrBuilder = null;
            }
        }
    
        /**
         * 标记第一个、最后一个、所有
         */
        public enum Which {
            FIRST, LAST, ALL
        }
    
    }

    仅仅为了方便使用!


    展开全文
  • 一个工具类, 方便对 TextView 中文字样式进行设置(或拼接不同样式的文字)。 介绍使用 代码块 一个工具类, 方便对 TextView 中文字样式进行设置(或拼接不同样式的文字)。 介绍使用 先看效果 ...

    一个工具类, 方便对 TextView 中文字样式进行设置(或拼接不同样式的文字)。

    介绍使用

    先看效果
    工具类使用效果
    对应的使用代码为:

    SpanUtil.create()
                    .addSection("这是") //添加一个字符串
                    .addForeColorSection("红色", Color.RED) //添加前景色为红色的文字
                    .addSection("字体,这是") //添加普通字符串
                    .addForeColorSection("蓝色", Color.rgb(0x00, 0x00, 0xff)) //添加前景色为蓝色的文字
                    .addSection("字体,这是")
                    .addForeColorSection("绿色", 0xff00ff00) //添加前景色为绿色的文字
                    .addSection("字体。")
                    .setForeColor("这是", 0x90900090,false, SpanUtil.Which.ALL)//将所有"这是"渲染为紫色(0x90900090)
                    .removeSpans("这是", 2) //移除下标2后第一个"这是"的Span样式
                    .setForeColor("字体", Color.MAGENTA) //渲染最后一个"字体"的字体颜色为Color.MAGENTA
                    //.clearSpans() //清除所有格式
                    //.setAlign(Layout.Alignment.ALIGN_CENTER, 0, 1)//设置文字对齐方式
                    //.addImage(R.mipmap.ic_launcher) //文字后添加图片
                    .insertImage(this,R.mipmap.ic_launcher,3) //文字中插入图片
                    .addStyleSection("加粗倾斜", Typeface.BOLD_ITALIC)
                    .setForeColor("加粗倾斜",0xff6090f0)
                    .showIn(mTv1); //显示到控件TextView中
    
            SpanUtil.create()
                    .addSection("这是前景色") //添加普通字符串
                    .setForeColor("前景色", Color.RED) //为"前景色"设置前景色
                    .setForeColor(Color.BLUE,0,2) //为前两个字符设置前景色
                    .addSection(",这是")
                    .addBackColorSection("背景色",Color.MAGENTA) //添加带背景色的文字片段
                    .addSection(",这是删除线")
                    .setStrikethrough("删除线") //为文字片段"删除线"设置删除线
                    .setForeColor("删除线",Color.LTGRAY) //设置文字颜色(前景色)
                    .addSection(",市场价:")
                    .addForeColorSection("¥29.99",Color.GRAY)  //添加带前景色的文字片段
                    .setAbsSize("¥29.99",38) //设置绝对字体
                    .setRelSize(".99",0.6f) //设置相对字体
                    .setStrikethrough("¥29.99") //设置删除线
                    .addSection(",本店:")
                    .addForeColorSection("¥39.99", Color.RED)
                    .setAbsSize("¥39.99",28)
                    .setRelSize(".99",0.6f)
                    .showIn(mTv2);
    
            SpanUtil.create().addSection("2")
                    .addSuperSection("10") //添加上标
                    .setRelSize("10",0.6f)
                    .addSection(" = 1024,")
                    .addSection("42 = 16")
                    .setAsSuperscript("2") //设置为上标
                    .setRelSize("2",0.6f)
                    .showIn(mTv3);

    SpannableStringBuilder 使用其实很简单,最重要的方法是 setSpan(),基本使用见博客:
    http://blog.csdn.net/u012422440/article/details/52133037
    为方便使用,所以封装了 SpanUtil,
    接下来就是工具类 SpanUtil 的代码

    代码块

    代码块语法遵循标准 markdown 代码,例如:

    import android.content.Context;
    import android.graphics.MaskFilter;
    import android.support.annotation.NonNull;
    import android.text.Layout;
    import android.text.SpannableStringBuilder;
    import android.text.Spanned;
    import android.text.style.AbsoluteSizeSpan;
    import android.text.style.AlignmentSpan;
    import android.text.style.BackgroundColorSpan;
    import android.text.style.ForegroundColorSpan;
    import android.text.style.ImageSpan;
    import android.text.style.MaskFilterSpan;
    import android.text.style.RelativeSizeSpan;
    import android.text.style.StrikethroughSpan;
    import android.text.style.StyleSpan;
    import android.text.style.SubscriptSpan;
    import android.text.style.SuperscriptSpan;
    import android.text.style.TypefaceSpan;
    import android.text.style.URLSpan;
    import android.text.style.UnderlineSpan;
    import android.widget.TextView;
    
    public final class SpanUtil {
    
        public static SpanBuilder create() {
            return new SpanBuilder();
        }
    
        public static class SpanBuilder {
    
            private SpannableStringBuilder spanStrBuilder;
    
            public SpanBuilder() {
                spanStrBuilder = new SpannableStringBuilder("");
            }
    
            /**
             * 添加文字片段
             */
            public SpanBuilder addSection(CharSequence section) {
                spanStrBuilder.append(section);
                return this;
            }
    
            /**
             * 添加字体片段
             *
             * @param section 要添加的文字
             * @param span    任何span
             * @param flag    可以是
             *                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE 不包含 section 前后文字,最常用
             *                Spanned.SPAN_INCLUSIVE_EXCLUSIVE 包含 section 前面文字
             *                Spanned.SPAN_EXCLUSIVE_INCLUSIVE 包含 section 后面文字
             *                Spanned.SPAN_INCLUSIVE_INCLUSIVE 包含 section 前后文字
             *                ……
             * @return SpanBuilder
             */
            public SpanBuilder addCertainSection(String section, Object span, int flag) {
                int start = spanStrBuilder.length();
                spanStrBuilder.append(section);
                int end = spanStrBuilder.length();
                spanStrBuilder.setSpan(span, start, end, flag);
                return this;
            }
    
            /**
             * 添加带前景色的文字片段
             */
            public SpanBuilder addForeColorSection(String section, int color) {
                return addCertainSection(section, new ForegroundColorSpan(color), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加带背景色的文字片段
             */
            public SpanBuilder addBackColorSection(String section, int color) {
                return addCertainSection(section, new BackgroundColorSpan(color), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加下标
             */
            public SpanBuilder addSubSection(String section) {
                return addCertainSection(section, new SubscriptSpan(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加上标
             */
            public SpanBuilder addSuperSection(String section) {
                return addCertainSection(section, new SuperscriptSpan(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加下划线片段
             */
            public SpanBuilder addUnderlineSection(String section) {
                return addCertainSection(section, new UnderlineSpan(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加删除线片段
             */
            public SpanBuilder addStrickoutSection(String section) {
                return addCertainSection(section, new StrikethroughSpan(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加绝对大小字体片段
             */
            public SpanBuilder addAbsSizeSection(String section, int size) {
                return addCertainSection(section, new AbsoluteSizeSpan(size,true), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加相对大小字体片段
             */
            public SpanBuilder addRelSizeSection(String section, float proportion) {
                return addCertainSection(section, new RelativeSizeSpan(proportion), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加 url 字体片段
             */
            public SpanBuilder addURLSection(String section, String url) {
                return addCertainSection(section, new URLSpan(url), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加某种风格(Style)的文字片段
             *
             * @param section
             * @param style   TypeFace.BOLD  加粗
             *                TypeFace.BOLD_ITALIC  加粗倾斜
             *                TypeFace.ITALIC  倾斜
             *                TypeFace.NORMAL  正常
             * @return
             */
            public SpanBuilder addStyleSection(String section, int style) {
                return addCertainSection(section, new StyleSpan(style), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加某种字体的文字片段
             *
             * @param section
             * @param family  The font family for this typeface.  Examples include
             *                "monospace", "serif", and "sans-serif".
             */
            public SpanBuilder addTypefaceSection(String section, String family) {
                return addCertainSection(section, new TypefaceSpan(family), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            /**
             * 添加带 Mask 的文字片段
             *
             * @param maskFilter BlurMaskFilter、EmbossMaskFilter
             *                   例://Blur a character
             *                   new BlurMaskFilter(density*2, BlurMaskFilter.Blur.NORMAL);
             *                   //Emboss a character
             *                   new EmbossMaskFilter(new float[] { 1, 1, 1 }, 0.4f, 6, 3.5f);
             * @return
             */
            public SpanBuilder addMaskSection(String section, MaskFilter maskFilter) {
                return addCertainSection(section, new MaskFilterSpan(maskFilter), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
    
            private SpanBuilder onDecor(String section, boolean ignoreCase, @NonNull Which which, DecorCallback decorCallback) {
                String baseStr = getString();
                if (ignoreCase) {
                    section = section.toUpperCase();
                    baseStr = baseStr.toUpperCase();
                }
                int start = 0;
                switch (which) {
                    case FIRST:
                        start = baseStr.indexOf(section);
                        if (start == -1) break;
                        decorCallback.decor(start, start + section.length());
                        break;
                    case LAST:
                        start = baseStr.lastIndexOf(section);
                        if (start == -1) break;
                        decorCallback.decor(start, start + section.length());
                        break;
                    case ALL:
                        while (true) {
                            start = baseStr.indexOf(section, start);
                            if (start == -1) break;
                            decorCallback.decor(start, start + section.length());
                            start += section.length();
                        }
                        break;
                }
                return this;
            }
    
    
            private interface DecorCallback {
                void decor(int start, int end);
            }
    
            /**
             * 加上前景色
             *
             * @param ignoreCase boolean,true 区分大小写;false, 不区分大小写
             */
            public SpanBuilder setForeColor(final String section, final int color, boolean ignoreCase, @NonNull Which which) {
    
                return onDecor(section, ignoreCase, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setForeColor(color, start, end);
                    }
                });
            }
    
    
            /**
             * 给最后该片段(section)加上前景色,不区分大小写
             */
            public SpanBuilder setForeColor(String section, int color) {
                return setForeColor(section, color, true, Which.LAST);
            }
    
            /**
             * 整体加上前景色
             */
            public SpanBuilder setForeColor(int color) {
                return setForeColor(color, 0, spanStrBuilder.length());
            }
    
            /**
             * 加上前景色
             */
            public SpanBuilder setForeColor(int color, int start, int end) {
                spanStrBuilder.setSpan(new ForegroundColorSpan(color), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 加上背景色
             */
            public SpanBuilder setBackColor(String section, final int color, boolean ignoreCase, @NonNull Which which) {
    
                return onDecor(section, ignoreCase, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setBackColor(color, start, end);
                    }
                });
            }
    
            /**
             * 给最后一个该片段(section)加上背景色,不区分大小写
             */
            public SpanBuilder setBackColor(String section, int color) {
                return setBackColor(section, color, true, Which.LAST);
            }
    
            /**
             * 整体加上背景色
             */
            public SpanBuilder setBackColor(int color) {
                return setBackColor(color, 0, spanStrBuilder.length());
            }
    
            /**
             * 加上背景色
             */
            public SpanBuilder setBackColor(int color, int start, int end) {
                spanStrBuilder.setSpan(new BackgroundColorSpan(color), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 设置为下标
             */
            public SpanBuilder setAsSubscript(@NonNull String section, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setAsSubscript(start, end);
                    }
                });
            }
    
            /**
             * 给最后一个该片段(section)设置为下标
             */
            public SpanBuilder setAsSubscript(String section) {
                return setAsSubscript(section, Which.LAST);
            }
    
            /**
             * 整体设置为下标
             */
            public SpanBuilder setAsSubscript() {
                return setAsSubscript(0, spanStrBuilder.length());
            }
    
            /**
             * 设置为下标
             */
            public SpanBuilder setAsSubscript(int start, int end) {
                spanStrBuilder.setSpan(new SubscriptSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 设置为上标
             */
            public SpanBuilder setAsSuperscript(String section, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setAsSuperscript(start, end);
                    }
                });
            }
    
            /**
             * 给最后一个该片段(section)设置为上标
             */
            public SpanBuilder setAsSuperscript(String section) {
                return setAsSuperscript(section, Which.LAST);
            }
    
            /**
             * 整体设置为上标
             */
            public SpanBuilder setAsSuperscript() {
                return setAsSuperscript(0, spanStrBuilder.length());
            }
    
            /**
             * 设置为上标
             */
            public SpanBuilder setAsSuperscript(int start, int end) {
                spanStrBuilder.setSpan(new SuperscriptSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 给片段设置下划线
             */
            public SpanBuilder setUnderline(String section, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setUnderline(start, end);
                    }
                });
            }
    
            /**
             * 给最后一个该片段(section)设置下划线
             */
            public SpanBuilder setUnderline(String section) {
                return setUnderline(section, Which.LAST);
            }
    
            /**
             * 给所有文字设置下划线
             */
            public SpanBuilder setUnderline() {
                return setUnderline(0, spanStrBuilder.length());
            }
    
            /**
             * 给片段设置下划线
             */
            public SpanBuilder setUnderline(int start, int end) {
                spanStrBuilder.setSpan(new UnderlineSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 给片段添加删除线
             */
            public SpanBuilder setStrikethrough(String section, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setStrikethrough(start, end);
                    }
                });
            }
    
            /**
             * 给最后一个该片段(section)添加删除线
             */
            public SpanBuilder setStrikethrough(String section) {
                return setStrikethrough(section, Which.LAST);
            }
    
            /**
             * 给所有文字添加删除线
             */
            public SpanBuilder setStrikethrough() {
                return setStrikethrough(0, spanStrBuilder.length());
            }
    
            /**
             * 给片段添加删除线
             */
            public SpanBuilder setStrikethrough(int start, int end) {
                spanStrBuilder.setSpan(new StrikethroughSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 给片段的字体设置绝对大小
             */
            public SpanBuilder setAbsSize(String section, final int size, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setAbsSize(size, start, end);
                    }
                });
            }
    
            /**
             * 给最后一个该片段(section)设置绝对大小
             */
            public SpanBuilder setAbsSize(String section, int size) {
                return setAbsSize(section, size, Which.LAST);
            }
    
            /**
             * 给所有文字设置绝对大小
             */
            public SpanBuilder setAbsSize(int size) {
                return setAbsSize(size, 0, spanStrBuilder.length());
            }
    
            /**
             * 给片段的字体设置绝对大小
             */
            public SpanBuilder setAbsSize(int size, int start, int end) {
                spanStrBuilder.setSpan(new AbsoluteSizeSpan(size,true), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 给片段的字体设置相对大小
             */
            public SpanBuilder setRelSize(String section, final float proportion, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setRelSize(proportion, start, end);
                    }
                });
            }
    
            /**
             * 给最后一个该片段的字体设置相对大小
             */
            public SpanBuilder setRelSize(String section, float proportion) {
                return setRelSize(section, proportion, Which.LAST);
            }
    
            /**
             * 给片段的字体设置相对大小
             */
            public SpanBuilder setRelSize(float proportion) {
                return setRelSize(proportion, 0, spanStrBuilder.length());
            }
    
            /**
             * 给片段的字体设置相对大小
             */
            public SpanBuilder setRelSize(float proportion, int start, int end) {
                spanStrBuilder.setSpan(new RelativeSizeSpan(proportion), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 转为 url 字体片段
             */
            public SpanBuilder setAsURL(String section, final String url, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setAsUrl(url, start, end);
                    }
                });
            }
    
            /**
             * 整体转为 url 字体片段
             */
            public SpanBuilder setAsUrl(String url) {
                return setAsUrl(url, 0, spanStrBuilder.length());
            }
    
            /**
             * 转为 url 字体片段
             */
            public SpanBuilder setAsUrl(String url, int start, int end) {
                spanStrBuilder.setSpan(new URLSpan(url), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 设置字体风格(粗、斜、正常)
             */
            public SpanBuilder setStyle(String section, final int style, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setStyle(style, start, end);
                    }
                });
            }
    
    
            /**
             * 给最后一个片段(section)设置字体风格(粗、斜、正常)
             */
            public SpanBuilder setStyle(String section, int style) {
                return setStyle(section, style, Which.LAST);
            }
    
            /**
             * 整体设置字体风格(粗、斜、正常)
             */
            public SpanBuilder setStyle(int style) {
                return setStyle(style, 0, spanStrBuilder.length());
            }
    
            /**
             * 设置字体风格(粗、斜、正常)
             */
            public SpanBuilder setStyle(int style, int start, int end) {
                spanStrBuilder.setSpan(new StyleSpan(style), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 设置字体
             *
             * @param family "monospace", "serif", and "sans-serif"
             * @param which  SpanUtil.Which.FIRST、SpanUtil.Which.LAST、SpanUtil.Which.ALL
             */
            public SpanBuilder setTypeface(String section, final String family, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setTypeface(family, start, end);
                    }
                });
            }
    
            /**
             * 给最后一个该片段(section)设置字体
             */
            public SpanBuilder setTypeface(String section, String family) {
                return setTypeface(section, family, Which.LAST);
            }
    
            /**
             * 整体设置字体
             */
            public SpanBuilder setTypeface(String family) {
                return setTypeface(family, 0, spanStrBuilder.length());
            }
    
            /**
             * 设置字体
             */
            public SpanBuilder setTypeface(String family, int start, int end) {
                spanStrBuilder.setSpan(new TypefaceSpan(family), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 设置 Mask
             *
             * @param maskFilter BlurMaskFilter、EmbossMaskFilter
             *                   例://Blur((使…) 变模糊) a character
             *                   new BlurMaskFilter(density*2, BlurMaskFilter.Blur.NORMAL);
             *                   //Emboss a character
             *                   new EmbossMaskFilter(new float[] { 1, 1, 1 }, 0.4f, 6, 3.5f);
             */
            public SpanBuilder setMask(String section, final MaskFilter maskFilter, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        setMask(maskFilter, start, end);
                    }
                });
            }
    
            /**
             * 为最后一个该片段(section)设置 Mask
             *
             * @param maskFilter BlurMaskFilter、EmbossMaskFilter
             *                   例://Blur a character
             *                   new BlurMaskFilter(density*2, BlurMaskFilter.Blur.NORMAL);
             *                   //Emboss a character
             *                   new EmbossMaskFilter(new float[] { 1, 1, 1 }, 0.4f, 6, 3.5f);
             */
            public SpanBuilder setMask(String section, MaskFilter maskFilter) {
                return setMask(section, maskFilter, Which.LAST);
            }
    
            /**
             * 为整体设置 Mask
             *
             * @param maskFilter BlurMaskFilter、EmbossMaskFilter
             *                   例://Blur a character
             *                   new BlurMaskFilter(density*2, BlurMaskFilter.Blur.NORMAL);
             *                   //Emboss a character
             *                   new EmbossMaskFilter(new float[] { 1, 1, 1 }, 0.4f, 6, 3.5f);
             */
            public SpanBuilder setMask(MaskFilter maskFilter) {
                return setMask(maskFilter, 0, spanStrBuilder.length());
            }
    
            /**
             * 设置 Mask
             *
             * @param maskFilter BlurMaskFilter、EmbossMaskFilter
             *                   例://Blur a character
             *                   new BlurMaskFilter(density*2, BlurMaskFilter.Blur.NORMAL);
             *                   //Emboss a character
             *                   new EmbossMaskFilter(new float[] { 1, 1, 1 }, 0.4f, 6, 3.5f);
             * @param start      开始位置
             * @param end        截止位置
             */
            public SpanBuilder setMask(MaskFilter maskFilter, int start, int end) {
                spanStrBuilder.setSpan(new MaskFilterSpan(maskFilter), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 设置对齐方式
             *
             * @param alignment Layout.Alignment.ALIGN_CENTER 居中
             *                  Layout.Alignment.ALIGN_NORMAL 正常(左对齐)
             *                  Layout.Alignment.ALIGN_OPPOSITE 反向(右对齐)
             * @param start     开始位置
             * @param end       截止位置
             */
            public SpanBuilder setAlign(Layout.Alignment alignment, int start, int end) {
                spanStrBuilder.setSpan(new AlignmentSpan.Standard(alignment), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 文字后添加图片
             *
             * @param resId
             * @return
             */
            public SpanBuilder addImage(Context context, int resId) {
                insertImage(context, resId, spanStrBuilder.length());
                return this;
            }
    
            /**
             * 文字中某位置(where)插入图片
             *
             * @param resId 图片资源 Id
             * @param where 插入位置:占一个字的位置,整体索引增加一个
             * @return
             */
            public SpanBuilder insertImage(Context context, int resId, int where) {
                spanStrBuilder.insert(where, " ");
                spanStrBuilder.setSpan(new ImageSpan(context, resId), where, where + 1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
                return this;
            }
    
            /**
             * 清除格式
             */
            public SpanBuilder clearSpans() {
                spanStrBuilder.clearSpans();
                return this;
            }
    
            /**
             * 移除格式
             */
            public SpanBuilder removeSpans(@NonNull String section, @NonNull Which which) {
    
                return onDecor(section, false, which, new DecorCallback() {
                    @Override
                    public void decor(int start, int end) {
                        removeSpans(start, end);
                    }
                });
            }
    
            /**
             * 移除最后一个该片段(section)的格式
             */
            public SpanBuilder removeSpans(@NonNull String section) {
                return removeSpans(section, Which.LAST);
            }
    
            /**
             * 移除格式,从某一个下标开始
             */
            public SpanBuilder removeSpans(@NonNull String section, int fromIndex) {
                String baseStr = getString();
                fromIndex = baseStr.indexOf(section, fromIndex);
                removeSpans(fromIndex, fromIndex + section.length());
                return this;
            }
    
            /**
             * 移除格式
             *
             * @param start 开始位置
             * @param end   结束位置
             * @return this
             */
            public SpanBuilder removeSpans(int start, int end) {
                Object[] spans = spanStrBuilder.getSpans(start, end, Object.class);
                for (Object span : spans) {
                    spanStrBuilder.removeSpan(span);
                }
                return this;
            }
    
            /**
             * 获得当前 SpanStringBuilder 实例
             */
            public SpannableStringBuilder getSpanStrBuilder() {
                return spanStrBuilder;
            }
    
            /**
             * 获得当前 SpanStringBuilder 中的字符串
             */
            public String getString() {
                return spanStrBuilder.toString();
            }
    
            /**
             * 显示到控件
             *
             * @param textView
             */
            public void showIn(TextView textView) {
                textView.setText(spanStrBuilder);
                spanStrBuilder.clearSpans();
                spanStrBuilder.clear();
                spanStrBuilder = null;
            }
        }
    
        /**
         * 标记第一个、最后一个、所有
         */
        public enum Which {
            FIRST, LAST, ALL
        }
    
    }
    展开全文
  • 使用不同的转义序列组合来达到不同的效果,如下面加上背景色的显示: echo -e "\033[前景色值;背景色值m 文本\033[0m" 前景色值和背景色值使用分号间隔,不分先后,因为两种值的颜色范围不一样,比如 黑色...

    ANSI控制码

    简介

    ANSI控制码用于在字符显示系统中控制光标移动和字符色彩等,常用于BBS系统中。

    ANSI ESCAPE SEQUENCES又称为VT100系列控制码,国内译为ANSI控制码。顾名思义,需要VT100系列终端的支持,当然现在已经不在局限于VT100了,包括xterm,linux都能很好完成。ANSI控制码依赖终端,不是依赖语言,所以在shell,perl,c里应用均没有问题。

    ANSI控制码开始的标志都为ESC[,ESC对应ASCII码表的033(八进制),linux命令echo用-e启用转义,\033来输入ESC,\033[31m即为ESC[31m。

     

    格式

    echo:-e 用来开启echo中的转义,\e 或 \033 来输出Esc符号

    格式: echo -e "\033[字背景颜色;字体颜色m字符串\033[0m"

    注意m后面紧跟字符串。

     

    ANSI控制码

    \33[0m 关闭所有属性 
    \33[1m 设置高亮度
    \33[4m 下划线 
    \33[5m 闪烁 
    \33[7m 反显 
    \33[8m 消隐 
    \33[30m -- \33[37m 设置前景色(字体色)30:黑 31:红     32:绿 33:黄    34:蓝色 35:紫色 36:深绿 37:白色
    \33[40m -- \33[47m 设置背景色                  40:黑 41:深红 42:绿 43:黄色 44:蓝色 45:紫色 46:深绿 47:白色
    \33[nA 光标上移n行 
    \33[nB 光标下移n行 
    \33[nC 光标右移n行 
    \33[nD 光标左移n行 
    \33[y;xH设置光标位置 
    \33[2J 清屏 
    \33[K 清除从光标到行尾的内容 
    \33[s 保存光标位置 
    \33[u 恢复光标位置 
    \33[?25l 隐藏光标 
    \33[?25h 显示光标

    显示字元属性控制

    [n1;n2;......m

    Ⅰ设定显示字元的属性状态;

    Ⅱ若有两个以上的属性状态要设定则以分号将代码(n1;n2;..)隔开;

    Ⅲ除非重新设定,否则原设定之属性一直被保留;

    1、Linux中设置文本颜色及背景色

    Shell 使用 ANSI 转义码 (ANSI escape codes) 进行颜色输出。转义序列颜色输出表如下

    颜色

    前景色(字体色)

    背景色

    黑色 (Black)

    30

    40

    红色 (Red)

    31

    41

    绿色 (Green)

    32

    42

    黄色 (Yellow)

    33

    43

    蓝色 (Blue)

    34

    44

    紫红色 (Magenta)

    35

    45

    青色 (Cyan)

    36

    46

    白色 (White)

    37

    47

    echo -e "\033[颜色值m 文本"

    这句代码中\033[ 作为转义序列的开始,你也可以使用 "\e[" 颜色值处设定前景色值。m 终止转义序列,后面紧跟着就是生效的文本。echo 需要 -e 来开启转义序列。可以用 printf 代替 echo。

    printf  "\e[颜色值m 文本\n"

    2、shell中设置字体颜色及背景实例

    例1:打印蓝色文本(两种方法)

    echo -e "\033[34m Hello World"
    printf "\e[34m Hello World\n"

    但是这样执行之后,会使得其后面的文本输出都是蓝色,连命令提示符都是蓝色。要使其返回颜色使用 \033[0m。

    使用不同的转义序列组合来达到不同的效果,如下面加上背景色的显示:

    echo -e "\033[前景色值;背景色值m 文本\033[0m"

    前景色值和背景色值使用分号间隔,不分先后,因为两种值的颜色范围不一样,比如 黑色 30 40 。另外分开写同样生效,如 \033[44m\033[32m

    3、Linux中设置字体属性(加粗、闪烁、下划线等)

    转义序列还可以设置文本在显示屏上显示的方式,如是否加粗等,如下表:

    ANSI 码

    含义

    0

    常规文本

    1

    粗体文本

    4

    含下划线文本

    5

    闪烁文本

    7

    反色(补色)文本

    加粗属性合并后,有些变化。如下表:

    关闭加粗

    颜色

    开启加粗

    颜色

    0;30

    黑 (Black)

    1;30

    深灰 (Dark Gray)

    0;31

    红 (Red)

    1;31

    深红 (Dark Red)

    0;32

    绿 (Green)

    1;32

    深绿 (Dark Green)

    0;33

    黄 (Yellow)

    1;33

    亮黄 (Yellow)

    0;34

    蓝 (Blue)

    1;34

    深蓝 (Dark Blue)

    0;35

    紫红 (Magenta)

    1;35

    暗紫红 (Dark Magenta)

    0;36

    青 (Cyan)

    1;36

    深青 (Dark Cyan)

    0;37

    浅   灰(White)

    1;37

    白 (White)

    特效可以叠加,需要使用“;”隔开,例如:闪烁+下划线+白底色+黑字为   \033[5;4;47;30m闪烁+下划线+白底色+黑字为\033[0m

    4、shell脚本实现各种字体颜色及背景设置

    #!/bin/bash 
    
    # 
    
    #下面是字体输出颜色及终端格式控制 
    
    #字体色范围:30-37 
    
    echo -e "\033[30m 黑色字 \033[0m" 
    
    echo -e "\033[31m 红色字 \033[0m" 
    
    echo -e "\033[32m 绿色字 \033[0m" 
    
    echo -e "\033[33m ×××字 \033[0m" 
    
    echo -e "\033[34m 蓝色字 \033[0m" 
    
    echo -e "\033[35m 紫色字 \033[0m" 
    
    echo -e "\033[36m 天蓝字 \033[0m" 
    
    echo -e "\033[37m 白色字 \033[0m" 
    
    #字背景颜色范围:40-47 
    
    echo -e "\033[40;37m 黑底白字 \033[0m" 
    
    echo -e "\033[41;30m 红底黑字 \033[0m" 
    
    echo -e "\033[42;34m 绿底蓝字 \033[0m" 
    
    echo -e "\033[43;34m 黄底蓝字 \033[0m" 
    
    echo -e "\033[44;30m 蓝底黑字 \033[0m" 
    
    echo -e "\033[45;30m 紫底黑字 \033[0m" 
    
    echo -e "\033[46;30m 天蓝底黑字 \033[0m" 
    
    echo -e "\033[47;34m 白底蓝字 \033[0m" 
    
     
    
    #控制选项说明 
    
    #\033[0m 关闭所有属性 
    
    #\033[1m 设置高亮度 
    
    #\033[4m 下划线 
    
    echo -e "\033[4;31m 下划线红字 \033[0m" 
    
    #闪烁 
    
    echo -e "\033[5;34m 红字在闪烁 \033[0m" 
    
    #反影 
    
    echo -e "\033[8m 消隐 \033[0m " 
    
     
    
    #\033[30m-\033[37m 设置前景色 
    
    #\033[40m-\033[47m 设置背景色 
    
    #\033[nA光标上移n行 
    
    #\033[nB光标下移n行 
    
    echo -e "\033[4A 光标上移4行 \033[0m" 
    
    #\033[nC光标右移n行 
    
    #\033[nD光标左移n行 
    
    #\033[y;xH设置光标位置 
    
    #\033[2J清屏 
    
    #\033[K清除从光标到行尾的内容 
    
    echo -e "\033[K 清除光标到行尾的内容 \033[0m" 
    
    #\033[s 保存光标位置 
    
    #\033[u 恢复光标位置 
    
    #\033[?25| 隐藏光标 
    
    #\033[?25h 显示光标 
    
    echo -e "\033[?25l 隐藏光标 \033[0m" 
    
    echo -e "\033[?25h 显示光标 \033[0m"

    5、使用echo让字符串显示不同颜色

    下面的命令可写入脚本执行,根据实际情况替换需要改变颜色的文本。

    echo -e "\033[30m 黑色字 可替换部分 \033[0m"
    
    echo -e "\033[31m 红色字 可替换部分 \033[0m"
    
    echo -e "\033[32m 绿色字 可替换部分 \033[0m"
    
    echo -e "\033[33m ×××字 可替换部分 \033[0m"
    
    echo -e "\033[34m 蓝色字 可替换部分 \033[0m"
    
    echo -e "\033[35m 紫色字 可替换部分 \033[0m"
    
    echo -e "\033[36m 天蓝字 可替换部分 \033[0m"
    
    echo -e "\033[37m 白色字 可替换部分 \033[0m"

    6、通过定义变量的方式给字体加颜色

    #!/bin/bash
    
    #通过变量给字体加颜色
    
    RED_COLOR='\E[1;31m'
    
    GREEN_COLOR='\E[1;32m'
    
    YELLOW_COLOR='\E[1;33m'
    
    BLUE_COLOR='\E[1;34m'
    
    PINK_COLOR='\E[1;35m'
    
    RES='\E[0m'
    
    echo -e "${RED_COLOR}=====红色可替换部分=====${RES}"
    
    echo -e "${GREEN_COLOR}=====绿色可替换部分=====${RES}"
    
    echo -e "${YELLOW_COLOR}=====×××可替换部分=====${RES}"
    
    echo -e "${BLUE_COLOR}=====蓝色可替换部分=====${RES}"
    
    echo -e "${PINK}=====粉色可替换部分=====${RES}"

    7、开发一个给输出内容加颜色的函数(也可以加背景颜色)

    在脚本中传2个参数,给指定内容(第一个参数),加指定颜色(第二个参数)

    #!/bin/bash
    
    #通过变量给字体加颜色
    
    #这里定义一个COLOR_1()函数,后面如果想改变字体颜色直接调用即可
    
    COLOR_1(){
    
    RED_COLOR='\E[1;31m'
    
    GREEN_COLOR='\E[1;32m'
    
    YELLOW_COLOR='\E[1;33m'
    
    BLUE_COLOR='\E[1;34m'
    
    PINK_COLOR='\E[1;35m'
    
    RES='\E[0m'
    
    #这里判断传入的参数是否不等于2个,如果不等于2个就提示并退出
    
    if [ $# -ne 2 ];then
    
        echo "Usage $0 content {red|yellow|blue|green|pink}"
    
        exit
    
    fi
    
     
    
    case "$2" in
    
       red|RED)
    
            echo -e "${RED_COLOR}$1${RES}"
    
            ;;
    
       yellow|YELLOW)
    
            echo -e "${YELLOW_COLOR}$1${RES}"
    
            ;;
    
       green|GREEN)
    
            echo -e "${GREEN_COLOR}$1${RES}"
    
            ;;
    
       blue|BLUE)
    
            echo -e "${BLUE_COLOR}$1${RES}"
    
            ;;
    
       pink|PINK)
    
            echo -e "${PINK_COLOR}$1${RES}"
    
            ;;
    
             *)
    
            echo -e "请输入指定的颜色代码:{red|yellow|blue|green|pink}"
    
    esac
    
    }
    
    COLOR_1 "程序安装报错!" red
    
    COLOR_1 "程序安装成功!" green
    
    COLOR_1 "输出相关注释信息" blue

     转自:

    https://blog.51cto.com/longlei/2357898

    展开全文
  • PPT文字发光效果设置操作。大猫菲菲15号教程:文字发光设置。步骤:选中文本框-格式-文本效果-发光-设置参数。多种效果可供选择,可在发光选项当中调整预设、大小、透明度等参数。
  • :textSize设置文字大小,推荐度量单位”sp”,如”15sp”   android :textStyle设置字形[bold(粗体) 0, italic(斜体) 1, bolditalic(又粗又斜) 2] 可以设置一个或多个,用“|”隔开   android :...
  • jQuery网页文字导出word格式插件是一款基于jquery.wordexport插件实现的简单WORD导出代码。
  • Java使用itexpdf生成PDF,正常情况下,新建一个段落Paragraph,然后可以给段落添加一个格式BaseFont Paragraph paragraphBlue ...效果如下: 但是这样整个段落只能是一个格式,如果我想让前面的字是蓝色,后面...
  • flash 文字特效软件

    2011-06-24 22:47:43
    自动生成swf格式文字动画,带背景特效文字特效,还可以设置背景图片。
  • 本文将介绍如何使用Spire.Doc来设置文字效果,包括文本边框,文本填充,文字阴影等。 //实例化一个Document对象 Document doc = new Document(); //向文档中添加一个Section对象 Section sec = doc.AddSection(); ...
  • 设置文字格式 设置段落格式 设置滚动效果段落设置素材 文字设置素材
  •   Spire.XLS for .NET 是一款专业的 .NET Excel 组件, ...在Excel表格中单元格也是我们经常会使用到的格式,这时我们如何使用Spire.XLS来完成呢?这就是本系列教程将给大家详细讲解的。>>下载Spire.XLS...
  • TextView设置字体格式以及滚动显示效果
  • 最近项目中遇到一个问题:POI 根据模板文件生成 word时,需要进行文字替换和图片替换,其中文字替换不必多说,只是图片替换时需要格式为浮于文字上方,网上找不到合适的资料,没办法 ,只好穷折腾了一天。...
  • HTML之设置文字和文本样式

    千次阅读 2020-04-21 17:32:12
    在CSS样式中,最基本的属性是用来设置文字和文本的样式。"文字"指的是单个文字或单词,"文本"指的是由文字组成的内容。为字体设置样式主要是设置字、词的样式,对文本设置样式样式主要是对整段文章设置样式。 设置文字...
  • HTML——设置滚动文字

    万次阅读 多人点赞 2018-05-14 22:11:19
    1. 滚动文字标签——marquee 使用&... 也可以在标签之间设置文字的字体、颜色等。2. 滚动方向属性——direction 语法格式: <marquee direction="滚动方向">滚动文...
  • 文章目录一、更改字体、颜色、大小1.1 内嵌HTML1.2 LaTeX二、设置文字背景色三、设置图片大小3.1 设置图片百分比3.2 设置图片大小3.3 设置图片居中四、RGB颜色对照表参考文献 Markdown是一种可以使用普通文本编辑器...
  • 先看实现效果: 设置刻度值旁边数字的大小、格式: //设置字体、大小、字符间距等 QFont font; font.setPointSize(Y_SCALE_FONT_SIZE); font.setFamily("Microsoft YaHei"); font.setLetterSpacing...
  • md设置文字颜色

    千次阅读 2020-10-16 08:59:42
    原文 $\color{#FF0000}{红}$ $\color{#FF7D00}{橙}$ $\color{#FFFF00}{黄}$ $\color{#00FF00}{绿}$ $\color{#0000FF}{蓝}$ $\color{#00FFFF}{靛}$ $\color{#FF00FF}{紫}$ 效果 红\color{#FF0000}{红}红 橙\color{#FF...
  • 设置指定文字的颜色

    千次阅读 2013-08-06 00:04:45
    有时候我们经常需要设定指定文字的颜色,比如查询到的文字设置成和其它不一样的颜色,高亮显示,刚刚我试了效果还不错,特放上来留着笔记,以后直接来copy就可以了,我是个懒虫,核心代码如下 //test===============...
  • [Office] 设置制表符格式

    千次阅读 2017-12-06 13:09:23
    设置制表符格式的目的是让段落中的文字设置多次对齐。实现以下的效果 先选中需要设置的段落,然后点击段落设置 设置的时候,根据Tab长度来设置 设置完成后在标尺上显示 之后,每次按下Tab键既可以跳相应的宽度了...
  • PPT文字映像设置步骤。大猫菲菲14号教程:文字映像设置。步骤:选中文本框-格式-文本效果-映像-设置参数。共9种效果可供选择,可在映像选项当中调整透明度、大小、距离、虚化等参数。
  • 在做项目的时候,经常会遇到过一行文字有两种颜色。有时候直接会想到用多个TextView来实现。今天就介绍一下更为简单的方法,用一个TextView实现。 效果: 先看一下xml代码: <?xml version="1.0" ...
  • PPT文字透视阴影设置步骤。大猫菲菲12号教程:文字阴影设置之透视阴影。步骤:选中文本框-文本效果-阴影-设置参数。共5种效果可选,可在文本效果格式当中调整透明度、大小、虚化、角度、距离等参数。
  • Markdown 通过简单标记语法,使普通文本内容具有一定格式。但它本身不支持修改字体、字号与颜色等功能的。CSDN-markdown 编辑器是其衍生版本,支持基于 PageDown ( Stack Overflow)所使用的编辑器的扩展功能(如...
  • 通过HTML和CSS设置文字方向

    千次阅读 2018-11-12 17:11:30
    但对于古汉语或者阿拉伯语等语言...对设置文字方向的几种方式的比较 方式 格式 文本 1 左对齐 完全倒叙 2 右对齐 部分倒叙 3 右对齐 完全倒叙 这篇文章解释得更详细: 我的小树林
  • Qt label使用html样式设置文字

    千次阅读 2018-10-29 16:01:07
    当想要label中显示的一段文字具有不同字体、颜色或者大小的时候,可以使用html语法实现效果; { QLabel * label = new QLabel(this); int number = 10; label-&gt;setText(tr("&lt;font style = '...
  • Textview设置文字样式和颜色

    千次阅读 2017-04-20 20:35:47
    可以使用setTypeface(Typeface)方法来设置文本框内文本的字体,而android的Typeface又使用TTF字体文件来设置字体 所以,我们可以在程序中放入TTF字体文件,在程序中使用Typeface来设置字体:第一步,在assets目录下...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 148,866
精华内容 59,546
关键字:

如何设置文字效果格式