/// <summary>
/// Generates a GradientVisualSettings properties class object and initializes each of its associated properties of the gradient visual settings with
/// default values. A different visual setting will be stored for each of the various states each property can be accessed in their associated control.
/// </summary>
/// <param name="DefaultGradColor1"></param>
/// <param name="DefaultGradColor2"></param>
/// <param name="DefaultGradType"></param>
/// <param name="fDefaultGradSpan"></param>
/// <param name="blUseDefaultGradSpan"></param>
/// <param name="ptDefaultGradOffset"></param>
/// <param name="blDrawGradient"></param>
/// <returns></returns>
public static VisualSettingProperties <GradientVisualSettings> CreateGradientVisualSettings(
Color DefaultGradColor1, Color DefaultGradColor2,
CoolGradientType DefaultGradType, float fDefaultGradSpan,
bool blUseDefaultGradSpan, Point ptDefaultGradOffset, bool blDrawGradient)
{
try
{
VisualSettingProperties <GradientVisualSettings> gradSettingProps = new VisualSettings.VisualSettingProperties <VisualSettings.GradientVisualSettings>();
for (int i = 0; i <= 5; i++)
{
VisualSettingEnum setting = (VisualSettingEnum)i;
GradientVisualSettings gradVisSetting =
new GradientVisualSettings
{
GradientColor1 = DefaultGradColor1,
GradientColor2 = DefaultGradColor2,
GradientType = DefaultGradType,
GradientSpan = fDefaultGradSpan,
UseDefaultGradientSpan = blUseDefaultGradSpan,
GradientOffset = ptDefaultGradOffset,
DrawGradient = blDrawGradient
};
gradSettingProps.AddSetting(setting, gradVisSetting);
}//next i
return(gradSettingProps);
}
catch (Exception err)
{
ErrorHandler.ShowErrorMessage(err, "Error in CreateGradientVisualSettings Overload 1 function of VisualSettingPropGenerator class.");
return(null);
}
}
/// <summary>
/// Draws the gradient background image of the DotCoolNativeButton according to the background gradient settings that are set for the control.
/// NOTE: The DotCoolNativeButton will use the button's background image, rather than the paint event handlers to render the background gradient
/// image so that the button's native functionality can be maintained.
/// </summary>
protected virtual void DrawGradientBackgroundImage()
{
Bitmap bmpGradBackMem = null;
Graphics gGradBackMem = null;
Graphics gGradBack = null;
try
{
bmpGradBackMem = new Bitmap(ClientRectangle.Width, ClientRectangle.Height);
gGradBackMem = Graphics.FromImage(bmpGradBackMem);
CoolGradientType BackGradTypeActive = GetBackGradientType();
Color BackGradColor1Active = GetBackGradientColor(1);
Color BackGradColor2Active = GetBackGradientColor(2);
float fGradSpan = GetBackGradientSpan();
Point ptGradOffset = GetBackGradientOffset();
if (BackGradTypeActive == CoolGradientType.None || BackGradColor1Active == Color.Transparent)
{
ClearGradientBackgroundImage();
return;
}
else
{
CoolGradient.DrawGradient(BackGradTypeActive, gGradBackMem, BackGradColor1Active, BackGradColor2Active, ClientRectangle,
fGradSpan, ptGradOffset.X, ptGradOffset.Y);
}
this.BackgroundImage = new Bitmap(ClientRectangle.Width, ClientRectangle.Height);
gGradBack = Graphics.FromImage(this.BackgroundImage);
gGradBack.DrawImage(bmpGradBackMem, ClientRectangle);
this.Refresh();
}
catch (Exception err)
{
ErrorHandler.ShowErrorMessage(err, "Error in DrawGradientBackgroundImage function of DotCoolNativeButton control.");
}
finally
{
if (gGradBackMem != null)
{
gGradBackMem.Dispose();
}
if (gGradBack != null)
{
gGradBack.Dispose();
}
if (bmpGradBackMem != null)
{
bmpGradBackMem.Dispose();
}
}
}
/// <summary>
/// Retrieves the default gradient span setting for the gradient type specified in the function's parameter. Each various gradient type will have
/// a default gradient span that will be considered the optimal size for displaying the specific type of gradient.
/// </summary>
/// <param name="gradType"></param>
/// <returns></returns>
public static float GetDefaultGradientSpan(CoolGradientType gradType)
{
try
{
switch (gradType)
{
case CoolGradientType.Horizontal:
case CoolGradientType.Vertical:
case CoolGradientType.ForwardDiagonal:
case CoolGradientType.BackwardDiagonal:
return(1f);
case CoolGradientType.Ellipsis:
return(2f);
case CoolGradientType.Circular:
return(1.5f);
case CoolGradientType.FourPointPoly:
return(1f);
case CoolGradientType.TenPointPoly:
return(1f);
case CoolGradientType.Triangular:
return(3f);
}//end switch
return(1f);
}
catch (Exception err)
{
ErrorHandler.ShowErrorMessage(err, "Error in GetDefaultGradientSpan function of CoolGradient class.");
return(1f);
}
}
/// <summary>
/// Draws the appropriate style of gradient based on gradient type flag specified in the function parameter.
/// </summary>
/// <param name="gradType"></param>
/// <param name="graphics"></param>
/// <param name="gradColor1"></param>
/// <param name="gradColor2"></param>
/// <param name="rectBounds"></param>
/// <param name="fGradientSpan"></param>
/// <param name="iOffsetX"></param>
/// <param name="iOffsetY"></param>
public static void DrawGradient(CoolGradientType gradType, Graphics graphics, Color gradColor1, Color gradColor2, Rectangle rectBounds,
float fGradientSpan = 0f, int iOffsetX = 0, int iOffsetY = 0)
{
try
{
//graphics.SmoothingMode = SmoothingMode.HighQuality;
//graphics.InterpolationMode = InterpolationMode.High;
if (fGradientSpan == 0)
{
fGradientSpan = GetDefaultGradientSpan(gradType);
}
switch (gradType)
{
case CoolGradientType.Horizontal:
DrawLinearGradient(graphics, gradColor1, gradColor2, rectBounds, LinearGradientMode.Horizontal, fGradientSpan, iOffsetX, iOffsetY);
break;
case CoolGradientType.Vertical:
DrawLinearGradient(graphics, gradColor1, gradColor2, rectBounds, LinearGradientMode.Vertical, fGradientSpan, iOffsetX, iOffsetY);
break;
case CoolGradientType.ForwardDiagonal:
DrawLinearGradient(graphics, gradColor1, gradColor2, rectBounds, LinearGradientMode.ForwardDiagonal, fGradientSpan, iOffsetX, iOffsetY);
break;
case CoolGradientType.BackwardDiagonal:
DrawLinearGradient(graphics, gradColor1, gradColor2, rectBounds, LinearGradientMode.BackwardDiagonal, fGradientSpan, iOffsetX, iOffsetY);
break;
case CoolGradientType.Ellipsis:
case CoolGradientType.Circular:
DrawEllipsisGradient(graphics, gradColor1, gradColor2, rectBounds, fGradientSpan, iOffsetX, iOffsetY,
gradType == CoolGradientType.Circular);
break;
case CoolGradientType.FourPointPoly:
DrawPolyGradient(graphics, gradColor1, gradColor2, rectBounds, 4, fGradientSpan, iOffsetX, iOffsetY);
break;
case CoolGradientType.TenPointPoly:
DrawPolyGradient(graphics, gradColor1, gradColor2, rectBounds, 10, fGradientSpan, iOffsetX, iOffsetY);
break;
case CoolGradientType.Triangular:
DrawTriangleGradient(graphics, gradColor1, gradColor2, rectBounds, fGradientSpan, iOffsetX, iOffsetY);
break;
}//end switch
}
catch (Exception err)
{
ErrorHandler.ShowErrorMessage(err, "Error in DrawGradient function of CoolGradient class.");
}
}
/// <summary>
/// Draws the background gradient image in the control based on the various gradient settings that are set for the control. All drawing will
/// be performed in memory-based device context before rendering onto the control to allow for flicker-free drawing.
/// </summary>
protected virtual void DrawBackGradientImage(Graphics gCtl)
{
Bitmap bmpGradBackMem = null;
Graphics gGradBackMem = null;
GraphicsState origGraphState = null;
try
{
// At the beginning of your drawing
origGraphState = gCtl.Save();
bmpGradBackMem = new Bitmap(this.Width, this.Height);
gGradBackMem = Graphics.FromImage(bmpGradBackMem);
CoolGradientType BackGradTypeActive = GetBackGradientType();
Color BackGradColor1Active = GetBackGradientColor(1);
Color BackGradColor2Active = GetBackGradientColor(2);
float fGradientSpan = GetBackGradientSpan();
Point ptGradOffset = GetBackGradientOffset();
Rectangle rectBounds = new Rectangle(0, 0, this.Width, this.Height);
if (BackGradColor1Active != Color.Transparent && BackGradTypeActive != CoolGradientType.None)
{
CoolDraw.DrawGradientShape(CoolShape.Rectangle, BackGradTypeActive, gGradBackMem, BackGradColor1Active,
BackGradColor2Active, rectBounds, Color.Transparent, 0, fGradientSpan, ptGradOffset.X, ptGradOffset.Y);
}
else
{
Color?FillColor = null;
if (BackGradColor1Active != Color.Transparent)
{
FillColor = BackGradColor1Active;
}
CoolDraw.DrawShape(CoolShape.Rectangle, gGradBackMem, rectBounds, Color.Transparent, 0,
0, 0, FillColor);
}//end if
Rectangle rectDraw = new Rectangle(0, 0, this.Width, this.Height);
//gCtl.CompositingMode = CompositingMode.SourceCopy;
gCtl.DrawImage(bmpGradBackMem, rectDraw);
}
catch (Exception err)
{
ErrorHandler.ShowErrorMessage(err, "Error in DrawBackGradientImage function of DotCoolPanel control.");
}
finally
{
if (origGraphState != null)
{
gCtl.Restore(origGraphState);
}
if (gGradBackMem != null)
{
gGradBackMem.Dispose();
}
if (bmpGradBackMem != null)
{
bmpGradBackMem.Dispose();
}
}
}
/// <summary>
/// Draws the appropriate gradient check symbol in the box portion of the check control when the control is checked, according to the current
/// state of the control.
/// </summary>
protected virtual void DrawCheckSymbol(Graphics gCtl)
{
Bitmap bmpGradCheckMem = null;
Graphics gGradCheckMem = null;
GraphicsState origGraphState = null;
try
{
// At the beginning of your drawing
origGraphState = gCtl.Save();
bmpGradCheckMem = new Bitmap(CheckSize.Width, CheckSize.Height);
gGradCheckMem = Graphics.FromImage(bmpGradCheckMem);
CoolGradientType CheckGradTypeActive = GetCheckGradientType();
Color CheckGradColor1Active = GetCheckGradientColor(1);
Color CheckGradColor2Active = GetCheckGradientColor(2);
float fGradientSpan = GetCheckGradientSpan();
Point ptGradOffset = GetCheckGradientOffset();
Color CheckBorderColorActive = GetCheckBorderColor();
int iBorderWidth = CheckBorderWidth;
Rectangle rectBounds = new Rectangle(Convert.ToInt32(iBorderWidth / 2), Convert.ToInt32(iBorderWidth / 2),
CheckSize.Width - iBorderWidth - 1,
CheckSize.Height - iBorderWidth - 1);
Point ptCheckLocation = new Point(Convert.ToInt32(m_BoxBounds.Left) + GetBorderWidth() + CheckOffset.X,
Convert.ToInt32(m_BoxBounds.Top) + GetBorderWidth() + CheckOffset.Y);
if (CheckGradColor1Active != Color.Transparent && CheckGradTypeActive != CoolGradientType.None)
{
CoolDraw.DrawGradientShape(CheckShape, CheckGradTypeActive, gGradCheckMem, CheckGradColor1Active,
CheckGradColor2Active, rectBounds, CheckBorderColorActive, iBorderWidth,
fGradientSpan, ptGradOffset.X, ptGradOffset.Y,
CheckRadius.X, CheckRadius.Y);
}
else
{
Color?FillColor = null;
if (CheckGradColor1Active != Color.Transparent)
{
FillColor = CheckGradColor1Active;
}
CoolDraw.DrawShape(CheckShape, gGradCheckMem, rectBounds, CheckBorderColorActive, iBorderWidth,
CheckRadius.X, CheckRadius.Y, FillColor);
}//end if
Rectangle rectDraw = new Rectangle(ptCheckLocation.X, ptCheckLocation.Y, CheckSize.Width, CheckSize.Height);
gCtl.CompositingMode = CompositingMode.SourceOver;
gCtl.DrawImage(bmpGradCheckMem, rectDraw);
}
catch (Exception err)
{
ErrorHandler.ShowErrorMessage(err, "Error in DrawCheckSymbol function of DotCoolCheckBase control.");
}
finally
{
if (origGraphState != null)
{
gCtl.Restore(origGraphState);
}
if (gGradCheckMem != null)
{
gGradCheckMem.Dispose();
}
if (bmpGradCheckMem != null)
{
bmpGradCheckMem.Dispose();
}
}
}
