c# - पाठ के साथ पारभासी वृत्त



winforms transparency (1)

यह एक मानक Label से प्राप्त एक कस्टम नियंत्रण है, जिसे पारभासी बनाया जा सकता है।
इंटरफ़ेस एक रंगीन सर्कल है जिसमें कुछ संख्याएँ हो सकती हैं।

नियंत्रण इन कस्टम गुणों को उजागर करता है:

Opacity : नियंत्रण की अस्पष्टता का स्तर BackGround [0, 255]
InnerPadding : आंतरिक आयत के बीच की दूरी, जो सर्कल सीमा और नियंत्रण सीमा को परिभाषित करती है।
FontPadding : पाठ और आंतरिक आयत के बीच की दूरी।

CreateParams ओवरराइड करते CreateParams पारदर्शिता प्राप्त की CreateParams , फिर ExStyle |= WS_EX_TRANSPARENT; स्थापना की ExStyle |= WS_EX_TRANSPARENT;

Control.SetStyle() विधि का उपयोग नियंत्रण व्यवहार को संशोधित करने के लिए किया जाता है, इन ControlStyles जोड़ते हुए:

ControlStyles.Opaque के नियंत्रण की पेंटिंग को रोकता है, इसलिए यह सिस्टम द्वारा प्रबंधित नहीं किया जाता है।
ControlStyles.SupportsTransparentBackColor नियंत्रण के लिए अल्फा मान स्वीकार करता है यह BackGround रंग है।

इसे काम पर देखने के लिए, एक नई कक्षा फ़ाइल बनाएँ, इस कोड के साथ अंदर के सभी कोड को नामस्थान को संरक्षित करते हुए प्रोजेक्ट / समाधान का निर्माण करें।
नया कस्टम नियंत्रण टूलबॉक्स में दिखाई देगा।
इसे फॉर्म पर छोड़ें। आवश्यकतानुसार इसके कस्टम गुणों को संशोधित करें।

नियंत्रण का एक दृश्य प्रतिनिधित्व:


जाहिरा तौर पर, ScreenToGif पूर्ण अस्पष्टता पर पिक्सेल परिवर्तन की उपेक्षा करता है।
इसकी राय में कुछ भी नहीं बदलता है, इसलिए यह optimizes कि यह कुछ भी नहीं दिखाएगा।

ध्यान दें:
मैं इसकी गद्दी की वजह से यहाँ TextRenderer का उपयोग नहीं किया। इस संदर्भ में नियंत्रण रखना कठिन है: ऊर्ध्वाधर केंद्र की स्थिति को समायोजित करने की आवश्यकता है और यह किसी भी गुणवत्ता में वृद्धि प्रदान नहीं करता है

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Text;
using System.Globalization;
using System.Windows.Forms;

[DesignerCategory("Code")]
class RoundCenterLabel : Label, INotifyPropertyChanged
{
    internal const int WS_EX_TRANSPARENT = 0x00000020;
    internal Font m_CustomFont = null;
    internal Color m_BackGroundColor;
    internal int m_InnerPadding = 0;
    internal int m_FontPadding = 25;
    internal int m_Opacity = 128;
    private readonly int fontPadding = 8;

    public event PropertyChangedEventHandler PropertyChanged;

    public RoundCenterLabel() => InitializeComponent();

    private void InitializeComponent()
    {
        this.SetStyle(ControlStyles.Opaque |
                      ControlStyles.SupportsTransparentBackColor |
                      ControlStyles.ResizeRedraw, true);
        this.SetStyle(ControlStyles.OptimizedDoubleBuffer, false);
        this.m_CustomFont = new Font("Segoe UI", 50, FontStyle.Regular, GraphicsUnit.Pixel);
        this.BackColor = Color.LimeGreen;
        this.ForeColor = Color.White;
    }

    private void NotifyPropertyChanged(string PropertyName)
    {
        this.Invalidate();
        this.FindForm()?.Refresh();
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(PropertyName));
    }

    public new Font Font
    {
        get => this.m_CustomFont;
        set { this.m_CustomFont = value;
              FontAdapter(value, this.DeviceDpi);
              NotifyPropertyChanged(nameof(this.Font));
        }
    }

    public override string Text {
        get => base.Text;
        set { base.Text = value;
              NotifyPropertyChanged(nameof(this.Text));
        }
    }

    public int InnerPadding {
        get => this.m_InnerPadding;
        set { this.m_InnerPadding = CheckValue(value, 0, this.ClientRectangle.Height - 10);
              NotifyPropertyChanged(nameof(this.InnerPadding)); }
    }

    public int FontPadding {
        get => this.m_FontPadding;
        set { this.m_FontPadding = CheckValue(value, 0, this.ClientRectangle.Height - 10);
              NotifyPropertyChanged(nameof(this.FontPadding));
        }
    }

    public int Opacity {
        get => this.m_Opacity;
        set { this.m_Opacity = CheckValue(value, 0, 255);
              UpdateBackColor(this.m_BackGroundColor);
              NotifyPropertyChanged(nameof(this.Opacity));
        }
    }

    public override Color BackColor {
        get => this.m_BackGroundColor;
        set { UpdateBackColor(value);
              NotifyPropertyChanged(nameof(this.BackColor));
        }
    }

    protected override void OnLayout(LayoutEventArgs e)
    {
        base.OnLayout(e);
        base.AutoSize = false;
    }

    protected override void OnPaint(PaintEventArgs e)
    {
        using (StringFormat format = new StringFormat(StringFormatFlags.LineLimit | StringFormatFlags.NoWrap, CultureInfo.CurrentUICulture.LCID))
        {
            format.LineAlignment = StringAlignment.Center;
            format.Alignment = StringAlignment.Center;

            e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
            e.Graphics.TextRenderingHint = TextRenderingHint.AntiAliasGridFit;
            using (SolidBrush circleBrush = new SolidBrush(this.m_BackGroundColor))
            using (SolidBrush foreBrush = new SolidBrush(this.ForeColor))
            {
                this.FontAdapter(this.m_CustomFont, e.Graphics.DpiY);
                RectangleF rect = InnerRectangle();
                e.Graphics.FillEllipse(circleBrush, rect);
                e.Graphics.DrawString(this.Text, this.m_CustomFont, foreBrush, rect, format);
            };
        };
    }

    private RectangleF InnerRectangle()
    {
        Tuple<float, float> refSize = GetMinMax(this.ClientRectangle.Height, this.ClientRectangle.Width);
        SizeF size = new SizeF(refSize.Item1 - (this.m_InnerPadding / 2), 
                               refSize.Item1 - (this.m_InnerPadding / 2));
        PointF position = new PointF((this.ClientRectangle.Width - size.Width) / 2,
                                     (this.ClientRectangle.Height - size.Height) / 2);
        return new RectangleF(position, size);
    }

    private void FontAdapter(Font font, float Dpi)
    {
        RectangleF rect = InnerRectangle();
        float FontSize = CheckValue((int)(rect.Height - this.m_FontPadding), 6, 
                                    (int)(rect.Height - this.m_FontPadding)) / (Dpi / 72.0F) - fontPadding;
        using (Font customfont = new Font(font.FontFamily, FontSize, font.Style, GraphicsUnit.Pixel))
            this.m_CustomFont = (Font)customfont.Clone();
    }

    private void UpdateBackColor(Color color)
    {
        this.m_BackGroundColor = Color.FromArgb(this.m_Opacity, Color.FromArgb(color.R, color.G, color.B));
        base.BackColor = this.m_BackGroundColor;
    }

    private int CheckValue(int Value, int Min, int Max)
    {
        return (Value < Min) ? Min : ((Value > Max) ? Max : Value);
    }

    private Tuple<float, float> GetMinMax(ValueType Value1, ValueType Value2)
    {
        if ((Value1 is Enum) || (Value1.GetType().IsNested)) return null;
        if ((Value2 is Enum) || (Value2.GetType().IsNested)) return null;
        return new Tuple<float, float>(Math.Min(Convert.ToSingle(Value1), Convert.ToSingle(Value2)),
                                       Math.Max(Convert.ToSingle(Value1), Convert.ToSingle(Value2)));
    }

    protected override CreateParams CreateParams 
    {
        get
        {
            CreateParams parameters = base.CreateParams;
            parameters.ExStyle |= WS_EX_TRANSPARENT;
            return parameters;
        }
    }
}

मैं एक ऐसी परियोजना पर काम कर रहा हूं जिसमें मुझे बीच में पाठ के साथ एक सर्कल जोड़ने की आवश्यकता है। मैं नीचे दिए गए कोड का उपयोग कर रहा हूं। लेकिन मेरी समस्या यह है कि सर्कल बहुत छोटा है, जब मैं इसे आकार देता हूं, तो यह अन्य नियंत्रण को ओवरलैप करता है। मैं सर्कल के समान सर्कल को चौड़ा करना चाहता हूं या बैक ग्राउंड को पारदर्शी कैसे बनाऊंगा?

protected override void OnPaint(PaintEventArgs e)
{
    base.OnPaint(e);

    using (Bitmap bitmap = new Bitmap(this.Width, this.Height))
    {
        using (Graphics graphics = Graphics.FromImage(bitmap))
        {
            graphics.SmoothingMode = SmoothingMode.HighQuality;
            graphics.Clear(this.BackColor);

            using (SolidBrush brush = new SolidBrush(this._FillColor))
            {                      
                graphics.FillEllipse(brush, 0x18 - 6, 0x18 - 6, (this.Width - 0x30) + 12, (this.Height - 0x30) + 12);
            }

            Brush FontColor = new SolidBrush(this.ForeColor);
            SizeF MS = graphics.MeasureString(Convert.ToString(Convert.ToInt32((100 / _Maximum) * _Value)), Font);
            graphics.DrawString(Convert.ToString(Convert.ToInt32((100 / _Maximum) * _Value)), Font, FontColor, Convert.ToInt32((Width / 2 - MS.Width / 2) + 2), Convert.ToInt32((Height / 2 - MS.Height / 2) + 3));
            bitmap.MakeTransparent(this.BackColor);
            e.Graphics.DrawImage(bitmap, 0, 0);

            graphics.Dispose();
            bitmap.Dispose();
        }
    }
}




transparency