Beispiel #1
1
		public BaseTextItem():base() {
			this.dataType = "System.String";
			this.stringFormat = StringFormat.GenericTypographic;
			this.contentAlignment = ContentAlignment.TopLeft;
			this.stringTrimming = StringTrimming.None;
			VisibleInReport = true;
		}
Beispiel #2
0
        //    http://stackoverflow.com/questions/14932063/convert-code-of-a-user-control-from-vb-net-to-c-sharp
        //https://mightycoco.wordpress.com/2009/09/22/getstringformatfromcontentallignment-converting-contentallignment-data-into-stringformat-data/
        public static StringFormat BuildStringFormat(StringTrimming stringTrimming,TextAlignment alignment)
        {
            StringFormat format = StringFormat.GenericTypographic;
            format.Trimming = stringTrimming;
            format.FormatFlags = StringFormatFlags.LineLimit;
            switch (alignment) {
                    case TextAlignment.Left:{
                        format.Alignment = StringAlignment.Near;
                        format.LineAlignment = StringAlignment.Near;
                        return format;
                    }
                    case TextAlignment.Center:{
                        format.Alignment = StringAlignment.Center;
                        format.LineAlignment = StringAlignment.Near;
                        return format;
                    }

                    case TextAlignment.Right:{
                        format.Alignment = StringAlignment.Far;
                        format.LineAlignment = StringAlignment.Near;
                        return format;
                    }

                    case TextAlignment.Justify:{
                        format.Alignment = StringAlignment.Center;
                        format.LineAlignment = StringAlignment.Near;
                        return format;
                    }
            }
            return format;
        }
	    public static TextFormatFlags TranslateTrimmingToFlag(StringTrimming trimming)
		{
			switch (trimming)
			{
                case StringTrimming.EllipsisCharacter:
			        {
			            return TextFormatFlags.EndEllipsis;
			        }
                case StringTrimming.EllipsisPath:
			        {
			            return TextFormatFlags.PathEllipsis;
			        }
                case StringTrimming.EllipsisWord:
			        {
			            return TextFormatFlags.WordEllipsis;
			        }
                case StringTrimming.Word:
			        {
			            return TextFormatFlags.WordBreak;
			        }
                default:
			        {
			            return TextFormatFlags.Default;
			        }
			}
		}
      /// <summary>
      /// <see cref="StringFormat"/> with options:
      /// Alignment = StringAlignment.Center;
      /// LineAlignment = StringAlignment.Center;
      /// Trimming = "trim";
      /// </summary>
      /// <returns>new <see cref="StringFormat"/> instance</returns>
      public static StringFormat Center(StringTrimming trim)
      {
         StringFormat sf = Center();

         sf.Trimming = trim;

         return sf;
      }
		public StringFormat(StringFormatFlags options) {
			this.native = LibIGraph.CreateStringFormat
				(StringAlignment.Near, options, StringAlignment.Near, StringTrimming.None);
			this.trimming = StringTrimming.None;
			this.alignment = StringAlignment.Near;
			this.lineAlignment = StringAlignment.Near;
			this.stringFormatFlags = options;
		}
 public void Trimming_SetValid_GetReturnsExpected(StringTrimming trimming)
 {
     using (var format = new StringFormat {
         Trimming = trimming
     })
     {
         Assert.Equal(trimming, format.Trimming);
     }
 }
		public StringFormat(StringFormatFlags options, int lang) {
			_alignment = StringAlignment.Near;
			_digitSubstituteLanguage = lang;
			_digitSubstituteMethod = StringDigitSubstitute.User;
			_flags = options;
			_hotkeyPrefix = HotkeyPrefix.None;
			_lineAlignment = StringAlignment.Near;
			_trimming = StringTrimming.Character;
		}
Beispiel #8
0
 /// <summary>
 /// Copies values of supplied <see cref="AppearenceText"/> to current object.
 /// </summary>
 /// <param name="appearence"><see cref="AppearenceText"/> object whose value is to be copied.</param>
 public void Assign(AppearenceText appearence)
 {
     alignment     = appearence.Alignment;
     font          = appearence.Font;
     lineAlignment = appearence.LineAlignment;
     trimming      = Trimming;
     xshift        = appearence.Xshift;
     yshift        = appearence.Yshift;
 }
      /// <summary>
      /// <see cref="StringFormat"/> with options:
      /// Alignment = StringAlignment.Near;
      /// LineAlignment = StringAlignment.Center;
      /// Trimming = "trim";
      /// FormatFlags |= StringFormatFlags.NoWrap;
      /// </summary>
      /// <returns>new <see cref="StringFormat"/> instance</returns>
      public static StringFormat NearCenterNoWrap(StringTrimming trim)
      {
         StringFormat sf = NearCenter();

         sf.Trimming = trim;
         sf.FormatFlags |= StringFormatFlags.NoWrap;

         return sf;
      }
Beispiel #10
0
 public RadPrintElement()
 {
     this.foreColor      = Color.Black;
     this.backColor      = Color.White;
     this.borderColor    = Color.Black;
     this.textAlignment  = ContentAlignment.MiddleCenter;
     this.text           = string.Empty;
     this.font           = SystemFonts.DefaultFont;
     this.stringTrimming = StringTrimming.EllipsisCharacter;
 }
Beispiel #11
0
 public StringFormat(StringFormatFlags options, int lang)
 {
     _alignment = StringAlignment.Near;
     _digitSubstituteLanguage = lang;
     _digitSubstituteMethod   = StringDigitSubstitute.User;
     _flags         = options;
     _hotkeyPrefix  = HotkeyPrefix.None;
     _lineAlignment = StringAlignment.Near;
     _trimming      = StringTrimming.Character;
 }
 public bitsTextOptions(bool rightToLeft, bool lineLimit, float angle, float firstTabOffset, float distanceBetweenTabs,
                        HotkeyPrefix hotkeyPrefix, StringTrimming trimming)
 {
     this.RightToLeft         = rightToLeft;
     this.LineLimit           = lineLimit;
     this.Angle               = angle;
     this.FirstTabOffset      = firstTabOffset;
     this.DistanceBetweenTabs = distanceBetweenTabs;
     this.HotkeyPrefix        = hotkeyPrefix;
     this.Trimming            = trimming;
 }
		public StringFormat (StringFormat source) {
			if (source == null)
				throw new ArgumentNullException("format");

			_alignment = source.LineAlignment;
			_digitSubstituteLanguage = source.DigitSubstitutionLanguage;
			_digitSubstituteMethod = source.DigitSubstitutionMethod;
			_flags = source.FormatFlags;
			_hotkeyPrefix = source.HotkeyPrefix;
			_lineAlignment = source.LineAlignment;
			_trimming = source.Trimming;
		}
	private StringFormat(bool typographic)
			{
				if(typographic)
				{
					this.options = (StringFormatFlags.LineLimit |
					                StringFormatFlags.NoClip);
				}
				else
				{
					this.trimming = StringTrimming.Character;
				}
			}
 public static TextFormatFlags TranslateTrimmingToFlag(StringTrimming trimming)
 {
     if (trimming == StringTrimming.EllipsisCharacter)
         return TextFormatFlags.EndEllipsis;
     else if (trimming == StringTrimming.EllipsisPath)
         return TextFormatFlags.PathEllipsis;
     if (trimming == StringTrimming.EllipsisWord)
         return TextFormatFlags.WordEllipsis;
     if (trimming == StringTrimming.Word)
         return TextFormatFlags.WordBreak;
     else
         return TextFormatFlags.Default;
 }
		public static TextFormatFlags TranslateTrimmingToFlag(StringTrimming trimming)
		{
			if (trimming == StringTrimming.EllipsisCharacter)
				return TextFormatFlags.EndEllipsis;
			else if (trimming == StringTrimming.EllipsisPath)
				return TextFormatFlags.PathEllipsis;
			if (trimming == StringTrimming.EllipsisWord)
				return TextFormatFlags.WordEllipsis;
			if (trimming == StringTrimming.Word)
				return TextFormatFlags.WordBreak;
			else
				return TextFormatFlags.Default;
		}
        private static System.Drawing.StringFormat InitStringFormat(StringTrimming triming)
        {
#if USE_NON_TYPOGRAPHIC
            //Shaves 20% off measure string time with less accuracy
            StringFormat format = StringFormat.GenericDefault.Clone() as StringFormat;
#else
            StringFormat format = StringFormat.GenericTypographic.Clone() as StringFormat;
#endif
            format.Alignment   = StringAlignment.Near;
            format.FormatFlags = StringFormatFlags.NoWrap | StringFormatFlags.MeasureTrailingSpaces;
            format.Trimming    = triming;
            return(format);
        }
Beispiel #18
0
 /// <summary>
 /// Initializes a new instance of the <see cref="TextObject"/> class with default settings.
 /// </summary>
 public TextObject()
 {
     FWordWrap          = true;
     FFont              = Config.DesignerSettings.DefaultFont;
     FTextFill          = new SolidFill(Color.Black);
     FTrimming          = StringTrimming.None;
     FFontWidthRatio    = 1;
     FTabWidth          = 58;
     FClip              = true;
     FHighlight         = new ConditionCollection();
     FlagSerializeStyle = false;
     SetFlags(Flags.HasSmartTag, true);
 }
Beispiel #19
0
 private StringFormat(bool typographic)
 {
     if (typographic)
     {
         this.options = (StringFormatFlags.LineLimit |
                         StringFormatFlags.NoClip);
         this.IsTypographic = true;
     }
     else
     {
         this.trimming = StringTrimming.Character;
     }
 }
Beispiel #20
0
 public TextFormatInfo(Font font, StringFormat format, SizeF size, Color textColor, Color shadowColor, PointF shadowOffset)
 {
     FontFamilyName = font.FontFamily.Name;
     FontSize       = font.Size;
     FontStyle      = font.Style;
     Alignment      = format.Alignment;
     LineAlignment  = format.LineAlignment;
     FormatFlags    = format.FormatFlags;
     Trimming       = format.Trimming;
     Size           = size;
     TextColor      = textColor;
     ShadowColor    = shadowColor;
     ShadowOffset   = shadowOffset;
 }
Beispiel #21
0
        public StringFormat(StringFormat source)
        {
            if (source == null)
            {
                throw new ArgumentNullException("format");
            }

            _alignment = source.LineAlignment;
            _digitSubstituteLanguage = source.DigitSubstitutionLanguage;
            _digitSubstituteMethod   = source.DigitSubstitutionMethod;
            _flags         = source.FormatFlags;
            _hotkeyPrefix  = source.HotkeyPrefix;
            _lineAlignment = source.LineAlignment;
            _trimming      = source.Trimming;
        }
Beispiel #22
0
		public static void DrawString(Graphics graphics,string text,
		                       Font font,Brush brush,
		                       RectangleF rectangle,
		                       StringTrimming stringTrimming,
		                       ContentAlignment alignment) 
		{
			if (graphics == null) {
				throw new ArgumentNullException("graphics");
			}
			StringFormat stringFormat = BuildStringFormat(stringTrimming,alignment);
			graphics.DrawString(text,
			                    font,
			                    brush,
			                    rectangle,
			                    stringFormat);
		}
	public StringFormat(StringFormat format)
			{
				if(format == null)
				{
					throw new ArgumentNullException("format");
				}
				this.options = format.options;
				this.language = format.language;
				this.alignment = format.alignment;
				this.digitMethod = format.digitMethod;
				this.hotkeyPrefix = format.hotkeyPrefix;
				this.lineAlignment = format.lineAlignment;
				this.trimming = format.trimming;
				this.ranges = format.ranges;
				this.firstTabOffset = format.firstTabOffset;
				this.tabStops = format.tabStops;
			}
Beispiel #24
0
        public static void DrawString(Graphics graphics, string text,
                                      Font font, Brush brush,
                                      RectangleF rectangle,
                                      StringTrimming stringTrimming,
                                      ContentAlignment alignment)
        {
            if (graphics == null)
            {
                throw new ArgumentNullException("graphics");
            }
            StringFormat stringFormat = BuildStringFormat(stringTrimming, alignment);

            graphics.DrawString(text,
                                font,
                                brush,
                                rectangle,
                                stringFormat);
        }
Beispiel #25
0
 public StringFormat(StringFormat format)
 {
     if (format == null)
     {
         throw new ArgumentNullException("format");
     }
     this.options        = format.options;
     this.language       = format.language;
     this.alignment      = format.alignment;
     this.digitMethod    = format.digitMethod;
     this.hotkeyPrefix   = format.hotkeyPrefix;
     this.lineAlignment  = format.lineAlignment;
     this.trimming       = format.trimming;
     this.ranges         = format.ranges;
     this.firstTabOffset = format.firstTabOffset;
     this.tabStops       = format.tabStops;
     this.IsTypographic  = format.IsTypographic;
 }
Beispiel #26
0
        TextLine Trim(TextLine line)
        {
            StringTrimming kind = _format.Trimming;

            if (kind == StringTrimming.None ||
                kind == StringTrimming.Character ||
                kind == StringTrimming.Word)
            {
                return(line);
            }

            if (kind == StringTrimming.EllipsisPath)
            {
                return(TrimPath(line));
            }

            return(TrimEllipsis(line, kind));
        }
Beispiel #27
0
        public static TextFormatFlags TranslateTrimmingToFlag(StringTrimming trimming)
        {
            switch (trimming)
            {
            case StringTrimming.EllipsisCharacter:
                return(TextFormatFlags.EndEllipsis);

            case StringTrimming.EllipsisPath:
                return(TextFormatFlags.PathEllipsis);

            case StringTrimming.EllipsisWord:
                return(TextFormatFlags.WordEllipsis);

            case StringTrimming.Word:
                return(TextFormatFlags.WordBreak);
            }
            return(TextFormatFlags.Default);
        }
Beispiel #28
0
        public void DrawTextLayout(object backend, TextLayout layout, double x, double y)
        {
            var   c       = (DrawingContext)backend;
            Size  measure = layout.GetSize();
            float h       = layout.Height > 0 ? (float)layout.Height : (float)measure.Height;

            System.Drawing.StringFormat stringFormat = TextLayoutContext.StringFormat;
            StringTrimming trimming = layout.Trimming.ToDrawingStringTrimming();

            if (layout.Height > 0 && stringFormat.Trimming != trimming)
            {
                stringFormat          = (System.Drawing.StringFormat)stringFormat.Clone();
                stringFormat.Trimming = trimming;
            }

            c.Graphics.DrawString(layout.Text, layout.Font.ToDrawingFont(), c.Brush,
                                  new RectangleF((float)x, (float)y, (float)measure.Width, h),
                                  stringFormat);
        }
Beispiel #29
0
        private void Configure()
        {
            // brush
            _color = Color.Black;

            // font
            _familyName = FontFamily.GenericSansSerif.Name;
            _size       = 8;
            _style      = FontStyle.Regular;

            // format
            StringFormat temp = new StringFormat();

            _alignment     = temp.Alignment;
            _flags         = temp.FormatFlags;
            _lineAlignment = temp.LineAlignment;
            _trimming      = temp.Trimming;
            temp.Dispose();
        }
Beispiel #30
0
        private void SetupPangoLayout(string text, ObjectFont font, StringTrimming trimming, double?width)
        {
            PangoStyle style = new PangoStyle
            {
                ExactSize  = font.Size,
                FontFamily = DataHelper.GetPreferredFont(text) ?? (font.NameSpecified ? font.Name : DataHelper.DefaultDocumentsFont)
            };

            if (font.Italic)
            {
                style.Italic = true;
            }
            if (font.Bold)
            {
                style.Bold = true;
            }
            if (font.Underline)
            {
                style.Underline = true;
            }
            if (font.StrikeThrought)
            {
                style.Strikethrough = true;
            }

            pangoLayout.SetMarkup(style.GetMarkup(text));
            pangoLayout.Ellipsize = EllipsizeMode.None;
            pangoLayout.Wrap      = WrapMode.Word;
            if (width != null)
            {
                pangoLayout.Width = (int)(width * Scale.PangoScale);
            }
            else
            {
                pangoLayout.Width = -1;
                if (trimming != StringTrimming.None)
                {
                    pangoLayout.Ellipsize = EllipsizeMode.End;
                }
            }
        }
        /// <summary>
        /// Creates a new object of the type StiTextOptions.
        /// </summary>
        /// <param name="rightToLeft">Horizontal output direction.</param>
        /// <param name="lineLimit">Show completed lines only.</param>
        /// <param name="wordWrap">Word wrap.</param>
        /// <param name="angle">Angle of a text rotation.</param>
        /// <param name="hotkeyPrefix">Type to draw hot keys.</param>
        /// <param name="trimming">Type to trim the end of a line.</param>
        /// <param name="firstTabOffset">First tab offset.</param>
        /// <param name="distanceBetweenTabs">Distance between tabs.</param>
        public StiTextOptions(bool rightToLeft, bool lineLimit, bool wordWrap,
                              float angle, HotkeyPrefix hotkeyPrefix, StringTrimming trimming,
                              float firstTabOffset, float distanceBetweenTabs)
        {
            this.wordWrap = wordWrap;

            if (rightToLeft == false &&
                lineLimit == false &&
                angle == 0f &&
                hotkeyPrefix == HotkeyPrefix.None &&
                trimming == StringTrimming.None &&
                firstTabOffset == 40f &&
                distanceBetweenTabs == 20f)
            {
                this.bits = null;
            }
            else
            {
                this.bits = new bitsTextOptions(rightToLeft, lineLimit, angle, firstTabOffset, distanceBetweenTabs, hotkeyPrefix, trimming);
            }
        }
            private static TextFormatFlags TranslateTrimmingForGdi(StringTrimming trimming)
            {
                switch (trimming)
                {
                case StringTrimming.None:
                    return(0);

                case StringTrimming.Character:     // There is no equivalent in GDI
                case StringTrimming.EllipsisCharacter:
                    return(TextFormatFlags.EndEllipsis);

                case StringTrimming.Word:     // There is no equivalent in GDI
                case StringTrimming.EllipsisWord:
                    return(TextFormatFlags.WordEllipsis);

                case StringTrimming.EllipsisPath:
                    return(TextFormatFlags.PathEllipsis);
                }

                Debug.Fail("Unknown StringTrimming");
                return(0);
            }
Beispiel #33
0
        public TextLayout(string text, TextFont font, BoxAlignment alignment, StringTrimming trimming, Vector2 maxSize)
        {
            textLines = LineBreaker.Split(text, (int)Math.Ceiling(maxSize.X), c => font.GetGlyph(c).Width);

            var glyphIndex = 0;
            var width      = 0.0f;
            var height     = 0.0f;

            foreach (var textLine in textLines)
            {
                var line = new TextLayoutLine(this, height, alignment, lines.Count == 0);
                foreach (var c in textLine)
                {
                    line.Add(font.GetGlyph(c), glyphIndex++);
                }

                // trimming != StringTrimming.None &&
                //if (maxSize.Y > 0 && height + line.Height > maxSize.Y)
                //    break;

                lines.Add(line);
                width   = Math.Max(width, line.Width);
                height += line.Height;
            }

            if (lines.Count == 0)
            {
                lines.Add(new TextLayoutLine(this, 0, alignment, true));
            }
            var lastLine = lines[lines.Count - 1];

            if (lastLine.GlyphCount == 0)
            {
                height += font.LineHeight;
            }
            lastLine.Add(new FontGlyph(null, 0, font.LineHeight), glyphIndex++);

            size = new Vector2(width, height);
        }
Beispiel #34
0
 public static TextFormatFlags TranslateTrimmingToFlag(StringTrimming trimming)
 {
     if (trimming == StringTrimming.EllipsisCharacter)
     {
         return(TextFormatFlags.EndEllipsis);
     }
     else if (trimming == StringTrimming.EllipsisPath)
     {
         return(TextFormatFlags.PathEllipsis);
     }
     if (trimming == StringTrimming.EllipsisWord)
     {
         return(TextFormatFlags.WordEllipsis);
     }
     if (trimming == StringTrimming.Word)
     {
         return(TextFormatFlags.WordBreak);
     }
     else
     {
         return(TextFormatFlags.Default);
     }
 }
Beispiel #35
0
        /// <summary>
        /// Gets a string format with specified settings.
        /// </summary>
        /// <param name="align">Text alignment information on the vertical plane.</param>
        /// <param name="lineAlign">Line alignment on the horizontal plane.</param>
        /// <param name="trimming"><b>StringTrimming</b> enumeration.</param>
        /// <param name="flags"><b>StringFormatFlags</b> enumeration that contains formatting information.</param>
        /// <param name="firstTab">The number of spaces between the beginning of a line of text and the first tab stop.</param>
        /// <param name="tabWidth">Distance between tab stops.</param>
        /// <returns>The <b>StringFormat</b> object.</returns>
        public StringFormat GetStringFormat(StringAlignment align, StringAlignment lineAlign,
                                            StringTrimming trimming, StringFormatFlags flags, float firstTab, float tabWidth)
        {
            int hash = align.GetHashCode() ^ (lineAlign.GetHashCode() << 2) ^ (trimming.GetHashCode() << 5) ^
                       (flags.GetHashCode() << 16) ^ (100 - firstTab).GetHashCode() ^ tabWidth.GetHashCode();
            StringFormat result = FStringFormats[hash] as StringFormat;

            if (result == null)
            {
                result               = new StringFormat();
                result.Alignment     = align;
                result.LineAlignment = lineAlign;
                result.Trimming      = trimming;
                result.FormatFlags   = flags;
                float[] tabStops = new float[64];
                for (int i = 0; i < 64; i++)
                {
                    tabStops[i] = i == 0 ? firstTab : tabWidth;
                }
                result.SetTabStops(0, tabStops);
                FStringFormats[hash] = result;
            }
            return(result);
        }
Beispiel #36
0
        public override void Draw(Graphics graphics)
        {
            StringTrimming designTrimmimg = StringTrimming.EllipsisCharacter;

            if (graphics == null)
            {
                throw new ArgumentNullException("graphics");
            }
            using (Brush b = new SolidBrush(this.BackColor)){
                graphics.FillRectangle(b, base.DrawingRectangle);
            }

            if (this.stringTrimming != StringTrimming.None)
            {
                designTrimmimg = stringTrimming;
            }
            TextDrawer.DrawString(graphics, this.Text, this.Font,
                                  new SolidBrush(this.ForeColor),
                                  this.ClientRectangle,
                                  designTrimmimg,
                                  this.contentAlignment);

            base.DrawControl(graphics, base.DrawingRectangle);
        }
Beispiel #37
0
		/// <summary>
		/// Creates <see cref="ParagraphFormat"/> object with implicit formatting.
		/// </summary>
		public ParagraphFormat()
		{
			Alignment = ParagraphAlignment.Left;
			VerticalAlignment = ParagraphVerticalAlignment.Top;
			MultiLine = true;
			ShowIncompleteLines = true;
			Trimming = StringTrimming.EllipsisCharacter;
			BackgroundBrush = null;
		}
Beispiel #38
0
		internal static extern Status GdipGetStringFormatTrimming(IntPtr format, out StringTrimming trimming);
      /// <summary>
      /// <see cref="StringFormat"/> with options:
      /// Alignment = StringAlignment.Center;
      /// LineAlignment = StringAlignment.Center;
      /// Trimming = "trim";
      /// FormatFlags |= StringFormatFlags.NoWrap;
      /// </summary>
      /// <returns>new <see cref="StringFormat"/> instance</returns>
      public static StringFormat CenterNoWrap(StringTrimming trim)
      {
         StringFormat sf = Center(trim);

         sf.FormatFlags |= StringFormatFlags.NoWrap;

         return sf;
      }
Beispiel #40
0
 /// <summary>
 /// Assigns the parameters from the specifed StringFormat class to the members of
 /// this TextFont.
 /// </summary>
 /// <param name="format">The StringFormat to apply to this object</param>
 public void SetFormat(StringFormat format)
 {
     _alignment = format.Alignment;
     _flags = format.FormatFlags;
     _lineAlignment = format.LineAlignment;
     _trimming = format.Trimming;
 }
Beispiel #41
0
        private void Configure()
        {
            // brush
            _color = Color.Black;

            // font
            _familyName = FontFamily.GenericSansSerif.Name;
            _size = 8;
            _style = FontStyle.Regular;

            // format
            StringFormat temp = new StringFormat();
            _alignment = temp.Alignment;
            _flags = temp.FormatFlags;
            _lineAlignment = temp.LineAlignment;
            _trimming = temp.Trimming;
            temp.Dispose();
        }
Beispiel #42
0
		internal void Deserialize(System.Xml.XmlElement styleElement)
		{
			m_BackColor1=ColorEx.Empty;
			if(styleElement.HasAttribute("bc1"))
			{
				m_BackColor1.Color=BarFunctions.ColorFromString(styleElement.GetAttribute("bc1"));
				m_BackColor1.Alpha=System.Xml.XmlConvert.ToByte(styleElement.GetAttribute("bc1a"));
			}
			else if(styleElement.HasAttribute("bc1csp"))
				m_BackColor1.ColorSchemePart=(eColorSchemePart)Enum.Parse(typeof(eColorSchemePart),styleElement.GetAttribute("bc1csp"));
			m_BackColor2=ColorEx.Empty;
			if(styleElement.HasAttribute("bc2"))
			{
				m_BackColor2.Color=BarFunctions.ColorFromString(styleElement.GetAttribute("bc2"));
				m_BackColor2.Alpha=System.Xml.XmlConvert.ToByte(styleElement.GetAttribute("bc2a"));
			}
			else if(styleElement.HasAttribute("bc2csp"))
				m_BackColor2.ColorSchemePart=(eColorSchemePart)Enum.Parse(typeof(eColorSchemePart),styleElement.GetAttribute("bc2csp"));
			m_ForeColor=ColorEx.Empty;
			if(styleElement.HasAttribute("fc"))
			{
				m_ForeColor.Color=BarFunctions.ColorFromString(styleElement.GetAttribute("fc"));
				m_ForeColor.Alpha=System.Xml.XmlConvert.ToByte(styleElement.GetAttribute("fca"));
			}
			else if(styleElement.HasAttribute("fccsp"))
				m_ForeColor.ColorSchemePart=(eColorSchemePart)Enum.Parse(typeof(eColorSchemePart),styleElement.GetAttribute("fccsp"));

			m_BorderColor=ColorEx.Empty;
			if(styleElement.HasAttribute("borderc"))
			{
				m_BorderColor.Color=BarFunctions.ColorFromString(styleElement.GetAttribute("borderc"));
				m_BorderColor.Alpha=System.Xml.XmlConvert.ToByte(styleElement.GetAttribute("borderca"));
			}
			else if(styleElement.HasAttribute("bordercsp"))
				m_BorderColor.ColorSchemePart=(eColorSchemePart)Enum.Parse(typeof(eColorSchemePart),styleElement.GetAttribute("bordercsp"));

			m_GradientAngle=System.Xml.XmlConvert.ToInt16(styleElement.GetAttribute("ga"));

			// Load font information if it exists
			m_Font=null;
			if(styleElement.HasAttribute("fontname"))
			{
				string FontName=styleElement.GetAttribute("fontname");
				float FontSize=System.Xml.XmlConvert.ToSingle(styleElement.GetAttribute("fontemsize"));
				System.Drawing.FontStyle FontStyle=(System.Drawing.FontStyle)System.Xml.XmlConvert.ToInt32(styleElement.GetAttribute("fontstyle"));
				try
				{
					m_Font=new Font(FontName,FontSize,FontStyle);
				}
				catch(Exception)
				{
					m_Font=null;
				}
			}
			// Load Image
			m_BackgroundImage=null;
			foreach(System.Xml.XmlElement xmlElem in styleElement.ChildNodes)
			{
				if(xmlElem.Name=="backimage")
				{
					m_BackgroundImage=BarFunctions.DeserializeImage(xmlElem);
					m_BackgroundImagePosition=(eBackgroundImagePosition)System.Xml.XmlConvert.ToInt32(xmlElem.GetAttribute("pos"));
					m_BackgroundImageAlpha=System.Xml.XmlConvert.ToByte(xmlElem.GetAttribute("alpha"));
				}
			}

			m_WordWrap=false;
			if(styleElement.HasAttribute("wordwrap"))
				m_WordWrap=System.Xml.XmlConvert.ToBoolean(styleElement.GetAttribute("wordwrap"));
            
			m_Alignment=StringAlignment.Near;
			if(styleElement.HasAttribute("align"))
				m_Alignment=(StringAlignment)System.Xml.XmlConvert.ToInt32(styleElement.GetAttribute("align"));
			m_LineAlignment=StringAlignment.Center;
			if(styleElement.HasAttribute("valign"))
				m_LineAlignment=(StringAlignment)System.Xml.XmlConvert.ToInt32(styleElement.GetAttribute("valign"));
			m_TextTrimming=StringTrimming.EllipsisCharacter;
			if(styleElement.HasAttribute("trim"))
				m_TextTrimming=(StringTrimming)System.Xml.XmlConvert.ToInt32(styleElement.GetAttribute("trim"));

			m_Border=eBorderType.None;
			if(styleElement.HasAttribute("border"))
				m_Border=(eBorderType)System.Xml.XmlConvert.ToInt32(styleElement.GetAttribute("border"));
	
			m_BorderWidth=1;
            if(styleElement.HasAttribute("borderw"))
				m_BorderWidth=System.Xml.XmlConvert.ToInt32(styleElement.GetAttribute("borderw"));

			m_CornerType=eCornerType.Square;
			if(styleElement.HasAttribute("cornertype"))
				m_CornerType=(eCornerType)System.Xml.XmlConvert.ToInt32(styleElement.GetAttribute("cornertype"));
			m_CornerDiameter=DEFAULT_CORNER_DIAMETER;
			if(styleElement.HasAttribute("cornerdiameter"))
				m_CornerDiameter=System.Xml.XmlConvert.ToInt32(styleElement.GetAttribute("cornerdiameter"));
		}
Beispiel #43
0
 public static extern IntPtr CreateStringFormat(StringAlignment alignment, StringFormatFlags formatFlags, StringAlignment lineAlignment, StringTrimming stringTrimming);
Beispiel #44
0
 extern public static void StringFormat_SetTrimming(IntPtr stringFormat, StringTrimming trimming);
Beispiel #45
0
        public static StringFormat BuildStringFormat(StringTrimming stringTrimming, ContentAlignment alignment)
        {
            StringFormat format = StringFormat.GenericTypographic;

            format.Trimming    = stringTrimming;
            format.FormatFlags = StringFormatFlags.LineLimit;

            if (alignment <= ContentAlignment.MiddleCenter)
            {
                switch (alignment)
                {
                case ContentAlignment.TopLeft: {
                    format.Alignment     = StringAlignment.Near;
                    format.LineAlignment = StringAlignment.Near;
                    return(format);
                }

                case ContentAlignment.TopCenter: {
                    format.Alignment     = StringAlignment.Center;
                    format.LineAlignment = StringAlignment.Near;
                    return(format);
                }

                case (ContentAlignment.TopCenter | ContentAlignment.TopLeft): {
                    return(format);
                }

                case ContentAlignment.TopRight: {
                    format.Alignment     = StringAlignment.Far;
                    format.LineAlignment = StringAlignment.Near;
                    return(format);
                }

                case ContentAlignment.MiddleLeft: {
                    format.Alignment     = StringAlignment.Near;
                    format.LineAlignment = StringAlignment.Center;
                    return(format);
                }

                case ContentAlignment.MiddleCenter: {
                    format.Alignment     = StringAlignment.Center;
                    format.LineAlignment = StringAlignment.Center;
                    return(format);
                }
                }
                return(format);
            }
            if (alignment <= ContentAlignment.BottomLeft)
            {
                if (alignment == ContentAlignment.MiddleRight)
                {
                    format.Alignment     = StringAlignment.Far;
                    format.LineAlignment = StringAlignment.Center;
                    return(format);
                }
                if (alignment != ContentAlignment.BottomLeft)
                {
                    return(format);
                }
            }
            else
            {
                if (alignment != ContentAlignment.BottomCenter)
                {
                    if (alignment == ContentAlignment.BottomRight)
                    {
                        format.Alignment     = StringAlignment.Far;
                        format.LineAlignment = StringAlignment.Far;
                    }
                    return(format);
                }
                format.Alignment     = StringAlignment.Center;
                format.LineAlignment = StringAlignment.Far;
                return(format);
            }
            format.Alignment     = StringAlignment.Near;
            format.LineAlignment = StringAlignment.Far;
            return(format);
        }
	public StringFormat(StringFormatFlags options)
			{
				this.options = options;
				this.trimming = StringTrimming.Character;
				
			}
 /// <summary>
 /// Creates a new object of the type StiTextOptions.
 /// </summary>
 /// <param name="rightToLeft">Horizontal output direction.</param>
 /// <param name="lineLimit">Show completed lines only.</param>
 /// <param name="wordWrap">Word wrap.</param>
 /// <param name="angle">Angle of a text rotation.</param>
 /// <param name="hotkeyPrefix">Type to draw hot keys.</param>
 /// <param name="trimming">Type to trim the end of a line.</param>
 public StiTextOptions(bool rightToLeft, bool lineLimit, bool wordWrap,
                       float angle, HotkeyPrefix hotkeyPrefix, StringTrimming trimming) :
     this(rightToLeft, lineLimit, wordWrap, angle, hotkeyPrefix, trimming,
          40f, 20f)
 {
 }
Beispiel #48
0
		/// <summary>
		/// Creates <see cref="ParagraphFormat"/> object.
		/// </summary>
		public ParagraphFormat(ParagraphAlignment pa, ParagraphVerticalAlignment pva,
		                       bool ml, bool sil, StringTrimming tr, Brush bg)
		{
			Alignment = pa;
			VerticalAlignment = pva;
			MultiLine = ml;
			ShowIncompleteLines = sil;
			Trimming = tr;
			BackgroundBrush = bg;
		}
 /// <summary>
 /// Resets the trimming.
 /// </summary>
 private void ResetTrimming()
 {
     trimming = StringTrimming.EllipsisCharacter;
 }
Beispiel #50
0
 public Texture2d CreateTexture(string text, string fontName, float fontSize, Vector2 maxSize, Vector2 padding, BoxAlignment alignment, StringTrimming trimming, out Vector2 textureSize)
 {
     using (var bitmap = CreateBitmap(text, fontName, fontSize, maxSize, padding, alignment, trimming, out textureSize, false))
         return(Texture2d.Load(bitmap, $"text:{text}@{fontName}:{fontSize}"));
 }
Beispiel #51
0
		// StringFormat
		private void CheckStringFormat (IntPtr sf, StringFormatFlags exepcted_flags, StringTrimming expected_trimmings)
		{
			StringAlignment sa = StringAlignment.Center;
			Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetStringFormatAlign (IntPtr.Zero, out sa), "GdipGetStringFormatAlign-null");
			Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatAlign (sf, out sa), "GdipGetStringFormatAlign");
			Assert.AreEqual (StringAlignment.Near, sa, "StringAlignment-1");

			StringAlignment la = StringAlignment.Center;
			Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetStringFormatLineAlign (IntPtr.Zero, out la), "GdipGetStringFormatLineAlign-null");
			Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatLineAlign (sf, out la), "GdipGetStringFormatLineAlign");
			Assert.AreEqual (StringAlignment.Near, la, "StringAlignment-2");

			StringFormatFlags flags = StringFormatFlags.DirectionRightToLeft;
			Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetStringFormatFlags (IntPtr.Zero, out flags), "GdipGetStringFormatFlags-null");
			Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatFlags (sf, out flags), "GdipGetStringFormatFlags");
			Assert.AreEqual (exepcted_flags, flags, "StringFormatFlags");

			HotkeyPrefix hotkey = HotkeyPrefix.Show;
			Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetStringFormatHotkeyPrefix (IntPtr.Zero, out hotkey), "GdipGetStringFormatHotkeyPrefix-null");
			Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatHotkeyPrefix (sf, out hotkey), "GdipGetStringFormatHotkeyPrefix");
			Assert.AreEqual (HotkeyPrefix.None, hotkey, "HotkeyPrefix");

			StringTrimming trimming = StringTrimming.None;
			Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetStringFormatTrimming (IntPtr.Zero, out trimming), "GdipGetStringFormatTrimming-null");
			Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatTrimming (sf, out trimming), "GdipGetStringFormatTrimming");
			Assert.AreEqual (expected_trimmings, trimming, "StringTrimming");

			StringDigitSubstitute sub = StringDigitSubstitute.Traditional;
			Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetStringFormatDigitSubstitution (IntPtr.Zero, 0, out sub), "GdipGetStringFormatDigitSubstitution-null");
			Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatDigitSubstitution (sf, 0, out sub), "GdipGetStringFormatDigitSubstitution");
			Assert.AreEqual (StringDigitSubstitute.User, sub, "StringDigitSubstitute");

			int count;
			Assert.AreEqual (Status.InvalidParameter, GDIPlus.GdipGetStringFormatMeasurableCharacterRangeCount (IntPtr.Zero, out count), "GdipGetStringFormatMeasurableCharacterRangeCount-null");
			Assert.AreEqual (Status.Ok, GDIPlus.GdipGetStringFormatMeasurableCharacterRangeCount (sf, out count), "GdipGetStringFormatMeasurableCharacterRangeCount");
			Assert.AreEqual (0, count, "count");
		}
 internal TextLayoutContext(DrawingContext context)
 {
     this.context = context;
     this.StringTrimming = StringTrimming.Word;
 }
Beispiel #53
0
 public static extern void StringFormat_SetTrimming(IntPtr stringFormat, StringTrimming trimming);
	// Constructors.
	public StringFormat()
			{
				this.trimming = StringTrimming.Character;
			}
		public void DrawStringLine(Graphics g, string text, Font font, Rectangle textRect, Color textColor, StringAlignment align = StringAlignment.Near, StringAlignment lineAlign = StringAlignment.Center, StringTrimming trimming = StringTrimming.EllipsisCharacter)
		{
			if (textRect.Width < 1 || textRect.Height < 1) return;
			if (text == null) return;

			// Expand text rect, because DrawString stops too soon
			textRect.Y += GetFontYOffset(font);
			textRect.Width += DrawStringWidthAdd;
			textRect.Height = Math.Max(textRect.Height, font.Height);

			bool manualEllipsis = trimming == StringTrimming.EllipsisCharacter || trimming == StringTrimming.EllipsisWord;
			if (trimming == StringTrimming.EllipsisCharacter)	trimming = StringTrimming.Character;
			if (trimming == StringTrimming.EllipsisWord)		trimming = StringTrimming.Word;

			if (manualEllipsis) textRect.Width -= 5;
			StringFormat nameLabelFormat = StringFormat.GenericDefault;
			nameLabelFormat.Alignment = align;
			nameLabelFormat.LineAlignment = lineAlign;
			nameLabelFormat.Trimming = trimming;
			nameLabelFormat.FormatFlags |= StringFormatFlags.NoWrap;

			int charsFit, lines;
			SizeF nameLabelSize = g.MeasureString(text, font, textRect.Size, nameLabelFormat, out charsFit, out lines);
			if (textRect.Width >= 1)
				g.DrawString(text, font, new SolidBrush(textColor), textRect, nameLabelFormat);

			if (charsFit < text.Length && manualEllipsis)
			{
				Pen ellipsisPen = new Pen(textColor);
				ellipsisPen.DashStyle = DashStyle.Dot;
				g.DrawLine(ellipsisPen, 
					textRect.Right - DrawStringWidthAdd, 
					(textRect.Y + textRect.Height * 0.5f) + (nameLabelSize.Height * 0.3f), 
					textRect.Right - DrawStringWidthAdd + 3, 
					(textRect.Y + textRect.Height * 0.5f) + (nameLabelSize.Height * 0.3f));
			}
		}
Beispiel #56
0
		public static StringFormat BuildStringFormat(StringTrimming stringTrimming,ContentAlignment alignment)
		{
			StringFormat format = StringFormat.GenericTypographic;
			format.Trimming = stringTrimming;
			format.FormatFlags = StringFormatFlags.LineLimit;

			if (alignment <= ContentAlignment.MiddleCenter){
				switch (alignment){
						case ContentAlignment.TopLeft:{
							format.Alignment = StringAlignment.Near;
							format.LineAlignment = StringAlignment.Near;
							return format;
						}
						case ContentAlignment.TopCenter:{
							format.Alignment = StringAlignment.Center;
							format.LineAlignment = StringAlignment.Near;
							return format;
						}
						case (ContentAlignment.TopCenter | ContentAlignment.TopLeft):{
							return format;
						}
						case ContentAlignment.TopRight:{
							format.Alignment = StringAlignment.Far;
							format.LineAlignment = StringAlignment.Near;
							return format;
						}
						case ContentAlignment.MiddleLeft:{
							format.Alignment = StringAlignment.Near;
							format.LineAlignment = StringAlignment.Center;
							return format;
						}
						case ContentAlignment.MiddleCenter:{
							format.Alignment = StringAlignment.Center;
							format.LineAlignment = StringAlignment.Center;
							return format;
						}
				}
				return format;
			}
			if (alignment <= ContentAlignment.BottomLeft){
				if (alignment == ContentAlignment.MiddleRight){
					format.Alignment = StringAlignment.Far;
					format.LineAlignment = StringAlignment.Center;
					return format;
				}
				if (alignment != ContentAlignment.BottomLeft){
					return format;
				}
			}
			else{
				if (alignment != ContentAlignment.BottomCenter){
					if (alignment == ContentAlignment.BottomRight)
					{
						format.Alignment = StringAlignment.Far;
						format.LineAlignment = StringAlignment.Far;
					}
					return format;
				}
				format.Alignment = StringAlignment.Center;
				format.LineAlignment = StringAlignment.Far;
				return format;
			}
			format.Alignment = StringAlignment.Near;
			format.LineAlignment = StringAlignment.Far;
			return format;
		}
Beispiel #57
0
        public Bitmap CreateBitmap(string text, string fontName, float fontSize, Vector2 maxSize, Vector2 padding, BoxAlignment alignment, StringTrimming trimming, out Vector2 textureSize, bool measureOnly)
        {
            if (string.IsNullOrEmpty(text))
            {
                text = " ";
            }

            StringAlignment horizontalAlignment;

            switch (alignment & BoxAlignment.Horizontal)
            {
            case BoxAlignment.Left: horizontalAlignment = StringAlignment.Near; break;

            case BoxAlignment.Right: horizontalAlignment = StringAlignment.Far; break;

            default: horizontalAlignment = StringAlignment.Center; break;
            }

            StringAlignment verticalAlignment;

            switch (alignment & BoxAlignment.Vertical)
            {
            case BoxAlignment.Top: verticalAlignment = StringAlignment.Near; break;

            case BoxAlignment.Bottom: verticalAlignment = StringAlignment.Far; break;

            default: verticalAlignment = StringAlignment.Center; break;
            }

            using (System.Drawing.Graphics graphics = System.Drawing.Graphics.FromHwnd(IntPtr.Zero))
                using (StringFormat stringFormat = new StringFormat(StringFormat.GenericTypographic))
                {
                    graphics.TextRenderingHint = TextRenderingHint.AntiAlias;
                    stringFormat.Alignment     = horizontalAlignment;
                    stringFormat.LineAlignment = verticalAlignment;
                    stringFormat.Trimming      = trimming;
                    stringFormat.FormatFlags   = StringFormatFlags.FitBlackBox | StringFormatFlags.MeasureTrailingSpaces | StringFormatFlags.NoClip; // | StringFormatFlags.LineLimit

                    var dpiScale = 96f / graphics.DpiY;
                    var font     = getFont(fontName, fontSize * dpiScale, FontStyle.Regular);

                    var measuredSize = graphics.MeasureString(text, font, new SizeF(maxSize.X, maxSize.Y), stringFormat);
                    var width        = (int)(measuredSize.Width + padding.X * 2 + 1);
                    var height       = (int)(measuredSize.Height + padding.Y * 2 + 1);

                    var offsetX = padding.X;
                    var offsetY = padding.Y;

                    textureSize = new Vector2(width, height);
                    if (measureOnly)
                    {
                        return(null);
                    }

                    var bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
                    try
                    {
                        using (System.Drawing.Graphics textGraphics = System.Drawing.Graphics.FromImage(bitmap))
                        {
                            textGraphics.TextRenderingHint = graphics.TextRenderingHint;
                            textGraphics.SmoothingMode     = SmoothingMode.HighQuality;
                            textGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic;

                            if (debugFont)
                            {
                                var r = new Random(debugSeed++);
                                textGraphics.Clear(Color.FromArgb(r.Next(100, 255), r.Next(100, 255), r.Next(100, 255)));
                            }

                            textGraphics.DrawString(text, font, shadowBrush, new RectangleF(offsetX + 1, offsetY + 1, width, height), stringFormat);
                            textGraphics.DrawString(text, font, textBrush, new RectangleF(offsetX, offsetY, width, height), stringFormat);
                        }
                    }
                    catch (Exception)
                    {
                        bitmap.Dispose();
                        throw;
                    }
                    return(bitmap);
                }
        }
Beispiel #58
0
 internal static extern int GdipGetStringFormatTrimming(HandleRef format, out StringTrimming trimming);
Beispiel #59
0
		internal void ApplyStyle(ItemStyle style)
		{
			if(style==null)
				return;

			m_Alignment=style.Alignment;
			if(!style.BackColor1.IsEmpty)
				m_BackColor1=style.BackColor1;
			if(!style.BackColor2.IsEmpty)
				m_BackColor2=style.BackColor2;
			if(style.BackgroundImage!=null)
                m_BackgroundImage=style.BackgroundImage;
			if(style.BackgroundImageAlpha!=255)
				m_BackgroundImageAlpha=style.BackgroundImageAlpha;
			if(style.BackgroundImagePosition!=eBackgroundImagePosition.Stretch)
				m_BackgroundImagePosition=style.BackgroundImagePosition;
			if(style.Border!=eBorderType.None)
				m_Border=style.Border;
			if(style.BorderDashStyle!=DashStyle.Solid)
				m_BorderDashStyle=style.BorderDashStyle;
			if(!style.BorderColor.IsEmpty)
				m_BorderColor=style.BorderColor;
			if(style.BorderSide!=DEFAULT_BORDERSIDE)
				m_BorderSide=style.BorderSide;
			if(style.BorderWidth!=1)
				m_BorderWidth=style.BorderWidth;
			if(style.Font!=null)
				m_Font=style.Font;
			if(!style.ForeColor.IsEmpty)
				m_ForeColor=style.ForeColor;
			if(style.LineAlignment!=StringAlignment.Center)
				m_LineAlignment=style.LineAlignment;
			if(style.TextTrimming!=StringTrimming.EllipsisCharacter)
				m_TextTrimming=style.TextTrimming;
			if(style.WordWrap!=false)
				m_WordWrap=style.WordWrap;
			if(style.MarginBottom!=0)
				m_MarginBottom=style.MarginBottom;
			if(style.MarginLeft!=0)
				m_MarginLeft=style.MarginLeft;
			if(style.MarginRight!=0)
				m_MarginRight=style.MarginRight;
			if(style.MarginTop!=0)
				m_MarginTop=style.MarginTop;
            if(style.CornerType!=eCornerType.Square)
				m_CornerType=style.CornerType;
			if(style.CornerDiameter!=DEFAULT_CORNER_DIAMETER)
				m_CornerDiameter=style.CornerDiameter;
            if (style.VerticalText)
                m_VerticalText = style.VerticalText;
            if (!style.UseMnemonic)
                _UseMnemonic = style.UseMnemonic;
		}
	public StringFormat(StringFormatFlags options, int language)
			{
				this.options = options;
				this.language = language;
				this.trimming = StringTrimming.Character;
			}