Beispiel #1
0
        private void RenderSysMenuIcon(
            Rectangle rcMenuIcon,
            Graphics g)
        {
            using (GraphicsPath XMenuIconPath = BuildMenuIconShape(ref rcMenuIcon))
            {
                FillMenuIconGradient(XMenuIconPath, g, m_MenuIconMix);

                using (XAntiAlias xaa = new XAntiAlias(g))
                {
                    DrawInnerMenuIconBorder(rcMenuIcon, g, m_clrMenuIconBorderInner);
                    g.DrawPath(
                        new Pen(m_clrMenuIconBorderOuter),
                        XMenuIconPath
                        );
                }
            }

            #region Draw icon
            if (m_MenuIcon != null)
            {
                int lH = m_MenuIcon.Height;
                int lW = m_MenuIcon.Width;

                Rectangle rcImage = new Rectangle((rcMenuIcon.Right - rcMenuIcon.Width / 2) - lW / 2 - 2, (rcMenuIcon.Bottom - rcMenuIcon.Height / 2) - lH / 2, lW, lH);
                g.DrawImage(
                    m_MenuIcon,
                    rcImage
                    );
            }
            #endregion
        }
Beispiel #2
0
        /// <summary>
        /// Main rendering method.
        /// </summary>
        /// <param name="rcBorder"> Border bounds</param>
        /// <param name="g"> Graphics object</param>
        public void Render(
            Rectangle rcBorder,
            Graphics g

            )
        {
            GraphicsPath XBorderPath = new GraphicsPath();

            switch (m_eBorderStyle)
            {
            case XBorderStyle.X3D:
                switch (m_eBorderType)
                {
                case XBorderType.Rectangular:
                    using (XAntiAlias xaa = new XAntiAlias(g))
                    {
                        DrawBorderLine(g, XBorderPath, rcBorder, 0, false);
                    }
                    break;

                case XBorderType.Rounded:
                    DrawBorderLine(g, XBorderPath, rcBorder, m_lRadius, false);
                    break;

                case XBorderType.Inclinated:
                    DrawBorderLine(g, XBorderPath, rcBorder, 0, false);
                    break;
                }
                break;

            case XBorderStyle.Flat:
                switch (m_eBorderType)
                {
                case XBorderType.Rectangular:
                    using (XAntiAlias xaa = new XAntiAlias(g))
                    {
                        DrawBorderLine(g, XBorderPath, rcBorder, 0, true);
                    }
                    break;

                case XBorderType.Rounded:
                    DrawBorderLine(g, XBorderPath, rcBorder, m_lRadius, true);
                    break;

                case XBorderType.Inclinated:
                    DrawBorderLine(g, XBorderPath, rcBorder, 0, false);
                    break;
                }
                break;
            }
        }
Beispiel #3
0
        private void DrawStatusGlow(
            Rectangle rect,
            Graphics g,
            Color clrGlowColor
            )
        {
            Rectangle rcGlow = rect;

            using (LinearGradientBrush lgbGlow = new LinearGradientBrush(
                       rcGlow,
                       Color.FromArgb(30, clrGlowColor),
                       Color.FromArgb(150, clrGlowColor),
                       LinearGradientMode.Vertical))
            {
                if (m_bEllipticalGlow)
                {
                    g.SetClip(rect);
                    using (XAntiAlias xaa = new XAntiAlias(g))
                    {
                        using (GraphicsPath XEllipseGlow = new GraphicsPath())
                        {
                            XEllipseGlow.AddEllipse(
                                rect.Left - 5,
                                rect.Top - rect.Height / 2,
                                rect.Width + 10,
                                rect.Height);

                            g.FillPath(
                                lgbGlow,
                                XEllipseGlow
                                );
                        }
                    }
                    g.ResetClip();
                }
                else
                {
                    rcGlow.Height = 5;
                    g.FillRectangle(
                        lgbGlow,
                        rcGlow
                        );
                }
            }
        }
Beispiel #4
0
        private void FillMenuIconGradient(
            GraphicsPath XFillPath,
            Graphics g,
            List <Color> mix
            )
        {
            using (XAntiAlias xaa = new XAntiAlias(g))
            {
                using (LinearGradientBrush lgb = new LinearGradientBrush
                                                     (XFillPath.GetBounds(),
                                                     mix[0],
                                                     mix[4],
                                                     LinearGradientMode.Vertical))
                {
                    lgb.InterpolationColors = XCoolFormHelper.ColorMix(mix, false);

                    g.FillPath(
                        lgb,
                        XFillPath
                        );
                }
            }
        }
        private void FillMenuIconGradient(
            GraphicsPath XFillPath,
            Graphics g,
            List<Color> mix
            )
        {


            using (XAntiAlias xaa = new XAntiAlias(g))
            {
                using (LinearGradientBrush lgb = new LinearGradientBrush
                    (XFillPath.GetBounds(),
                     mix[0],
                     mix[4],
                     LinearGradientMode.Vertical))
                {
                   
                    lgb.InterpolationColors = XCoolFormHelper.ColorMix(mix, false);
                    
                    g.FillPath(
                      lgb,
                      XFillPath
                    );

                }
            }
            
            
        
        }
        private void RenderSysMenuIcon(
            Rectangle rcMenuIcon,
            Graphics g)
        {
            using (GraphicsPath XMenuIconPath = BuildMenuIconShape(ref rcMenuIcon))
            {


                FillMenuIconGradient(XMenuIconPath, g, m_MenuIconMix);

                using (XAntiAlias xaa = new XAntiAlias(g))
                {
                    DrawInnerMenuIconBorder(rcMenuIcon, g, m_clrMenuIconBorderInner);
                    g.DrawPath(
                     new Pen(m_clrMenuIconBorderOuter),
                      XMenuIconPath
                     );
                    
                }

            }

            #region Draw icon
            if (m_MenuIcon != null) {
                int lH = m_MenuIcon.Height;
                int lW = m_MenuIcon.Width;

                Rectangle rcImage = new Rectangle((rcMenuIcon.Right - rcMenuIcon.Width / 2) - lW / 2 - 2, (rcMenuIcon.Bottom - rcMenuIcon.Height / 2) - lH / 2, lW, lH);
                g.DrawImage(
                  m_MenuIcon,
                  rcImage
                );
            }
            #endregion
        }
        /// <summary>
        /// Fills titlebar button.
        /// </summary>
        /// <param name="rcBtn"> Button bounding rectangle.</param>
        /// <param name="g"> Graphics object.</param>
        /// <param name="clrStart"> Color used to fill the button.</param>
        /// <param name="clrEnd"> Color used to fill the outer glow.</param>
        /// <param name="XBoxClip"> Path to perform clipping tasks.</param>
        private void FillButton(
         Rectangle rcBtn,
         Graphics g,
         Color clrStart,
         Color clrEnd,
         GraphicsPath XBoxClip
         )
        {



            switch (m_eFillMode)
            {
                case XButtonFillMode.UpperGlow:
                    rcBtn.Height = 3;
                    using (LinearGradientBrush lgb = new LinearGradientBrush(
                             rcBtn,
                             clrStart,
                             clrEnd,
                             LinearGradientMode.Vertical))
                    {
                        
                        g.FillRectangle(
                          lgb,
                          rcBtn
                        );

                    }
                    break;
                case XButtonFillMode.FullFill:
                    // restrict drawing inside button box / rectangle:
                    g.SetClip(XBoxClip);
                    g.SetClip(rcBtn, CombineMode.Intersect);
                    
                    #region Fill button
                    using (SolidBrush sb = new SolidBrush(clrStart))
                    {
                        
                        g.FillRectangle(
                          sb,
                          rcBtn
                          );
                    }
                    #endregion

                    using (XAntiAlias xaa = new XAntiAlias(g))
                    {
                        #region Fill shine
                        using (GraphicsPath XBtnGlow = new GraphicsPath())
                        {
                            XBtnGlow.AddEllipse(rcBtn.Left - 5, rcBtn.Bottom - rcBtn.Height / 2 + 3, rcBtn.Width + 11, rcBtn.Height + 11);
                            using (PathGradientBrush pgb = new PathGradientBrush(XBtnGlow))
                            {
                                pgb.CenterColor = Color.FromArgb(235, Color.White);
                                pgb.SurroundColors = new Color[] { Color.FromArgb(0, clrEnd) };
                                pgb.SetSigmaBellShape(0.8f);

                                g.FillPath(
                                  pgb,
                                  XBtnGlow
                                );

                            }
                        }
                        #endregion

                        #region Fill upper glow
                        rcBtn.Height = rcBtn.Height / 2 - 2;
                        using (LinearGradientBrush lgb = new LinearGradientBrush(
                                 rcBtn,
                                 Color.FromArgb(80, Color.White),
                                 Color.FromArgb(140, Color.White),
                                 LinearGradientMode.Vertical))
                        {
                            using (GraphicsPath XGlowPath = XCoolFormHelper.RoundRect((RectangleF)rcBtn, 0, 0, 4, 4))
                            {
                                lgb.WrapMode = WrapMode.TileFlipXY;
                                g.FillPath(
                                  lgb,
                                  XGlowPath
                                );

                            }

                        }
                        #endregion

                        
                    }
                    // reset clipping back:
                    g.ResetClip();
                    break;


            }
            
        }
Beispiel #8
0
        public void RenderTitleBarButtonsBox(
            Rectangle rcBox,
            Graphics g,
            int lSinglePosX,
            int lSinglePosY
            )
        {
            using (XAntiAlias xaa = new XAntiAlias(g))
            {
                int lBtnWidth  = 0;
                int lBtnHeight = 0;
                foreach (XTitleBarButton btn in m_xtbButtons)
                {
                    if (btn.ButtonStyle == XTitleBarButton.XTitleBarButtonStyle.MacStyle)
                    {
                        m_bShouldRenderButtonBox = false;
                    }

                    lBtnWidth  = btn.XButtonWidth;
                    lBtnHeight = btn.XButtonHeight;
                }
                int lX = rcBox.Right - lBtnWidth;
                int lY = rcBox.Bottom - lBtnHeight;

                if (m_bShouldRenderButtonBox)
                {
                    using (GraphicsPath XButtonBox = BuildTitleBarButtonsBox(rcBox))
                    {
                        switch (m_eButtonBoxFill)
                        {
                        case XButtonBoxFill.ColorMix:
                            using (LinearGradientBrush lgb = new LinearGradientBrush(
                                       rcBox,
                                       m_ButtonBoxColors[0],
                                       m_ButtonBoxColors[4],
                                       LinearGradientMode.Vertical))
                            {
                                lgb.InterpolationColors = XCoolFormHelper.ColorMix
                                                          (
                                    m_ButtonBoxColors,
                                    false
                                                          );

                                g.FillPath(
                                    lgb,
                                    XButtonBox
                                    );
                            }
                            break;

                        case XButtonBoxFill.TitleBarRectangleRendering:
                            RectangleF rcDownRect = XButtonBox.GetBounds();
                            RectangleF rcUpRect   = XButtonBox.GetBounds();
                            g.SetClip(XButtonBox);
                            rcUpRect.Height /= 2;
                            using (LinearGradientBrush lgbUpperRect = new LinearGradientBrush(
                                       rcUpRect,
                                       m_clrUpperFillStart,
                                       m_clrUpperFillEnd,
                                       LinearGradientMode.Vertical
                                       ))
                            {
                                lgbUpperRect.WrapMode = WrapMode.TileFlipY;
                                g.FillRectangle(
                                    lgbUpperRect,
                                    rcUpRect
                                    );
                            }

                            rcDownRect.Height = rcDownRect.Height / 2;
                            rcDownRect.Y      = rcUpRect.Bottom;
                            using (LinearGradientBrush lgbDwnRect = new LinearGradientBrush(
                                       rcDownRect,
                                       m_clrFillStart,
                                       m_clrFillEnd,
                                       LinearGradientMode.Vertical
                                       ))
                            {
                                g.FillRectangle(
                                    lgbDwnRect,
                                    rcDownRect
                                    );
                            }

                            g.ResetClip();
                            break;
                        }


                        #region Draw button separators
                        g.DrawLine(
                            new Pen(m_clrButtonBoxOuter),
                            rcBox.Right - lBtnWidth,
                            rcBox.Bottom,
                            rcBox.Right - lBtnWidth,
                            rcBox.Top + 1);
                        g.DrawLine(
                            new Pen(m_clrButtonBoxInner),
                            rcBox.Right - lBtnWidth - 1,
                            rcBox.Bottom,
                            rcBox.Right - lBtnWidth - 1,
                            rcBox.Top + 1);
                        g.DrawLine(
                            new Pen(m_clrButtonBoxOuter),
                            rcBox.Right - lBtnWidth * 2,
                            rcBox.Bottom - 2,
                            rcBox.Right - lBtnWidth * 2,
                            rcBox.Top + 1);
                        g.DrawLine(
                            new Pen(m_clrButtonBoxInner),
                            rcBox.Right - lBtnWidth * 2 - 1,
                            rcBox.Bottom - 2,
                            rcBox.Right - lBtnWidth * 2 - 1,
                            rcBox.Top + 1);
                        #endregion

                        #region Render buttons
                        g.SetClip(XButtonBox);
                        foreach (XTitleBarButton btn in m_xtbButtons)
                        {
                            btn.XButtonLeft = lX;
                            btn.XButtonTop  = lY;

                            btn.RenderTitleBarButton(
                                btn.XButtonLeft,
                                btn.XButtonTop,
                                g,
                                XButtonBox
                                );
                            lX -= btn.XButtonWidth + 1;
                        }
                        g.ResetClip();
                        #endregion


                        g.DrawPath(
                            new Pen(m_clrButtonBoxOuter),
                            XButtonBox
                            );

                        DrawInnerTitleBarBoxBorder(g, rcBox, m_clrButtonBoxInner);
                    }
                }
                else
                {
                    int lSP = lSinglePosX;
                    foreach (XTitleBarButton btn in m_xtbButtons)
                    {
                        btn.XButtonHeight = 13;
                        btn.XButtonWidth  = 13;
                        btn.XButtonLeft   = lSP;
                        btn.XButtonTop    = lSinglePosY;

                        btn.RenderTitleBarButton(
                            btn.XButtonLeft,
                            btn.XButtonTop,
                            g,
                            null
                            );
                        lSP -= btn.XButtonWidth + 4;
                    }
                }
            }
        }
Beispiel #9
0
        private void FillTitleBar(
            Graphics g,
            Rectangle rcTitleBar
            )
        {
            GraphicsPath XTitleBarPath = new GraphicsPath();

            XTitleBarPath = BuildTitleBarShape(rcTitleBar);
            using (XAntiAlias xaa = new XAntiAlias(g))
            {
                #region Fill titlebar
                switch (m_eTitleBarFill)
                {
                case XTitleBarFill.AdvancedRendering:
                    using (LinearGradientBrush lgb = new LinearGradientBrush(
                               rcTitleBar,
                               m_TitleBarMix[0],
                               m_TitleBarMix[4],
                               LinearGradientMode.Vertical))
                    {
                        lgb.InterpolationColors = XCoolFormHelper.ColorMix(
                            m_TitleBarMix,
                            true
                            );

                        g.FillPath(
                            lgb,
                            XTitleBarPath
                            );
                    }


                    #region Draw titlebar glow
                    using (GraphicsPath XGlow = new GraphicsPath())
                    {
                        XGlow.AddEllipse(
                            rcTitleBar.Left,
                            rcTitleBar.Bottom / 2 + 4,
                            rcTitleBar.Width,
                            rcTitleBar.Height
                            );

                        using (PathGradientBrush pgb = new PathGradientBrush(XGlow))
                        {
                            pgb.CenterColor    = Color.White;
                            pgb.SurroundColors = new Color[] { Color.FromArgb(0, 229, 121, 13) };

                            g.SetClip(XTitleBarPath);
                            g.FillPath(
                                pgb,
                                XGlow
                                );
                            g.ResetClip();
                        }
                    }
                    #endregion

                    break;

                case XTitleBarFill.Texture:
                    if (m_TitleBarTexture != null)
                    {
                        using (TextureBrush tb = new TextureBrush(m_TitleBarTexture))
                        {
                            g.FillPath(
                                tb,
                                XTitleBarPath
                                );
                        }
                    }
                    break;

                case XTitleBarFill.LinearRendering:
                    RectangleF rcLinearFill = XTitleBarPath.GetBounds();
                    g.SetClip(XTitleBarPath);
                    using (LinearGradientBrush lgbLinearFill = new LinearGradientBrush(
                               rcLinearFill,
                               m_clrFillStart,
                               m_clrFillEnd,
                               LinearGradientMode.Vertical
                               ))
                    {
                        g.FillRectangle(
                            lgbLinearFill,
                            rcLinearFill
                            );
                    }

                    g.ResetClip();
                    break;

                case XTitleBarFill.UpperGlow:
                    RectangleF rcGlow = XTitleBarPath.GetBounds();
                    g.SetClip(XTitleBarPath);
                    rcGlow.Height /= 2;
                    using (LinearGradientBrush lgbUpperGlow = new LinearGradientBrush(
                               rcGlow,
                               m_clrUpperFillStart,
                               m_clrUpperFillEnd,
                               LinearGradientMode.Vertical
                               ))
                    {
                        g.FillRectangle(
                            lgbUpperGlow,
                            rcGlow
                            );
                    }

                    g.ResetClip();
                    break;

                case XTitleBarFill.RectangleRendering:
                    RectangleF rcDownRect = XTitleBarPath.GetBounds();
                    RectangleF rcUpRect   = XTitleBarPath.GetBounds();
                    g.SetClip(XTitleBarPath);
                    rcUpRect.Height /= 2;
                    using (LinearGradientBrush lgbUpperRect = new LinearGradientBrush(
                               rcUpRect,
                               m_clrUpperFillStart,
                               m_clrUpperFillEnd,
                               LinearGradientMode.Vertical
                               ))
                    {
                        lgbUpperRect.WrapMode = WrapMode.TileFlipY;
                        g.FillRectangle(
                            lgbUpperRect,
                            rcUpRect
                            );
                    }

                    rcDownRect.Height = rcDownRect.Height / 2;
                    rcDownRect.Y      = rcUpRect.Bottom;
                    using (LinearGradientBrush lgbDwnRect = new LinearGradientBrush(
                               rcDownRect,
                               m_clrFillStart,
                               m_clrFillEnd,
                               LinearGradientMode.Vertical
                               ))
                    {
                        g.FillRectangle(
                            lgbDwnRect,
                            rcDownRect
                            );
                    }

                    g.ResetClip();
                    break;
                }



                #endregion


                #region Draw back image
                DrawTitleBarBackImage(g, rcTitleBar, XTitleBarPath);
                #endregion

                DrawOuterTitleBarBorder(g, rcTitleBar, m_clrOuterTitleBarColor);
                DrawInnerTitleBarBorder(g, rcTitleBar, m_clrInnerTitleBarColor);
            }
            XTitleBarPath.Dispose();
        }
        private void DrawStatusGlow(
            Rectangle rect,
            Graphics g,
            Color clrGlowColor
           )
        {
            Rectangle rcGlow = rect;
            using (LinearGradientBrush lgbGlow = new LinearGradientBrush(
                       rcGlow,
                       Color.FromArgb(30, clrGlowColor),
                       Color.FromArgb(150, clrGlowColor),
                       LinearGradientMode.Vertical))
            {
                if (m_bEllipticalGlow)
                {
                    g.SetClip(rect);
                    using (XAntiAlias xaa = new XAntiAlias(g))
                    {
                        using (GraphicsPath XEllipseGlow = new GraphicsPath())
                        {
                            XEllipseGlow.AddEllipse(
                            rect.Left - 5,
                            rect.Top - rect.Height / 2,
                            rect.Width + 10,
                            rect.Height);

                            g.FillPath(
                              lgbGlow,
                              XEllipseGlow
                            );
                        }
                    }
                    g.ResetClip();

                }
                else
                {
                    rcGlow.Height = 5;
                    g.FillRectangle(
                      lgbGlow,
                      rcGlow
                    );

                }
            }
        
        }
        public void RenderTitleBarButtonsBox(
            Rectangle rcBox,
            Graphics g,
            int lSinglePosX,
            int lSinglePosY
           )
        {

           
            using (XAntiAlias xaa = new XAntiAlias(g))
            {
                int lBtnWidth = 0;
                int lBtnHeight = 0;
                foreach (XTitleBarButton btn in m_xtbButtons)
                {
                    if (btn.ButtonStyle == XTitleBarButton.XTitleBarButtonStyle.MacStyle)
                        m_bShouldRenderButtonBox = false;
                    
                     lBtnWidth = btn.XButtonWidth;
                     lBtnHeight = btn.XButtonHeight;
                   
                    
                }
                int lX = rcBox.Right - lBtnWidth;
                int lY = rcBox.Bottom - lBtnHeight;

                if (m_bShouldRenderButtonBox)
                {
                    using (GraphicsPath XButtonBox = BuildTitleBarButtonsBox(rcBox))
                    {
                        switch (m_eButtonBoxFill){
                            case XButtonBoxFill.ColorMix:
                                using (LinearGradientBrush lgb = new LinearGradientBrush(
                                rcBox,
                                m_ButtonBoxColors[0],
                                m_ButtonBoxColors[4],
                                LinearGradientMode.Vertical))
                                {

                                    lgb.InterpolationColors = XCoolFormHelper.ColorMix
                                    (
                                        m_ButtonBoxColors,
                                        false
                                    );

                                    g.FillPath(
                                    lgb,
                                    XButtonBox
                                    );
                                }
                                break;
                            case XButtonBoxFill.TitleBarRectangleRendering:
                                RectangleF rcDownRect = XButtonBox.GetBounds();
                                RectangleF rcUpRect = XButtonBox.GetBounds();
                                g.SetClip(XButtonBox);
                                rcUpRect.Height /= 2;
                                using (LinearGradientBrush lgbUpperRect = new LinearGradientBrush(
                                      rcUpRect,
                                      m_clrUpperFillStart,
                                      m_clrUpperFillEnd,
                                      LinearGradientMode.Vertical
                                      ))
                                {

                                    lgbUpperRect.WrapMode = WrapMode.TileFlipY;
                                    g.FillRectangle(
                                      lgbUpperRect,
                                      rcUpRect
                                    );
                                }

                                rcDownRect.Height = rcDownRect.Height / 2;
                                rcDownRect.Y = rcUpRect.Bottom;
                                using (LinearGradientBrush lgbDwnRect = new LinearGradientBrush(
                                      rcDownRect,
                                      m_clrFillStart,
                                      m_clrFillEnd,
                                      LinearGradientMode.Vertical
                                      ))
                                {

                                    g.FillRectangle(
                                      lgbDwnRect,
                                      rcDownRect
                                    );
                                }

                                g.ResetClip();
                                break;

                        }


                        #region Draw button separators
                        g.DrawLine(
                          new Pen(m_clrButtonBoxOuter),
                          rcBox.Right - lBtnWidth,
                          rcBox.Bottom,
                          rcBox.Right - lBtnWidth,
                          rcBox.Top + 1);
                        g.DrawLine(
                          new Pen(m_clrButtonBoxInner),
                          rcBox.Right - lBtnWidth - 1,
                          rcBox.Bottom,
                          rcBox.Right - lBtnWidth - 1,
                          rcBox.Top + 1);
                        g.DrawLine(
                          new Pen(m_clrButtonBoxOuter),
                          rcBox.Right - lBtnWidth * 2,
                          rcBox.Bottom - 2,
                          rcBox.Right - lBtnWidth * 2,
                          rcBox.Top + 1);
                        g.DrawLine(
                          new Pen(m_clrButtonBoxInner),
                          rcBox.Right - lBtnWidth * 2 - 1,
                          rcBox.Bottom - 2,
                          rcBox.Right - lBtnWidth * 2 - 1,
                          rcBox.Top + 1);
                        #endregion

                        #region Render buttons
                        g.SetClip(XButtonBox);
                        foreach (XTitleBarButton btn in m_xtbButtons)
                        {

                            btn.XButtonLeft = lX;
                            btn.XButtonTop = lY;

                            btn.RenderTitleBarButton(
                                btn.XButtonLeft,
                                btn.XButtonTop,
                                g,
                                XButtonBox
                            );
                            lX -= btn.XButtonWidth + 1;

                        }
                        g.ResetClip();
                        #endregion


                        g.DrawPath(
                          new Pen(m_clrButtonBoxOuter),
                          XButtonBox
                        );

                        DrawInnerTitleBarBoxBorder(g, rcBox, m_clrButtonBoxInner);
                       
                        
                    }
                    
                }
                else
                {
                    int lSP = lSinglePosX;
                    foreach (XTitleBarButton btn in m_xtbButtons)
                    {
                        btn.XButtonHeight = 13;
                        btn.XButtonWidth = 13;
                        btn.XButtonLeft = lSP;
                        btn.XButtonTop = lSinglePosY;

                        btn.RenderTitleBarButton(
                            btn.XButtonLeft,
                            btn.XButtonTop,
                            g,
                            null
                        );
                        lSP -= btn.XButtonWidth + 4;

                    }
                }
            }
           
             
        }
        private void FillTitleBar(
            Graphics g,
            Rectangle rcTitleBar
            )
        {
            GraphicsPath XTitleBarPath = new GraphicsPath();
            XTitleBarPath = BuildTitleBarShape(rcTitleBar);
            using (XAntiAlias xaa = new XAntiAlias(g))
            {

                    #region Fill titlebar 
                    switch (m_eTitleBarFill)
                    {
                        case XTitleBarFill.AdvancedRendering:
                           using (LinearGradientBrush lgb = new LinearGradientBrush(
                                   rcTitleBar,
                                   m_TitleBarMix[0],
                                   m_TitleBarMix[4],
                                   LinearGradientMode.Vertical))
                            {


                                lgb.InterpolationColors = XCoolFormHelper.ColorMix(
                                    m_TitleBarMix,
                                    true
                                );

                                g.FillPath(
                                  lgb,
                                  XTitleBarPath
                                );
                            }
                            

                            #region Draw titlebar glow
                            using (GraphicsPath XGlow = new GraphicsPath())
                            {
                                XGlow.AddEllipse(
                                    rcTitleBar.Left,
                                    rcTitleBar.Bottom / 2 + 4,
                                    rcTitleBar.Width,
                                    rcTitleBar.Height
                                );

                                using (PathGradientBrush pgb = new PathGradientBrush(XGlow))
                                {
                                    pgb.CenterColor = Color.White;
                                    pgb.SurroundColors = new Color[] { Color.FromArgb(0, 229, 121, 13) };

                                    g.SetClip(XTitleBarPath);
                                    g.FillPath(
                                      pgb,
                                      XGlow
                                    );
                                    g.ResetClip();

                                }
                            }
                            #endregion
                             
                             break;
                          case XTitleBarFill.Texture:
                              if (m_TitleBarTexture != null) {
                                  using (TextureBrush tb = new TextureBrush(m_TitleBarTexture))
                                  {
                                      
                                      g.FillPath(
                                        tb,
                                        XTitleBarPath
                                      );
                                  }
                              }
                             break;
                         case XTitleBarFill.LinearRendering:
                            RectangleF rcLinearFill = XTitleBarPath.GetBounds();
                            g.SetClip(XTitleBarPath);
                            using (LinearGradientBrush lgbLinearFill = new LinearGradientBrush(
                                  rcLinearFill,
                                  m_clrFillStart,
                                  m_clrFillEnd,
                                  LinearGradientMode.Vertical
                                  ))
                            {
                                
                                g.FillRectangle(
                                  lgbLinearFill,
                                  rcLinearFill
                                );
                            }
                            
                            g.ResetClip();
                            break;
                        case XTitleBarFill.UpperGlow:
                            RectangleF rcGlow = XTitleBarPath.GetBounds();
                            g.SetClip(XTitleBarPath);
                            rcGlow.Height /= 2;
                            using (LinearGradientBrush lgbUpperGlow = new LinearGradientBrush(
                                  rcGlow,
                                  m_clrUpperFillStart,
                                  m_clrUpperFillEnd,
                                  LinearGradientMode.Vertical
                                  ))
                            {
                                
                                g.FillRectangle(
                                  lgbUpperGlow,
                                  rcGlow
                                );
                            }

                            g.ResetClip();
                            break;
                        case XTitleBarFill.RectangleRendering:
                            RectangleF rcDownRect = XTitleBarPath.GetBounds();
                            RectangleF rcUpRect = XTitleBarPath.GetBounds();
                            g.SetClip(XTitleBarPath);
                            rcUpRect.Height /= 2;
                            using (LinearGradientBrush lgbUpperRect = new LinearGradientBrush(
                                  rcUpRect,
                                  m_clrUpperFillStart,
                                  m_clrUpperFillEnd,
                                  LinearGradientMode.Vertical
                                  ))
                            {

                                lgbUpperRect.WrapMode = WrapMode.TileFlipY;
                                g.FillRectangle(
                                  lgbUpperRect,
                                  rcUpRect
                                );
                            }

                            rcDownRect.Height = rcDownRect.Height / 2;
                            rcDownRect.Y = rcUpRect.Bottom;
                            using (LinearGradientBrush lgbDwnRect = new LinearGradientBrush(
                                  rcDownRect,
                                  m_clrFillStart,
                                  m_clrFillEnd,
                                  LinearGradientMode.Vertical
                                  ))
                            {

                                g.FillRectangle(
                                  lgbDwnRect,
                                  rcDownRect
                                );
                            }

                            g.ResetClip();
                            break;

                            
                    }

                    

                    #endregion
                  

                    #region Draw back image
                    DrawTitleBarBackImage(g, rcTitleBar, XTitleBarPath);
                    #endregion
                   
                DrawOuterTitleBarBorder(g, rcTitleBar, m_clrOuterTitleBarColor);
                DrawInnerTitleBarBorder(g, rcTitleBar, m_clrInnerTitleBarColor);

            }
            XTitleBarPath.Dispose();
        }
Beispiel #13
0
        public void RenderHolderButtons(
            int x,
            int y,
            Graphics g
            )
        {
            int lX = x;
            Rectangle rcIcon = new Rectangle();
            RectangleF rcImage = new RectangleF();
            RectangleF rcFrame = new RectangleF();

            foreach (XHolderButton xbtn in m_xhBtn)
            {

                if (xbtn.ButtonImage != null)
                {
                    xbtn.Left = lX;
                    xbtn.Top = y + 1;

                    rcIcon = new Rectangle(
                    lX,
                    y + 1,
                    xbtn.ButtonImage.Size.Width,
                    xbtn.ButtonImage.Size.Height
                    );

                    if (xbtn.Hot)
                    {
                        using (XAntiAlias xaa = new XAntiAlias(g))
                        {
                            using (GraphicsPath XHolderBtnPath = BuildHolderButtonFrame(rcIcon, 100, 40))
                            {

                                using (LinearGradientBrush lgb = new LinearGradientBrush(
                                      XHolderBtnPath.GetBounds(),
                                      Color.FromArgb(xbtn.FrameAlpha, xbtn.FrameStartColor),
                                      Color.FromArgb(xbtn.FrameAlpha, xbtn.FrameEndColor),
                                      LinearGradientMode.Vertical
                                      ))
                                {
                                    g.FillPath(
                                       lgb,
                                       XHolderBtnPath
                                    );
                                }

                                rcFrame = XHolderBtnPath.GetBounds();

                            }
                            int lFrameImageWidth = 0;
                            if (xbtn.FrameBackImage != null)
                            {
                                // draw frame image:
                                rcImage = new RectangleF(
                                rcFrame.Right - xbtn.FrameBackImage.Width,
                                rcFrame.Bottom - xbtn.FrameBackImage.Height,
                                xbtn.FrameBackImage.Width,
                                xbtn.FrameBackImage.Height
                                );
                                g.DrawImage(xbtn.FrameBackImage, rcImage);
                                lFrameImageWidth = xbtn.FrameBackImage.Height;
                            }
                            // draw caption / description:
                            g.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
                            g.DrawString(
                                xbtn.XHolderButtonCaption,
                                xbtn.XHolderButtonCaptionFont,
                                new SolidBrush(xbtn.XHolderButtonCaptionColor),
                                rcFrame.Left + 2,
                                rcIcon.Bottom + 4
                            );

                            StringFormat sf = new StringFormat();
                            sf.Alignment = StringAlignment.Near;
                            sf.LineAlignment = StringAlignment.Near;
                            sf.Trimming = StringTrimming.EllipsisCharacter;
                            sf.FormatFlags = StringFormatFlags.LineLimit;

                            float fCaptionWidth = g.MeasureString(xbtn.XHolderButtonCaption, xbtn.XHolderButtonCaptionFont).Height;

                            RectangleF rcDescription = new RectangleF(
                            rcFrame.Left + 2,
                            rcIcon.Bottom + fCaptionWidth,
                            rcFrame.Width,
                            rcFrame.Height - lFrameImageWidth);
                            g.DrawString(
                              xbtn.XHolderButtonDescription,
                              xbtn.XHolderButtonDescriptionFont,
                              new SolidBrush(xbtn.XHolderButtonDescriptionColor),
                              rcDescription,
                              sf);

                        }

                    }

                    // draw button:
                    g.DrawImage(
                    xbtn.ButtonImage,
                    rcIcon
                    );

                    xbtn.ButtonRectangle = rcIcon;

                    // update position:
                    lX += rcIcon.Width + 2;
                }

            }
        }
Beispiel #14
0
        /// <summary>
        /// Fills titlebar button.
        /// </summary>
        /// <param name="rcBtn"> Button bounding rectangle.</param>
        /// <param name="g"> Graphics object.</param>
        /// <param name="clrStart"> Color used to fill the button.</param>
        /// <param name="clrEnd"> Color used to fill the outer glow.</param>
        /// <param name="XBoxClip"> Path to perform clipping tasks.</param>
        private void FillButton(
            Rectangle rcBtn,
            Graphics g,
            Color clrStart,
            Color clrEnd,
            GraphicsPath XBoxClip
            )
        {
            switch (m_eFillMode)
            {
            case XButtonFillMode.UpperGlow:
                rcBtn.Height = 3;
                using (LinearGradientBrush lgb = new LinearGradientBrush(
                           rcBtn,
                           clrStart,
                           clrEnd,
                           LinearGradientMode.Vertical))
                {
                    g.FillRectangle(
                        lgb,
                        rcBtn
                        );
                }
                break;

            case XButtonFillMode.FullFill:
                // restrict drawing inside button box / rectangle:
                g.SetClip(XBoxClip);
                g.SetClip(rcBtn, CombineMode.Intersect);

                #region Fill button
                using (SolidBrush sb = new SolidBrush(clrStart))
                {
                    g.FillRectangle(
                        sb,
                        rcBtn
                        );
                }
                #endregion

                using (XAntiAlias xaa = new XAntiAlias(g))
                {
                    #region Fill shine
                    using (GraphicsPath XBtnGlow = new GraphicsPath())
                    {
                        XBtnGlow.AddEllipse(rcBtn.Left - 5, rcBtn.Bottom - rcBtn.Height / 2 + 3, rcBtn.Width + 11, rcBtn.Height + 11);
                        using (PathGradientBrush pgb = new PathGradientBrush(XBtnGlow))
                        {
                            pgb.CenterColor    = Color.FromArgb(235, Color.White);
                            pgb.SurroundColors = new Color[] { Color.FromArgb(0, clrEnd) };
                            pgb.SetSigmaBellShape(0.8f);

                            g.FillPath(
                                pgb,
                                XBtnGlow
                                );
                        }
                    }
                    #endregion

                    #region Fill upper glow
                    rcBtn.Height = rcBtn.Height / 2 - 2;
                    using (LinearGradientBrush lgb = new LinearGradientBrush(
                               rcBtn,
                               Color.FromArgb(80, Color.White),
                               Color.FromArgb(140, Color.White),
                               LinearGradientMode.Vertical))
                    {
                        using (GraphicsPath XGlowPath = XCoolFormHelper.RoundRect((RectangleF)rcBtn, 0, 0, 4, 4))
                        {
                            lgb.WrapMode = WrapMode.TileFlipXY;
                            g.FillPath(
                                lgb,
                                XGlowPath
                                );
                        }
                    }
                    #endregion
                }
                // reset clipping back:
                g.ResetClip();
                break;
            }
        }
Beispiel #15
0
 /// <summary>
 /// Main rendering method.
 /// </summary>
 /// <param name="rcBorder"> Border bounds</param>
 /// <param name="g"> Graphics object</param>
 public void Render(
     Rectangle rcBorder,
     Graphics g
     
     )
 {
     GraphicsPath XBorderPath = new GraphicsPath();
     switch (m_eBorderStyle)
     {
         case XBorderStyle.X3D:
            switch (m_eBorderType)
            {
                     case XBorderType.Rectangular:
                         using (XAntiAlias xaa = new XAntiAlias(g))
                         {
                             DrawBorderLine(g, XBorderPath, rcBorder, 0, false);
                         }
                         break;
                     case XBorderType.Rounded:
                         DrawBorderLine(g, XBorderPath, rcBorder, m_lRadius, false);
                         break;
                     case XBorderType.Inclinated:
                         DrawBorderLine(g, XBorderPath, rcBorder, 0, false);
                         break;
             }
             break;
         case XBorderStyle.Flat:
             switch (m_eBorderType)
             {
                     case XBorderType.Rectangular:
                         using (XAntiAlias xaa = new XAntiAlias(g))
                         {
                             DrawBorderLine(g, XBorderPath, rcBorder, 0, true);
                         }
                         break;
                     case XBorderType.Rounded:
                         DrawBorderLine(g, XBorderPath, rcBorder, m_lRadius, true);
                         break;
                     case XBorderType.Inclinated:
                         DrawBorderLine(g, XBorderPath, rcBorder, 0, false);
                         break;
              }
              break;
       }
 }
Beispiel #16
0
        public void RenderHolderButtons(
            int x,
            int y,
            Graphics g
            )
        {
            int        lX      = x;
            Rectangle  rcIcon  = new Rectangle();
            RectangleF rcImage = new RectangleF();
            RectangleF rcFrame = new RectangleF();

            foreach (XHolderButton xbtn in m_xhBtn)
            {
                if (xbtn.ButtonImage != null)
                {
                    xbtn.Left = lX;
                    xbtn.Top  = y + 1;

                    rcIcon = new Rectangle(
                        lX,
                        y + 1,
                        xbtn.ButtonImage.Size.Width,
                        xbtn.ButtonImage.Size.Height
                        );

                    if (xbtn.Hot)
                    {
                        using (XAntiAlias xaa = new XAntiAlias(g))
                        {
                            using (GraphicsPath XHolderBtnPath = BuildHolderButtonFrame(rcIcon, 100, 40))
                            {
                                using (LinearGradientBrush lgb = new LinearGradientBrush(
                                           XHolderBtnPath.GetBounds(),
                                           Color.FromArgb(xbtn.FrameAlpha, xbtn.FrameStartColor),
                                           Color.FromArgb(xbtn.FrameAlpha, xbtn.FrameEndColor),
                                           LinearGradientMode.Vertical
                                           ))
                                {
                                    g.FillPath(
                                        lgb,
                                        XHolderBtnPath
                                        );
                                }

                                rcFrame = XHolderBtnPath.GetBounds();
                            }
                            int lFrameImageWidth = 0;
                            if (xbtn.FrameBackImage != null)
                            {
                                // draw frame image:
                                rcImage = new RectangleF(
                                    rcFrame.Right - xbtn.FrameBackImage.Width,
                                    rcFrame.Bottom - xbtn.FrameBackImage.Height,
                                    xbtn.FrameBackImage.Width,
                                    xbtn.FrameBackImage.Height
                                    );
                                g.DrawImage(xbtn.FrameBackImage, rcImage);
                                lFrameImageWidth = xbtn.FrameBackImage.Height;
                            }
                            // draw caption / description:
                            g.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
                            g.DrawString(
                                xbtn.XHolderButtonCaption,
                                xbtn.XHolderButtonCaptionFont,
                                new SolidBrush(xbtn.XHolderButtonCaptionColor),
                                rcFrame.Left + 2,
                                rcIcon.Bottom + 4
                                );

                            StringFormat sf = new StringFormat();
                            sf.Alignment     = StringAlignment.Near;
                            sf.LineAlignment = StringAlignment.Near;
                            sf.Trimming      = StringTrimming.EllipsisCharacter;
                            sf.FormatFlags   = StringFormatFlags.LineLimit;

                            float fCaptionWidth = g.MeasureString(xbtn.XHolderButtonCaption, xbtn.XHolderButtonCaptionFont).Height;

                            RectangleF rcDescription = new RectangleF(
                                rcFrame.Left + 2,
                                rcIcon.Bottom + fCaptionWidth,
                                rcFrame.Width,
                                rcFrame.Height - lFrameImageWidth);
                            g.DrawString(
                                xbtn.XHolderButtonDescription,
                                xbtn.XHolderButtonDescriptionFont,
                                new SolidBrush(xbtn.XHolderButtonDescriptionColor),
                                rcDescription,
                                sf);
                        }
                    }

                    // draw button:
                    g.DrawImage(
                        xbtn.ButtonImage,
                        rcIcon
                        );

                    xbtn.ButtonRectangle = rcIcon;

                    // update position:
                    lX += rcIcon.Width + 2;
                }
            }
        }