CString CBCGPTagManager::WriteBrush (const CString& strTag, const CBCGPBrush& value)
{
CString strValue;
WriteTag (strValue, WriteInt (s_BrushType, value.GetGradientType(), CBCGPBrush::BCGP_NO_GRADIENT));
if (value.GetGradientType() == CBCGPBrush::BCGP_NO_GRADIENT)
{
WriteTag (strValue, WriteColor (s_BrushColor, value.GetColor()));
}
else
{
CString strColors;
WriteTag (strColors, WriteColor (s_BrushColor, value.GetColor()));
WriteTag (strColors, WriteColor (s_BrushColor, value.GetGradientColor()));
WriteItem (strValue, s_BrushColors, strColors);
}
WriteTag (strValue, WriteInt (s_Opacity, bcg_clamp(bcg_round(value.GetOpacity() * 255.0), 0, 255), 255));
CString str;
WriteItem (str, strTag, strValue);
return str;
}
void TextComp::Write (ostream& out) {
GraphicComp::Write(out);
TextGraphic* text = GetText();
out << text->GetLineHeight() << "\n";
WriteString(text->GetOriginal(), out);
WriteBgFilled(text->BgFilled(), out);
WriteColor(text->GetFgColor(), out);
WriteColor(text->GetBgColor(), out);
WriteFont(text->GetFont(), out);
WriteTransformer(text->GetTransformer(), out);
}
void LineComp::Write (ostream& out) {
GraphicComp::Write(out);
Line* line = GetLine();
Coord x0, y0, x1, y1;
line->GetOriginal(x0, y0, x1, y1);
out << x0 << " " << y0 << " " << x1 << " " << y1 << " ";
WriteBgFilled(line->BgFilled(), out);
WriteColor(line->GetFgColor(), out);
WriteColor(line->GetBgColor(), out);
WriteBrush(line->GetBrush(), out);
WriteTransformer(line->GetTransformer(), out);
}
void SplineComp::Write (ostream& out) {
VerticesComp::Write(out);
SFH_OpenBSpline* spline = GetSpline();
const Coord* x, *y;
int count = spline->GetOriginal(x, y);
WriteVertices(x, y, count, out);
WriteBgFilled(spline->BgFilled(), out);
WriteColor(spline->GetFgColor(), out);
WriteColor(spline->GetBgColor(), out);
WriteBrush(spline->GetBrush(), out);
WritePattern(spline->GetPattern(), out);
WriteTransformer(spline->GetTransformer(), out);
}
void PinComp::Write (ostream& out) {
Connector::Write(out);
PinGraphic* pin = GetPin();
Coord x0, y0;
int mobility = _mobility;
pin->GetOriginal(x0, y0);
out << x0 << " " << y0 << " " << mobility << " ";
WriteBgFilled(pin->BgFilled(), out);
WriteColor(pin->GetFgColor(), out);
WriteColor(pin->GetBgColor(), out);
WriteBrush(pin->GetBrush(), out);
WriteTransformer(pin->GetTransformer(), out);
}
void RectComp::Write (ostream& out) {
GraphicComp::Write(out);
SF_Rect* rect = GetRect();
Coord x0, y0, x1, y1;
rect->GetOriginal(x0, y0, x1, y1);
out << x0 << " " << y0 << " " << x1 << " " << y1 << " ";
WriteBgFilled(rect->BgFilled(), out);
WriteColor(rect->GetFgColor(), out);
WriteColor(rect->GetBgColor(), out);
WriteBrush(rect->GetBrush(), out);
WritePattern(rect->GetPattern(), out);
WriteTransformer(rect->GetTransformer(), out);
}
void PadComp::Write (ostream& out) {
Connector::Write(out);
PadGraphic* pad = GetPad();
Coord l, b, r, t;
int mobility = _mobility;
pad->GetOriginal(l, b, r, t);
out << l << " " << b << " " << r << " " << t << " " << mobility << " ";
WriteBgFilled(pad->BgFilled(), out);
WriteColor(pad->GetFgColor(), out);
WriteColor(pad->GetBgColor(), out);
WriteBrush(pad->GetBrush(), out);
WriteTransformer(pad->GetTransformer(), out);
}
void MultiLineComp::Write (ostream& out) {
VerticesComp::Write(out);
SF_MultiLine* ml = GetMultiLine();
const Coord* x, *y;
int count = ml->GetOriginal(x, y);
WriteVertices(x, y, count, out);
WriteBgFilled(ml->BgFilled(), out);
WriteColor(ml->GetFgColor(), out);
WriteColor(ml->GetBgColor(), out);
WriteBrush(ml->GetBrush(), out);
WritePattern(ml->GetPattern(), out);
WriteTransformer(ml->GetTransformer(), out);
}
void EllipseComp::Write (ostream& out) {
GraphicComp::Write(out);
SF_Ellipse* ellipse = GetEllipse();
Coord x0, y0;
int r1, r2;
ellipse->GetOriginal(x0, y0, r1, r2);
out << x0 << " " << y0 << " " << r1 << " " << r2 << " ";
WriteBgFilled(ellipse->BgFilled(), out);
WriteColor(ellipse->GetFgColor(), out);
WriteColor(ellipse->GetBgColor(), out);
WriteBrush(ellipse->GetBrush(), out);
WritePattern(ellipse->GetPattern(), out);
WriteTransformer(ellipse->GetTransformer(), out);
}
void LinkComp::Write (ostream& out) {
GraphicComp::Write(out);
Line* line = GetLine();
WriteTransformer(line->GetTransformer(), out);
unidraw->GetCatalog()->WriteComponent(_conn1, out);
unidraw->GetCatalog()->WriteComponent(_conn2, out);
Graphic* parent = line->Parent();
WriteBgFilled(parent->BgFilled(), out);
WriteColor(parent->GetFgColor(), out);
WriteColor(parent->GetBgColor(), out);
WriteBrush(parent->GetBrush(), out);
WriteTransformer(parent->GetTransformer(), out);
}
// message proccessor
LRESULT CALLBACK MessageWindowWinproc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
switch (message) {
case WM_QCP_PICK:
{
::SetActiveWindow(nppData._nppHandle);
WriteColor((COLORREF)wparam);
break;
}
case WM_QCP_CANCEL:
{
::SetActiveWindow(nppData._nppHandle);
break;
}
case WM_QCP_START_SCREEN_PICKER:
{
::SetWindowPos(nppData._nppHandle, HWND_BOTTOM, 0,0,0,0, SWP_NOMOVE|SWP_NOSIZE);
}
case WM_QCP_END_SCREEN_PICKER:
{
::ShowWindow(nppData._nppHandle, SW_SHOW);
}
default:
{
return TRUE;
}
}
return TRUE;
}
static INLINE UINT32 gdi_SetPixelBmp(HGDI_BITMAP hBmp, UINT32 X, UINT32 Y,
UINT32 crColor)
{
BYTE* p = &hBmp->data[(Y * hBmp->scanline) + X * GetBytesPerPixel(
hBmp->format)];
WriteColor(p, hBmp->format, crColor);
return crColor;
}
CString CBCGPTagManager::WriteColor (const CString& strTag, const CBCGPColor& value, const CBCGPColor& valueDefault)
{
if (value == valueDefault)
{
return CString ();
}
return WriteColor (strTag, value);
}
static int freerdp_image_copy_from_retina(BYTE* pDstData, DWORD DstFormat,
int nDstStep, int nXDst, int nYDst,
int nWidth, int nHeight, BYTE* pSrcData, int nSrcStep, int nXSrc, int nYSrc)
{
BYTE* pSrcPixel;
BYTE* pDstPixel;
int x, y;
int nSrcPad;
int nDstPad;
int srcBitsPerPixel;
int srcBytesPerPixel;
int dstBitsPerPixel;
int dstBytesPerPixel;
srcBitsPerPixel = 24;
srcBytesPerPixel = 8;
if (nSrcStep < 0)
nSrcStep = srcBytesPerPixel * nWidth;
dstBitsPerPixel = GetBitsPerPixel(DstFormat);
dstBytesPerPixel = GetBytesPerPixel(DstFormat);
if (nDstStep < 0)
nDstStep = dstBytesPerPixel * nWidth;
nSrcPad = (nSrcStep - (nWidth * srcBytesPerPixel));
nDstPad = (nDstStep - (nWidth * dstBytesPerPixel));
pSrcPixel = &pSrcData[(nYSrc * nSrcStep) + (nXSrc * 4)];
pDstPixel = &pDstData[(nYDst * nDstStep) + (nXDst * 4)];
for (y = 0; y < nHeight; y++)
{
for (x = 0; x < nWidth; x++)
{
UINT32 R, G, B;
UINT32 color;
/* simple box filter scaling, could be improved with better algorithm */
B = pSrcPixel[0] + pSrcPixel[4] + pSrcPixel[nSrcStep + 0] + pSrcPixel[nSrcStep +
4];
G = pSrcPixel[1] + pSrcPixel[5] + pSrcPixel[nSrcStep + 1] + pSrcPixel[nSrcStep +
5];
R = pSrcPixel[2] + pSrcPixel[6] + pSrcPixel[nSrcStep + 2] + pSrcPixel[nSrcStep +
6];
pSrcPixel += 8;
color = GetColor(DstFormat, R >> 2, G >> 2, B >> 2, 0xFF);
WriteColor(pDstPixel, DstFormat, color);
pDstPixel += dstBytesPerPixel;
}
pSrcPixel = &pSrcPixel[nSrcPad + nSrcStep];
pDstPixel = &pDstPixel[nDstPad];
}
return 1;
}
BOOL gdi_Rectangle(HGDI_DC hdc, UINT32 nXDst, UINT32 nYDst, UINT32 nWidth,
UINT32 nHeight)
{
UINT32 x, y;
UINT32 color;
if (!gdi_ClipCoords(hdc, &nXDst, &nYDst, &nWidth, &nHeight, NULL, NULL))
return TRUE;
color = hdc->textColor;
color = GetColor(hdc->format, 0, 0xFF, 0, 0xFF);
for (y = 0; y < nHeight; y++)
{
BYTE* dstLeft = gdi_get_bitmap_pointer(hdc, nXDst,
nYDst + y);
BYTE* dstRight = gdi_get_bitmap_pointer(hdc, nXDst + nWidth - 1,
nYDst + y);
if (dstLeft)
WriteColor(dstLeft, hdc->format, color);
if (dstRight)
WriteColor(dstRight, hdc->format, color);
}
for (x = 0; x < nWidth; x++)
{
BYTE* dstTop = gdi_get_bitmap_pointer(hdc, nXDst + x,
nYDst);
BYTE* dstBottom = gdi_get_bitmap_pointer(hdc, nXDst + x,
nYDst + nHeight - 1);
if (dstTop)
WriteColor(dstTop, hdc->format, color);
if (dstBottom)
WriteColor(dstBottom, hdc->format, color);
}
return FALSE;
}
void StencilComp::Write (ostream& out) {
GraphicComp::Write(out);
UStencil* stencil = GetStencil();
Bitmap* image, *mask;
stencil->GetOriginal(image, mask);
WriteBitmap(image, out);
Mark(out);
if (mask == nil) {
out << no_mask;
} else if (mask == image) {
out << mask_equals_image;
} else {
out << valid_mask;
WriteBitmap(mask, out);
}
WriteBgFilled(stencil->BgFilled(), out);
WriteColor(stencil->GetFgColor(), out);
WriteColor(stencil->GetBgColor(), out);
WriteTransformer(stencil->GetTransformer(), out);
WriteString(_filename, out);
}
//保存配置
bool __cdecl CSkinEditAttribute::SaveSkinOption()
{
WriteColor(SKIN_EDIT_CRFOCUSTX,m_crFocusTX);
WriteColor(SKIN_EDIT_CRFOCUSBK,m_crFocusBK);
WriteColor(SKIN_EDIT_CRNOFOCUSTX,m_crNoFocusTX);
WriteColor(SKIN_EDIT_CRNOFOCUSBK,m_crNoFocusBK);
WriteColor(SKIN_EDIT_CRDISFOCUSTX,m_crDisFocusTK);
WriteColor(SKIN_EDIT_CRDISFOCUSBK,m_crDisFocusBK);
return true;
}
bool Serializer::WriteVariantData(const Variant& value)
{
switch (value.GetType())
{
case VAR_NONE:
return true;
case VAR_INT:
return WriteInt(value.GetInt());
case VAR_BOOL:
return WriteBool(value.GetBool());
case VAR_FLOAT:
return WriteFloat(value.GetFloat());
case VAR_VECTOR2:
return WriteVector2(value.GetVector2());
case VAR_VECTOR3:
return WriteVector3(value.GetVector3());
case VAR_VECTOR4:
return WriteVector4(value.GetVector4());
case VAR_QUATERNION:
return WriteQuaternion(value.GetQuaternion());
case VAR_COLOR:
return WriteColor(value.GetColor());
case VAR_STRING:
return WriteString(value.GetString());
case VAR_BUFFER:
return WriteBuffer(value.GetBuffer());
// Serializing pointers is not supported. Write null
case VAR_VOIDPTR:
case VAR_PTR:
return WriteUInt(0);
case VAR_RESOURCEREF:
return WriteResourceRef(value.GetResourceRef());
case VAR_RESOURCEREFLIST:
return WriteResourceRefList(value.GetResourceRefList());
case VAR_VARIANTVECTOR:
return WriteVariantVector(value.GetVariantVector());
case VAR_VARIANTMAP:
return WriteVariantMap(value.GetVariantMap());
case VAR_INTRECT:
return WriteIntRect(value.GetIntRect());
case VAR_INTVECTOR2:
return WriteIntVector2(value.GetIntVector2());
case VAR_MATRIX3:
return WriteMatrix3(value.GetMatrix3());
case VAR_MATRIX3X4:
return WriteMatrix3x4(value.GetMatrix3x4());
case VAR_MATRIX4:
return WriteMatrix4(value.GetMatrix4());
default:
return false;
}
}
BOOL gdi_FillRect(HGDI_DC hdc, const HGDI_RECT rect, HGDI_BRUSH hbr)
{
UINT32 x, y;
UINT32 color, dstColor;
BOOL monochrome = FALSE;
UINT32 nXDest, nYDest;
UINT32 nWidth, nHeight;
const BYTE* srcp;
DWORD formatSize;
gdi_RectToCRgn(rect, &nXDest, &nYDest, &nWidth, &nHeight);
if (!hdc || !hbr)
return FALSE;
if (!gdi_ClipCoords(hdc, &nXDest, &nYDest, &nWidth, &nHeight, NULL, NULL))
return TRUE;
switch (hbr->style)
{
case GDI_BS_SOLID:
color = hbr->color;
for (x = 0; x < nWidth; x++)
{
BYTE* dstp = gdi_get_bitmap_pointer(hdc, nXDest + x,
nYDest);
if (dstp)
WriteColor(dstp, hdc->format, color);
}
srcp = gdi_get_bitmap_pointer(hdc, nXDest, nYDest);
formatSize = GetBytesPerPixel(hdc->format);
for (y = 1; y < nHeight; y++)
{
BYTE* dstp = gdi_get_bitmap_pointer(hdc, nXDest, nYDest + y);
memcpy(dstp, srcp, nWidth * formatSize);
}
break;
case GDI_BS_HATCHED:
case GDI_BS_PATTERN:
monochrome = (hbr->pattern->format == PIXEL_FORMAT_MONO);
formatSize = GetBytesPerPixel(hbr->pattern->format);
for (y = 0; y < nHeight; y++)
{
for (x = 0; x < nWidth; x++)
{
const UINT32 yOffset = ((nYDest + y) * hbr->pattern->width %
hbr->pattern->height) * formatSize;
const UINT32 xOffset = ((nXDest + x) % hbr->pattern->width) * formatSize;
const BYTE* patp = &hbr->pattern->data[yOffset + xOffset];
BYTE* dstp = gdi_get_bitmap_pointer(hdc, nXDest + x,
nYDest + y);
if (!patp)
return FALSE;
if (monochrome)
{
if (*patp == 0)
dstColor = hdc->bkColor;
else
dstColor = hdc->textColor;
}
else
{
dstColor = ReadColor(patp, hbr->pattern->format);
dstColor = ConvertColor(dstColor, hbr->pattern->format, hdc->format, NULL);
}
if (dstp)
WriteColor(dstp, hdc->format, dstColor);
}
}
break;
default:
break;
}
if (!gdi_InvalidateRegion(hdc, nXDest, nYDest, nWidth, nHeight))
return FALSE;
return TRUE;
}
void cvCPref::WritePrefs()
{
UpdateData();
m_d_DensityPlot=m_d_dplotlist.GetCurSel();
m_d_EditAction=m_d_editlist.GetCurSel();
m_d_VectorPlot=m_d_vplotlist.GetCurSel();
FILE *fp;
CString fname = ((CFemmApp *)AfxGetApp())->GetExecutablePath() + "cview.cfg";
fp=fopen(fname,"wt");
if (fp!=NULL)
{
WriteColor("SelColor",SelColor,fp);
WriteColor("BkgndColor",BackColor,fp);
WriteColor("MeshColor",MeshColor,fp);
WriteColor("BlockColor",BlockColor,fp);
WriteColor("LineColor",LineColor,fp);
WriteColor("GridColor",GridColor,fp);
WriteColor("NodeColor",NodeColor,fp);
WriteColor("RegionColor",RegionColor,fp);
WriteColor("TextColor",TextColor,fp);
WriteColor("FluxRColor",RealFluxLineColor,fp);
WriteColor("FluxIColor",ImagFluxLineColor,fp);
WriteColor("NameColor",NameColor,fp);
WriteColor("MaskColor", MaskLineColor,fp);
WriteColor("VectorRColor", RealVectorColor,fp);
WriteColor("VectorIColor", ImagVectorColor,fp);
WriteColor("Color00",Color00,fp);
WriteColor("Color01",Color01,fp);
WriteColor("Color02",Color02,fp);
WriteColor("Color03",Color03,fp);
WriteColor("Color04",Color04,fp);
WriteColor("Color05",Color05,fp);
WriteColor("Color06",Color06,fp);
WriteColor("Color07",Color07,fp);
WriteColor("Color08",Color08,fp);
WriteColor("Color09",Color09,fp);
WriteColor("Color10",Color10,fp);
WriteColor("Color11",Color11,fp);
WriteColor("Color12",Color12,fp);
WriteColor("Color13",Color13,fp);
WriteColor("Color14",Color14,fp);
WriteColor("Color15",Color15,fp);
WriteColor("Color16",Color16,fp);
WriteColor("Color17",Color17,fp);
WriteColor("Color18",Color18,fp);
WriteColor("Color19",Color19,fp);
WriteColor("Grey00",Grey00,fp);
WriteColor("Grey01",Grey01,fp);
WriteColor("Grey02",Grey02,fp);
WriteColor("Grey03",Grey03,fp);
WriteColor("Grey04",Grey04,fp);
WriteColor("Grey05",Grey05,fp);
WriteColor("Grey06",Grey06,fp);
WriteColor("Grey07",Grey07,fp);
WriteColor("Grey08",Grey08,fp);
WriteColor("Grey09",Grey09,fp);
WriteColor("Grey10",Grey10,fp);
WriteColor("Grey11",Grey11,fp);
WriteColor("Grey12",Grey12,fp);
WriteColor("Grey13",Grey13,fp);
WriteColor("Grey14",Grey14,fp);
WriteColor("Grey15",Grey15,fp);
WriteColor("Grey16",Grey16,fp);
WriteColor("Grey17",Grey17,fp);
WriteColor("Grey18",Grey18,fp);
WriteColor("Grey19",Grey19,fp);
fprintf(fp,"<EditAction> = %i\n",m_d_EditAction);
fprintf(fp,"<DensityPlot> = %i\n",m_d_DensityPlot);
fprintf(fp,"<VectorPlot> = %i\n",m_d_VectorPlot);
fprintf(fp,"<GridFlag> = %i\n",m_d_GridFlag);
fprintf(fp,"<SnapFlag> = %i\n",m_d_SnapFlag);
fprintf(fp,"<MeshFlag> = %i\n",m_d_MeshFlag);
fprintf(fp,"<LegendFlag> = %i\n",m_d_LegendFlag);
fprintf(fp,"<NumContours> = %i\n",m_d_NumContours);
fprintf(fp,"<ShowAr> = %i\n",m_d_ShowAr);
fprintf(fp,"<ShowAi> = %i\n",m_d_ShowAi);
fprintf(fp,"<ShowMask> = %i\n",m_d_ShowMask);
fprintf(fp,"<GreyContours> = %i\n",m_d_GreyContours);
fprintf(fp,"<PtsFlag> = %i\n",m_d_PtsFlag);
fprintf(fp,"<ResetOnReload> = %i\n",m_d_ResetOnReload);
fprintf(fp,"<Smooth> = %i\n",m_d_Smooth);
fprintf(fp,"<PlotPoints> = %i\n",m_d_PlotPoints);
fprintf(fp,"<ShowNames> = %i\n",m_d_shownames);
fprintf(fp,"<LineIntegralPoints> = %i\n",m_d_LineIntegralPoints);
fclose(fp);
}
}
void ezJSONWriter::AddVariableColor(const char* szName, const ezColor& value)
{
BeginVariable(szName);
WriteColor(value);
EndVariable();
}
void ezJSONWriter::WriteVariant(const ezVariant& value)
{
switch (value.GetType())
{
case ezVariant::Type::Invalid:
//EZ_REPORT_FAILURE("Variant of Type 'Invalid' cannot be written as JSON.");
WriteNULL();
return;
case ezVariant::Type::Bool:
WriteBool(value.Get<bool>());
return;
case ezVariant::Type::Int8:
WriteInt32(value.Get<ezInt8>());
return;
case ezVariant::Type::UInt8:
WriteUInt32(value.Get<ezUInt8>());
return;
case ezVariant::Type::Int16:
WriteInt32(value.Get<ezInt16>());
return;
case ezVariant::Type::UInt16:
WriteUInt32(value.Get<ezUInt16>());
return;
case ezVariant::Type::Int32:
WriteInt32(value.Get<ezInt32>());
return;
case ezVariant::Type::UInt32:
WriteUInt32(value.Get<ezUInt32>());
return;
case ezVariant::Type::Int64:
WriteInt64(value.Get<ezInt64>());
return;
case ezVariant::Type::UInt64:
WriteUInt64(value.Get<ezUInt64>());
return;
case ezVariant::Type::Float:
WriteFloat(value.Get<float>());
return;
case ezVariant::Type::Double:
WriteDouble(value.Get<double>());
return;
case ezVariant::Type::Color:
WriteColor(value.Get<ezColor>());
return;
case ezVariant::Type::Vector2:
WriteVec2(value.Get<ezVec2>());
return;
case ezVariant::Type::Vector3:
WriteVec3(value.Get<ezVec3>());
return;
case ezVariant::Type::Vector4:
WriteVec4(value.Get<ezVec4>());
return;
case ezVariant::Type::Quaternion:
WriteQuat(value.Get<ezQuat>());
return;
case ezVariant::Type::Matrix3:
WriteMat3(value.Get<ezMat3>());
return;
case ezVariant::Type::Matrix4:
WriteMat4(value.Get<ezMat4>());
return;
case ezVariant::Type::String:
WriteString(value.Get<ezString>().GetData());
return;
case ezVariant::Type::Time:
WriteTime(value.Get<ezTime>());
return;
case ezVariant::Type::Uuid:
WriteUuid(value.Get<ezUuid>());
return;
default:
break;
}
EZ_REPORT_FAILURE("The Variant Type %i is not supported by ezJSONWriter::WriteVariant.", value.GetType());
}
//保存配置
bool __cdecl CSkinButtonAttribute::SaveSkinOption()
{
WriteColor(SKIN_BUTTON_CRTEXTCOLOR,m_crTextColor);
WriteString(SKIN_BUTTON_STRIMAGEPATH,m_strImagePath);
return true;
}
bool ParticleEffect2D::Save(Serializer& dest) const
{
if (!sprite_)
return false;
XMLFile xmlFile(context_);
XMLElement rootElem = xmlFile.CreateRoot("particleEmitterConfig");
String fileName = GetFileNameAndExtension(sprite_->GetName());
rootElem.CreateChild("texture").SetAttribute("name", fileName);
WriteVector2(rootElem, "sourcePosition", Vector2::ZERO);
WriteVector2(rootElem, "sourcePositionVariance", sourcePositionVariance_);
WriteFloat(rootElem, "speed", speed_);
WriteFloat(rootElem, "speedVariance", speedVariance_);
WriteFloat(rootElem, "particleLifeSpan", particleLifeSpan_);
WriteFloat(rootElem, "particleLifespanVariance", particleLifespanVariance_);
WriteFloat(rootElem, "angle", angle_);
WriteFloat(rootElem, "angleVariance", angleVariance_);
WriteVector2(rootElem, "gravity", gravity_);
WriteFloat(rootElem, "radialAcceleration", radialAcceleration_);
WriteFloat(rootElem, "tangentialAcceleration", tangentialAcceleration_);
WriteFloat(rootElem, "radialAccelVariance", radialAccelVariance_);
WriteFloat(rootElem, "tangentialAccelVariance", tangentialAccelVariance_);
WriteColor(rootElem, "startColor", startColor_);
WriteColor(rootElem, "startColorVariance", startColorVariance_);
WriteColor(rootElem, "finishColor", finishColor_);
WriteColor(rootElem, "finishColorVariance", finishColorVariance_);
WriteInt(rootElem, "maxParticles", maxParticles_);
WriteFloat(rootElem, "startParticleSize", startParticleSize_);
WriteFloat(rootElem, "startParticleSizeVariance", startParticleSizeVariance_);
WriteFloat(rootElem, "finishParticleSize", finishParticleSize_);
// Typo in pex file
WriteFloat(rootElem, "FinishParticleSizeVariance", FinishParticleSizeVariance_);
float duration = duration_;
if (duration == M_INFINITY)
duration = -1.0f;
WriteFloat(rootElem, "duration", duration);
WriteInt(rootElem, "emitterType", (int)emitterType_);
WriteFloat(rootElem, "maxRadius", maxRadius_);
WriteFloat(rootElem, "maxRadiusVariance", maxRadiusVariance_);
WriteFloat(rootElem, "minRadius", minRadius_);
WriteFloat(rootElem, "minRadiusVariance", minRadiusVariance_);
WriteFloat(rootElem, "rotatePerSecond", rotatePerSecond_);
WriteFloat(rootElem, "rotatePerSecondVariance", rotatePerSecondVariance_);
WriteInt(rootElem, "blendFuncSource", srcBlendFuncs[blendMode_]);
WriteInt(rootElem, "blendFuncDestination", destBlendFuncs[blendMode_]);
WriteFloat(rootElem, "rotationStart", rotationStart_);
WriteFloat(rootElem, "rotationStartVariance", rotationStartVariance_);
WriteFloat(rootElem, "rotationEnd", rotationEnd_);
WriteFloat(rootElem, "rotationEndVariance", rotationEndVariance_);
return xmlFile.Save(dest);
}
static INLINE BOOL BitBlt_write(HGDI_DC hdcDest, HGDI_DC hdcSrc, UINT32 nXDest,
UINT32 nYDest, UINT32 nXSrc, UINT32 nYSrc, UINT32 x, UINT32 y,
BOOL useSrc, BOOL usePat, UINT32 style,
const char* rop, const gdiPalette* palette)
{
UINT32 dstColor;
UINT32 colorA;
UINT32 colorB = 0;
UINT32 colorC = 0;
BYTE* dstp = gdi_get_bitmap_pointer(hdcDest, nXDest + x, nYDest + y);
if (!dstp)
{
WLog_ERR(TAG, "dstp=%p", (void*) dstp);
return FALSE;
}
colorA = ReadColor(dstp, hdcDest->format);
if (useSrc)
{
const BYTE* srcp = gdi_get_bitmap_pointer(hdcSrc, nXSrc + x, nYSrc + y);
if (!srcp)
{
WLog_ERR(TAG, "srcp=%p", (void*) srcp);
return FALSE;
}
colorC = ReadColor(srcp, hdcSrc->format);
colorC = FreeRDPConvertColor(colorC, hdcSrc->format, hdcDest->format, palette);
}
if (usePat)
{
switch (style)
{
case GDI_BS_SOLID:
colorB = hdcDest->brush->color;
break;
case GDI_BS_HATCHED:
case GDI_BS_PATTERN:
{
const BYTE* patp = gdi_get_brush_pointer(hdcDest, nXDest + x, nYDest + y);
if (!patp)
{
WLog_ERR(TAG, "patp=%p", (void*) patp);
return FALSE;
}
colorB = ReadColor(patp, hdcDest->format);
}
break;
default:
break;
}
}
dstColor = process_rop(colorC, colorA, colorB, rop, hdcDest->format);
return WriteColor(dstp, hdcDest->format, dstColor);
}
//保存配置
bool __cdecl CSkinListAttribute::SaveSkinOption()
{
WriteColor(SKIN_LIST_CRHEADTEXT,m_crHeadText);
WriteString(SKIN_LIST_STRIMAGEHEADPATH,m_strImageHeadPath);
return true;
}
