public TextViewDialog() { InitializeComponent(); this.sf = new StringFormat(StringFormat.GenericTypographic); sf.FormatFlags |= StringFormatFlags.MeasureTrailingSpaces; tf = TextFormatFlags.NoPadding | TextFormatFlags.GlyphOverhangPadding; }
public CalendarRendererBoxEventArgs(CalendarRendererEventArgs original, Rectangle bounds, string text, TextFormatFlags flags) : this(original) { Bounds = bounds; Text = text; Format |= flags; }
protected ButtonBase() : base() { flat_style = FlatStyle.Standard; flat_button_appearance = new FlatButtonAppearance (this); this.image_key = string.Empty; this.text_image_relation = TextImageRelation.Overlay; this.use_mnemonic = true; use_visual_style_back_color = true; image_index = -1; image = null; image_list = null; image_alignment = ContentAlignment.MiddleCenter; ImeMode = ImeMode.Disable; text_alignment = ContentAlignment.MiddleCenter; is_default = false; is_pressed = false; text_format = new StringFormat(); text_format.Alignment = StringAlignment.Center; text_format.LineAlignment = StringAlignment.Center; text_format.HotkeyPrefix = HotkeyPrefix.Show; text_format.FormatFlags |= StringFormatFlags.LineLimit; text_format_flags = TextFormatFlags.HorizontalCenter; text_format_flags |= TextFormatFlags.VerticalCenter; text_format_flags |= TextFormatFlags.TextBoxControl; SetStyle (ControlStyles.ResizeRedraw | ControlStyles.Opaque | ControlStyles.UserMouse | ControlStyles.SupportsTransparentBackColor | ControlStyles.CacheText | ControlStyles.OptimizedDoubleBuffer, true); SetStyle (ControlStyles.StandardClick, false); }
public void Update(Graphics g, string text, Font font, Padding internalBounds, Rectangle bounds, Color color, TextFormatFlags formatFlags, IThemeTextOption[] options) { IntPtr compatHdc = this._TextHDC; if (bounds.Equals(_TextHDCBounds)) { //Same bounds, reuse HDC and Clear it IntPtr hClearBrush = Native.GDI.CreateSolidBrush(ColorTranslator.ToWin32(Color.Black)); Native.RECT cleanRect = new Native.RECT(bounds); Native.GDI.FillRect(compatHdc, ref cleanRect, hClearBrush); Native.GDI.DeleteObject(hClearBrush); } else { //Other bounds, create new HDC IntPtr outputHdc = g.GetHdc(); IntPtr DIB; compatHdc = CreateNewHDC(outputHdc, bounds, out DIB); //Store new data _TextHDC = compatHdc; _TextHDCBounds = bounds; //Clear up CleanUpHDC(DIB); g.ReleaseHdc(outputHdc); } DrawOnHDC(compatHdc, text, font, internalBounds, bounds, color, formatFlags, options); }
public static void DrawTextBox(Graphics g, Rectangle bounds, string textBoxText, Font font, Rectangle textBounds, TextFormatFlags flags, TextBoxState state) { InitializeRenderer((int) state); DrawBackground(g, bounds, state); Color foreColor = visualStyleRenderer.GetColor(ColorProperty.TextColor); TextRenderer.DrawText(g, textBoxText, font, textBounds, foreColor, flags); }
public static void DrawTextBox(Graphics g, Rectangle bounds, string textBoxText, Font font, TextFormatFlags flags, TextBoxState state) { InitializeRenderer((int) state); Rectangle backgroundContentRectangle = visualStyleRenderer.GetBackgroundContentRectangle(g, bounds); backgroundContentRectangle.Inflate(-2, -2); DrawTextBox(g, bounds, textBoxText, font, backgroundContentRectangle, flags, state); }
public static void DrawButton (Graphics g, Rectangle bounds, string buttonText, Font font, TextFormatFlags flags, Image image, Rectangle imageBounds, bool focused, PushButtonState state) { if (Application.RenderWithVisualStyles || always_use_visual_styles == true) { VisualStyleRenderer vsr = GetPushButtonRenderer (state); vsr.DrawBackground (g, bounds); if (image != null) vsr.DrawImage (g, imageBounds, image); } else { if (state == PushButtonState.Pressed) ControlPaint.DrawButton (g, bounds, ButtonState.Pushed); else ControlPaint.DrawButton (g, bounds, ButtonState.Normal); if (image != null) g.DrawImage (image, imageBounds); } Rectangle focus_rect = bounds; focus_rect.Inflate (-3, -3); if (focused) ControlPaint.DrawFocusRectangle (g, focus_rect); if (buttonText != String.Empty) if (state == PushButtonState.Disabled) TextRenderer.DrawText (g, buttonText, font, focus_rect, SystemColors.GrayText, flags); else TextRenderer.DrawText (g, buttonText, font, focus_rect, SystemColors.ControlText, flags); }
public void DrawText(TextFormatFlags flags) { string text = this.header.Text; int width = TextRenderer.MeasureText(" ", this.font).Width; Rectangle bounds = Rectangle.Inflate(this.bounds, -width, 0); TextRenderer.DrawText(this.graphics, text, this.font, bounds, this.foreColor, flags); }
/// <summary> /// Initialises a new instance of the <see cref="CanvasText"/> class. /// </summary> public CanvasText() : base(CanvasItemLayout.ItemType.Component) { _stringFormat = TextFormatFlags.SingleLine | TextFormatFlags.WordEllipsis | TextFormatFlags.NoPadding | TextFormatFlags.Top | TextFormatFlags.NoPrefix; Alignment = CanvasTextAlign.Middle; Font = CanvasItemLayout.DefaultFont; }
public static ThemedText CreateWithGlow(Graphics g, string text, Font font, Padding internalBounds, Rectangle bounds, Color color, TextFormatFlags formatFlags, int glowSize) { return Create(g, text, font, internalBounds, bounds, color, formatFlags, new IThemeTextOption[] { new GlowOption(glowSize) } ); }
public DrawnText(String text, Font font, Rectangle rect, Color color, TextFormatFlags tf) { this.text = text; this.font = font; this.rectangle = rect; this.color = color; this.tf = tf; }
public int UxThemeDrawThemeText (IntPtr hTheme, IDeviceContext dc, int iPartId, int iStateId, string text, TextFormatFlags textFlags, Rectangle bounds) { XplatUIWin32.RECT BoundsRect = XplatUIWin32.RECT.FromRectangle (bounds); int result = UXTheme.DrawThemeText (hTheme, dc.GetHdc (), iPartId, iStateId, text, text.Length, (uint)textFlags, 0, ref BoundsRect); dc.ReleaseHdc (); return result; }
public static void DrawCheckBox (Graphics g, Point glyphLocation, Rectangle textBounds, string checkBoxText, Font font, TextFormatFlags flags, Image image, Rectangle imageBounds, bool focused, CheckBoxState state) { Rectangle bounds = new Rectangle (glyphLocation, GetGlyphSize (g, state)); if (Application.RenderWithVisualStyles || always_use_visual_styles == true) { VisualStyleRenderer vsr = GetCheckBoxRenderer (state); vsr.DrawBackground (g, bounds); if (image != null) vsr.DrawImage (g, imageBounds, image); if (focused) ControlPaint.DrawFocusRectangle (g, textBounds); if (checkBoxText != String.Empty) if (state == CheckBoxState.CheckedDisabled || state == CheckBoxState.MixedDisabled || state == CheckBoxState.UncheckedDisabled) TextRenderer.DrawText (g, checkBoxText, font, textBounds, SystemColors.GrayText, flags); else TextRenderer.DrawText (g, checkBoxText, font, textBounds, SystemColors.ControlText, flags); } else { switch (state) { case CheckBoxState.CheckedDisabled: case CheckBoxState.MixedDisabled: case CheckBoxState.MixedPressed: ControlPaint.DrawCheckBox (g, bounds, ButtonState.Inactive | ButtonState.Checked); break; case CheckBoxState.CheckedHot: case CheckBoxState.CheckedNormal: ControlPaint.DrawCheckBox (g, bounds, ButtonState.Checked); break; case CheckBoxState.CheckedPressed: ControlPaint.DrawCheckBox (g, bounds, ButtonState.Pushed | ButtonState.Checked); break; case CheckBoxState.MixedHot: case CheckBoxState.MixedNormal: ControlPaint.DrawMixedCheckBox (g, bounds, ButtonState.Checked); break; case CheckBoxState.UncheckedDisabled: case CheckBoxState.UncheckedPressed: ControlPaint.DrawCheckBox (g, bounds, ButtonState.Inactive); break; case CheckBoxState.UncheckedHot: case CheckBoxState.UncheckedNormal: ControlPaint.DrawCheckBox (g, bounds, ButtonState.Normal); break; } if (image != null) g.DrawImage (image, imageBounds); if (focused) ControlPaint.DrawFocusRectangle (g, textBounds); if (checkBoxText != String.Empty) TextRenderer.DrawText (g, checkBoxText, font, textBounds, SystemColors.ControlText, flags); } }
public WindowsGraphicsWrapper( IDeviceContext idc, TextFormatFlags flags) { if( idc is Graphics ) { ApplyGraphicsProperties properties = ApplyGraphicsProperties.None; if( (flags & TextFormatFlags.PreserveGraphicsClipping) != 0) { properties |= ApplyGraphicsProperties.Clipping; } if( (flags & TextFormatFlags.PreserveGraphicsTranslateTransform) != 0) { properties |= ApplyGraphicsProperties.TranslateTransform; } // Create the WindowsGraphics from the Grahpics object only if Graphics properties need // to be reapplied to the DC wrapped by the WindowsGraphics. if( properties != ApplyGraphicsProperties.None ) { this.wg = WindowsGraphics.FromGraphics( idc as Graphics, properties); } } else { // If passed-in IDeviceContext object is a WindowsGraphics we can use it directly. this.wg = idc as WindowsGraphics; if( this.wg != null ) { // In this case we cache the idc to compare it against the wg in the Dispose method to avoid // disposing of the wg. this.idc = idc; } } if( this.wg == null ) { // The IDeviceContext object is not a WindowsGraphics, or it is a custom IDeviceContext, or // it is a Graphics object but we did not need to re-apply Graphics propertiesto the hdc. // So create the WindowsGraphics from the hdc directly. // Cache the IDC so the hdc can be released on dispose. this.idc = idc; this.wg = WindowsGraphics.FromHdc( idc.GetHdc() ); } // Set text padding on the WindowsGraphics (if any). if( (flags & TextFormatFlags.LeftAndRightPadding) != 0 ) { wg.TextPadding = TextPaddingOptions.LeftAndRightPadding; } else if ((flags & TextFormatFlags.NoPadding) != 0 ) { wg.TextPadding = TextPaddingOptions.NoPadding; } // else wg.TextPadding = TextPaddingOptions.GlyphOverhangPadding - the default value. }
public void DrawText(TextFormatFlags flags) { string text = (this.itemIndex == -1) ? this.item.Text : this.subItem.Text; Font font = (this.itemIndex == -1) ? this.item.Font : this.subItem.Font; Color foreColor = (this.itemIndex == -1) ? this.item.ForeColor : this.subItem.ForeColor; int width = TextRenderer.MeasureText(" ", font).Width; Rectangle bounds = Rectangle.Inflate(this.bounds, -width, 0); TextRenderer.DrawText(this.graphics, text, font, bounds, foreColor, flags); }
private void InstantiateNew(string text, Font font, Color foreColor, Color backColor, TextFormatFlags flags) { _text = text; _font = font; _foreColor = foreColor; _backColor = backColor; _flags = flags; }
public MirLabel() { DrawControlTexture = true; _drawFormat = TextFormatFlags.WordBreak; _font = new Font(Settings.FontName, 8F); _outLine = true; _outLineColour = Color.Black; _text = string.Empty; }
public TipText(Graphics graphics, Font font, string text) : base(graphics) { if (text != null && text.Length > short.MaxValue) throw new ArgumentException("TipText: text too long (max. is " + short.MaxValue + " characters)", "text"); tipFont = font; tipText = text; Color = SystemColors.InfoText; textFormatFlags = TextFormatFlags.Default; }
/// <include file='doc\ToolStripItemTextRenderEventArgs.uex' path='docs/doc[@for="ToolStripItemTextRenderEventArgs.ToolStripItemTextRenderEventArgs"]/*' /> /// <devdoc> /// This class represents all the information to render the winbar /// </devdoc> public ToolStripItemTextRenderEventArgs(Graphics g, ToolStripItem item, string text, Rectangle textRectangle, Color textColor, Font textFont, TextFormatFlags format) : base(g, item) { this.text = text; this.textRectangle = textRectangle; this.defaultTextColor = textColor; this.textFont = textFont; this.textAlignment = item.TextAlign; this.textFormat = format; textDirection = item.TextDirection; }
public TextPart(XmlElement element, ChatMessagePart parent = null, Font font = null) : base(parent, font) { stf = StringFormat.GenericTypographic; stf.FormatFlags |= StringFormatFlags.NoClip; formatFlags = TextFormatFlags.Default | TextFormatFlags.TextBoxControl | TextFormatFlags.NoPadding | TextFormatFlags.NoPrefix | TextFormatFlags.NoClipping; Text = XML = element.InnerText; PreParse(element); InitText(); }
/// <include file='doc\ToolStripItemTextRenderEventArgs.uex' path='docs/doc[@for="ToolStripItemTextRenderEventArgs.ToolStripItemTextRenderEventArgs"]/*' /> /// <devdoc> /// This class represents all the information to render the winbar /// </devdoc> public ToolStripItemTextRenderEventArgs(Graphics g, ToolStripItem item, string text, Rectangle textRectangle, Color textColor, Font textFont, ContentAlignment textAlign) : base(g, item) { this.text = text; this.textRectangle = textRectangle; this.defaultTextColor = textColor; this.textFont = textFont; this.textFormat = ToolStripItemInternalLayout.ContentAlignToTextFormat(textAlign, item.RightToLeft == RightToLeft.Yes); // in 2K and XP++ hide underlined &File unless ALT is pressed this.textFormat = (item.ShowKeyboardCues) ? textFormat : textFormat | TextFormatFlags.HidePrefix; textDirection = item.TextDirection; }
public static void DrawGroupBox(Graphics g, Rectangle bounds, string groupBoxText, Font font, Color textColor, TextFormatFlags flags, GroupBoxState state) { if (RenderWithVisualStyles) { DrawThemedGroupBoxWithText(g, bounds, groupBoxText, font, textColor, flags, state); } else { DrawUnthemedGroupBoxWithText(g, bounds, groupBoxText, font, textColor, flags, state); } }
public static void DrawText(Graphics graphics, string text, Font font, Rectangle bounds, Color color, TextFormatFlags flags, TextStyle textStyle) { if (!VisualStyleRenderer.IsSupported) { TextRenderer.DrawText(graphics, text, font, bounds, color, flags); return; } IntPtr primaryHdc = graphics.GetHdc(); // Create a memory DC so we can work offscreen IntPtr memoryHdc = CreateCompatibleDC(primaryHdc); // Create a device-independent bitmap and select it into our DC BITMAPINFO info = new BITMAPINFO(); info.biSize = Marshal.SizeOf(info); info.biWidth = bounds.Width; info.biHeight = -bounds.Height; info.biPlanes = 1; info.biBitCount = 32; info.biCompression = 0; // BI_RGB IntPtr dib = CreateDIBSection(primaryHdc, info, 0, 0, IntPtr.Zero, 0); SelectObject(memoryHdc, dib); // Create and select font IntPtr fontHandle = font.ToHfont(); SelectObject(memoryHdc, fontHandle); // Draw glowing text VisualStyleRenderer renderer = new VisualStyleRenderer(System.Windows.Forms.VisualStyles.VisualStyleElement.Window.Caption.Active); DTTOPTS dttOpts = new DTTOPTS(); dttOpts.dwSize = Marshal.SizeOf(typeof(DTTOPTS)); if (textStyle == TextStyle.Glowing) { dttOpts.dwFlags = DTT_COMPOSITED | DTT_GLOWSIZE | DTT_TEXTCOLOR; } else { dttOpts.dwFlags = DTT_COMPOSITED | DTT_TEXTCOLOR; } dttOpts.crText = ColorTranslator.ToWin32(color); dttOpts.iGlowSize = 8; // This is about the size Microsoft Word 2007 uses RECT textBounds = new RECT(0, 0, bounds.Right - bounds.Left, bounds.Bottom - bounds.Top); DrawThemeTextEx(renderer.Handle, memoryHdc, 0, 0, text, -1, (int)flags, ref textBounds, ref dttOpts); // Copy to foreground const int SRCCOPY = 0x00CC0020; BitBlt(primaryHdc, bounds.Left, bounds.Top, bounds.Width, bounds.Height, memoryHdc, 0, 0, SRCCOPY); // Clean up DeleteObject(fontHandle); DeleteObject(dib); DeleteDC(memoryHdc); graphics.ReleaseHdc(primaryHdc); }
// // Summary: // Draws the specified text at the specified location using the specified device // context, font, color, and formatting instructions. // // Parameters: // foreColor: // The System.Drawing.Color to apply to the drawn text. // // font: // The System.Drawing.Font to apply to the drawn text. // // dc: // The device context in which to draw the text. // // pt: // The System.Drawing.Point that represents the upper-left corner of the drawn // text. // // flags: // A bitwise combination of the System.Drawing.GDI.TextFormatFlags values. // // text: // The text to draw. // // Exceptions: // System.ArgumentNullException: // dc is null. public static void DrawText(IDeviceContext dc, string text, Font font, Rectangle rc, Color foreColor, TextFormatFlags flags) { Graphics grfx = dc as Graphics; if (grfx != null) { rc.X += (int) grfx.Transform.OffsetX; rc.Y += (int) grfx.Transform.OffsetY; } TextRenderer.DrawText(dc, text, font, rc, foreColor, flags); }
public static void DrawGroupBox (Graphics g, Rectangle bounds, string groupBoxText, Font font, Color textColor, TextFormatFlags flags, GroupBoxState state) { Size font_size = TextRenderer.MeasureText (groupBoxText, font); if (Application.RenderWithVisualStyles || always_use_visual_styles == true) { VisualStyleRenderer vsr; Rectangle new_bounds; switch (state) { case GroupBoxState.Normal: default: vsr = new VisualStyleRenderer (VisualStyleElement.Button.GroupBox.Normal); new_bounds = new Rectangle (bounds.Left, bounds.Top + (int)(font_size.Height / 2) - 1, bounds.Width, bounds.Height - (int)(font_size.Height / 2) + 1); break; case GroupBoxState.Disabled: vsr = new VisualStyleRenderer (VisualStyleElement.Button.GroupBox.Disabled); new_bounds = new Rectangle (bounds.Left, bounds.Top + (int)(font_size.Height / 2) - 2, bounds.Width, bounds.Height - (int)(font_size.Height / 2) + 2); break; } if (groupBoxText == String.Empty) vsr.DrawBackground (g, bounds); else vsr.DrawBackgroundExcludingArea (g, new_bounds, new Rectangle (bounds.Left + 9, bounds.Top, font_size.Width - 3, font_size.Height)); if (textColor == Color.Empty) textColor = vsr.GetColor (ColorProperty.TextColor); if (groupBoxText != String.Empty) TextRenderer.DrawText (g, groupBoxText, font, new Point (bounds.Left + 8, bounds.Top), textColor, flags); } else { // MS has a pretty big bug when rendering the non-visual styles group box. Instead of using the height // part of the bounds as height, they use it as the bottom, so the boxes are drawn in completely different // places. Rather than emulate this bug, we do it correctly. After googling for a while, I don't think // anyone has ever actually used this class for anything, so it should be fine. :) Rectangle new_bounds = new Rectangle (bounds.Left, bounds.Top + (int)(font_size.Height / 2), bounds.Width, bounds.Height - (int)(font_size.Height / 2)); // Don't paint over the background where we are going to put the text Region old_clip = g.Clip; g.SetClip (new Rectangle (bounds.Left + 9, bounds.Top, font_size.Width - 3, font_size.Height), System.Drawing.Drawing2D.CombineMode.Exclude); ControlPaint.DrawBorder3D (g, new_bounds, Border3DStyle.Etched); g.Clip = old_clip; if (groupBoxText != String.Empty) { if (textColor == Color.Empty) textColor = state == GroupBoxState.Normal ? SystemColors.ControlText : SystemColors.GrayText; TextRenderer.DrawText (g, groupBoxText, font, new Point (bounds.Left + 8, bounds.Top), textColor, flags); } } }
protected BaseTextControl() { IncrementalSearchEnabled = true; _focusPen = new Pen(Color.Black); _focusPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dot; _format = new StringFormat(StringFormatFlags.LineLimit | StringFormatFlags.NoClip | StringFormatFlags.FitBlackBox | StringFormatFlags.MeasureTrailingSpaces); _baseFormatFlags = TextFormatFlags.PreserveGraphicsClipping | TextFormatFlags.PreserveGraphicsTranslateTransform; SetFormatFlags(); LeftMargin = 3; }
public static void DrawTabItem(Graphics g, Rectangle bounds, string tabItemText, Font font, TextFormatFlags flags, bool focused, TabItemState state) { InitializeRenderer(VisualStyleElement.Tab.TabItem.Normal, (int) state); visualStyleRenderer.DrawBackground(g, bounds); Rectangle rectangle = Rectangle.Inflate(bounds, -3, -3); Color foreColor = visualStyleRenderer.GetColor(ColorProperty.TextColor); TextRenderer.DrawText(g, tabItemText, font, rectangle, foreColor, flags); if (focused) { ControlPaint.DrawFocusRectangle(g, rectangle); } }
public LinkPart(ChatMessagePart parent=null,Font font = null) : base(parent,font) { if (font == null) defaultFont = new Font(parent.Font, parent.Font.Style | FontStyle.Underline); else defaultFont = new Font(font, font.Style | FontStyle.Underline); formatFlags = TextFormatFlags.Default | TextFormatFlags.TextBoxControl | TextFormatFlags.NoPadding | TextFormatFlags.NoPrefix; clickedFont = defaultFont; }
internal Area(Graphics g, Rectangle bounds, string text, Color textColor, Color backColor, Color borderColor) { _graphics = g; _bounds = bounds; _text = text; _textColor = textColor; _backgroundColor = backColor; _borderColor = borderColor; _borderWidth = 1; _textFlags |= TextFormatFlags.HorizontalCenter; _textFlags |= TextFormatFlags.VerticalCenter; }
protected BaseTextControl() { IncrementalSearchEnabled = true; _focusPen = new Pen(Color.Black); _focusPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dot; // ml: added flags for vertical centering and no wrapping. _format = new StringFormat(StringFormatFlags.NoClip | StringFormatFlags.FitBlackBox | StringFormatFlags.MeasureTrailingSpaces | StringFormatFlags.NoWrap); _baseFormatFlags = TextFormatFlags.PreserveGraphicsClipping | TextFormatFlags.VerticalCenter | TextFormatFlags.PreserveGraphicsTranslateTransform; SetFormatFlags(); LeftMargin = 3; }
public int UxThemeGetThemeTextExtent(IntPtr hTheme, IDeviceContext dc, int iPartId, int iStateId, string textToDraw, TextFormatFlags flags, out Rectangle result) { XplatUIWin32.RECT retval; int hresult = UXTheme.GetThemeTextExtent(hTheme, dc.GetHdc(), iPartId, iStateId, textToDraw, textToDraw.Length, (int)flags, 0, out retval); dc.ReleaseHdc(); result = retval.ToRectangle(); return(hresult); }
/// <summary> /// Draw text without a glowing background, for use on a composition element. /// </summary> /// <param name="g">Graphics reference.</param> /// <param name="text">Text to be drawn.</param> /// <param name="font">Font to use for text.</param> /// <param name="bounds">Bounding area for the text.</param> /// <param name="state">State of the source element.</param> /// <param name="color"><see cref="Color"/> of the text.</param> /// <param name="copyBackground">Should existing background be copied into the bitmap.</param> /// <param name="sf">StringFormat of the memento.</param> public static void DrawCompositionText(Graphics g, string text, Font font, Rectangle bounds, PaletteState state, Color color, bool copyBackground, StringFormat sf) { // Get the hDC for the graphics instance and create a memory DC IntPtr gDC = g.GetHdc(); try { IntPtr mDC = PI.CreateCompatibleDC(gDC); PI.BITMAPINFO bmi = new PI.BITMAPINFO { biWidth = bounds.Width, biHeight = -(bounds.Height), biCompression = 0, biBitCount = 32, biPlanes = 1 }; bmi.biSize = (uint)Marshal.SizeOf(bmi); // Create a device independent bitmap and select into the memory DC IntPtr hDIB = PI.CreateDIBSection(gDC, ref bmi, 0, out _, IntPtr.Zero, 0); PI.SelectObject(mDC, hDIB); if (copyBackground) { // Copy existing background into the bitmap PI.BitBlt(mDC, 0, 0, bounds.Width, bounds.Height, gDC, bounds.X, bounds.Y, 0x00CC0020); } // Select the font for use when drawing IntPtr hFont = font.ToHfont(); PI.SelectObject(mDC, hFont); // Get renderer for the correct state VisualStyleRenderer renderer = new VisualStyleRenderer(state == PaletteState.Normal ? VisualStyleElement.Window.Caption.Active : VisualStyleElement.Window.Caption.Inactive); // Create structures needed for theme drawing call PI.RECT textBounds = new PI.RECT { left = 0, top = 0, right = (bounds.Right - bounds.Left), bottom = (bounds.Bottom - bounds.Top) }; PI.DTTOPTS dttOpts = new PI.DTTOPTS { dwSize = Marshal.SizeOf(typeof(PI.DTTOPTS)), dwFlags = PI.DTT_COMPOSITED | PI.DTT_TEXTCOLOR, crText = ColorTranslator.ToWin32(color) }; // Always draw text centered TextFormatFlags textFormat = TextFormatFlags.SingleLine | TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter; ////Seb | TextFormatFlags.EndEllipsis; // Perform actual drawing //PI.DrawThemeTextEx(renderer.Handle, // mDC, 0, 0, // text, -1, (int)StringFormatToFlags(sf), // ref textBounds, ref dttOpts); PI.DrawThemeTextEx(renderer.Handle, mDC, 0, 0, text, -1, (int)textFormat, ref textBounds, ref dttOpts); // Copy to foreground PI.BitBlt(gDC, bounds.Left, bounds.Top, bounds.Width, bounds.Height, mDC, 0, 0, 0x00CC0020); // Dispose of allocated objects PI.DeleteObject(hFont); PI.DeleteObject(hDIB); PI.DeleteDC(mDC); } catch { // ignored } finally { // Must remember to release the hDC g.ReleaseHdc(gDC); } }
protected virtual void OnPaintForeground(PaintEventArgs e) { Color color = MetroPaint.BorderColor.Button.Normal(this.Theme); Color foreColor; if (this.isHovered && !this.isPressed && base.Enabled) { foreColor = MetroPaint.ForeColor.Tile.Hover(this.Theme); } else if (this.isHovered && this.isPressed && base.Enabled) { foreColor = MetroPaint.ForeColor.Tile.Press(this.Theme); } else if (!base.Enabled) { foreColor = MetroPaint.ForeColor.Tile.Disabled(this.Theme); } else { foreColor = MetroPaint.ForeColor.Tile.Normal(this.Theme); } if (this.useCustomForeColor) { foreColor = this.ForeColor; } if (this.isPressed || this.isHovered || this.isFocused) { using (Pen pen = new Pen(color)) { pen.Width = 3f; Rectangle rect = new Rectangle(1, 1, base.Width - 3, base.Height - 3); e.Graphics.DrawRectangle(pen, rect); } } e.Graphics.SmoothingMode = SmoothingMode.HighQuality; e.Graphics.CompositingQuality = CompositingQuality.HighQuality; if (this.useTileImage && this.tileImage != null) { ContentAlignment contentAlignment = this.tileImageAlign; Rectangle rect2; if (contentAlignment <= ContentAlignment.MiddleCenter) { switch (contentAlignment) { case ContentAlignment.TopLeft: rect2 = new Rectangle(new Point(0, 0), new Size(this.TileImage.Width, this.TileImage.Height)); goto IL_430; case ContentAlignment.TopCenter: rect2 = new Rectangle(new Point(base.Width / 2 - this.TileImage.Width / 2, 0), new Size(this.TileImage.Width, this.TileImage.Height)); goto IL_430; case (ContentAlignment)3: break; case ContentAlignment.TopRight: rect2 = new Rectangle(new Point(base.Width - this.TileImage.Width, 0), new Size(this.TileImage.Width, this.TileImage.Height)); goto IL_430; default: if (contentAlignment == ContentAlignment.MiddleLeft) { rect2 = new Rectangle(new Point(0, base.Height / 2 - this.TileImage.Height / 2), new Size(this.TileImage.Width, this.TileImage.Height)); goto IL_430; } if (contentAlignment == ContentAlignment.MiddleCenter) { rect2 = new Rectangle(new Point(base.Width / 2 - this.TileImage.Width / 2, base.Height / 2 - this.TileImage.Height / 2), new Size(this.TileImage.Width, this.TileImage.Height)); goto IL_430; } break; } } else if (contentAlignment <= ContentAlignment.BottomLeft) { if (contentAlignment == ContentAlignment.MiddleRight) { rect2 = new Rectangle(new Point(base.Width - this.TileImage.Width, base.Height / 2 - this.TileImage.Height / 2), new Size(this.TileImage.Width, this.TileImage.Height)); goto IL_430; } if (contentAlignment == ContentAlignment.BottomLeft) { rect2 = new Rectangle(new Point(0, base.Height - this.TileImage.Height), new Size(this.TileImage.Width, this.TileImage.Height)); goto IL_430; } } else { if (contentAlignment == ContentAlignment.BottomCenter) { rect2 = new Rectangle(new Point(base.Width / 2 - this.TileImage.Width / 2, base.Height - this.TileImage.Height), new Size(this.TileImage.Width, this.TileImage.Height)); goto IL_430; } if (contentAlignment == ContentAlignment.BottomRight) { rect2 = new Rectangle(new Point(base.Width - this.TileImage.Width, base.Height - this.TileImage.Height), new Size(this.TileImage.Width, this.TileImage.Height)); goto IL_430; } } rect2 = new Rectangle(new Point(0, 0), new Size(this.TileImage.Width, this.TileImage.Height)); IL_430: e.Graphics.DrawImage(this.TileImage, rect2); } if (this.TileCount > 0 && this.paintTileCount) { Size size = TextRenderer.MeasureText(this.TileCount.ToString(), MetroFonts.TileCount); e.Graphics.TextRenderingHint = TextRenderingHint.AntiAlias; TextRenderer.DrawText(e.Graphics, this.TileCount.ToString(), MetroFonts.TileCount, new Point(base.Width - size.Width, 0), foreColor); e.Graphics.TextRenderingHint = TextRenderingHint.SystemDefault; } TextRenderer.MeasureText(this.Text, MetroFonts.Tile(this.tileTextFontSize, this.tileTextFontWeight)); TextFormatFlags flags = MetroPaint.GetTextFormatFlags(this.TextAlign, true) | TextFormatFlags.LeftAndRightPadding | TextFormatFlags.EndEllipsis; Rectangle clientRectangle = base.ClientRectangle; if (this.isPressed) { clientRectangle.Inflate(-4, -12); } else { clientRectangle.Inflate(-2, -10); } TextRenderer.DrawText(e.Graphics, this.Text, MetroFonts.Tile(this.tileTextFontSize, this.tileTextFontWeight), clientRectangle, foreColor, flags); }
/// <include file='doc\DataGridViewCell.uex' path='docs/doc[@for="DataGridViewCell.GetPreferredSize"]/*' /> protected override Size GetPreferredSize(Graphics graphics, DataGridViewCellStyle cellStyle, int rowIndex, Size constraintSize) { if (this.DataGridView == null) { return(new Size(-1, -1)); } if (cellStyle == null) { throw new ArgumentNullException(nameof(cellStyle)); } Size preferredSize; Rectangle borderWidthsRect = this.StdBorderWidths; int borderAndPaddingWidths = borderWidthsRect.Left + borderWidthsRect.Width + cellStyle.Padding.Horizontal; int borderAndPaddingHeights = borderWidthsRect.Top + borderWidthsRect.Height + cellStyle.Padding.Vertical; DataGridViewFreeDimension freeDimension = DataGridViewCell.GetFreeDimensionFromConstraint(constraintSize); object formattedValue = GetFormattedValue(rowIndex, ref cellStyle, DataGridViewDataErrorContexts.Formatting | DataGridViewDataErrorContexts.PreferredSize); string formattedString = formattedValue as string; if (string.IsNullOrEmpty(formattedString)) { formattedString = " "; } TextFormatFlags flags = DataGridViewUtilities.ComputeTextFormatFlagsForCellStyleAlignment(this.DataGridView.RightToLeftInternal, cellStyle.Alignment, cellStyle.WrapMode); if (cellStyle.WrapMode == DataGridViewTriState.True && formattedString.Length > 1) { switch (freeDimension) { case DataGridViewFreeDimension.Width: { preferredSize = new Size(DataGridViewCell.MeasureTextWidth(graphics, formattedString, cellStyle.Font, Math.Max(1, constraintSize.Height - borderAndPaddingHeights - DATAGRIDVIEWTEXTBOXCELL_verticalTextMarginTopWithWrapping - DATAGRIDVIEWTEXTBOXCELL_verticalTextMarginBottom), flags), 0); break; } case DataGridViewFreeDimension.Height: { preferredSize = new Size(0, DataGridViewCell.MeasureTextHeight(graphics, formattedString, cellStyle.Font, Math.Max(1, constraintSize.Width - borderAndPaddingWidths - DATAGRIDVIEWTEXTBOXCELL_horizontalTextMarginLeft - DATAGRIDVIEWTEXTBOXCELL_horizontalTextMarginRight), flags)); break; } default: { preferredSize = DataGridViewCell.MeasureTextPreferredSize(graphics, formattedString, cellStyle.Font, 5.0F, flags); break; } } } else { switch (freeDimension) { case DataGridViewFreeDimension.Width: { preferredSize = new Size(DataGridViewCell.MeasureTextSize(graphics, formattedString, cellStyle.Font, flags).Width, 0); break; } case DataGridViewFreeDimension.Height: { preferredSize = new Size(0, DataGridViewCell.MeasureTextSize(graphics, formattedString, cellStyle.Font, flags).Height); break; } default: { preferredSize = DataGridViewCell.MeasureTextSize(graphics, formattedString, cellStyle.Font, flags); break; } } } if (freeDimension != DataGridViewFreeDimension.Height) { preferredSize.Width += DATAGRIDVIEWTEXTBOXCELL_horizontalTextMarginLeft + DATAGRIDVIEWTEXTBOXCELL_horizontalTextMarginRight + borderAndPaddingWidths; if (this.DataGridView.ShowCellErrors) { // Making sure that there is enough room for the potential error icon preferredSize.Width = Math.Max(preferredSize.Width, borderAndPaddingWidths + DATAGRIDVIEWCELL_iconMarginWidth * 2 + iconsWidth); } } if (freeDimension != DataGridViewFreeDimension.Width) { int verticalTextMarginTop = cellStyle.WrapMode == DataGridViewTriState.True ? DATAGRIDVIEWTEXTBOXCELL_verticalTextMarginTopWithWrapping : DATAGRIDVIEWTEXTBOXCELL_verticalTextMarginTopWithoutWrapping; preferredSize.Height += verticalTextMarginTop + DATAGRIDVIEWTEXTBOXCELL_verticalTextMarginBottom + borderAndPaddingHeights; if (this.DataGridView.ShowCellErrors) { // Making sure that there is enough room for the potential error icon preferredSize.Height = Math.Max(preferredSize.Height, borderAndPaddingHeights + DATAGRIDVIEWCELL_iconMarginHeight * 2 + iconsHeight); } } return(preferredSize); }
/// <summary> /// Implements the custom drawing for the button. /// </summary> /// <param name="paintEvent">The paint event args.</param> protected override void OnPaint(PaintEventArgs paintEvent) { GraphicsPath gp = CreateOutlinePath(paintEvent.Graphics); if (state == State.Disabled) { using (Brush b = new SolidBrush(Color.FromArgb(128, BackColor))) { paintEvent.Graphics.FillRectangle(b, ClientRectangle); } } else { DrawHighlight(paintEvent.Graphics, gp); } using (Pen p = new Pen(Enabled ? highlightColor : Color.FromArgb(128, Color.FromKnownColor(KnownColor.GrayText)), Enabled ? hightlightWidth : 0.1f)) { paintEvent.Graphics.DrawPath(p, gp); } // ReSharper disable RedundantCast // This cast is done to enable Mono to package this int offset = (state == State.Pushed) ? (int)buttonDepress : 0; // ReSharper restore RedundantCast RectangleF available = new RectangleF(ClientRectangle.Location, ClientRectangle.Size); // Draw the image... Image drawImage = GetDrawImage(); if (drawImage != null) { // Figure out where to stick the image. RectangleF imageRect = GetAlignedRectangle(available, drawImage.Size, ImageAlign); float imageAndMargins = imageRect.Width + (2f * imageMargin); switch (ImageAlign) { case ContentAlignment.BottomLeft: case ContentAlignment.MiddleLeft: case ContentAlignment.TopLeft: available.Width -= imageAndMargins; available.Offset(imageAndMargins, 0f); imageRect.Offset(imageMargin, 0f); break; case ContentAlignment.BottomRight: case ContentAlignment.MiddleRight: case ContentAlignment.TopRight: available.Width -= imageAndMargins; imageRect.Offset(-imageMargin, 0f); break; } if (offset != 0) { imageRect.Offset(offset, offset); } paintEvent.Graphics.DrawImage(drawImage, imageRect); } // Now fill in the text { Size headlineSize = TextRenderer.MeasureText(paintEvent.Graphics, Text, Font); Size subscriptSize = TextRenderer.MeasureText(paintEvent.Graphics, subscript, subscriptFont); Size combined = new Size(Math.Max(headlineSize.Width, subscriptSize.Width), headlineSize.Height + subscriptSize.Height + textGap); Rectangle textRect = Rectangle.Round(GetAlignedRectangle(available, combined, TextAlign)); // Draw the headline text... if (offset != 0) { textRect.Offset(offset, offset); } TextFormatFlags tf = TextFormatFlags.WordEllipsis; if (!showUnderLine) { tf |= TextFormatFlags.HidePrefix; } Color textColor = Enabled ? ForeColor : Color.FromKnownColor(KnownColor.GrayText); TextRenderer.DrawText(paintEvent.Graphics, Text, Font, new Rectangle(textRect.X, textRect.Y, textRect.Width, headlineSize.Height), textColor, Color.Transparent, tf); // Draw the subscript text... TextRenderer.DrawText(paintEvent.Graphics, subscript, subscriptFont, new Rectangle(textRect.X, textRect.Y + headlineSize.Height + textGap, textRect.Width, subscriptSize.Height), textColor, Color.Transparent, TextFormatFlags.WordEllipsis); } }
private void ListView_DrawSubItem(object sender, DrawListViewSubItemEventArgs e) { // We draw the current line of items (= item with sub items) on a temp bitmap, then draw the bitmap at once. This is to reduce flickering. Bitmap _bitmap = new Bitmap(e.Item.Bounds.Width, e.Item.Bounds.Height); Graphics _graphics = Graphics.FromImage(_bitmap); if (e.ItemState.HasFlag(ListViewItemStates.Selected)) { _graphics.FillRectangle(new SolidBrush(_itemSelected), new Rectangle(new Point(e.Bounds.X, 0), e.Bounds.Size)); } else if (e.Bounds.Contains(LastPosition) && (MouseState == MouseStates.Hover)) { _graphics.FillRectangle(new SolidBrush(_itemHover), new Rectangle(new Point(e.Bounds.X, 0), e.Bounds.Size)); } else { _graphics.FillRectangle(new SolidBrush(_itemEnabled), new Rectangle(new Point(e.Bounds.X, 0), e.Bounds.Size)); } // Draw separator // graphics.DrawLine(new Pen(Color.Red), e.Bounds.Left, 0, e.Bounds.Right, 0); foreach (ListViewItem.ListViewSubItem subItem in e.Item.SubItems) { // Draw text _graphics.DrawString(subItem.Text, Font, new SolidBrush(Color.Black), new Rectangle(subItem.Bounds.X + _itemPadding, _itemPadding, subItem.Bounds.Width - (2 * _itemPadding), subItem.Bounds.Height - (2 * _itemPadding)), GetStringFormat()); } // Draw the item text for views other than the Details view if (_listView.View != View.Details) { e.DrawText(); } TextFormatFlags _textFormatFlags = TextFormatFlags.Left; StringFormat _stringFormat = new StringFormat(); // Store the column text alignment, letting it default // to Left if it has not been set to Center or Right. switch (e.Header.TextAlign) { case HorizontalAlignment.Center: { _stringFormat.Alignment = StringAlignment.Center; _textFormatFlags = TextFormatFlags.HorizontalCenter; break; } case HorizontalAlignment.Right: { _stringFormat.Alignment = StringAlignment.Far; _textFormatFlags = TextFormatFlags.Right; break; } case HorizontalAlignment.Left: { break; } default: { throw new ArgumentOutOfRangeException(); } } // Draw the text and background for a sub item with a // negative value. double _subItemValue; if ((e.ColumnIndex > 0) && double.TryParse(e.SubItem.Text, NumberStyles.Currency, NumberFormatInfo.CurrentInfo, out _subItemValue) && (_subItemValue < 0)) { // Unless the item is selected, draw the standard // background to make it stand out from the gradient. if ((e.ItemState & ListViewItemStates.Selected) == 0) { e.DrawBackground(); } // Draw the sub item text in red to highlight it. _graphics.DrawString(e.SubItem.Text, Font, Brushes.Red, e.Bounds, _stringFormat); return; } e.Graphics.DrawImage((Image)_bitmap.Clone(), new Point(0, e.Item.Bounds.Location.Y)); // Draw normal text for a sub item with a non negative // or non numerical value. e.DrawText(_textFormatFlags); _graphics.Dispose(); _bitmap.Dispose(); }
// PaintPrivate is used in three places that need to duplicate the paint code: // 1. DataGridViewCell::Paint method // 2. DataGridViewCell::GetContentBounds // 3. DataGridViewCell::GetErrorIconBounds // // if computeContentBounds is true then PaintPrivate returns the contentBounds // else if computeErrorIconBounds is true then PaintPrivate returns the errorIconBounds // else it returns Rectangle.Empty; private Rectangle PaintPrivate(Graphics graphics, Rectangle clipBounds, Rectangle cellBounds, int rowIndex, DataGridViewElementStates cellState, object formattedValue, string errorText, DataGridViewCellStyle cellStyle, DataGridViewAdvancedBorderStyle advancedBorderStyle, DataGridViewPaintParts paintParts, bool computeContentBounds, bool computeErrorIconBounds, bool paint) { // Parameter checking. // One bit and one bit only should be turned on Debug.Assert(paint || computeContentBounds || computeErrorIconBounds); Debug.Assert(!paint || !computeContentBounds || !computeErrorIconBounds); Debug.Assert(!computeContentBounds || !computeErrorIconBounds || !paint); Debug.Assert(!computeErrorIconBounds || !paint || !computeContentBounds); Debug.Assert(cellStyle != null); // If computeContentBounds == TRUE then resultBounds will be the contentBounds. // If computeErrorIconBounds == TRUE then resultBounds will be the error icon bounds. // Else resultBounds will be Rectangle.Empty; Rectangle resultBounds = Rectangle.Empty; if (paint && DataGridViewCell.PaintBorder(paintParts)) { PaintBorder(graphics, clipBounds, cellBounds, cellStyle, advancedBorderStyle); } Rectangle borderWidths = BorderWidths(advancedBorderStyle); Rectangle valBounds = cellBounds; valBounds.Offset(borderWidths.X, borderWidths.Y); valBounds.Width -= borderWidths.Right; valBounds.Height -= borderWidths.Bottom; SolidBrush br; Point ptCurrentCell = this.DataGridView.CurrentCellAddress; bool cellCurrent = ptCurrentCell.X == this.ColumnIndex && ptCurrentCell.Y == rowIndex; bool cellEdited = cellCurrent && this.DataGridView.EditingControl != null; bool cellSelected = (cellState & DataGridViewElementStates.Selected) != 0; if (DataGridViewCell.PaintSelectionBackground(paintParts) && cellSelected && !cellEdited) { br = this.DataGridView.GetCachedBrush(cellStyle.SelectionBackColor); } else { br = this.DataGridView.GetCachedBrush(cellStyle.BackColor); } if (paint && DataGridViewCell.PaintBackground(paintParts) && br.Color.A == 255 && valBounds.Width > 0 && valBounds.Height > 0) { graphics.FillRectangle(br, valBounds); } if (cellStyle.Padding != Padding.Empty) { if (this.DataGridView.RightToLeftInternal) { valBounds.Offset(cellStyle.Padding.Right, cellStyle.Padding.Top); } else { valBounds.Offset(cellStyle.Padding.Left, cellStyle.Padding.Top); } valBounds.Width -= cellStyle.Padding.Horizontal; valBounds.Height -= cellStyle.Padding.Vertical; } if (paint && cellCurrent && !cellEdited) { // Draw focus rectangle if (DataGridViewCell.PaintFocus(paintParts) && this.DataGridView.ShowFocusCues && this.DataGridView.Focused && valBounds.Width > 0 && valBounds.Height > 0) { ControlPaint.DrawFocusRectangle(graphics, valBounds, Color.Empty, br.Color); } } Rectangle errorBounds = valBounds; string formattedString = formattedValue as string; if (formattedString != null && ((paint && !cellEdited) || computeContentBounds)) { // Font independent margins int verticalTextMarginTop = cellStyle.WrapMode == DataGridViewTriState.True ? DATAGRIDVIEWTEXTBOXCELL_verticalTextMarginTopWithWrapping : DATAGRIDVIEWTEXTBOXCELL_verticalTextMarginTopWithoutWrapping; valBounds.Offset(DATAGRIDVIEWTEXTBOXCELL_horizontalTextMarginLeft, verticalTextMarginTop); valBounds.Width -= DATAGRIDVIEWTEXTBOXCELL_horizontalTextMarginLeft + DATAGRIDVIEWTEXTBOXCELL_horizontalTextMarginRight; valBounds.Height -= verticalTextMarginTop + DATAGRIDVIEWTEXTBOXCELL_verticalTextMarginBottom; if (valBounds.Width > 0 && valBounds.Height > 0) { TextFormatFlags flags = DataGridViewUtilities.ComputeTextFormatFlagsForCellStyleAlignment(this.DataGridView.RightToLeftInternal, cellStyle.Alignment, cellStyle.WrapMode); if (paint) { if (DataGridViewCell.PaintContentForeground(paintParts)) { if ((flags & TextFormatFlags.SingleLine) != 0) { flags |= TextFormatFlags.EndEllipsis; } TextRenderer.DrawText(graphics, formattedString, cellStyle.Font, valBounds, cellSelected ? cellStyle.SelectionForeColor : cellStyle.ForeColor, flags); } } else { resultBounds = DataGridViewUtilities.GetTextBounds(valBounds, formattedString, flags, cellStyle); } } } else if (computeErrorIconBounds) { if (!string.IsNullOrEmpty(errorText)) { resultBounds = ComputeErrorIconBounds(errorBounds); } } else { Debug.Assert(cellEdited || formattedString == null); Debug.Assert(paint || computeContentBounds); } if (this.DataGridView.ShowCellErrors && paint && DataGridViewCell.PaintErrorIcon(paintParts)) { PaintErrorIcon(graphics, cellStyle, rowIndex, cellBounds, errorBounds, errorText); } return(resultBounds); }
public static Size MeasureText(IDeviceContext dc, string text, Font font, Size proposedSize, TextFormatFlags flags) { return(MeasureTextInternal(dc, text, font, proposedSize, flags, false)); }
internal static void DrawTextInternal(IDeviceContext dc, string text, Font font, Rectangle bounds, Color foreColor, Color backColor, TextFormatFlags flags, bool useDrawString) { if (dc == null) { throw new ArgumentNullException("dc"); } if (text == null || text.Length == 0) { return; } // We use MS GDI API's unless told not to, or we aren't on Windows if (!useDrawString && !XplatUI.RunningOnUnix) { if ((flags & TextFormatFlags.VerticalCenter) == TextFormatFlags.VerticalCenter || (flags & TextFormatFlags.Bottom) == TextFormatFlags.Bottom) { flags |= TextFormatFlags.SingleLine; } // Calculate the text bounds (there is often padding added) Rectangle new_bounds = PadRectangle(bounds, flags); new_bounds.Offset((int)(dc as Graphics).Transform.OffsetX, (int)(dc as Graphics).Transform.OffsetY); IntPtr hdc = IntPtr.Zero; bool clear_clip_region = false; // If we need to use the graphics clipping region, add it to our hdc if ((flags & TextFormatFlags.PreserveGraphicsClipping) == TextFormatFlags.PreserveGraphicsClipping) { Graphics graphics = (Graphics)dc; Region clip_region = graphics.Clip; if (!clip_region.IsInfinite(graphics)) { IntPtr hrgn = clip_region.GetHrgn(graphics); hdc = dc.GetHdc(); SelectClipRgn(hdc, hrgn); DeleteObject(hrgn); clear_clip_region = true; } } if (hdc == IntPtr.Zero) { hdc = dc.GetHdc(); } // Set the fore color if (foreColor != Color.Empty) { SetTextColor(hdc, ColorTranslator.ToWin32(foreColor)); } // Set the back color if (backColor != Color.Transparent && backColor != Color.Empty) { SetBkMode(hdc, 2); //1-Transparent, 2-Opaque SetBkColor(hdc, ColorTranslator.ToWin32(backColor)); } else { SetBkMode(hdc, 1); //1-Transparent, 2-Opaque } XplatUIWin32.RECT r = XplatUIWin32.RECT.FromRectangle(new_bounds); IntPtr prevobj; if (font != null) { prevobj = SelectObject(hdc, font.ToHfont()); Win32DrawText(hdc, text, text.Length, ref r, (int)flags); prevobj = SelectObject(hdc, prevobj); DeleteObject(prevobj); } else { Win32DrawText(hdc, text, text.Length, ref r, (int)flags); } if (clear_clip_region) { SelectClipRgn(hdc, IntPtr.Zero); } dc.ReleaseHdc(); } // Use Graphics.DrawString as a fallback method else { Graphics g; IntPtr hdc = IntPtr.Zero; if (dc is Graphics) { g = (Graphics)dc; } else { hdc = dc.GetHdc(); g = Graphics.FromHdc(hdc); } StringFormat sf = FlagsToStringFormat(flags); Rectangle new_bounds = PadDrawStringRectangle(bounds, flags); g.DrawString(text, font, ThemeEngine.Current.ResPool.GetSolidBrush(foreColor), new_bounds, sf); if (!(dc is Graphics)) { g.Dispose(); dc.ReleaseHdc(); } } }
/// GetTextSize /// Given constraints, format flags a font and text, determine the size of the string /// employs an MRU of the last several constraints passed in via a ring-buffer of size MaxCacheSize. /// Assumes Text and TextFormatFlags are the same, if either were to change, a call to /// InvalidateCache should be made public Size GetTextSize(string?text, Font?font, Size proposedConstraints, TextFormatFlags flags) { if (!TextRequiresWordBreak(text, font, proposedConstraints, flags)) { // Text fits within proposed width // IF we're here, this means we've got text that can fit into the proposedConstraints // without wrapping. We've determined this because our // as a side effect of calling TextRequiresWordBreak, // unconstrainedPreferredSize is set. return(_unconstrainedPreferredSize); } else { // Text does NOT fit within proposed width - requires WordBreak // IF we're here, this means that the wrapping width is smaller // than our max width. For example: we measure the text with infinite // bounding box and we determine the width to fit all the characters // to be 200 px wide. We would come here only for proposed widths less // than 200 px. // Create our ring buffer if we don't have one if (_sizeCacheList is null) { _sizeCacheList = new PreferredSizeCache[MaxCacheSize]; } // check the existing constraints from previous calls foreach (PreferredSizeCache sizeCache in _sizeCacheList) { if (sizeCache.ConstrainingSize == proposedConstraints) { return(sizeCache.PreferredSize); } else if ((sizeCache.ConstrainingSize.Width == proposedConstraints.Width) && (sizeCache.PreferredSize.Height <= proposedConstraints.Height)) { // Caching a common case where the width matches perfectly, and the stored preferred height // is smaller or equal to the constraining size. // prefSize = GetPreferredSize(w,Int32.MaxValue); // prefSize = GetPreferredSize(w,prefSize.Height); return(sizeCache.PreferredSize); } // } // if we've gotten here, it means we don't have a cache entry, therefore // we should add a new one in the next available slot. Size prefSize = TextRenderer.MeasureText(text, font, proposedConstraints, flags); _nextCacheEntry = (_nextCacheEntry + 1) % MaxCacheSize; _sizeCacheList[_nextCacheEntry] = new PreferredSizeCache(proposedConstraints, prefSize); return(prefSize); } }
public static Size MeasureText(string text, Font font, Size proposedSize, TextFormatFlags flags) { return(MeasureTextInternal(Hwnd.GraphicsContext, text, font, proposedSize, flags, false)); }
/// TextRequiresWordBreak /// If you give the text all the space in the world it wants, then there should be no reason /// for it to break on a word. So we find out what the unconstrained size is (Int32.MaxValue, Int32.MaxValue) /// for a string - eg. 35, 13. If the size passed in has a larger width than 35, then we know that /// the WordBreak flag is not necessary. public bool TextRequiresWordBreak(string?text, Font?font, Size size, TextFormatFlags flags) { // if the unconstrained size of the string is larger than the proposed width // we need the word break flag, otherwise we don't, its a perf hit to use it. return(GetUnconstrainedSize(text, font, flags).Width > size.Width); }
private static TextFormatFlags StringFormatToFlags(StringFormat sf) { TextFormatFlags flags = new TextFormatFlags(); // Translation table: http://msdn.microsoft.com/msdnmag/issues/06/03/TextRendering/default.aspx?fig=true#fig4 switch (sf.Alignment) { // Horizontal Alignment case StringAlignment.Center: flags = flags & TextFormatFlags.HorizontalCenter; break; case StringAlignment.Far: flags = flags & TextFormatFlags.Right; break; default: flags = flags & TextFormatFlags.Left; break; } switch (sf.LineAlignment) { // Vertical Alignment case StringAlignment.Far: flags = flags & TextFormatFlags.Bottom; break; case StringAlignment.Center: flags = flags & TextFormatFlags.VerticalCenter; break; default: flags = flags & TextFormatFlags.Top; break; } switch (sf.Trimming) { // Ellipsis case StringTrimming.EllipsisCharacter: flags = flags & TextFormatFlags.EndEllipsis; break; case StringTrimming.EllipsisPath: flags = flags & TextFormatFlags.PathEllipsis; break; case StringTrimming.EllipsisWord: flags = flags & TextFormatFlags.WordEllipsis; break; } // Hotkey Prefix if (sf.HotkeyPrefix == HotkeyPrefix.None) { flags = flags & TextFormatFlags.NoPrefix; } else if (sf.HotkeyPrefix == HotkeyPrefix.Hide) { flags = flags & TextFormatFlags.HidePrefix; } // Text Padding if (sf.FormatFlags == StringFormatFlags.FitBlackBox) { flags = flags & TextFormatFlags.NoPadding; } // Text Wrapping if (sf.FormatFlags == StringFormatFlags.NoWrap) { flags = flags & TextFormatFlags.SingleLine; } else if (sf.FormatFlags == StringFormatFlags.LineLimit) { flags = flags & TextFormatFlags.TextBoxControl; } // Other Flags if (sf.FormatFlags == StringFormatFlags.DirectionRightToLeft) { flags = flags & TextFormatFlags.RightToLeft; } if (sf.FormatFlags == StringFormatFlags.NoClip) { flags = flags & TextFormatFlags.NoClipping; } return(flags); }
private static StringFormat FlagsToStringFormat(TextFormatFlags flags) { StringFormat sf = new StringFormat(); // Translation table: http://msdn.microsoft.com/msdnmag/issues/06/03/TextRendering/default.aspx?fig=true#fig4 // Horizontal Alignment if ((flags & TextFormatFlags.HorizontalCenter) == TextFormatFlags.HorizontalCenter) { sf.Alignment = StringAlignment.Center; } else if ((flags & TextFormatFlags.Right) == TextFormatFlags.Right) { sf.Alignment = StringAlignment.Far; } else { sf.Alignment = StringAlignment.Near; } // Vertical Alignment if ((flags & TextFormatFlags.Bottom) == TextFormatFlags.Bottom) { sf.LineAlignment = StringAlignment.Far; } else if ((flags & TextFormatFlags.VerticalCenter) == TextFormatFlags.VerticalCenter) { sf.LineAlignment = StringAlignment.Center; } else { sf.LineAlignment = StringAlignment.Near; } // Ellipsis if ((flags & TextFormatFlags.EndEllipsis) == TextFormatFlags.EndEllipsis) { sf.Trimming = StringTrimming.EllipsisCharacter; } else if ((flags & TextFormatFlags.PathEllipsis) == TextFormatFlags.PathEllipsis) { sf.Trimming = StringTrimming.EllipsisPath; } else if ((flags & TextFormatFlags.WordEllipsis) == TextFormatFlags.WordEllipsis) { sf.Trimming = StringTrimming.EllipsisWord; } else { sf.Trimming = StringTrimming.Character; } // Hotkey Prefix if ((flags & TextFormatFlags.NoPrefix) == TextFormatFlags.NoPrefix) { sf.HotkeyPrefix = HotkeyPrefix.None; } else if ((flags & TextFormatFlags.HidePrefix) == TextFormatFlags.HidePrefix) { sf.HotkeyPrefix = HotkeyPrefix.Hide; } else { sf.HotkeyPrefix = HotkeyPrefix.Show; } // Text Padding if ((flags & TextFormatFlags.NoPadding) == TextFormatFlags.NoPadding) { sf.FormatFlags |= StringFormatFlags.FitBlackBox; } // Text Wrapping if ((flags & TextFormatFlags.SingleLine) == TextFormatFlags.SingleLine) { sf.FormatFlags |= StringFormatFlags.NoWrap; } else if ((flags & TextFormatFlags.TextBoxControl) == TextFormatFlags.TextBoxControl) { sf.FormatFlags |= StringFormatFlags.LineLimit; } // Other Flags //if ((flags & TextFormatFlags.RightToLeft) == TextFormatFlags.RightToLeft) // sf.FormatFlags |= StringFormatFlags.DirectionRightToLeft; if ((flags & TextFormatFlags.NoClipping) == TextFormatFlags.NoClipping) { sf.FormatFlags |= StringFormatFlags.NoClip; } return(sf); }
public abstract void CPDrawStringDisabled(IDeviceContext dc, string s, Font font, Color_ color, Rectangle_ layoutRectangle, TextFormatFlags format);
public CGlyph(char chr, float MaxHigh) { _SIZEh = MaxHigh; float outline = CFonts.Outline; TextFormatFlags flags = TextFormatFlags.NoPadding | TextFormatFlags.NoPrefix; float factor = GetFactor(chr, flags); CFonts.Height = SIZEh * factor; Bitmap bmp = new Bitmap(10, 10); System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(bmp); Font fo = CFonts.GetFont(); Size sizeB = TextRenderer.MeasureText(g, chr.ToString(), fo, new Size(int.MaxValue, int.MaxValue), flags); SizeF size = g.MeasureString(chr.ToString(), fo); g.Dispose(); bmp.Dispose(); bmp = new Bitmap((int)(sizeB.Width * 2f), sizeB.Height); g = System.Drawing.Graphics.FromImage(bmp); g.Clear(System.Drawing.Color.Transparent); g.SmoothingMode = SmoothingMode.AntiAlias; g.InterpolationMode = InterpolationMode.HighQualityBicubic; g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.ClearTypeGridFit; CFonts.Height = SIZEh; fo = CFonts.GetFont(); PointF point = new PointF( outline * Math.Abs(sizeB.Width - size.Width) + (sizeB.Width - size.Width) / 2f + SIZEh / 5f, (sizeB.Height - size.Height - (size.Height + SIZEh / 4f) * (1f - factor)) / 2f); GraphicsPath path = new GraphicsPath(); path.AddString( chr.ToString(), fo.FontFamily, (int)fo.Style, SIZEh, point, new StringFormat()); Pen pen = new Pen( Color.FromArgb( (int)CFonts.OutlineColor.A * 255, (int)CFonts.OutlineColor.R * 255, (int)CFonts.OutlineColor.G * 255, (int)CFonts.OutlineColor.B * 255), SIZEh * outline); pen.LineJoin = LineJoin.Round; g.DrawPath(pen, path); g.FillPath(Brushes.White, path); /* * g.DrawString( * chr.ToString(), * fo, * Brushes.White, * point); * */ Texture = CDraw.AddTexture(bmp); //bmp.Save("test.png", ImageFormat.Png); Chr = chr; width = (int)((1f + outline / 2f) * sizeB.Width * Texture.width / factor / bmp.Width); bmp.Dispose(); g.Dispose(); fo.Dispose(); }
private void PaintTab(Graphics g, Tab t, int index, bool selected) { PointPath path = GetTabPath(index); Color tabColor = selected ? this.Owner.SelectedTabColor : this.Owner.TabColor; if ((!selected || this.Owner.ShowHitTest) && this.Owner.Focused && path.HitTest(this.Owner.PointToClient(Control.MousePosition))) { if (this.Owner.ShowHitTest) { tabColor = Color.LightBlue; } else { tabColor = ControlPaint.Light(tabColor, 0.60f); } } using (Brush b = new SolidBrush(tabColor)) { g.FillPointPath(b, path); using Pen bp = new Pen(b); g.DrawPointPath(bp, path, true); } using (Pen p = new Pen(this.Owner.TabBorderColor)) { g.DrawPointPath(p, path, false); } int textAreaWidth = path.MinimumBounds.Width - 2 * TAB_CLOSE_BUTTON_RADIUS - TAB_CLOSE_BUTTON_PADDING; int textAreaX = path.MinimumBounds.X; if (t.Icon != null) { int x = path.MinimumBounds.Left + TAB_ICON_PADDING; int y = path.MinimumBounds.Top + (path.MinimumBounds.Height - TAB_ICON_SIZE) / 2; g.DrawImage(t.Icon, new Rectangle(x, y, TAB_ICON_SIZE, TAB_ICON_SIZE)); textAreaWidth -= TAB_ICON_SIZE + 2 * TAB_ICON_PADDING; textAreaX += TAB_ICON_SIZE + 2 * TAB_ICON_PADDING; } Rectangle bounds = new Rectangle(textAreaX, path.MinimumBounds.Y, textAreaWidth, path.MinimumBounds.Height); TextFormatFlags flags = TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter | TextFormatFlags.SingleLine | TextFormatFlags.LeftAndRightPadding; if (t.Text.Contains(Path.DirectorySeparatorChar) || t.Text.Contains(Path.AltDirectorySeparatorChar)) { flags |= TextFormatFlags.PathEllipsis; } else { flags |= TextFormatFlags.WordEllipsis; } TextRenderer.DrawText(g, t.Text, t.Font, bounds, t.ForeColor, flags); PaintTabClose(g, index); }
public void ShowAccellerator() { this.tff = tffShowPrefix; this.UseMnemonic = true; this.Invalidate(); }
/// <summary> /// /// </summary> /// <param name="alignment"></param> /// <param name="rightToleft"></param> /// <returns></returns> internal static TextFormatFlags GetTextFormatFlags(ContentAlignment alignment, bool rightToleft) { TextFormatFlags textFormatFlags = TextFormatFlags.SingleLine | TextFormatFlags.WordBreak; if (rightToleft) { textFormatFlags |= (TextFormatFlags.Right | TextFormatFlags.RightToLeft); } if (alignment <= ContentAlignment.MiddleCenter) { switch (alignment) { case ContentAlignment.TopLeft: //textFormatFlags = textFormatFlags; break; case ContentAlignment.TopCenter: textFormatFlags |= TextFormatFlags.HorizontalCenter; break; case (ContentAlignment.TopLeft | ContentAlignment.TopCenter): break; case ContentAlignment.TopRight: textFormatFlags |= TextFormatFlags.Right; break; default: if (alignment != ContentAlignment.MiddleLeft) { if (alignment == ContentAlignment.MiddleCenter) { textFormatFlags |= (TextFormatFlags.HorizontalCenter | TextFormatFlags.VerticalCenter); } } else { textFormatFlags |= TextFormatFlags.VerticalCenter; } break; } } else { if (alignment <= ContentAlignment.BottomLeft) { if (alignment != ContentAlignment.MiddleRight) { if (alignment == ContentAlignment.BottomLeft) { textFormatFlags |= TextFormatFlags.Bottom; } } else { textFormatFlags |= (TextFormatFlags.Right | TextFormatFlags.VerticalCenter); } } else { if (alignment != ContentAlignment.BottomCenter) { if (alignment == ContentAlignment.BottomRight) { textFormatFlags |= (TextFormatFlags.Bottom | TextFormatFlags.Right); } } else { textFormatFlags |= (TextFormatFlags.Bottom | TextFormatFlags.HorizontalCenter); } } } return(textFormatFlags); }
private static void DrawText(Graphics g, Rectangle bounds, string text, Font font, Color foreColor, TextFormatFlags flags) { TextRenderer.DrawText(g, text, font, bounds, foreColor, flags); }
/// <summary> /// Provides the size, in pixels, of the specified text when drawn with the specified font and formatting /// instructions, using the specified size to create the initial bounding rectangle for the text. /// </summary> /// <param name="text">The text to measure.</param> /// <param name="font">The <see cref="Font"/> to apply to the measured text.</param> /// <param name="proposedSize">The <see cref="Size"/> of the initial bounding rectangle.</param> /// <param name="flags">The formatting instructions to apply to the measured text.</param> /// <returns> /// The <see cref="Size"/>, in pixels, of <paramref name="text"/> drawn with the specified /// <paramref name="font"/> and format. /// </returns> /// <exception cref="ArgumentOutOfRangeException"> /// Thrown if <see cref="TextFormatFlags.ModifyString"/> is set. /// </exception> public static Size MeasureText(ReadOnlySpan <char> text, Font?font, Size proposedSize, TextFormatFlags flags) => MeasureTextInternal(text, font, proposedSize, BlockModifyString(flags));
//private static IntPtr SmallImageListHandle; //private static IntPtr LargeImageListHandle; //SHFILEINFO shFileInfo = new SHFILEINFO(); public UserControl1() { InitializeComponent(); ChangedItems = new List <string>(); iconcache = new ImageList(); //this.DoubleBuffered = true; this.Margin = new Padding(0); //textBox1.Enter += (s, e) => { // textBox1.SelectAll(); //}; //textBox1.MouseDown += (s, e) => { // if (textBox1.SelectionLength == 0) { // textBox1.SelectAll(); // } //}; listView1 = new ListViewEx(); listView1.Dock = DockStyle.Fill; panel2.Controls.Add(listView1); listView1.View = View.Details; listView1.OwnerDraw = true; listView1.VirtualMode = true; listView1.VirtualListSize = 0; //listView1.FullRowSelect = true; //listView1.View = View.Details; listView1.ShowItemToolTips = true; listView1.SmallImageList = new ImageList(); //listView1.StateImageList = imageList1; //listView1.LargeImageList = new ImageList(); //listView1.SmallImageList.ColorDepth = ColorDepth.Depth32Bit; listView1.SmallImageList.ImageSize = new Size(16, 16); //SHFILEINFO shFileInfo = new SHFILEINFO(); //SmallImageListHandle = NativeMethods.SHGetFileInfo(String.Empty, 0, // out shFileInfo, (uint)Marshal.SizeOf(shFileInfo), // NativeMethods.SHGFI_SMALLICON | NativeMethods.SHGFI_SYSICONINDEX); //LargeImageListHandle = NativeMethods.SHGetFileInfo(String.Empty, 0, // out shFileInfo, (uint)Marshal.SizeOf(shFileInfo), // NativeMethods.SHGFI_LARGEICON | NativeMethods.SHGFI_SYSICONINDEX); //NativeMethods.SendMessage(listView1.Handle, NativeMethods.LVM_SETIMAGELIST, // new IntPtr(NativeMethods.LVSIL_SMALL), SmallImageListHandle); //NativeMethods.SendMessage(listView1.Handle, NativeMethods.LVM_SETIMAGELIST, // new IntPtr(NativeMethods.LVSIL_NORMAL), LargeImageListHandle); this.sortcolum = 0; this.type = SortType.Name; this.sortOrder = 1; //hwnd_ = listView1.Handle; //dc_ = Win32API.GetDC(hwnd_); //hfont_ = listView1.Font.ToHfont(); headerBrush = new SolidBrush(Color.DarkGray); //int styles = (int)MF.Win32API.NativeMethods.SendMessage(listView1.Handle, (int)LVM_GETEXTENDEDLISTVIEWSTYLE, 0, (IntPtr)0); //styles |= LVS_EX_DOUBLEBUFFER; //MF.Win32API.NativeMethods.SendMessage(listView1.Handle, (int)LVM_SETEXTENDEDLISTVIEWSTYLE, 0, (IntPtr)styles); //DateWidth = GetTextExtend(DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss")).width+10; //DateTimeColumWidth = GetTextExtend(DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss")).width + 10; //Win32API.ReleaseDC(hwnd_, dc_); //Win32API.DeleteObject(hfont_); DateTimeColumWidth = Util.GetTextExtend(listView, DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss")).width + 10; ColumnHeader headerName = new ColumnHeader(); headerName.Name = "name"; headerName.Text = "name"; listView1.Columns.Add(headerName); ColumnHeader headerType = new ColumnHeader(); headerType.Name = "type"; headerType.Text = "type"; listView1.Columns.Add(headerType); ColumnHeader headerSize = new ColumnHeader(); headerSize.Name = "size"; headerSize.Text = "size"; listView1.Columns.Add(headerSize); ColumnHeader headerLastWriteTime = new ColumnHeader(); headerLastWriteTime.Name = "lastwritetime"; headerLastWriteTime.Text = "lastwritetime"; headerLastWriteTime.Width = DateTimeColumWidth; //headerLastWriteTime.AutoResize(ColumnHeaderAutoResizeStyle.ColumnContent); listView1.Columns.Add(headerLastWriteTime); listView1.RetrieveVirtualItem += (sender, e) => { if (e.ItemIndex < Items.Count) { var item = Items[e.ItemIndex]; var listviewitem = new ListViewItem(); listviewitem.Text = item.Name; //if (item.IsFile) { //listviewitem.ForeColor = Color.Yellow; listviewitem.SubItems.Add(item.type); //} //else { // listviewitem.SubItems.Add("Dir"); //} // listviewitem.ImageIndex = 0; listviewitem.SubItems.Add(getFileSizeFormat(item.Size)); if (item.LastWriteTime != null) { listviewitem.SubItems.Add(item.LastWriteTime.ToString("yyyy/MM/dd HH:mm:ss")); } if (item.type == ".exe") { if (!iconcache.Images.ContainsKey(item.Name)) { Image icon; if (IconMethods.getIcon(Path.Combine(this.Dir, item.Name), out icon)) { iconcache.Images.Add(item.Name, icon); } } } //listviewitem.SubItems.Add(item.LastWriteTime.ToLongDateString()); e.Item = listviewitem; // NativeMethods.SHGetFileInfo(Path.Combine(this.Dir, item.Name), 0, out shFileInfo, //(uint)Marshal.SizeOf(shFileInfo), NativeMethods.SHGFI_ICON | //NativeMethods.SHGFI_SYSICONINDEX | NativeMethods.SHGFI_OVERLAYINDEX); // // 最上位8ビットを除いた値をアイコンインデックス値とする // int iconIndex = (shFileInfo.iIcon & 0xFFFFFF); // listviewitem.ImageIndex = iconIndex; // LVITEM lvitem = new LVITEM(); // lvitem.stateMask = NativeMethods.LVIS_OVERLAYMASK; // // 最上位8ビットの値を、8-11ビット目に格納、それ以外のビットは 0 にする // lvitem.state = ((shFileInfo.iIcon >> 16) & 0x0F00); // NativeMethods.SendMessage(listView1.Handle, // NativeMethods.LVM_SETITEMSTATE, listviewitem.Index, ref lvitem); // if (shFileInfo.hIcon != IntPtr.Zero) // NativeMethods.DestroyIcon(shFileInfo.hIcon); } }; //Brush b = new SolidBrush(Color.Red); listView1.DrawSubItem += (sender, e) => { //// 描画するSubItemが2列目(ColumnIndexが1)の時は、StringAligment.Farに設定して、右寄せにする //// それ以外は、Nearにして、標準の左寄せ //StringFormat drawFormat = new StringFormat(); //if (e.ColumnIndex == 2) { // drawFormat.Alignment = StringAlignment.Far; //} //else { // drawFormat.Alignment = StringAlignment.Near; //} //System.Drawing.Brush brush; //// Forcus = 0x0010,Selected = 0x0001 として ItemStateにForcusとSelectedがセットされていた場合、 //// 2bitで書くと Selected = 0001 0000 ItemState = 0000 0001で //// この二つ論理積を取ると0000 0001(0x0001 = Selected)となる。 ////if ((e.ItemState & ListViewItemStates.Selected) == ListViewItemStates.Selected) { //if (listView1.SelectedIndices.Contains(e.ItemIndex)) { // // Hightlightで範囲を塗りつぶす // if (e.ColumnIndex == 0) { // e.Graphics.FillRectangle(SystemBrushes.Highlight, e.Bounds); // // 上でセルを塗りつぶしているので、表示する文字を反転する // brush = SystemBrushes.HighlightText; // }else{ // brush = SystemBrushes.WindowText; // } //} //else { // //if (!Items[e.ItemIndex].IsFile) { // // brush = SystemBrushes.HighlightText; // //} else { // // 塗りつぶされていない通常のセルはWindowsTextに設定する // brush = SystemBrushes.WindowText; // //} //} //// 上で設定した,brushとdrawFormatを利用して文字を描画する //e.Graphics.DrawString(e.SubItem.Text, e.Item.Font, brush, e.Bounds, drawFormat); //// drawFormatを開放する //drawFormat.Dispose(); //TextFormatFlags flg; if (e.ColumnIndex == 0) { flg = TextFormatFlags.EndEllipsis | TextFormatFlags.VerticalCenter; //flg = TextFormatFlags.WordBreak; //e.Graphics.DrawImage(imageList1.Images[0], e.Bounds.Location.X, e.Bounds.Location.Y); } else if (e.ColumnIndex == 2) { flg = TextFormatFlags.Right; } else { flg = TextFormatFlags.Left; } Color brush; if (ChangedItems.Contains(e.Item.Text)) { e.Graphics.FillRectangle(SystemBrushes.GrayText, e.Bounds); } if (e.ColumnIndex == 0 && listView1.SelectedIndices.Contains(e.ItemIndex)) { //if (e.ColumnIndex == 0) { Rectangle sr = new Rectangle(e.Bounds.Location.X + 16 + 4, e.Bounds.Location.Y, listView1.Columns[e.ColumnIndex].Width - (16 + 4), e.Bounds.Height); e.Graphics.FillRectangle(SystemBrushes.Highlight, sr); //} //Rectangle hr = new Rectangle(e.Bounds.Location, new Size(listView1.Width, e.Bounds.Height)); //e.Graphics.FillRectangle(SystemBrushes.Highlight, hr); brush = SystemColors.HighlightText; } else { if (Items[e.ItemIndex].IsFile) { brush = SystemColors.WindowText; } else { brush = Color.Blue; } } if (e.ColumnIndex == 0) { var item = Items[e.ItemIndex]; var img = item.type == ".exe"?iconcache.Images[item.Name]: IconCache.Inst.getImage(Path.Combine(this.Dir, item.Name), item.type, item.IsFile); if (img != null) { e.Graphics.DrawImage(img, e.Bounds.Location.X, e.Bounds.Location.Y, img.Width, img.Height); } } //Rectangle r = new Rectangle(e.Bounds.Location, new Size(listView1.Columns[e.ColumnIndex].Width, e.Bounds.Height)); int x = e.ColumnIndex == 0 ? e.Bounds.Location.X + 16 + 4 : e.Bounds.Location.X; int w = e.ColumnIndex == 0 ? listView1.Columns[e.ColumnIndex].Width - (16 + 4) : listView1.Columns[e.ColumnIndex].Width; //Rectangle r = new Rectangle(e.Bounds.Location.X+16+2, e.Bounds.Location.Y, listView1.Columns[e.ColumnIndex].Width, e.Bounds.Height); Rectangle r = new Rectangle(x, e.Bounds.Location.Y, w, e.Bounds.Height); TextRenderer.DrawText(e.Graphics, e.SubItem.Text, e.Item.Font, r, brush, flg); //e.DrawFocusRectangle(e.Item.Bounds); //var str = string.Join(" ", Array.ConvertAll(e.SubItem.Text.ToCharArray(), //delegate(Char c) { return c + "\x200c"; })); //TextRenderer.DrawText(e.Graphics, str, e.Item.Font, r, brush, flg); //e.DrawFocusRectangle(e.Item.Bounds); }; //Brush b = new SolidBrush(Color.DarkGray); listView1.DrawColumnHeader += (sender, e) => { if (e.ColumnIndex == sortcolum) { e.DrawBackground(); e.DrawText(TextFormatFlags.VerticalCenter | TextFormatFlags.Left); //e.Graphics.FillRectangle(b, e.Bounds.Left, e.Bounds.Top, 5, 5); if (this.sortOrder == 1) { e.Graphics.FillPolygon(headerBrush, new Point[] { new Point(e.Bounds.Right - 10, e.Bounds.Top + 5), new Point(e.Bounds.Right - 5, e.Bounds.Bottom - 5), new Point(e.Bounds.Right - 15, e.Bounds.Bottom - 5) }); } else if (this.sortOrder == -1) { e.Graphics.FillPolygon(headerBrush, new Point[] { new Point(e.Bounds.Right - 15, e.Bounds.Top + 5), new Point(e.Bounds.Right - 5, e.Bounds.Top + 5), new Point(e.Bounds.Right - 10, e.Bounds.Bottom - 5) }); } } else { e.DrawDefault = true; } }; listView1.ColumnClick += (s, e) => { if (this.sortcolum == e.Column) { this.sortOrder = -1 * this.sortOrder; } else { this.sortOrder = 1; } this.sortcolum = e.Column; //listView.Invalidate(new Rectangle(0, 0, listView.Width, listView.Height-listView.ClientSize.Height), true); switch (e.Column) { case 0: this.sort(SortType.Name, this.sortOrder); break; case 1: this.sort(SortType.Type, this.sortOrder); break; case 2: this.sort(SortType.Size, this.sortOrder); break; case 3: this.sort(SortType.WriteTime, this.sortOrder); break; default: break; } }; //bool res = false; listView1.MouseDown += (s, e) => { var lv = s as ListView; if (e.Button == MouseButtons.Middle || e.Button == MouseButtons.Right) { var item = lv.GetItemAt(e.Location.X, e.Location.Y); if (item != null) { if ((e.Button == MouseButtons.Right && !lv.SelectedIndices.Contains(item.Index)) || e.Button == MouseButtons.Middle) { var indexs = new int[lv.SelectedIndices.Count]; lv.SelectedIndices.CopyTo(indexs, 0); for (int i = 0; i < indexs.Length; i++) { listView1.Items[indexs[i]].Selected = false; } item.Selected = true; } } } }; textBox1.KeyDown += (sender, e) => { if (e.KeyCode == Keys.Return) { Dir = textBox1.Text; } }; CloseLabel.Click += (s, e) => { Close(); }; fileSystemWatcher1.IncludeSubdirectories = false; //fileSystemWatcher1.NotifyFilter = (NotifyFilters.DirectoryName | NotifyFilters.FileName | NotifyFilters.Size); fileSystemWatcher1.SynchronizingObject = this; fileSystemWatcher1.Created += new FileSystemEventHandler(fileSystemWatcher1_Changed); fileSystemWatcher1.Deleted += new FileSystemEventHandler(fileSystemWatcher1_Changed); fileSystemWatcher1.Changed += new FileSystemEventHandler(fileSystemWatcher1_Changed); fileSystemWatcher1.Renamed += (s, e) => { //var index = e.OldFullPath.LastIndexOf("\\"); //var oldname = e.OldFullPath.Substring(index + 1, e.OldFullPath.Length - (index + 1)); var old = Items.First(x => { return(x.Name.Equals(e.OldName)); }); if (old != null) { old.Name = e.Name; var index = Items.IndexOf(old); listView1.RedrawItems(index, index, false); } }; }
private Rectangle GetAdjustedEditingControlBounds(Rectangle editingControlBounds, DataGridViewCellStyle cellStyle) { Debug.Assert(cellStyle.WrapMode != DataGridViewTriState.NotSet); Debug.Assert(this.DataGridView != null); TextBox txtEditingControl = this.DataGridView.EditingControl as TextBox; int originalWidth = editingControlBounds.Width; if (txtEditingControl != null) { switch (cellStyle.Alignment) { case DataGridViewContentAlignment.TopLeft: case DataGridViewContentAlignment.MiddleLeft: case DataGridViewContentAlignment.BottomLeft: // Add 3 pixels on the left of the editing control to match non-editing text position if (this.DataGridView.RightToLeftInternal) { editingControlBounds.X += 1; editingControlBounds.Width = Math.Max(0, editingControlBounds.Width - DATAGRIDVIEWTEXTBOXCELL_horizontalTextOffsetLeft - 2); } else { editingControlBounds.X += DATAGRIDVIEWTEXTBOXCELL_horizontalTextOffsetLeft; editingControlBounds.Width = Math.Max(0, editingControlBounds.Width - DATAGRIDVIEWTEXTBOXCELL_horizontalTextOffsetLeft - 1); } break; case DataGridViewContentAlignment.TopCenter: case DataGridViewContentAlignment.MiddleCenter: case DataGridViewContentAlignment.BottomCenter: editingControlBounds.X += 1; editingControlBounds.Width = Math.Max(0, editingControlBounds.Width - 3); break; case DataGridViewContentAlignment.TopRight: case DataGridViewContentAlignment.MiddleRight: case DataGridViewContentAlignment.BottomRight: // Shorten the editing control by 5 pixels to match non-editing text position if (this.DataGridView.RightToLeftInternal) { editingControlBounds.X += DATAGRIDVIEWTEXTBOXCELL_horizontalTextOffsetRight - 1; editingControlBounds.Width = Math.Max(0, editingControlBounds.Width - DATAGRIDVIEWTEXTBOXCELL_horizontalTextOffsetRight); } else { editingControlBounds.X += 1; editingControlBounds.Width = Math.Max(0, editingControlBounds.Width - DATAGRIDVIEWTEXTBOXCELL_horizontalTextOffsetRight - 1); } break; } switch (cellStyle.Alignment) { case DataGridViewContentAlignment.TopLeft: case DataGridViewContentAlignment.TopCenter: case DataGridViewContentAlignment.TopRight: editingControlBounds.Y += DATAGRIDVIEWTEXTBOXCELL_verticalTextOffsetTop; editingControlBounds.Height = Math.Max(0, editingControlBounds.Height - DATAGRIDVIEWTEXTBOXCELL_verticalTextOffsetTop); break; case DataGridViewContentAlignment.MiddleLeft: case DataGridViewContentAlignment.MiddleCenter: case DataGridViewContentAlignment.MiddleRight: editingControlBounds.Height++; break; case DataGridViewContentAlignment.BottomLeft: case DataGridViewContentAlignment.BottomCenter: case DataGridViewContentAlignment.BottomRight: editingControlBounds.Height = Math.Max(0, editingControlBounds.Height - DATAGRIDVIEWTEXTBOXCELL_verticalTextOffsetBottom); break; } int preferredHeight; if (cellStyle.WrapMode == DataGridViewTriState.False) { preferredHeight = txtEditingControl.PreferredSize.Height; } else { string editedFormattedValue = (string)((IDataGridViewEditingControl)txtEditingControl).GetEditingControlFormattedValue(DataGridViewDataErrorContexts.Formatting); if (string.IsNullOrEmpty(editedFormattedValue)) { editedFormattedValue = " "; } TextFormatFlags flags = DataGridViewUtilities.ComputeTextFormatFlagsForCellStyleAlignment(this.DataGridView.RightToLeftInternal, cellStyle.Alignment, cellStyle.WrapMode); using (Graphics g = WindowsFormsUtils.CreateMeasurementGraphics()) { preferredHeight = DataGridViewCell.MeasureTextHeight(g, editedFormattedValue, cellStyle.Font, originalWidth, flags); } } if (preferredHeight < editingControlBounds.Height) { switch (cellStyle.Alignment) { case DataGridViewContentAlignment.TopLeft: case DataGridViewContentAlignment.TopCenter: case DataGridViewContentAlignment.TopRight: // Single pixel move - leave it as is for now break; case DataGridViewContentAlignment.MiddleLeft: case DataGridViewContentAlignment.MiddleCenter: case DataGridViewContentAlignment.MiddleRight: editingControlBounds.Y += (editingControlBounds.Height - preferredHeight) / 2; break; case DataGridViewContentAlignment.BottomLeft: case DataGridViewContentAlignment.BottomCenter: case DataGridViewContentAlignment.BottomRight: editingControlBounds.Y += editingControlBounds.Height - preferredHeight; break; } } } return(editingControlBounds); }
public int UxThemeDrawThemeText(IntPtr hTheme, IDeviceContext dc, int iPartId, int iStateId, string text, TextFormatFlags textFlags, Rectangle bounds) { XplatUIWin32.RECT BoundsRect = XplatUIWin32.RECT.FromRectangle(bounds); int result = UXTheme.DrawThemeText(hTheme, dc.GetHdc(), iPartId, iStateId, text, text.Length, (uint)textFlags, 0, ref BoundsRect); dc.ReleaseHdc(); return(result); }
public static Size MeasureText(string?text, Font?font, Size proposedSize, TextFormatFlags flags) => MeasureTextInternal(text, font, proposedSize, flags);
protected override void OnDrawSubItem(DrawListViewSubItemEventArgs e) { switch (DrawMode) { case drawMode.Default: base.OnDrawSubItem(e); break; case drawMode.Stylish: base.OnDrawSubItem(e); Graphics g = e.Graphics; g.SmoothingMode = Smoothing; g.TextRenderingHint = TextRendering; TextFormatFlags flags = TextFormatFlags.Left; using (StringFormat sf = new StringFormat()) { // Store the column text alignment, letting it default // to Left if it has not been set to Center or Right. switch (e.Header.TextAlign) { case HorizontalAlignment.Center: sf.Alignment = StringAlignment.Center; flags = TextFormatFlags.HorizontalCenter; break; case HorizontalAlignment.Right: sf.Alignment = StringAlignment.Far; flags = TextFormatFlags.Right; break; } // Draw the text and background for a subitem with a // negative value. double subItemValue; if (e.ColumnIndex > 0 && Double.TryParse( e.SubItem.Text, NumberStyles, NumberFormatInfo.CurrentInfo, out subItemValue) && subItemValue < 0) { // Unless the item is selected, draw the standard // background to make it stand out from the gradient. if ((e.ItemState & ListViewItemStates.Selected) == 0) { e.DrawBackground(); } // Draw the subitem text in red to highlight it. g.DrawString(e.SubItem.Text, Font, new SolidBrush(SubTextColor), e.Bounds, sf); return; } if (ShowCellBorder) { foreach (var items in Items) { e.Graphics.DrawRectangle(CellBorderFocused.GetPen(), new Rectangle(e.Bounds.X + (int)HeaderBorder.GetPen().Width, e.Bounds.Y + (int)HeaderBorder.GetPen().Width, e.Bounds.Width - (2 * (int)HeaderBorder.GetPen().Width), e.Bounds.Height - (2 * (int)HeaderBorder.GetPen().Width))); } } // Draw normal text for a subitem with a nonnegative // or nonnumerical value. e.DrawText(flags); } break; } }
public static Size Measure(string text, Font font, TextFormatFlags flags) { return(TextRenderer.MeasureText(text, font, MaxSize, flags)); }
public void Print(string text, Font font, Color color, Rectangle box, TextFormatFlags flags) { textItems.Add(new TextItem(text, font, color, box, flags)); }
public CalendarRendererBoxEventArgs(CalendarRendererEventArgs original, Rectangle bounds, string text, Color textColour, TextFormatFlags flags) : this(original) { Bounds = bounds; Text = text; TextColour = TextColour; Format |= flags; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Handles the CellPainting event of the dataGridView1 control. /// </summary> /// ------------------------------------------------------------------------------------ protected override void OnCellPainting(DataGridViewCellPaintingEventArgs e) { base.OnCellPainting(e); if (e.Handled || e.RowIndex < 0 || e.ColumnIndex < 0 || m_list == null || m_list.Count == 0 || m_list[e.RowIndex] == null) { return; } e.Handled = true; // Paint everything but the focus rectangle, foreground and background. // I'm not sure what's left, but just in case... DataGridViewPaintParts parts = e.PaintParts; parts &= ~DataGridViewPaintParts.Focus; parts &= ~DataGridViewPaintParts.Background; parts &= ~DataGridViewPaintParts.ContentForeground; e.Paint(e.CellBounds, parts); e.PaintBackground(e.CellBounds, false); IInspectorObject io = m_list[e.RowIndex]; Rectangle rcText = e.CellBounds; Rectangle rcHotSpot = Rectangle.Empty; bool isSelected = ((e.State & DataGridViewElementStates.Selected) > 0); bool isInBlock = (!isSelected && e.RowIndex >= m_firstRowInShadind && e.RowIndex <= m_lastRowInShading); bool isIndentedCell = (e.ColumnIndex == 0); if (isIndentedCell) { // Calculate the location and size of the rectangle into which text will be drawn. // Adjust the text rectangle to account for the +/- image and the proper indent level. rcHotSpot = GetExpandCollapseRect(e.CellBounds, io.Level); int dx = ((rcHotSpot.Right - rcText.X) + 5); rcText.X += dx; rcText.Width -= dx; } // Draw the background color for the cell. using (SolidBrush br = new SolidBrush(DefaultCellStyle.BackColor)) { if (isSelected) { br.Color = DefaultCellStyle.SelectionBackColor; } else if (isInBlock && m_clrShading != Color.Empty) { br.Color = m_clrShading; } e.Graphics.FillRectangle(br, rcText); } Color clrFore = (isSelected ? e.CellStyle.SelectionForeColor : e.CellStyle.ForeColor); TextFormatFlags flags = TextFormatFlags.Left | TextFormatFlags.VerticalCenter | TextFormatFlags.EndEllipsis | TextFormatFlags.SingleLine; TextRenderer.DrawText(e.Graphics, e.FormattedValue as string, e.CellStyle.Font, rcText, clrFore, flags); DrawBorders(e, isIndentedCell, (isInBlock && m_clrShading != Color.Empty ? m_clrShading : GridColor), (isInBlock ? rcText.X: rcHotSpot.X)); if (!isIndentedCell) { return; } DrawTreeLines(e, rcHotSpot, io.Level); if (io.HasChildren) { // Draw the expand or collapse (+/-) image. e.Graphics.DrawImage(m_list.IsExpanded(e.RowIndex) ? Properties.Resources.kimidCollapse : Properties.Resources.kimidExpand, rcHotSpot); } }