CBCGPBaseInfo::XBase* CBCGPBaseInfo::CreateBaseFromTag (const CString& tag, XCreateBaseFromNameProc lpCreateProc)
{
if (lpCreateProc == NULL)
{
ASSERT(FALSE);
return NULL;
}
CBCGPBaseInfo::XBase* base = NULL;
CString strElementName;
{
CBCGPTagManager tm (tag);
tm.ReadString (CBCGPBaseInfo::s_szTag_ElementName, strElementName);
}
if (!strElementName.IsEmpty ())
{
base = (lpCreateProc)(strElementName);
if (base != NULL)
{
base->FromTag (tag);
}
}
return base;
}
BOOL CBCGPTagManager::ParseToolBarImages (const CString& strItem, CBCGPToolBarImages& value, LPCTSTR lpszID)
{
CBCGPTagManager tm (strItem);
CSize size (value.GetImageSize ());
value.Clear ();
value.SetTransparentColor ((COLORREF)(-1));
tm.ReadSize (s_Size, size);
BOOL bPreMultiplyCheck = TRUE;
tm.ReadBool (s_PreMltCheck, bPreMultiplyCheck);
value.SetPreMultiplyAutoCheck (bPreMultiplyCheck);
if (size != CSize (0, 0))
{
value.SetImageSize (size);
}
value.LoadStr (lpszID);
if (size == CSize (0, 0))
{
value.SetSingleImage ();
}
COLORREF clrTransparent = CLR_DEFAULT;
if (tm.ReadColor (s_Transparent, clrTransparent))
{
value.SetTransparentColor (clrTransparent);
}
#ifndef _BCGSUITE_
if (m_clrBase != (COLORREF)-1 &&
m_clrTarget != (COLORREF)-1)
{
value.AddaptColors (m_clrBase, m_clrTarget);
}
#endif
if (CBCGPToolBarImages::IsRTL () && value.GetImageWell () != NULL &&
clrTransparent == CLR_DEFAULT)
{
BITMAP bmp;
if (::GetObject (value.GetImageWell (), sizeof (BITMAP), &bmp) != 0)
{
if (bmp.bmBitsPixel == 32)
{
value.Mirror ();
}
}
}
return TRUE;
}
BOOL CBCGPBaseInfo::XID::FromTag (const CString& strTag)
{
CBCGPTagManager tm (strTag);
BOOL bResult = tm.ReadString (s_szTag_Name, m_Name);
if (tm.ReadUInt (s_szTag_Value, m_Value))
{
bResult = TRUE;
}
return bResult;
}
BOOL CBCGPTagManager::ParseColor (const CString& strItem, CBCGPColor& value)
{
CBCGPTagManager tm (strItem);
CStringArray sa;
CString strA, strR, strG, strB;
tm.ExcludeTag (s_A, strA);
strA.TrimLeft ();
strA.TrimRight ();
tm.ExcludeTag (s_R, strR);
strR.TrimLeft ();
strR.TrimRight ();
tm.ExcludeTag (s_G, strG);
strG.TrimLeft ();
strG.TrimRight ();
tm.ExcludeTag (s_B, strB);
strB.TrimLeft ();
strB.TrimRight ();
if (strR.IsEmpty () || strG.IsEmpty () || strB.IsEmpty ())
{
if (!ParseString (strItem, _T(","), sa, TRUE, FALSE))
{
strR = tm.GetBuffer ();
strR.TrimLeft ();
strR.TrimRight ();
sa.Add (strR);
}
}
else
{
sa.Add (strR);
sa.Add (strG);
sa.Add (strB);
if (!strA.IsEmpty ())
{
sa.Add (strA);
}
}
if (sa.GetSize () > 0)
{
const int count = (int) sa.GetSize ();
if (count >= 3)
{
value.r = bcg_clamp((double)_ttol(sa[0]) / 255.0, 0.0, 1.0);
value.g = bcg_clamp((double)_ttol(sa[1]) / 255.0, 0.0, 1.0);
value.b = bcg_clamp((double)_ttol(sa[2]) / 255.0, 0.0, 1.0);
value.a = count == 4 ? bcg_clamp((double)_ttol(sa[3]) / 255.0, 0.0, 1.0) : 1.0;
return TRUE;
}
}
return FALSE;
}
BOOL CBCGPTagManager::ParsePoint (const CString& strItem, CPoint& value)
{
CBCGPTagManager tm (strItem);
CStringArray sa;
CString strX, strY;
tm.ExcludeTag (s_X, strX);
strX.TrimLeft ();
strX.TrimRight ();
tm.ExcludeTag (s_Y, strY);
strY.TrimLeft ();
strY.TrimRight ();
if (strX.IsEmpty () || strY.IsEmpty ())
{
if (!ParseString (tm.GetBuffer (), _T(","), sa, TRUE, FALSE))
{
return FALSE;
}
}
else
{
sa.Add (strX);
sa.Add (strY);
}
if (sa.GetSize () == 2)
{
value.x = _ttol(sa[0]);
value.y = _ttol(sa[1]);
return TRUE;
}
return FALSE;
}
BOOL CBCGPTagManager::ParseSize (const CString& strItem, CSize& value)
{
CBCGPTagManager tm (strItem);
CStringArray sa;
CString strW, strH;
tm.ExcludeTag (s_Width, strW);
strW.TrimLeft ();
strW.TrimRight ();
tm.ExcludeTag (s_Height, strH);
strH.TrimLeft ();
strH.TrimRight ();
if (strW.IsEmpty () || strH.IsEmpty ())
{
if (!ParseString (tm.GetBuffer (), _T(","), sa, TRUE, FALSE))
{
return FALSE;
}
}
else
{
sa.Add (strW);
sa.Add (strH);
}
if (sa.GetSize () == 2)
{
value.cx = _ttol(sa[0]);
value.cy = _ttol(sa[1]);
return TRUE;
}
return FALSE;
}
BOOL CBCGPTagManager::ParseBrush (const CString& strItem, CBCGPBrush& value)
{
CBCGPTagManager tm (strItem);
int type = CBCGPBrush::BCGP_NO_GRADIENT;
tm.ReadInt(s_BrushType, type);
type = bcg_clamp(type, CBCGPBrush::BCGP_NO_GRADIENT, CBCGPBrush::BCGP_GRADIENT_RADIAL_BOTTOM_RIGHT);
int opacity = 255;
tm.ReadInt (s_Opacity, opacity);
if (type == CBCGPBrush::BCGP_NO_GRADIENT)
{
CBCGPColor clr;
tm.ReadColor (s_BrushColor, clr);
value.SetColor (clr, bcg_clamp((double)opacity / 255.0, 0.0, 1.0));
}
else
{
CString strColors;
if (tm.ExcludeTag (s_BrushColors, strColors))
{
CBCGPTagManager tmColors(strColors);
CBCGPColor clr1;
tmColors.ReadColor (s_BrushColor, clr1);
CBCGPColor clr2;
tmColors.ReadColor (s_BrushColor, clr2);
value.SetColors (clr1, clr2, (CBCGPBrush::BCGP_GRADIENT_TYPE)type, bcg_clamp((double)opacity / 255.0, 0.0, 1.0));
}
}
return TRUE;
}
BOOL CBCGPTagManager::ParseGridColorData (const CString& strItem, BCGP_GRID_COLOR_DATA::ColorData& value)
{
CBCGPTagManager tm (strItem);
value.InitColors ();
tm.ReadColor (s_ColorFill , value.m_clrBackground);
tm.ReadColor (s_ColorText , value.m_clrText);
tm.ReadColor (s_ColorFillGradient, value.m_clrGradient);
tm.ReadInt (s_GradientAngle , value.m_nGradientAngle);
tm.ReadColor (s_ColorBorder , value.m_clrBorder);
return TRUE;
}
BOOL CBCGPTagManager::ParseControlRendererParams (const CString& strItem, CBCGPControlRendererParams& value)
{
CBCGPTagManager tm (strItem);
CBCGPControlRendererParams params;
params.SetResourceID (value.GetResourceID ());
#ifndef _BCGSUITE_
params.SetBaseColor (m_clrBase, m_clrTarget);
#endif
if (!tm.ReadRect (s_Rect, params.m_rectImage))
{
CSize size;
if (tm.ReadSize (s_Size, size))
{
params.m_rectImage = CRect (CPoint (0, 0), size);
}
}
if (params.m_rectImage.IsRectEmpty ())
{
return FALSE;
}
tm.ReadRect (s_Corners, params.m_rectCorners);
tm.ReadRect (s_Sides, params.m_rectSides);
tm.ReadRect (s_Interior, params.m_rectInter);
tm.ReadColor (s_Transparent, params.m_clrTransparent);
tm.ReadBool (s_PreMltCheck, params.m_bPreMultiplyCheck);
value = params;
return TRUE;
}
void CSetPageBase::InitPropList()
{
CBCGPTagManager tm;
CString strRes(_T("IDR_SETCONFIG_XML_") + m_strConfigName.MakeUpper());
if (!tm.LoadFromResource(strRes, _T("XML")))
{
return;
}
CString strStyle;
if (!tm.ExcludeTag(_T("SETCONFIG"), strStyle))
{
return;
}
tm.SetBuffer(strStyle);
int nVersion;
tm.ReadInt(_T("VERSION"), nVersion);
if (nVersion != 1)
{
return;
}
CString strPropertys;
if (tm.ExcludeTag(_T("PROPERTYS"), strPropertys))
{
CBCGPTagManager tmPropertys(strPropertys);
CMyBCGPProp* pPropGroup = NULL;
CString strProperty;
while (tmPropertys.ExcludeTag(_T("PROPERTY"), strProperty))
{
CBCGPTagManager tmProperty(strProperty);
CString strName = _T("NO NAME");
tmProperty.ReadString(_T("NAME"), strName);
BOOL bGroup = FALSE;
if (tmProperty.ReadBool(_T("GROUP"), bGroup) && bGroup)
{
if (pPropGroup)
{
m_wndPropList.AddProperty(pPropGroup, FALSE, FALSE);
pPropGroup = NULL;
}
pPropGroup = new CMyBCGPProp(strName);
}
else if (pPropGroup)
{
CString strType = _T("Combo");
tmProperty.ReadString(_T("TYPE"), strType);
if (strType.CompareNoCase(_T("Combo")) == 0)
{
CString strValue;
tmProperty.ReadString(_T("VALUE"), strValue);
CMyBCGPProp* pProp = new CMyBCGPProp(strName, (_variant_t)strValue);
CString strItem;
while (tmProperty.ExcludeTag(_T("ITEM"), strItem))
{
CBCGPTagManager tmItem(strItem);
tmItem.ReadString(_T("VALUE"), strValue);
CString strShort, strPreview;
tmItem.ReadString(_T("SHORT"), strShort);
tmItem.ReadString(_T("PREVIEW"), strPreview);
Entity_Backward(strPreview, s_EntityText);
EntityToSymbol(strPreview);
pProp->AddComboOption(strValue, strShort, strPreview);
}
pPropGroup->AddSubItem(pProp);
}
else if (strType.CompareNoCase(_T("Number")) == 0)
{
int nValue;
tmProperty.ReadInt(_T("VALUE"), nValue);
CMyBCGPProp* pProp = new CMyBCGPProp(strName, (_variant_t)nValue);
CSize range;
tmProperty.ReadSize(_T("RANGE"), range);
BOOL bBuddy = FALSE;
tmProperty.ReadBool(_T("BUDDY"), bBuddy);
CMyBCGPProp* pPropBuddy = NULL;
if (bBuddy)
{
pPropBuddy = DYNAMIC_DOWNCAST(CMyBCGPProp, pPropGroup->GetSubItem(pPropGroup->GetSubItemsCount() - 1));
}
CString strShort, strPreview;
tmProperty.ReadString(_T("SHORT"), strShort);
tmProperty.ReadString(_T("PREVIEW"), strPreview);
Entity_Backward(strPreview, s_EntityText);
EntityToSymbol(strPreview);
pProp->SetNumberSpin(range.cx, range.cy, strShort, strPreview, pPropBuddy);
pPropGroup->AddSubItem(pProp);
}
else if (strType.CompareNoCase(_T("Text")) == 0)
{
CString strValue;
tmProperty.ReadString(_T("VALUE"), strValue);
CMyBCGPProp* pProp = new CMyBCGPProp(strName, (_variant_t)strValue);
CString strShort, strPreview;
tmProperty.ReadString(_T("SHORT"), strShort);
tmProperty.ReadString(_T("PREVIEW"), strPreview);
Entity_Backward(strPreview, s_EntityText);
EntityToSymbol(strPreview);
pProp->SetEditText(strShort, strPreview);
pPropGroup->AddSubItem(pProp);
}
}
}
if (pPropGroup)
{
m_wndPropList.AddProperty(pPropGroup, FALSE, FALSE);
pPropGroup = NULL;
}
}
}
BOOL CBCGPTagManager::ParseFont (const CString& strItem, LOGFONT& value)
{
CBCGPTagManager tm (strItem);
CString strFontItem;
if (tm.ExcludeTag (s_FaceName, strFontItem))
{
ASSERT(!strFontItem.IsEmpty ());
if (!strFontItem.IsEmpty ())
{
memcpy (value.lfFaceName, (LPCTSTR)strFontItem, min(strFontItem.GetLength (), LF_FACESIZE) * sizeof(TCHAR));
}
}
int val = 0;
if (tm.ReadInt (s_Height, val))
{
value.lfHeight = val;
}
if (value.lfHeight > 0)
{
if (tm.ReadInt (s_Width, val))
{
value.lfWidth = val;
}
}
if (tm.ExcludeTag (s_Weight, strFontItem))
{
struct WEIGHT_FONT_TYPE
{
LPCTSTR name;
LONG weight;
};
const WEIGHT_FONT_TYPE WEIGHT_FONT_TYPES[] =
{
{_T("DONTCARE") , FW_DONTCARE },
{_T("THIN") , FW_THIN },
{_T("EXTRALIGHT"), FW_EXTRALIGHT},
{_T("LIGHT") , FW_LIGHT },
{_T("NORMAL") , FW_NORMAL },
{_T("MEDIUM") , FW_MEDIUM },
{_T("SEMIBOLD") , FW_SEMIBOLD },
{_T("BOLD") , FW_BOLD },
{_T("EXTRABOLD") , FW_EXTRABOLD },
{_T("HEAVY") , FW_HEAVY },
{_T("ULTRALIGHT"), FW_ULTRALIGHT},
{_T("REGULAR") , FW_REGULAR },
{_T("DEMIBOLD") , FW_DEMIBOLD },
{_T("ULTRABOLD") , FW_ULTRABOLD },
{_T("BLACK") , FW_BLACK }
};
for(long i = 0; i < sizeof(WEIGHT_FONT_TYPES) / sizeof(WEIGHT_FONT_TYPE); i++)
{
if(strFontItem.CompareNoCase (WEIGHT_FONT_TYPES[i].name) == 0)
{
value.lfWeight = WEIGHT_FONT_TYPES[i].weight;
break;
}
}
}
if(tm.ExcludeTag (s_Quality, strFontItem))
{
struct QUALITY_FONT_TYPE
{
LPCTSTR name;
BYTE quality;
};
const QUALITY_FONT_TYPE QUALITY_FONT_TYPES[] =
{
{_T("DEFAULT") , DEFAULT_QUALITY },
{_T("DRAFT") , DRAFT_QUALITY },
{_T("PROOF") , PROOF_QUALITY },
{_T("NONANTIALIASED") , NONANTIALIASED_QUALITY },
{_T("ANTIALIASED") , ANTIALIASED_QUALITY },
{_T("CLEARTYPE") , 5},//CLEARTYPE_QUALITY
{_T("CLEARTYPE_NATURAL"), 6} //CLEARTYPE_NATURAL_QUALITY
};
for(long i = 0; i < sizeof(QUALITY_FONT_TYPES) / sizeof(QUALITY_FONT_TYPE); i++)
{
if(strFontItem.CompareNoCase (QUALITY_FONT_TYPES[i].name) == 0)
{
if (QUALITY_FONT_TYPES[i].quality <= ANTIALIASED_QUALITY)
{
value.lfQuality = QUALITY_FONT_TYPES[i].quality;
}
else
{
OSVERSIONINFO osvi;
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
::GetVersionEx (&osvi);
if(osvi.dwPlatformId == VER_PLATFORM_WIN32_NT &&
osvi.dwMajorVersion >= 5)
{
value.lfQuality = QUALITY_FONT_TYPES[i].quality;
}
}
break;
}
}
}
return TRUE;
}
BOOL CBCGPTagManager::ParseRect (const CString& strItem, CRect& value)
{
CBCGPTagManager tm (strItem);
CString str1;
CString str2;
tm.ExcludeTag (s_Offset, str1);
str1.TrimLeft ();
str1.TrimRight ();
tm.ExcludeTag (s_Size, str2);
str2.TrimLeft ();
str2.TrimRight ();
CPoint pt (0, 0);
CSize sz (0, 0);
if (ParsePoint (str1, pt) && ParseSize (str2, sz))
{
value = CRect (pt, sz);
return TRUE;
}
tm.SetBuffer (strItem);
tm.ExcludeTag (s_LT, str1);
str1.TrimLeft ();
str1.TrimRight ();
tm.ExcludeTag (s_RB, str2);
str2.TrimLeft ();
str2.TrimRight ();
CPoint pt2 (0, 0);
if (ParsePoint (str1, pt) && ParsePoint (str2, pt2))
{
value = CRect (pt, pt2);
return TRUE;
}
CStringArray sa;
CString strL, strT, strR, strB;
tm.SetBuffer (strItem);
tm.ExcludeTag (s_Left, strL);
strL.TrimLeft ();
strL.TrimRight ();
tm.ExcludeTag (s_Top, strT);
strT.TrimLeft ();
strT.TrimRight ();
tm.ExcludeTag (s_Right, strR);
strR.TrimLeft ();
strR.TrimRight ();
tm.ExcludeTag (s_Bottom, strB);
strB.TrimLeft ();
strB.TrimRight ();
if (strL.IsEmpty () || strT.IsEmpty () || strR.IsEmpty () || strB.IsEmpty ())
{
if (!ParseString (tm.GetBuffer (), _T(","), sa, TRUE, FALSE))
{
return FALSE;
}
}
else
{
sa.Add (strL);
sa.Add (strT);
sa.Add (strR);
sa.Add (strB);
}
if (sa.GetSize () == 4)
{
value.left = _ttol(sa[0]);
value.top = _ttol(sa[1]);
value.right = _ttol(sa[2]);
value.bottom = _ttol(sa[3]);
return TRUE;
}
return FALSE;
}
BOOL CBCGPTagManager::ParseColor (const CString& strItem, COLORREF& value)
{
CBCGPTagManager tm (strItem);
CStringArray sa;
CString strA, strR, strG, strB;
tm.ExcludeTag (s_A, strA);
strA.TrimLeft ();
strA.TrimRight ();
tm.ExcludeTag (s_R, strR);
strR.TrimLeft ();
strR.TrimRight ();
tm.ExcludeTag (s_G, strG);
strG.TrimLeft ();
strG.TrimRight ();
tm.ExcludeTag (s_B, strB);
strB.TrimLeft ();
strB.TrimRight ();
if (strR.IsEmpty () || strG.IsEmpty () || strB.IsEmpty ())
{
if (!ParseString (strItem, _T(","), sa, TRUE, FALSE))
{
strR = tm.GetBuffer ();
strR.TrimLeft ();
strR.TrimRight ();
sa.Add (strR);
}
}
else
{
sa.Add (strR);
sa.Add (strG);
sa.Add (strB);
if (!strA.IsEmpty ())
{
sa.Add (strA);
}
}
if (sa.GetSize () > 0)
{
const int count = (int) sa.GetSize ();
if (count == 3)
{
value = AddaptColor (RGB((BYTE)_ttol(sa[0]), (BYTE)_ttol(sa[1]), (BYTE)_ttol(sa[2])),
m_clrBase, m_clrTarget);
return TRUE;
}
else if (count == 4)
{
value = RGB((BYTE)_ttol(sa[0]), (BYTE)_ttol(sa[1]), (BYTE)_ttol(sa[2])) | (((DWORD)(BYTE)(_ttol(sa[3]))) << 24);
return TRUE;
}
else if (count == 1)
{
value = (COLORREF)_ttol(sa[0]);
return TRUE;
}
}
return FALSE;
}
BOOL CBCGPTagManager::ParseGridColors (const CString& strItem, BCGP_GRID_COLOR_DATA& value)
{
CBCGPGridColors colors;
CBCGPTagManager tm (strItem);
tm.ReadGridColorData (s_Grid_EvenColors , colors.m_EvenColors);
tm.ReadGridColorData (s_Grid_OddColors , colors.m_OddColors);
tm.ReadGridColorData (s_Grid_GroupColors , colors.m_GroupColors);
tm.ReadGridColorData (s_Grid_GroupSelColors , colors.m_GroupSelColors);
tm.ReadGridColorData (s_Grid_SelColors , colors.m_SelColors);
tm.ReadGridColorData (s_Grid_HeaderColors , colors.m_HeaderColors);
tm.ReadGridColorData (s_Grid_HeaderSelColors , colors.m_HeaderSelColors);
tm.ReadGridColorData (s_Grid_LeftOffsetColors , colors.m_LeftOffsetColors);
tm.ReadColor (s_ColorBackground , colors.m_clrBackground);
tm.ReadColor (s_ColorText , colors.m_clrText);
tm.ReadColor (s_Grid_ColorHeader , colors.m_clrHeader);
tm.ReadColor (s_Grid_ColorHorzLine , colors.m_clrHorzLine);
tm.ReadColor (s_Grid_ColorVertLine , colors.m_clrVertLine);
tm.ReadColor (s_Grid_ColorPreviewText, colors.m_clrPreviewText);
value = colors;
return TRUE;
}
BOOL CBCGPTagManager::ParseTextFormat (const CString& strItem, CBCGPTextFormat& value)
{
CBCGPTagManager tm (strItem);
CString family;
tm.ReadString (s_TextFormatFamily, family);
if (family.IsEmpty ())
{
return FALSE;
}
double size = 0.0;
tm.ReadDouble (s_TextFormatSize, size);
if (size == 0.0)
{
return FALSE;
}
int nValue = 0;
tm.ReadInt (s_TextFormatWeight, nValue);
long weight = (long)bcg_clamp(nValue, FW_THIN, FW_HEAVY);
nValue = (int)CBCGPTextFormat::BCGP_FONT_STYLE_NORMAL;
tm.ReadInt (s_TextFormatStyle, nValue);
CBCGPTextFormat::BCGP_FONT_STYLE style = (CBCGPTextFormat::BCGP_FONT_STYLE)
bcg_clamp(nValue, (int)CBCGPTextFormat::BCGP_FONT_STYLE_NORMAL, (int)CBCGPTextFormat::BCGP_FONT_STYLE_ITALIC);
CString locale;
tm.ReadString (s_TextFormatLocale, locale);
CBCGPTextFormat format(family, (float)size, weight, style, locale);
nValue = (int)CBCGPTextFormat::BCGP_TEXT_ALIGNMENT_LEADING;
tm.ReadInt (s_TextFormatAlignHorz, nValue);
format.SetTextAlignment ((CBCGPTextFormat::BCGP_TEXT_ALIGNMENT)
bcg_clamp(nValue, (int)CBCGPTextFormat::BCGP_TEXT_ALIGNMENT_LEADING, (int)CBCGPTextFormat::BCGP_TEXT_ALIGNMENT_CENTER));
nValue = (int)CBCGPTextFormat::BCGP_TEXT_ALIGNMENT_LEADING;
tm.ReadInt (s_TextFormatAlignVert, nValue);
format.SetTextVerticalAlignment ((CBCGPTextFormat::BCGP_TEXT_ALIGNMENT)
bcg_clamp(nValue, (int)CBCGPTextFormat::BCGP_TEXT_ALIGNMENT_LEADING, (int)CBCGPTextFormat::BCGP_TEXT_ALIGNMENT_CENTER));
BOOL bValue = FALSE;
tm.ReadBool (s_TextFormatWordWrap, bValue);
format.SetWordWrap (bValue);
bValue = FALSE;
tm.ReadBool (s_TextFormatClipping, bValue);
format.SetClipText (bValue);
double dValue = 0.0;
tm.ReadDouble (s_TextFormatAngle, dValue);
format.SetDrawingAngle (dValue);
value = format;
return TRUE;
}
BOOL CBCGPTagManager::ParseToolTipParams (const CString& strItem, CBCGPToolTipParams& value)
{
CBCGPTagManager tm (strItem);
CBCGPToolTipParams params;
#ifndef _BCGSUITE_
tm.ReadBool (s_TTP_BallonTooltip , params.m_bBallonTooltip);
#else
tm.ReadBool (s_TTP_BallonTooltip , params.m_bBalloonTooltip);
#endif
tm.ReadBool (s_TTP_DrawIcon , params.m_bDrawIcon);
tm.ReadBool (s_TTP_DrawDescription , params.m_bDrawDescription);
tm.ReadInt (s_TTP_MaxDescrWidth , params.m_nMaxDescrWidth);
tm.ReadBool (s_TTP_RoundedCorners , params.m_bRoundedCorners);
tm.ReadBool (s_TTP_BoldLabel , params.m_bBoldLabel);
tm.ReadColor (s_ColorFill , params.m_clrFill);
tm.ReadColor (s_ColorFillGradient , params.m_clrFillGradient);
tm.ReadInt (s_GradientAngle , params.m_nGradientAngle);
tm.ReadColor (s_ColorText , params.m_clrText);
tm.ReadColor (s_ColorBorder , params.m_clrBorder);
tm.ReadBool (s_TTP_DrawSeparator , params.m_bDrawSeparator);
value = params;
return TRUE;
}