ComponentFactory.Krypton.Toolkit.RenderGlassHelpers.DrawBackGlassLinear C# (CSharp) Method

        private static IDisposable DrawBackGlassLinear(RectangleF drawRect,
                                                       RectangleF outerRect,
                                                       Color color1,
                                                       Color color2,
                                                       Color glassColor1,
                                                       Color glassColor2,
                                                       VisualOrientation orientation,
                                                       Graphics g,
                                                       float glassPercent,
                                                       IDisposable memento)
        {
            // Cannot draw a zero length rectangle
            if ((drawRect.Width > 0) && (drawRect.Height > 0) &&
                (outerRect.Width > 0) && (outerRect.Height > 0))
            {
                bool generate = true;
                MementoBackGlassLinear cache;

                // Access a cache instance and decide if cache resources need generating
                if ((memento == null) || !(memento is MementoBackGlassLinear))
                {
                    if (memento != null)
                        memento.Dispose();

                    cache = new MementoBackGlassLinear(drawRect, outerRect, color1, color2,
                                                       glassColor1, glassColor2, orientation, glassPercent);
                    memento = cache;
                }
                else
                {
                    cache = (MementoBackGlassLinear)memento;
                    generate = !cache.UseCachedValues(drawRect, outerRect, color1, color2,
                                                      glassColor1, glassColor2, orientation, glassPercent);
                }

                // Do we need to generate the contents of the cache?
                if (generate)
                {
                    // Dispose of existing values
                    cache.Dispose();

                    RectangleF glassRect;
                    RectangleF mainRect;
                    float glassLength;

                    // Glass covers specified percentage of the orienatated length
                    if (VerticalOrientation(orientation))
                        glassLength = (int)(outerRect.Height * glassPercent) + outerRect.Y - drawRect.Y;
                    else
                        glassLength = (int)(outerRect.Width * glassPercent) + outerRect.X - drawRect.X;

                    // Create rectangles that cover the glass and main area
                    switch (orientation)
                    {
                        case VisualOrientation.Left:
                            glassRect = new RectangleF(drawRect.X, drawRect.Y, glassLength, drawRect.Height);
                            mainRect = new RectangleF(glassRect.Right + 1, drawRect.Y, drawRect.Width - glassRect.Width - 1, drawRect.Height);
                            break;
                        case VisualOrientation.Right:
                            mainRect = new RectangleF(drawRect.X, drawRect.Y, drawRect.Width - glassLength, drawRect.Height);
                            glassRect = new RectangleF(mainRect.Right, drawRect.Y, glassLength, drawRect.Height);
                            break;
                        case VisualOrientation.Top:
                        default:
                            glassRect = new RectangleF(drawRect.X, drawRect.Y, drawRect.Width, glassLength);
                            mainRect = new RectangleF(drawRect.X, glassRect.Bottom + 1, drawRect.Width, drawRect.Height - glassRect.Height - 1);
                            break;
                        case VisualOrientation.Bottom:
                            mainRect = new RectangleF(drawRect.X, drawRect.Y, drawRect.Width, drawRect.Height - glassLength);
                            glassRect = new RectangleF(drawRect.X, mainRect.Bottom, drawRect.Width, glassLength);
                            break;
                    }

                    cache.totalBrush = new SolidBrush(color1);
                    cache.glassRect = glassRect;
                    cache.mainRect = mainRect;

                    // Create gradient rectangles
                    RectangleF glassGradientRect = new RectangleF(cache.glassRect.X - 1, cache.glassRect.Y - 1, cache.glassRect.Width + 2, cache.glassRect.Height + 2);
                    RectangleF mainGradientRect = new RectangleF(cache.mainRect.X - 1, cache.mainRect.Y - 1, cache.mainRect.Width + 2, cache.mainRect.Height + 2);

                    // Cannot draw a zero length rectangle
                    if ((cache.glassRect.Width > 0) && (cache.glassRect.Height > 0) &&
                        (cache.mainRect.Width > 0) && (cache.mainRect.Height > 0) &&
                        (glassGradientRect.Width > 0) && (glassGradientRect.Height > 0) &&
                        (mainGradientRect.Width > 0) && (mainGradientRect.Height > 0))
                    {
                        cache.topBrush = new LinearGradientBrush(glassGradientRect, glassColor1, glassColor2, AngleFromOrientation(orientation));
                        cache.bottomBrush = new LinearGradientBrush(mainGradientRect, color1, color2, AngleFromOrientation(orientation));
                    }
                }

                // Draw entire area in a solid color
                g.FillRectangle(cache.totalBrush, drawRect);

                if ((cache.topBrush != null) && (cache.bottomBrush != null))
                {
                    g.FillRectangle(cache.topBrush, cache.glassRect);
                    g.FillRectangle(cache.bottomBrush, cache.mainRect);
                }
            }

            return memento;
        }