Esempio n. 1
0
        protected override void OnPaintBackground(PaintEventArgs e)
        {
            try
            {
                Color backColor = BackColor;

                if (!useCustomBackColor)
                {
                    backColor = WellsMetroPaint.GetStyleColor(Style);
                }

                if (backColor.A == 255)
                {
                    e.Graphics.Clear(backColor);
                    return;
                }

                base.OnPaintBackground(e);

                OnCustomPaintBackground(new WellsMetroPaintEventArgs(backColor, Color.Empty, e.Graphics));
            }
            catch
            {
                Invalidate();
            }
        }
Esempio n. 2
0
        protected virtual void OnPaintForeground(PaintEventArgs e)
        {
            if (useCustomForeColor)
            {
                baseTextBox.ForeColor = ForeColor;
            }
            else
            {
                baseTextBox.ForeColor = WellsMetroPaint.ForeColor.Button.Normal(Theme);
            }

            Color borderColor = WellsMetroPaint.BorderColor.Button.Normal(Theme);

            if (useStyleColors)
            {
                borderColor = WellsMetroPaint.GetStyleColor(Style);
            }

            using (Pen p = new Pen(borderColor))
            {
                e.Graphics.DrawRectangle(p, new Rectangle(0, 0, Width - 1, Height - 1));
            }

            DrawIcon(e.Graphics);
        }
Esempio n. 3
0
 private void DrawTabSelected(int index, Graphics graphics)
 {
     using (Brush selectionBrush = new SolidBrush(WellsMetroPaint.GetStyleColor(Style)))
     {
         Rectangle selectedTabRect = GetTabRect(index);
         Rectangle borderRectangle = new Rectangle(selectedTabRect.X + ((index == 0) ? 2 : 0), GetTabRect(index).Bottom + 2 - TabBottomBorderHeight, selectedTabRect.Width + ((index == 0) ? 0 : 2), TabBottomBorderHeight);
         graphics.FillRectangle(selectionBrush, borderRectangle);
     }
 }
Esempio n. 4
0
        private Size MeasureText(string text)
        {
            Size preferredSize;

            using (Graphics g = CreateGraphics())
            {
                Size proposedSize = new Size(int.MaxValue, int.MaxValue);
                preferredSize = TextRenderer.MeasureText(g, text, WellsMetroFonts.TabControl(metroLabelSize, metroLabelWeight),
                                                         proposedSize,
                                                         WellsMetroPaint.GetTextFormatFlags(TextAlign) |
                                                         TextFormatFlags.NoPadding);
            }
            return(preferredSize);
        }
Esempio n. 5
0
        private void DrawTab(int index, Graphics graphics)
        {
            Color foreColor;
            Color backColor = BackColor;

            if (!useCustomBackColor)
            {
                backColor = WellsMetroPaint.BackColor.Form(Theme);
            }

            TabPage   tabPage = TabPages[index];
            Rectangle tabRect = GetTabRect(index);

            if (!Enabled)
            {
                foreColor = WellsMetroPaint.ForeColor.Label.Disabled(Theme);
            }
            else
            {
                if (useCustomForeColor)
                {
                    foreColor = DefaultForeColor;
                }
                else
                {
                    foreColor = !useStyleColors?WellsMetroPaint.ForeColor.TabControl.Normal(Theme) : WellsMetroPaint.GetStyleColor(Style);
                }
            }

            if (index == 0)
            {
                tabRect.X = DisplayRectangle.X;
            }

            Rectangle bgRect = tabRect;

            tabRect.Width += 20;

            using (Brush bgBrush = new SolidBrush(backColor))
            {
                graphics.FillRectangle(bgBrush, bgRect);
            }

            TextRenderer.DrawText(graphics, tabPage.Text, WellsMetroFonts.TabControl(metroLabelSize, metroLabelWeight),
                                  tabRect, foreColor, backColor, WellsMetroPaint.GetTextFormatFlags(TextAlign));
        }
Esempio n. 6
0
        protected override void OnDrawItem(DrawItemEventArgs e)
        {
            if (e.Index >= 0)
            {
                Color foreColor;
                Color backColor = BackColor;

                if (!useCustomBackColor)
                {
                    backColor = WellsMetroPaint.BackColor.Form(Theme);
                }

                if (e.State == (DrawItemState.NoAccelerator | DrawItemState.NoFocusRect) || e.State == DrawItemState.None)
                {
                    using (SolidBrush b = new SolidBrush(backColor))
                    {
                        e.Graphics.FillRectangle(b, new Rectangle(e.Bounds.Left, e.Bounds.Top, e.Bounds.Width, e.Bounds.Height));
                    }

                    foreColor = WellsMetroPaint.ForeColor.Link.Normal(Theme);
                }
                else
                {
                    using (SolidBrush b = new SolidBrush(WellsMetroPaint.GetStyleColor(Style)))
                    {
                        e.Graphics.FillRectangle(b, new Rectangle(e.Bounds.Left, e.Bounds.Top, e.Bounds.Width, e.Bounds.Height));
                    }

                    foreColor = WellsMetroPaint.ForeColor.Tile.Normal(Theme);
                }

                Rectangle textRect = new Rectangle(0, e.Bounds.Top, e.Bounds.Width, e.Bounds.Height);
                TextRenderer.DrawText(e.Graphics, GetItemText(Items[e.Index]), WellsMetroFonts.ComboBox(metroComboBoxSize, metroComboBoxWeight), textRect, foreColor, TextFormatFlags.Left | TextFormatFlags.VerticalCenter);
            }
            else
            {
                base.OnDrawItem(e);
            }
        }
Esempio n. 7
0
        public override Size GetPreferredSize(Size proposedSize)
        {
            Size preferredSize;

            base.GetPreferredSize(proposedSize);

            using (var g = CreateGraphics())
            {
                proposedSize  = new Size(int.MaxValue, int.MaxValue);
                preferredSize = TextRenderer.MeasureText(g, ProgressPercentText, WellsMetroFonts.ProgressBar(metroLabelSize, metroLabelWeight), proposedSize, WellsMetroPaint.GetTextFormatFlags(TextAlign));
            }

            return(preferredSize);
        }
Esempio n. 8
0
        protected virtual void OnPaintForeground(PaintEventArgs e)
        {
            Color borderColor, foreColor;

            if (useCustomForeColor)
            {
                foreColor = ForeColor;

                if (isHovered && !isPressed && Enabled)
                {
                    borderColor = WellsMetroPaint.BorderColor.CheckBox.Hover(Theme);
                }
                else if (isHovered && isPressed && Enabled)
                {
                    borderColor = WellsMetroPaint.BorderColor.CheckBox.Press(Theme);
                }
                else if (!Enabled)
                {
                    borderColor = WellsMetroPaint.BorderColor.CheckBox.Disabled(Theme);
                }
                else
                {
                    borderColor = WellsMetroPaint.BorderColor.CheckBox.Normal(Theme);
                }
            }
            else
            {
                if (isHovered && !isPressed && Enabled)
                {
                    foreColor   = WellsMetroPaint.ForeColor.CheckBox.Hover(Theme);
                    borderColor = WellsMetroPaint.BorderColor.CheckBox.Hover(Theme);
                }
                else if (isHovered && isPressed && Enabled)
                {
                    foreColor   = WellsMetroPaint.ForeColor.CheckBox.Press(Theme);
                    borderColor = WellsMetroPaint.BorderColor.CheckBox.Press(Theme);
                }
                else if (!Enabled)
                {
                    foreColor   = WellsMetroPaint.ForeColor.CheckBox.Disabled(Theme);
                    borderColor = WellsMetroPaint.BorderColor.CheckBox.Disabled(Theme);
                }
                else
                {
                    foreColor = !useStyleColors?WellsMetroPaint.ForeColor.CheckBox.Normal(Theme) : WellsMetroPaint.GetStyleColor(Style);

                    borderColor = WellsMetroPaint.BorderColor.CheckBox.Normal(Theme);
                }
            }

            using (Pen p = new Pen(borderColor))
            {
                Rectangle boxRect = new Rectangle(0, Height / 2 - 6, 12, 12);
                e.Graphics.DrawRectangle(p, boxRect);
            }

            if (Checked)
            {
                Color fillColor = CheckState == CheckState.Indeterminate ? borderColor : WellsMetroPaint.GetStyleColor(Style);

                using (SolidBrush b = new SolidBrush(fillColor))
                {
                    Rectangle boxRect = new Rectangle(2, Height / 2 - 4, 9, 9);
                    e.Graphics.FillRectangle(b, boxRect);
                }
            }

            Rectangle textRect = new Rectangle(16, 0, Width - 16, Height);

            TextRenderer.DrawText(e.Graphics, Text, WellsMetroFonts.CheckBox(metroCheckBoxSize, metroCheckBoxWeight), textRect, foreColor, WellsMetroPaint.GetTextFormatFlags(TextAlign));

            OnCustomPaintForeground(new WellsMetroPaintEventArgs(Color.Empty, foreColor, e.Graphics));

            if (displayFocusRectangle && isFocused)
            {
                ControlPaint.DrawFocusRectangle(e.Graphics, ClientRectangle);
            }
        }
Esempio n. 9
0
        public override Size GetPreferredSize(Size proposedSize)
        {
            Size preferredSize;

            base.GetPreferredSize(proposedSize);

            using (var g = CreateGraphics())
            {
                proposedSize         = new Size(int.MaxValue, int.MaxValue);
                preferredSize        = TextRenderer.MeasureText(g, Text, WellsMetroFonts.CheckBox(metroCheckBoxSize, metroCheckBoxWeight), proposedSize, WellsMetroPaint.GetTextFormatFlags(TextAlign));
                preferredSize.Width += 16;
            }

            return(preferredSize);
        }
Esempio n. 10
0
        protected virtual void OnPaintForeground(PaintEventArgs e)
        {
            Color foreColor;

            if (isHovered && !isPressed && Enabled)
            {
                foreColor = WellsMetroPaint.ForeColor.Tile.Hover(Theme);
            }
            else if (isHovered && isPressed && Enabled)
            {
                foreColor = WellsMetroPaint.ForeColor.Tile.Press(Theme);
            }
            else if (!Enabled)
            {
                foreColor = WellsMetroPaint.ForeColor.Tile.Disabled(Theme);
            }
            else
            {
                foreColor = WellsMetroPaint.ForeColor.Tile.Normal(Theme);
            }

            if (useCustomForeColor)
            {
                foreColor = ForeColor;
            }

            if (isPressed)
            {
            }

            e.Graphics.SmoothingMode      = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
            e.Graphics.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;

            if (useTileImage)
            {
                if (tileImage != null)
                {
                    Rectangle imageRectangle;
                    switch (tileImageAlign)
                    {
                    case ContentAlignment.BottomLeft:
                        imageRectangle = new Rectangle(new Point(0, Height - TileImage.Height), new System.Drawing.Size(TileImage.Width, TileImage.Height));
                        break;

                    case ContentAlignment.BottomCenter:
                        imageRectangle = new Rectangle(new Point(Width / 2 - TileImage.Width / 2, Height - TileImage.Height), new System.Drawing.Size(TileImage.Width, TileImage.Height));
                        break;

                    case ContentAlignment.BottomRight:
                        imageRectangle = new Rectangle(new Point(Width - TileImage.Width, Height - TileImage.Height), new System.Drawing.Size(TileImage.Width, TileImage.Height));
                        break;

                    case ContentAlignment.MiddleLeft:
                        imageRectangle = new Rectangle(new Point(0, Height / 2 - TileImage.Height / 2), new System.Drawing.Size(TileImage.Width, TileImage.Height));
                        break;

                    case ContentAlignment.MiddleCenter:
                        imageRectangle = new Rectangle(new Point(Width / 2 - TileImage.Width / 2, Height / 2 - TileImage.Height / 2), new System.Drawing.Size(TileImage.Width, TileImage.Height));
                        break;

                    case ContentAlignment.MiddleRight:
                        imageRectangle = new Rectangle(new Point(Width - TileImage.Width, Height / 2 - TileImage.Height / 2), new System.Drawing.Size(TileImage.Width, TileImage.Height));
                        break;

                    case ContentAlignment.TopLeft:
                        imageRectangle = new Rectangle(new Point(0, 0), new System.Drawing.Size(TileImage.Width, TileImage.Height));
                        break;

                    case ContentAlignment.TopCenter:
                        imageRectangle = new Rectangle(new Point(Width / 2 - TileImage.Width / 2, 0), new System.Drawing.Size(TileImage.Width, TileImage.Height));
                        break;

                    case ContentAlignment.TopRight:
                        imageRectangle = new Rectangle(new Point(Width - TileImage.Width, 0), new System.Drawing.Size(TileImage.Width, TileImage.Height));
                        break;

                    default:
                        imageRectangle = new Rectangle(new Point(0, 0), new System.Drawing.Size(TileImage.Width, TileImage.Height));
                        break;
                    }

                    e.Graphics.DrawImage(TileImage, imageRectangle);
                }
            }

            if (TileCount > 0 && paintTileCount)
            {
                Size countSize = TextRenderer.MeasureText(TileCount.ToString(), WellsMetroFonts.TileCount);

                e.Graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
                TextRenderer.DrawText(e.Graphics, TileCount.ToString(), WellsMetroFonts.TileCount, new Point(Width - countSize.Width, 0), foreColor);
                e.Graphics.TextRenderingHint = System.Drawing.Text.TextRenderingHint.SystemDefault;
            }

            Size textSize = TextRenderer.MeasureText(Text, WellsMetroFonts.Tile(tileTextFontSize, tileTextFontWeight));

            TextFormatFlags flags         = WellsMetroPaint.GetTextFormatFlags(TextAlign) | TextFormatFlags.LeftAndRightPadding | TextFormatFlags.EndEllipsis;
            Rectangle       textRectangle = ClientRectangle;

            if (isPressed)
            {
                textRectangle.Inflate(-2, -2);
            }

            TextRenderer.DrawText(e.Graphics, Text, WellsMetroFonts.Tile(tileTextFontSize, tileTextFontWeight), textRectangle, foreColor, flags);

            if (false && isFocused)
            {
                ControlPaint.DrawFocusRectangle(e.Graphics, ClientRectangle);
            }
        }
Esempio n. 11
0
        protected virtual void OnPaintForeground(PaintEventArgs e)
        {
            Color foreColor;

            if (useCustomForeColor)
            {
                foreColor = ForeColor;
            }
            else
            {
                if (!Enabled)
                {
                    if (Parent != null)
                    {
                        if (Parent is WellsMetroTile)
                        {
                            foreColor = WellsMetroPaint.ForeColor.Tile.Disabled(Theme);
                        }
                        else
                        {
                            foreColor = WellsMetroPaint.ForeColor.Label.Normal(Theme);
                        }
                    }
                    else
                    {
                        foreColor = WellsMetroPaint.ForeColor.Label.Disabled(Theme);
                    }
                }
                else
                {
                    if (Parent != null)
                    {
                        if (Parent is WellsMetroTile)
                        {
                            foreColor = WellsMetroPaint.ForeColor.Tile.Normal(Theme);
                        }
                        else
                        {
                            if (useStyleColors)
                            {
                                foreColor = WellsMetroPaint.GetStyleColor(Style);
                            }
                            else
                            {
                                foreColor = WellsMetroPaint.ForeColor.Label.Normal(Theme);
                            }
                        }
                    }
                    else
                    {
                        if (useStyleColors)
                        {
                            foreColor = WellsMetroPaint.GetStyleColor(Style);
                        }
                        else
                        {
                            foreColor = WellsMetroPaint.ForeColor.Label.Normal(Theme);
                        }
                    }
                }
            }

            if (LabelMode == WellsMetroLabelMode.Selectable)
            {
                CreateBaseTextBox();
                UpdateBaseTextBox();

                if (!baseTextBox.Visible)
                {
                    TextRenderer.DrawText(e.Graphics, Text, WellsMetroFonts.Label(metroLabelSize, metroLabelWeight), ClientRectangle, foreColor, WellsMetroPaint.GetTextFormatFlags(TextAlign));
                }
            }
            else
            {
                DestroyBaseTextbox();
                TextRenderer.DrawText(e.Graphics, Text, WellsMetroFonts.Label(metroLabelSize, metroLabelWeight), ClientRectangle, foreColor, WellsMetroPaint.GetTextFormatFlags(TextAlign, wrapToLine));
                OnCustomPaintForeground(new WellsMetroPaintEventArgs(Color.Empty, foreColor, e.Graphics));
            }
        }
Esempio n. 12
0
        protected virtual void OnPaintForeground(PaintEventArgs e)
        {
            Color foreColor;

            if (useCustomForeColor)
            {
                foreColor = ForeColor;
            }
            else
            {
                if (isHovered && !isPressed && Enabled)
                {
                    foreColor = WellsMetroPaint.ForeColor.Link.Hover(Theme);
                }
                else if (isHovered && isPressed && Enabled)
                {
                    foreColor = WellsMetroPaint.ForeColor.Link.Press(Theme);
                }
                else if (!Enabled)
                {
                    foreColor = WellsMetroPaint.ForeColor.Link.Disabled(Theme);
                }
                else
                {
                    foreColor = !useStyleColors?WellsMetroPaint.ForeColor.Link.Normal(Theme) : WellsMetroPaint.GetStyleColor(Style);
                }
            }

            TextRenderer.DrawText(e.Graphics, Text, WellsMetroFonts.Link(metroLinkSize, metroLinkWeight), ClientRectangle, foreColor, WellsMetroPaint.GetTextFormatFlags(TextAlign));

            OnCustomPaintForeground(new WellsMetroPaintEventArgs(Color.Empty, foreColor, e.Graphics));

            if (displayFocusRectangle && isFocused)
            {
                ControlPaint.DrawFocusRectangle(e.Graphics, ClientRectangle);
            }
        }
Esempio n. 13
0
        protected virtual void OnPaintForeground(PaintEventArgs e)
        {
            Color borderColor, foreColor;

            if (isHovered && !isPressed && Enabled)
            {
                borderColor = WellsMetroPaint.BorderColor.Button.Hover(Theme);
                foreColor   = WellsMetroPaint.ForeColor.Button.Hover(Theme);
            }
            else if (isHovered && isPressed && Enabled)
            {
                borderColor = WellsMetroPaint.BorderColor.Button.Press(Theme);
                foreColor   = WellsMetroPaint.ForeColor.Button.Press(Theme);
            }
            else if (!Enabled)
            {
                borderColor = WellsMetroPaint.BorderColor.Button.Disabled(Theme);
                foreColor   = WellsMetroPaint.ForeColor.Button.Disabled(Theme);
            }
            else
            {
                borderColor = WellsMetroPaint.BorderColor.Button.Normal(Theme);
                if (useCustomForeColor)
                {
                    foreColor = ForeColor;
                }
                else if (useStyleColors)
                {
                    foreColor = WellsMetroPaint.GetStyleColor(Style);
                }
                else
                {
                    foreColor = WellsMetroPaint.ForeColor.Button.Normal(Theme);
                }
            }

            using (Pen p = new Pen(borderColor))
            {
                Rectangle borderRect = new Rectangle(0, 0, Width - 1, Height - 1);
                e.Graphics.DrawRectangle(p, borderRect);
            }

            if (Highlight && !isHovered && !isPressed && Enabled)
            {
                using (Pen p = WellsMetroPaint.GetStylePen(Style))
                {
                    Rectangle borderRect = new Rectangle(0, 0, Width - 1, Height - 1);
                    e.Graphics.DrawRectangle(p, borderRect);
                    borderRect = new Rectangle(1, 1, Width - 3, Height - 3);
                    e.Graphics.DrawRectangle(p, borderRect);
                }
            }

            TextRenderer.DrawText(e.Graphics, Text, WellsMetroFonts.Button(metroButtonSize, metroButtonWeight), ClientRectangle, foreColor, WellsMetroPaint.GetTextFormatFlags(TextAlign));

            OnCustomPaintForeground(new WellsMetroPaintEventArgs(Color.Empty, foreColor, e.Graphics));

            if (displayFocusRectangle && isFocused)
            {
                ControlPaint.DrawFocusRectangle(e.Graphics, ClientRectangle);
            }
        }
Esempio n. 14
0
        protected virtual void OnPaintForeground(PaintEventArgs e)
        {
            Color foreColor;

            if (useCustomBackground)
            {
                foreColor = WellsMetroPaint.GetStyleColor(Style);
            }
            else
            {
                if (Parent is WellsMetroTile)
                {
                    foreColor = WellsMetroPaint.ForeColor.Tile.Normal(Theme);
                }
                else
                {
                    foreColor = WellsMetroPaint.GetStyleColor(Style);
                }
            }

            using (Pen forePen = new Pen(foreColor, (float)Width / 5))
            {
                int padding = (int)Math.Ceiling((float)Width / 10);

                e.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;

                if (progress != -1)
                {
                    float sweepAngle;
                    float progFrac = (float)(progress - minimum) / (float)(maximum - minimum);

                    if (ensureVisible)
                    {
                        sweepAngle = 30 + 300f * progFrac;
                    }
                    else
                    {
                        sweepAngle = 360f * progFrac;
                    }

                    if (backwards)
                    {
                        sweepAngle = -sweepAngle;
                    }

                    e.Graphics.DrawArc(forePen, padding, padding, Width - 2 * padding - 1, Height - 2 * padding - 1, angle, sweepAngle);
                }
                else
                {
                    const int maxOffset = 180;
                    for (int offset = 0; offset <= maxOffset; offset += 15)
                    {
                        int alpha = 290 - (offset * 290 / maxOffset);

                        if (alpha > 255)
                        {
                            alpha = 255;
                        }
                        if (alpha < 0)
                        {
                            alpha = 0;
                        }

                        Color col = Color.FromArgb(alpha, forePen.Color);
                        using (Pen gradPen = new Pen(col, forePen.Width))
                        {
                            float startAngle = angle + (offset - (ensureVisible ? 30 : 0)) * (backwards ? 1 : -1);
                            float sweepAngle = 15 * (backwards ? 1 : -1);
                            e.Graphics.DrawArc(gradPen, padding, padding, Width - 2 * padding - 1, Height - 2 * padding - 1, startAngle, sweepAngle);
                        }
                    }
                }
            }

            OnCustomPaintForeground(new WellsMetroPaintEventArgs(Color.Empty, foreColor, e.Graphics));
        }
Esempio n. 15
0
        protected virtual void OnPaintForeground(PaintEventArgs e)
        {
            Color borderColor, foreColor;

            if (isHovered && !isPressed && Enabled)
            {
                foreColor   = WellsMetroPaint.ForeColor.CheckBox.Hover(Theme);
                borderColor = WellsMetroPaint.BorderColor.CheckBox.Hover(Theme);
            }
            else if (isHovered && isPressed && Enabled)
            {
                foreColor   = WellsMetroPaint.ForeColor.CheckBox.Press(Theme);
                borderColor = WellsMetroPaint.BorderColor.CheckBox.Press(Theme);
            }
            else if (!Enabled)
            {
                foreColor   = WellsMetroPaint.ForeColor.CheckBox.Disabled(Theme);
                borderColor = WellsMetroPaint.BorderColor.CheckBox.Disabled(Theme);
            }
            else
            {
                foreColor = !useStyleColors?WellsMetroPaint.ForeColor.CheckBox.Normal(Theme) : WellsMetroPaint.GetStyleColor(Style);

                borderColor = WellsMetroPaint.BorderColor.CheckBox.Normal(Theme);
            }

            using (Pen p = new Pen(borderColor))
            {
                Rectangle boxRect = new Rectangle((DisplayStatus ? 30 : 0), 0, ClientRectangle.Width - (DisplayStatus ? 31 : 1), ClientRectangle.Height - 1);
                e.Graphics.DrawRectangle(p, boxRect);
            }

            Color fillColor = Checked ? WellsMetroPaint.GetStyleColor(Style) : WellsMetroPaint.BorderColor.CheckBox.Normal(Theme);

            using (SolidBrush b = new SolidBrush(fillColor))
            {
                Rectangle boxRect = new Rectangle(DisplayStatus ? 32 : 2, 2, ClientRectangle.Width - (DisplayStatus ? 34 : 4), ClientRectangle.Height - 4);
                e.Graphics.FillRectangle(b, boxRect);
            }

            Color backColor = BackColor;

            if (!useCustomBackColor)
            {
                backColor = WellsMetroPaint.BackColor.Form(Theme);
            }

            using (SolidBrush b = new SolidBrush(backColor))
            {
                int left = Checked ? Width - 11 : (DisplayStatus ? 30 : 0);

                Rectangle boxRect = new Rectangle(left, 0, 11, ClientRectangle.Height);
                e.Graphics.FillRectangle(b, boxRect);
            }
            using (SolidBrush b = new SolidBrush(WellsMetroPaint.BorderColor.CheckBox.Hover(Theme)))
            {
                int left = Checked ? Width - 10 : (DisplayStatus ? 30 : 0);

                Rectangle boxRect = new Rectangle(left, 0, 10, ClientRectangle.Height);
                e.Graphics.FillRectangle(b, boxRect);
            }

            if (DisplayStatus)
            {
                Rectangle textRect = new Rectangle(0, 0, 30, ClientRectangle.Height);
                TextRenderer.DrawText(e.Graphics, Text, WellsMetroFonts.Link(metroLinkSize, metroLinkWeight), textRect, foreColor, WellsMetroPaint.GetTextFormatFlags(TextAlign));
            }

            if (displayFocusRectangle && isFocused)
            {
                ControlPaint.DrawFocusRectangle(e.Graphics, ClientRectangle);
            }
        }
Esempio n. 16
0
        private void DrawProgressText(Graphics graphics)
        {
            if (HideProgressText)
            {
                return;
            }

            Color foreColor;

            if (!Enabled)
            {
                foreColor = WellsMetroPaint.ForeColor.ProgressBar.Disabled(Theme);
            }
            else
            {
                foreColor = WellsMetroPaint.ForeColor.ProgressBar.Normal(Theme);
            }

            TextRenderer.DrawText(graphics, ProgressPercentText, WellsMetroFonts.ProgressBar(metroLabelSize, metroLabelWeight), ClientRectangle, foreColor, WellsMetroPaint.GetTextFormatFlags(TextAlign));
        }
Esempio n. 17
0
 private void DrawProgressMarquee(Graphics graphics)
 {
     graphics.FillRectangle(WellsMetroPaint.GetStyleBrush(Style), marqueeX, 0, ProgressBarMarqueeWidth, ClientRectangle.Height);
 }
Esempio n. 18
0
 private void DrawProgressContinuous(Graphics graphics)
 {
     graphics.FillRectangle(WellsMetroPaint.GetStyleBrush(Style), 0, 0, (int)ProgressBarWidth, ClientRectangle.Height);
 }
Esempio n. 19
0
        private void UpdateBaseTextBox()
        {
            if (!baseTextBox.Visible)
            {
                return;
            }

            SuspendLayout();
            baseTextBox.SuspendLayout();

            if (useCustomBackColor)
            {
                baseTextBox.BackColor = BackColor;
            }
            else
            {
                baseTextBox.BackColor = WellsMetroPaint.BackColor.Form(Theme);
            }

            if (!Enabled)
            {
                if (Parent != null)
                {
                    if (Parent is WellsMetroTile)
                    {
                        baseTextBox.ForeColor = WellsMetroPaint.ForeColor.Tile.Disabled(Theme);
                    }
                    else
                    {
                        if (useStyleColors)
                        {
                            baseTextBox.ForeColor = WellsMetroPaint.GetStyleColor(Style);
                        }
                        else
                        {
                            baseTextBox.ForeColor = WellsMetroPaint.ForeColor.Label.Disabled(Theme);
                        }
                    }
                }
                else
                {
                    if (useStyleColors)
                    {
                        baseTextBox.ForeColor = WellsMetroPaint.GetStyleColor(Style);
                    }
                    else
                    {
                        baseTextBox.ForeColor = WellsMetroPaint.ForeColor.Label.Disabled(Theme);
                    }
                }
            }
            else
            {
                if (Parent != null)
                {
                    if (Parent is WellsMetroTile)
                    {
                        baseTextBox.ForeColor = WellsMetroPaint.ForeColor.Tile.Normal(Theme);
                    }
                    else
                    {
                        if (useStyleColors)
                        {
                            baseTextBox.ForeColor = WellsMetroPaint.GetStyleColor(Style);
                        }
                        else
                        {
                            baseTextBox.ForeColor = WellsMetroPaint.ForeColor.Label.Normal(Theme);
                        }
                    }
                }
                else
                {
                    if (useStyleColors)
                    {
                        baseTextBox.ForeColor = WellsMetroPaint.GetStyleColor(Style);
                    }
                    else
                    {
                        baseTextBox.ForeColor = WellsMetroPaint.ForeColor.Label.Normal(Theme);
                    }
                }
            }

            baseTextBox.Font        = WellsMetroFonts.Label(metroLabelSize, metroLabelWeight);
            baseTextBox.Text        = Text;
            baseTextBox.BorderStyle = BorderStyle.None;

            Size = GetPreferredSize(Size.Empty);

            baseTextBox.ResumeLayout();
            ResumeLayout();
        }