예제 #1
0
        public static void MapFontProperty(IViewHandler viewHandler, Text virtualView)
        {
            var nativeView = (TextView)viewHandler.NativeView;
            var font       = virtualView.GetFont(DefaultFont);

            // note: default values (fonts) should be discussed at a more abstract level first
            if (font == DefaultFont)
            {
                return;
            }

            TypefaceStyle typefaceStyle = TypefaceStyle.Normal;

            switch (font.Weight)
            {
            case Weight.Bold:
                typefaceStyle = font.Italic ? TypefaceStyle.BoldItalic : TypefaceStyle.Bold;
                break;

            case Weight.Regular:
                typefaceStyle = font.Italic ? TypefaceStyle.Italic : TypefaceStyle.Normal;
                break;
            }
            nativeView.SetTypeface(nativeView.Typeface, typefaceStyle);
            nativeView.TextSize = font.Size;
            virtualView.InvalidateMeasurement();
        }
        private static void applyCustomTypeFace(Paint paint, Typeface tf)
        {
            TypefaceStyle oldStyle;
            Typeface      old = paint.Typeface;

            if (old == null)
            {
                oldStyle = 0;
            }
            else
            {
                oldStyle = old.Style;
            }

            TypefaceStyle fake = oldStyle & ~tf.Style;

            if ((fake & TypefaceStyle.Bold) != 0)
            {
                paint.FakeBoldText = true;
            }

            if ((fake & TypefaceStyle.Italic) != 0)
            {
                paint.TextSkewX = -0.25f;
            }

            paint.SetTypeface(tf);
        }
예제 #3
0
 public Entry(string?fontFamily, FontWeight fontWeight, TypefaceStyle style)
 {
     FontFamily = fontFamily;
     FontWeight = fontWeight;
     Style      = style;
     _hashCode  = (FontFamily?.GetHashCode() ?? 0) ^ FontWeight.GetHashCode() ^ Style.GetHashCode();
 }
예제 #4
0
 public bool SetTypeface(Typeface typeface, TypefaceStyle style = TypefaceStyle.Normal)
 {
     if (m_viewX is Button)
     {
         ((Button)m_viewX).SetTypeface(typeface, style);
     }
     else if (m_viewX is TextView)
     {
         ((TextView)m_viewX).SetTypeface(typeface, style);
     }
     else if (m_viewX is EditText)
     {
         ((EditText)m_viewX).SetTypeface(typeface, style);
     }
     else if (m_viewX is Switch)
     {
         ((Switch)m_viewX).SetTypeface(typeface, style);
     }
     else if (m_viewX is Spinner)
     {
         Spinner          spinner = (Spinner)m_viewX;
         TextImageAdapter adapter = spinner.Adapter as TextImageAdapter;
         if (adapter != null)
         {
             adapter.Typeface      = typeface;
             adapter.TypefaceStyle = style;
         }
     }
     else
     {
         return(false);
     }
     return(true);
 }
예제 #5
0
        public SpannableString ConvertToSpannable(StateNode state, DisplayMetrics displayMetrics)
        {
            var nodes = Flatten(state).TrimNewLines();

            var s = new SpannableString(string.Concat(nodes as IEnumerable<TextEx>));
            int start = 0;
            foreach (var n in nodes)
            {
                if (string.IsNullOrEmpty(n.Text))
                {
                    if (n is StringAnchor a)
                    {
                        //s.SetSpan(new ClickableSpan(a.Owner), start, start + a.Length, SpanTypes.InclusiveExclusive);
                        //s.SetSpan(new UnderlineSpan(), start, start + a.Length, SpanTypes.InclusiveExclusive);
                    }
                    continue;
                }

                if (n.Bold != null || n.Italic != null || n.FontSize != null || n.Foreground != null)
                {
                    TypefaceStyle style = 0;
                    if (n.Bold == true && n.Italic == true)
                        style = TypefaceStyle.BoldItalic;
                    else if (n.Bold == true)
                        style = TypefaceStyle.Bold;
                    else if (n.Italic == true)
                        style = TypefaceStyle.Italic;
                    else
                        style = TypefaceStyle.Normal;


                    ColorStateList color = null;
                    if (n.Foreground != null) color = ColorStateList.ValueOf(new AColor(
                            (byte)(n.Foreground.Value.R * 255),
                            (byte)(n.Foreground.Value.G * 255),
                            (byte)(n.Foreground.Value.B * 255),
                            (byte)(n.Foreground.Value.A * 255)
                        ));

                    int fontSize = -1;

                    if (n.FontSize != null)
                        fontSize = (int) Math.Round(TypedValue.ApplyDimension(ComplexUnitType.Sp, (float) n.FontSize.Value, displayMetrics), MidpointRounding.AwayFromZero);

                    s.SetSpan(new TextAppearanceSpan(null, style, fontSize, color, null), start, start + n.Text.Length, SpanTypes.InclusiveExclusive);
                }
                if (n.Sub == true)
                    s.SetSpan(new SubscriptSpan(), start, start + n.Text.Length, SpanTypes.InclusiveExclusive);
                if (n.Super == true)
                    s.SetSpan(new SuperscriptSpan(), start, start + n.Text.Length, SpanTypes.InclusiveExclusive);
                if (n.Strike == true)
                    s.SetSpan(new StrikethroughSpan(), start, start + n.Text.Length, SpanTypes.InclusiveExclusive);
                if (n.Underline == true)
                    s.SetSpan(new UnderlineSpan(), start, start + n.Text.Length, SpanTypes.InclusiveExclusive);

                start += n.Text.Length;
            }

            return s;
        }
예제 #6
0
        public static void SetTextFont(this TextView textView, TypefaceStyle style)
        {
            var assetManager = Application.Context.ApplicationContext.Assets;
            var typeface     = Typeface.CreateFromAsset(assetManager, Java.Lang.String.Format(Locale.Us, "fonts/%s", "IckyTicketMono.ttf"));

            textView.SetTypeface(typeface, style);
        }
예제 #7
0
        public void SetCustomFont(string assetPath)
        {
            try
            {
                this.CustomFontPath = assetPath;
                if (!string.IsNullOrEmpty(assetPath))
                {
                    Typeface face = FontLoader.GetFont(Context.Assets, assetPath);
                    if (face != null)
                    {
                        TypefaceStyle style = TypefaceStyle.Normal;
                        //Not all custom fonts have compatible text sytle, so we ignore it

                        /*
                         * if (this.Typeface != null) //Takes care of android:textStyle=""
                         * {
                         *  style = Typeface.Style;
                         * }
                         */
                        this.SetTypeface(face, style);
                    }
                }
            }
            catch (Exception ex)
            {
                Container.Track.LogWarning(ex.Message, "CoreTextView");
            }
        }
예제 #8
0
        private void CreateStyleSpanForMatches(IEditable e, Pattern pattern,
                                               TypefaceStyle style)
        {
            Func <IParcelableSpan> creator = () => new StyleSpan(style);

            CreateSpanForMatches(e, pattern, creator);
        }
예제 #9
0
        private TypefaceStyle?ResolveTypefaceStyle(string styleName)
        {
            if (string.IsNullOrWhiteSpace(styleName))
            {
                return(null);
            }
            TypefaceStyle style = TypefaceStyle.Normal;

            if (!string.IsNullOrWhiteSpace(styleName))
            {
                // try to split style name (as may have bold, normal and italic in it). Ignore invalid names. Deafult to Normal.
                var styleNames = styleName.Split("|");
                if (styleNames.Contains("bold") && styleNames.Contains("italic"))
                {
                    style = TypefaceStyle.BoldItalic;
                }
                else if (styleNames.Contains("bold"))
                {
                    style = TypefaceStyle.Bold;
                }
                else if (styleNames.Contains("italic"))
                {
                    style = TypefaceStyle.Italic;
                }
            }
            return(style);
        }
예제 #10
0
        public void SetTypeface(Typeface tf, TypefaceStyle style)
        {
            if (style > 0)
            {
                if (tf == null)
                {
                    tf = Typeface.DefaultFromStyle(style);
                }
                else
                {
                    tf = Typeface.Create(tf, style);
                }

                this.Typeface = tf;
                // now compute what (if any) algorithmic styling is needed
                TypefaceStyle typefaceStyle = tf != null ? tf.Style : TypefaceStyle.Normal;
                TypefaceStyle need          = style & ~typefaceStyle;

                _textPaint.FakeBoldText = ((need & TypefaceStyle.Bold) != 0);
                _textPaint.TextSkewX    = ((need & TypefaceStyle.Italic) != 0 ? -0.25f : 0);
            }
            else
            {
                _textPaint.FakeBoldText = false;
                _textPaint.TextSkewX    = 0;
                this.Typeface           = tf;
            }
        }
예제 #11
0
 public override void SetTypeface(Typeface tf, TypefaceStyle style)
 {
     base.SetTypeface (tf, style);
     RefitText(Text, tf);
     SetWillNotDraw(false);
     PostInvalidate();
 }
예제 #12
0
 public CustomTypefaceSpan(string family, Typeface type, TypefaceStyle style, int size)
     : base(family)
 {
     newType = type;
     this.style = style;
     this.size = size;
 }
예제 #13
0
 public void SetCountTypeface(Typeface typeface, TypefaceStyle style)
 {
     Count.SetTypeface(typeface, style);
     if (_initialized)
     {
         Count.Invalidate();
     }
 }
예제 #14
0
 public void SetLabelTypeface(Typeface typeface, TypefaceStyle style)
 {
     Label.SetTypeface(typeface, style);
     if (_initialized)
     {
         Label.Invalidate();
     }
 }
예제 #15
0
        public InstalledTypeface GetInstalledTypeface(string fontName, TypefaceStyle wellknownSubFam)
        {
            //not auto resolve
            InstalledTypefaceGroup selectedFontGroup;
            InstalledTypeface      _found;

            switch (wellknownSubFam)
            {
            default: return(null);

            case TypefaceStyle.Regular: selectedFontGroup = _regular; break;

            case TypefaceStyle.Bold: selectedFontGroup = _bold; break;

            case TypefaceStyle.Italic: selectedFontGroup = _italic; break;

            case (TypefaceStyle.Bold | TypefaceStyle.Italic): selectedFontGroup = _bold_italic; break;
            }
            if (selectedFontGroup.TryGetValue(fontName.ToUpper(), out _found))
            {
                return(_found);
            }
            //-------------------------------------------
            //not found then ...


            //retry ....
            //if (wellknownSubFam == TypefaceStyle.Bold)
            //{
            //    //try get from Gras?
            //    //eg. tahoma
            //    if (_subFamToFontGroup.TryGetValue("GRAS", out selectedFontGroup))
            //    {

            //        if (selectedFontGroup.TryGetValue(fontName.ToUpper(), out _found))
            //        {
            //            return _found;
            //        }

            //    }
            //}
            //else if (wellknownSubFam == TypefaceStyle.Italic)
            //{
            //    //TODO: simulate oblique (italic) font???
            //    selectedFontGroup = _normal;

            //    if (selectedFontGroup.TryGetValue(fontName.ToUpper(), out _found))
            //    {
            //        return _found;
            //    }
            //}

            if (_found == null && _fontNotFoundHandler != null)
            {
                return(_fontNotFoundHandler(this, fontName, GetSubFam(wellknownSubFam)));
            }
            return(_found);
        }
예제 #16
0
        bool AddFontPreview(PreviewFontInfo previewFont, string srcPath)
        {
            _onlyFontNames[previewFont.Name] = true;

            TypefaceStyle typefaceStyle = TypefaceStyle.Regular;

            switch (previewFont.OS2TranslatedStyle)
            {
            case OpenFont.Extensions.TranslatedOS2FontStyle.BOLD:
                typefaceStyle = TypefaceStyle.Bold;
                break;

            case OpenFont.Extensions.TranslatedOS2FontStyle.ITALIC:
            case OpenFont.Extensions.TranslatedOS2FontStyle.OBLIQUE:
                typefaceStyle = TypefaceStyle.Italic;
                break;

            case OpenFont.Extensions.TranslatedOS2FontStyle.REGULAR:
                typefaceStyle = TypefaceStyle.Regular;
                break;

            case (OpenFont.Extensions.TranslatedOS2FontStyle.BOLD | OpenFont.Extensions.TranslatedOS2FontStyle.ITALIC):
                typefaceStyle = TypefaceStyle.Bold | TypefaceStyle.Italic;
                break;
            }
            //---------------
            //some font subfam="Bold Italic" but OS2TranslatedStyle is only Italic
            //so we should check the subfam name too!
            string[] fontSubFamUpperCaseName_split = previewFont.SubFamilyName.ToUpper().Split(' ');
            if (fontSubFamUpperCaseName_split.Length > 1)
            {
                if (typefaceStyle != (TypefaceStyle.Bold | TypefaceStyle.Italic))
                {
                    //translate more
                    if ((fontSubFamUpperCaseName_split[0] == "BOLD" && fontSubFamUpperCaseName_split[1] == "ITALIC") ||
                        (fontSubFamUpperCaseName_split[0] == "ITALIC" && fontSubFamUpperCaseName_split[1] == "BOLD"))
                    {
                        typefaceStyle = TypefaceStyle.Bold | TypefaceStyle.Italic;
                    }
                }
            }
            else
            {
                //=1
                switch (fontSubFamUpperCaseName_split[0])
                {
                case "BOLD": typefaceStyle = TypefaceStyle.Bold; break;

                case "ITALIC": typefaceStyle = TypefaceStyle.Italic; break;
                }
            }
            return(Register(new InstalledTypeface(previewFont.Name, previewFont.SubFamilyName, srcPath, typefaceStyle, previewFont.Weight)
            {
                ActualStreamOffset = previewFont.ActualStreamOffset
            }));
        }
 internal InstalledTypeface(string fontName,
                            string fontSubFamily,
                            string fontPath,
                            TypefaceStyle typefaceStyle)
 {
     FontName      = fontName;
     FontSubFamily = fontSubFamily;
     FontPath      = fontPath;
     TypefaceStyle = typefaceStyle;
 }
예제 #18
0
        public Typeface GetTypeface(string name, TypefaceStyle installedFontStyle)
        {
            InstalledTypeface inst = _installedTypefaceCollection.GetInstalledTypeface(name, InstalledTypefaceCollection.GetSubFam(installedFontStyle));

            if (inst != null)
            {
                return(typefaceStore.GetTypeface(inst));
            }
            return(null);
        }
예제 #19
0
        private static void ApplyCustomTypeface(Paint paint, Typeface tf, TypefaceStyle style, int size)
        {
            if (style == TypefaceStyle.Italic)
                paint.TextSkewX = -0.25f;

            if(size > 0)
                paint.TextSize = size;

            paint.SetTypeface (tf);
        }
예제 #20
0
        /// <summary>
        /// get typeface from wellknown style
        /// </summary>
        /// <param name="fontname"></param>
        /// <param name="style"></param>
        /// <returns></returns>
        public Typeface GetTypeface(string fontname, TypefaceStyle style)
        {
            InstalledTypeface installedFont = FontCollection.GetInstalledTypeface(fontname, style);

            if (installedFont == null)
            {
                return(null);
            }
            return(GetTypefaceOrCreateNew(installedFont));
        }
예제 #21
0
 public TextAppearance(int textSizePx, ColorStateList textColor, Typeface typeface, float shadowRadius, float shadowDx, float shadowDy, Color shadowColor)
 {
     TextSizePx   = textSizePx;
     TextColor    = textColor;
     Typeface     = typeface;
     Style        = TypefaceStyle.Normal;
     ShadowRadius = shadowRadius;
     ShadowDx     = shadowDx;
     ShadowDy     = shadowDy;
     ShadowColor  = shadowColor;
 }
예제 #22
0
 public TextAppearance(int textSizePx, ColorStateList textColor, Typeface typeface, TypefaceStyle style, float shadowRadius, float shadowDx, float shadowDy)
 {
     TextSizePx   = textSizePx;
     TextColor    = textColor;
     Typeface     = typeface;
     Style        = style;
     ShadowRadius = shadowRadius;
     ShadowDx     = shadowDx;
     ShadowDy     = shadowDy;
     ShadowColor  = Color.Gray;
 }
예제 #23
0
 public void SetTextStyle(string texts, TypefaceStyle style)
 {
     try
     {
         DecoratedContent.SetSpan(new StyleSpan(style), Content.IndexOf(texts, StringComparison.Ordinal), Content.IndexOf(texts, StringComparison.Ordinal) + (texts.Length), SpanTypes.ExclusiveExclusive);
     }
     catch (Exception e)
     {
         Console.WriteLine(e);
     }
 }
예제 #24
0
        TextView CreateTextViewEx(string text, Color clr, int textSize, TypefaceStyle ts, Context context)
        {
            TextView tv = new TextView(context);

            tv.Text = text;
            tv.SetTextColor(clr);
            tv.SetTypeface(null, ts);
            tv.SetTextSize(ComplexUnitType.Sp, textSize);

            return(tv);
        }
예제 #25
0
 public TextAppearance(int textSizePx, ColorStateList textColor, float shadowRadius, float shadowDx, float shadowDy)
 {
     TextSizePx   = textSizePx;
     TextColor    = textColor;
     Typeface     = null;
     Style        = TypefaceStyle.Normal;
     ShadowRadius = shadowRadius;
     ShadowDx     = shadowDx;
     ShadowDy     = shadowDy;
     ShadowColor  = Color.Gray;
 }
예제 #26
0
 public TextAppearance()
 {
     TextSizePx   = -1;
     TextColor    = null;
     Typeface     = null;
     Style        = TypefaceStyle.Normal;
     ShadowRadius = -1f;
     ShadowDx     = float.MinValue;
     ShadowDy     = float.MinValue;
     ShadowColor  = Color.Transparent;
 }
예제 #27
0
 public void SetTextStyle(string texts, TypefaceStyle style)
 {
     try
     {
         DecoratedContent.SetSpan(new StyleSpan(style), Content.IndexOf(texts, StringComparison.Ordinal), Content.IndexOf(texts, StringComparison.Ordinal) + texts.Length, SpanTypes.ExclusiveExclusive);
     }
     catch (Exception e)
     {
         Methods.DisplayReportResultTrack(e);
     }
 }
예제 #28
0
 public TextAppearance(int textSizePx, ColorStateList textColor)
 {
     TextSizePx   = textSizePx;
     TextColor    = textColor;
     Typeface     = null;
     Style        = TypefaceStyle.Normal;
     ShadowRadius = 0f;
     ShadowDx     = 0f;
     ShadowDy     = 0f;
     ShadowColor  = Color.Transparent;
 }
예제 #29
0
 public TextAppearance(int textSizePx, ColorStateList textColor, Typeface typeface, TypefaceStyle style)
 {
     TextSizePx   = textSizePx;
     TextColor    = textColor;
     Typeface     = typeface;
     Style        = style;
     ShadowRadius = 0f;
     ShadowDx     = 0f;
     ShadowDy     = 0f;
     ShadowColor  = Color.Transparent;
 }
예제 #30
0
 internal InstalledTypeface(string fontName,
                            string fontSubFamily,
                            string fontPath,
                            TypefaceStyle typefaceStyle,
                            ushort weight)
 {
     FontName      = fontName;
     FontSubFamily = fontSubFamily;
     FontPath      = fontPath;
     TypefaceStyle = typefaceStyle;
     Weight        = weight;
 }
예제 #31
0
 public void ApplyTypedArray(TypedArray arr)
 {
     Gravity      = (GravityFlags)arr.GetInt(Resource.Styleable.odometer_android_gravity, (int)Gravity);
     ShadowColor  = arr.GetColor(Resource.Styleable.odometer_android_shadowColor, ShadowColor);
     ShadowDx     = arr.GetFloat(Resource.Styleable.odometer_android_shadowDx, ShadowDx);
     ShadowDy     = arr.GetFloat(Resource.Styleable.odometer_android_shadowDy, ShadowDy);
     ShadowRadius = arr.GetFloat(Resource.Styleable.odometer_android_shadowRadius, ShadowRadius);
     Text         = arr.GetString(Resource.Styleable.odometer_android_text);
     TextColor    = arr.GetColor(Resource.Styleable.odometer_android_textColor, TextColor);
     TextSize     = arr.GetDimension(Resource.Styleable.odometer_android_textSize, TextSize);
     TextStyle    = (TypefaceStyle)arr.GetInt(Resource.Styleable.odometer_android_textStyle, (int)TextStyle);
 }
 public SnackbarConfig()
 {
     ActionButtonTextColor     = SnackbarConfigDefaults.ActionButtonTextColor;
     ActionButtonTypeface      = SnackbarConfigDefaults.ActionButtonTypeface;
     ActionButtonTypefaceStyle = SnackbarConfigDefaults.ActionButtonTypefaceStyle;
     AnimationMode             = SnackbarConfigDefaults.AnimationMode;
     BackgroundColor           = SnackbarConfigDefaults.BackgroundColor;
     Duration             = SnackbarConfigDefaults.Duration;
     MessageTextColor     = SnackbarConfigDefaults.MessageTextColor;
     MessageTypeface      = SnackbarConfigDefaults.MessageTypeface;
     MessageTypefaceStyle = SnackbarConfigDefaults.MessageTypefaceStyle;
 }
 private static void SetTextStyle(SpannableString spendable, string texts, TypefaceStyle style)
 {
     try
     {
         string content = spendable.ToString();
         spendable.SetSpan(new StyleSpan(style), content.IndexOf(texts, StringComparison.Ordinal), content.IndexOf(texts, StringComparison.Ordinal) + texts.Length, SpanTypes.ExclusiveExclusive);
     }
     catch (Exception e)
     {
         Console.WriteLine(e);
     }
 }
		public PagerSlidingTabStrip (Context context, IAttributeSet attrs, int defStyle)
			: base (context, attrs, defStyle)
		{
			MyOnGlobalLayoutListner = new MyOnGlobalLayoutListener (this);
			adapterObserver = new PagerAdapterObserver (this);
			FillViewport = true;
			this.VerticalScrollBarEnabled = false;
			this.HorizontalScrollBarEnabled = false;
			SetWillNotDraw(false);
			tabsContainer = new LinearLayout (context);
			tabsContainer.Orientation = Android.Widget.Orientation.Horizontal;
			tabsContainer.LayoutParameters = new LayoutParams(LayoutParams.MatchParent, LayoutParams.MatchParent);
			AddView(tabsContainer);

			var dm = Resources.DisplayMetrics;
			scrollOffset = (int)TypedValue.ApplyDimension(ComplexUnitType.Dip, scrollOffset, dm);
			indicatorHeight = (int)TypedValue.ApplyDimension(ComplexUnitType.Dip, indicatorHeight, dm);
			underlineHeight = (int)TypedValue.ApplyDimension(ComplexUnitType.Dip, underlineHeight, dm);
			dividerPadding = (int)TypedValue.ApplyDimension(ComplexUnitType.Dip, dividerPadding, dm);
			tabPadding = (int)TypedValue.ApplyDimension(ComplexUnitType.Dip, tabPadding, dm);
			dividerWidth = (int)TypedValue.ApplyDimension(ComplexUnitType.Dip, dividerWidth, dm);
			tabTextSize = (int)TypedValue.ApplyDimension(ComplexUnitType.Sp, tabTextSize, dm);

			//get system attrs (android:textSize and android:textColor)
			var a = context.ObtainStyledAttributes(attrs, Attrs);
			tabTextSize = a.GetDimensionPixelSize(TextSizeIndex, tabTextSize);
			var colorStateList = a.GetColorStateList(TextColorIndex);
			var textPrimaryColor = a.GetColor(TextColorPrimaryIndex, Android.Resource.Color.White);


      underlineColor = textPrimaryColor;
			dividerColor = textPrimaryColor;
			indicatorColor = textPrimaryColor;

      int padding = a.GetDimensionPixelSize(PaddingIndex, 0);
			paddingLeft = padding > 0 ? padding : a.GetDimensionPixelSize(PaddingLeftIndex, 0);
			paddingRight = padding > 0 ? padding : a.GetDimensionPixelSize(PaddingRightIndex, 0);
			


			a = context.ObtainStyledAttributes(attrs, Resource.Styleable.PagerSlidingTabStrip);
			indicatorColor = a.GetColor(Resource.Styleable.PagerSlidingTabStrip_pstsIndicatorColor, indicatorColor);
			underlineColor = a.GetColor(Resource.Styleable.PagerSlidingTabStrip_pstsUnderlineColor, underlineColor);
      dividerColor = a.GetColor(Resource.Styleable.PagerSlidingTabStrip_pstsDividerColor, dividerColor);
      dividerWidth = a.GetDimensionPixelSize(Resource.Styleable.PagerSlidingTabStrip_pstsDividerWidth, dividerWidth);
			indicatorHeight = a.GetDimensionPixelSize(Resource.Styleable.PagerSlidingTabStrip_pstsIndicatorHeight, indicatorHeight);
			underlineHeight = a.GetDimensionPixelSize(Resource.Styleable.PagerSlidingTabStrip_pstsUnderlineHeight, underlineHeight);
			dividerPadding = a.GetDimensionPixelSize(Resource.Styleable.PagerSlidingTabStrip_pstsDividerPadding, dividerPadding);
			tabPadding = a.GetDimensionPixelSize(Resource.Styleable.PagerSlidingTabStrip_pstsTabPaddingLeftRight, tabPadding);
			tabBackgroundResId = a.GetResourceId(Resource.Styleable.PagerSlidingTabStrip_pstsTabBackground, tabBackgroundResId);
			shouldExpand = a.GetBoolean(Resource.Styleable.PagerSlidingTabStrip_pstsShouldExpand, shouldExpand);
			scrollOffset = a.GetDimensionPixelSize(Resource.Styleable.PagerSlidingTabStrip_pstsScrollOffset, scrollOffset);
			textAllCaps = a.GetBoolean(Resource.Styleable.PagerSlidingTabStrip_pstsTextAllCaps, textAllCaps);
			isPaddingMiddle = a.GetBoolean(Resource.Styleable.PagerSlidingTabStrip_pstsPaddingMiddle, isPaddingMiddle);
			tabTypefaceStyle = (TypefaceStyle)a.GetInt(Resource.Styleable.PagerSlidingTabStrip_pstsTextStyle, (int)TypefaceStyle.Bold);
			tabTypefaceSelectedStyle = (TypefaceStyle)a.GetInt(Resource.Styleable.PagerSlidingTabStrip_pstsTextSelectedStyle, (int)TypefaceStyle.Bold);
      tabTextColorSelected = a.GetColorStateList(Resource.Styleable.PagerSlidingTabStrip_pstsTextColorSelected);
      textAlpha = a.GetInt(Resource.Styleable.PagerSlidingTabStrip_pstsTextAlpha, textAlpha);
      a.Recycle();

      tabTextColor = colorStateList == null ? GetColorStateList(Color.Argb(textAlpha,
        Color.GetRedComponent(textPrimaryColor),
        Color.GetGreenComponent(textPrimaryColor),
        Color.GetBlueComponent(textPrimaryColor))) : colorStateList;

      tabTextColorSelected = tabTextColorSelected == null ? GetColorStateList(textPrimaryColor) : tabTextColorSelected;


			SetMarginBottomTabContainer();

			rectPaint = new Paint();
			rectPaint.AntiAlias = true;
			rectPaint.SetStyle(Paint.Style.Fill);

			dividerPaint = new Paint();
			dividerPaint.AntiAlias = true;
			dividerPaint.StrokeWidth = dividerWidth;

			defaultTabLayoutParams = new LinearLayout.LayoutParams(LayoutParams.WrapContent, LayoutParams.MatchParent);
			expandedTabLayoutParams = new LinearLayout.LayoutParams(0, LayoutParams.MatchParent, 1.0f);
		}
        TextView GetHeaderItem(TypefaceStyle style)
        {
            TextView view = new TextView(context);

            var parameters = new LinearLayout.LayoutParams(LayoutParams.WrapContent, LayoutParams.WrapContent, 0.33f);
            parameters.LeftMargin = Padding;
            view.LayoutParameters = parameters;

            view.Typeface = Typeface.Create("Helvetica Neue", style);
            view.Gravity = Android.Views.GravityFlags.CenterVertical;
            view.SetTextColor(Color.White);
            view.SetPadding(0, 20, 0, 20);

            return view;
        }
		/// <summary>
		/// Sets the typeface and style used to draw the tab text.
		/// 
		/// Please note - if the current adapter is an <see cref="IIconTabProvider"/> this will
		/// have no effect.
		/// </summary>
		/// <param name="typeface">The typeface.</param>
		/// <param name="style">The style.</param>
		public void SetTypeface(Typeface typeface, TypefaceStyle style)
		{
			this._tabTypeface = typeface;
			this._tabTypefaceStyle = style;
			UpdateTabStyles();
		}
 public void SetTypeface(Typeface typeFace, TypefaceStyle style)
 {
     this.tabTypeface = typeFace;
     this.typefaceStyle = style;
 }
예제 #38
0
		private Typeface CreateTypeface(Context context, int typefaceValue)
		{
			try
			{

				Typeface typeface;
				switch (typefaceValue)
				{
				case ArialNormal:
					typeface = Typeface.CreateFromAsset(context.Assets, "fonts/arial.ttf");
					break;
				case ArialBold:
					typeface = Typeface.CreateFromAsset(context.Assets, "fonts/arialbold.ttf");
					m_Style = TypefaceStyle.Bold;
					break;
				case ArialItalic:
					typeface = Typeface.CreateFromAsset(context.Assets, "fonts/arialitalic.ttf");
					m_Style = TypefaceStyle.Italic;
					break;
				case ArialBoldItalic:
					typeface = Typeface.CreateFromAsset(context.Assets, "fonts/arial_bold_italic.ttf");
					m_Style = TypefaceStyle.BoldItalic;
					break;
				default:
					throw new ArgumentException("Unknown typeface attribute value " + typefaceValue);
				}
				return typeface;

			}
			catch (Exception)
			{
			}

			return null;
		}
        public ForwardNavigationMenu(Context context, IAttributeSet attrs, int defStyle)
            : base(context, attrs, defStyle)
        {
            _mainContainer = new LinearLayout (context);
            _mainContainer.Orientation = Android.Widget.Orientation.Vertical;
            _mainContainer.LayoutParameters = new LayoutParams (LayoutParams.MatchParent, LayoutParams.MatchParent);
            _context = context;

            var dm = Resources.DisplayMetrics;
            textSize = (int)TypedValue.ApplyDimension (ComplexUnitType.Sp, textSize, dm);

            var a = context.ObtainStyledAttributes (attrs, Attrs);

            a = context.ObtainStyledAttributes (attrs, Resource.Styleable.ForwardNavigationMenu);
            contentPadding = a.GetDimensionPixelSize (Resource.Styleable.ForwardNavigationMenu_fnmContentPadding, contentPadding);
            padding = a.GetDimensionPixelSize (Resource.Styleable.ForwardNavigationMenu_fnmPadding, padding);
            paddingLeft = a.GetDimensionPixelSize (Resource.Styleable.ForwardNavigationMenu_fnmPaddingLeft, paddingLeft);
            paddingBottom = a.GetDimensionPixelSize (Resource.Styleable.ForwardNavigationMenu_fnmPaddingBottom, paddingBottom);
            paddingRight = a.GetDimensionPixelSize (Resource.Styleable.ForwardNavigationMenu_fnmPaddingRight, paddingRight);
            paddingTop = a.GetDimensionPixelSize (Resource.Styleable.ForwardNavigationMenu_fnmPaddingTop, paddingTop);

            margin = a.GetDimensionPixelSize (Resource.Styleable.ForwardNavigationMenu_fnmMargin, margin);
            marginRight = a.GetDimensionPixelSize (Resource.Styleable.ForwardNavigationMenu_fnmMarginRight, marginRight);
            marginLeft = a.GetDimensionPixelSize (Resource.Styleable.ForwardNavigationMenu_fnmMarginLeft, marginLeft);
            marginBottom = a.GetDimensionPixelSize (Resource.Styleable.ForwardNavigationMenu_fnmMarginBottom, marginBottom);
            marginTop = a.GetDimensionPixelSize (Resource.Styleable.ForwardNavigationMenu_fnmMarginTop, marginTop);

            typefaceStyle = (TypefaceStyle)a.GetInt (Resource.Styleable.ForwardNavigationMenu_fnmTextStyle, (int)TypefaceStyle.Normal);
            textAlpha = a.GetInt (Resource.Styleable.ForwardNavigationMenu_fnmTextAlpha, textAlpha);
            a.Recycle ();

            _mainContainer.SetPadding (contentPadding, contentPadding, contentPadding, contentPadding);
            AddView (_mainContainer);
        }
예제 #40
0
        private Typeface CreateTypeface(Context context, int typefaceValue)
        {
            try
            {

                Typeface typeface;
                switch (typefaceValue)
                {
                    case RobotoThin:
                        typeface = Typeface.CreateFromAsset(context.Assets, "fonts/Roboto-Thin.ttf");
                        break;
                    case RobotoThinItalic:
                        typeface = Typeface.CreateFromAsset(context.Assets, "fonts/Roboto-ThinItalic.ttf");
                        style = TypefaceStyle.Italic;
                        break;
                    case RobotoLight:
                        typeface = Typeface.CreateFromAsset(context.Assets, "fonts/Roboto-Light.ttf");
                        break;
                    case RobotoLightItalic:
                        typeface = Typeface.CreateFromAsset(context.Assets, "fonts/Roboto-LightItalic.ttf");
                        style = TypefaceStyle.Italic;
                        break;
                    case RobotoRegular:
                        typeface = Typeface.CreateFromAsset(context.Assets, "fonts/Roboto-Regular.ttf");
                        break;
                    case RobotoItalic:
                        typeface = Typeface.CreateFromAsset(context.Assets, "fonts/Roboto-Italic.ttf");
                        style = TypefaceStyle.Italic;
                        break;
                    case RobotoMedium:
                        typeface = Typeface.CreateFromAsset(context.Assets, "fonts/Roboto-Medium.ttf");
                        break;
                    case RobotoMediumItalic:
                        typeface = Typeface.CreateFromAsset(context.Assets, "fonts/Roboto-MediumItalic.ttf");
                        style = TypefaceStyle.Italic;
                        break;
                    case RobotoBold:
                        typeface = Typeface.CreateFromAsset(context.Assets, "fonts/Roboto-Bold.ttf");
                        style = TypefaceStyle.Bold;
                        break;
                    case RobotoBoldItalic:
                        typeface = Typeface.CreateFromAsset(context.Assets, "fonts/Roboto-BoldItalic.ttf");
                        style = TypefaceStyle.BoldItalic;
                        break;
                    case RobotoBlack:
                        typeface = Typeface.CreateFromAsset(context.Assets, "fonts/Roboto-Black.ttf");
                        break;
                    case RobotoBlackItalic:
                        typeface = Typeface.CreateFromAsset(context.Assets, "fonts/Roboto-BlackItalic.ttf");
                        style = TypefaceStyle.Italic;
                        break;
                    case RobotoCondensed:
                        typeface = Typeface.CreateFromAsset(context.Assets, "fonts/Roboto-Condensed.ttf");
                        break;
                    case RobotoCondensedItalic:
                        typeface = Typeface.CreateFromAsset(context.Assets, "fonts/Roboto-CondensedItalic.ttf");
                        style = TypefaceStyle.Italic;
                        break;
                    case RobotoCondensedBold:
                        typeface = Typeface.CreateFromAsset(context.Assets, "fonts/Roboto-BoldCondensed.ttf");
                        style = TypefaceStyle.Bold;
                        break;
                    case RobotoCondensedBoldItalic:
                        typeface = Typeface.CreateFromAsset(context.Assets, "fonts/Roboto-BoldCondensedItalic.ttf");
                        style = TypefaceStyle.BoldItalic;
                        break;
                    default:
                        throw new ArgumentException("Unknown typeface attribute value " + typefaceValue);
                }
                return typeface;

            }
            catch (Exception)
            {
            }

            return null;
        }
예제 #41
0
 public override void SetTypeface(Typeface tf, TypefaceStyle style)
 {
     base.SetTypeface(tf, style);
 }
예제 #42
0
 public HintSpan(string family, TypefaceStyle style, int size, ColorStateList color, ColorStateList linkColor)
     : base(family, style, size, color, linkColor)
 {
 }
예제 #43
0
 private Font (string path, TypefaceStyle style)
 {
     this.path = path;
     this.style = style;
 }