pengjunjie/core
1
0
Fork 1
mirror of https://github.com/ONLYOFFICE/core.git synced 2026-07-11 02:44:13 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
8edf8e808ece8fcc2e85a6ff03fc0d2fdbd0186e
core/ASCImageStudio3/ASCImagePaint3/ImageTextStatic3.h

1113 lines
34 KiB
C++
Raw Blame History

#pragma once
#include "resource.h"
#include <PaintStruct.h>
#include "TextFormat.h"
#include "TextToPath.h"
#include <ImageColors.h>
#include <ImageCore.h>
[object, uuid("D7DC8BC9-3F5A-4de4-BFB1-F92930AF14EE"), dual, helpstring("IImageTextStatic3 Interface"), pointer_default(unique)]
__interface IImageTextStatic3 : IDispatch
{
// general
[id(1)] HRESULT Draw([in,out, satype(BYTE)] SAFEARRAY ** Image, [in] BSTR Text, [in] long Left, [in] long Top, [in] long Right, [in] long Bottom);
[id(2)] HRESULT DrawMedia([in, out] IUnknown** Image, [in] BSTR Text, [in] long Left, [in] long Top, [in] long Right, [in] long Bottom);
[id(3)] HRESULT DrawEllipse([in,out, satype(BYTE)] SAFEARRAY ** Image, [in] BSTR Text, [in] long Left, [in] long Top, [in] long Right, [in] long Bottom, [in] double StartAngle, [in] double SweepAngle);
[id(4)] HRESULT DrawMediaEllipse([in, out] IUnknown** Image, [in] BSTR Text, [in] long Left, [in] long Top, [in] long Right, [in] long Bottom, [in] double StartAngle, [in] double SweepAngle);
[id(5)] HRESULT DrawPolyline([in,out, satype(BYTE)] SAFEARRAY ** Image, [in, satype("double")] SAFEARRAY** Array, [in] BSTR Text);
[id(6)] HRESULT DrawMediaPolyline([in, out] IUnknown** Image, [in, satype("double")] SAFEARRAY** Array, [in] BSTR Text);
// font
[id(101), propget] HRESULT fontName([out, retval] BSTR* pVal);
[id(101), propput] HRESULT fontName([in] BSTR newVal);
[id(102), propget] HRESULT fontSize([out, retval] double* pVal);
[id(102), propput] HRESULT fontSize([in] double newVal);
[id(103), propget] HRESULT fontBold([out, retval] VARIANT_BOOL* pVal);
[id(103), propput] HRESULT fontBold([in] VARIANT_BOOL newVal);
[id(104), propget] HRESULT fontItalic([out, retval] VARIANT_BOOL* pVal);
[id(104), propput] HRESULT fontItalic([in] VARIANT_BOOL newVal);
[id(105), propget] HRESULT fontUnderline([out, retval] VARIANT_BOOL* pVal);
[id(105), propput] HRESULT fontUnderline([in] VARIANT_BOOL newVal);
[id(106), propget] HRESULT fontStrikeout([out, retval] VARIANT_BOOL* pVal);
[id(106), propput] HRESULT fontStrikeout([in] VARIANT_BOOL newVal);
// brush
[id(203), propget] HRESULT brushType([out, retval] long* pVal);
[id(203), propput] HRESULT brushType([in] long newVal);
[id(204), propget] HRESULT brushColor1([out, retval] long* pVal);
[id(204), propput] HRESULT brushColor1([in] long newVal);
[id(205), propget] HRESULT brushColor2([out, retval] long* pVal);
[id(205), propput] HRESULT brushColor2([in] long newVal);
[id(206), propget] HRESULT brushAlpha1([out, retval] long* pVal);
[id(206), propput] HRESULT brushAlpha1([in] long newVal);
[id(207), propget] HRESULT brushAlpha2([out, retval] long* pVal);
[id(207), propput] HRESULT brushAlpha2([in] long newVal);
[id(208), propget] HRESULT brushTexturePath([out, retval] BSTR* val);
[id(208), propput] HRESULT brushTexturePath([in] BSTR val);
[id(209), propget] HRESULT brushTextureAlpha([out, retval] long* val);
[id(209), propput] HRESULT brushTextureAlpha([in] long val);
[id(210), propget] HRESULT brushTextureMode([out, retval] long* val);
[id(210), propput] HRESULT brushTextureMode([in] long val);
[id(211), propput] HRESULT brushTexture([in] BSTR Name, [in, satype("BYTE")] SAFEARRAY** Image);
// formatting
[id(301), propget] HRESULT formatAlignVertical([out, retval] long* pVal);
[id(301), propput] HRESULT formatAlignVertical([in] long newVal);
[id(302), propget] HRESULT formatAlignHorizontal([out, retval] long* pVal);
[id(302), propput] HRESULT formatAlignHorizontal([in] long newVal);
[id(303), propget] HRESULT formatRotate([out, retval] long* pVal);
[id(303), propput] HRESULT formatRotate([in] long newVal);
// shadow
[id(401), propget] HRESULT shadowVisible([out, retval] VARIANT_BOOL* pVal);
[id(401), propput] HRESULT shadowVisible([in] VARIANT_BOOL newVal);
[id(402), propget] HRESULT shadowDistanceX([out, retval] long* pVal);
[id(402), propput] HRESULT shadowDistanceX([in] long newVal);
[id(403), propget] HRESULT shadowDistanceY([out, retval] long* pVal);
[id(403), propput] HRESULT shadowDistanceY([in] long newVal);
[id(404), propget] HRESULT shadowColor([out, retval] long* pVal);
[id(404), propput] HRESULT shadowColor([in] long newVal);
[id(405), propget] HRESULT shadowAlpha([out, retval] long* pVal);
[id(405), propput] HRESULT shadowAlpha([in] long newVal);
[id(406), propget] HRESULT shadowBlur([out, retval] long* pVal);
[id(406), propput] HRESULT shadowBlur([in] long newVal);
// edge
[id(501), propget] HRESULT edgeVisible([out, retval] long* pVal);
[id(501), propput] HRESULT edgeVisible([in] long newVal);
[id(502), propget] HRESULT edgeDistance([out, retval] long* pVal);
[id(502), propput] HRESULT edgeDistance([in] long newVal);
[id(503), propget] HRESULT edgeColor([out, retval] long* pVal);
[id(503), propput] HRESULT edgeColor([in] long newVal);
[id(504), propget] HRESULT edgeAlpha([out, retval] long* pVal);
[id(504), propput] HRESULT edgeAlpha([in] long newVal);
// presets
[id(601), propget] HRESULT currentPresetName([out, retval] BSTR* pVal);
[id(601), propput] HRESULT currentPresetName([in] BSTR newVal);
[id(602), propget] HRESULT currentPresetIndex([out, retval] long* pVal);
[id(602), propput] HRESULT currentPresetIndex([in] long newVal);
[id(651)] HRESULT SavePresets([in] BSTR path);
[id(652)] HRESULT LoadPresets([in] BSTR path, VARIANT_BOOL append);
[id(653)] HRESULT GetPresetCount([out,retval] long* count);
[id(654)] HRESULT GetPresetName([in] long index, [out] BSTR* name);
[id(655)] HRESULT DeletePreset([in] BSTR path, [in] long index);
[id(656)] HRESULT SetFormat([in, satype("BYTE")] SAFEARRAY** Array);
[id(657)] HRESULT GetFormat([out, retval, satype("BYTE")] SAFEARRAY** Array);
};
[ coclass, uuid("188CF510-A263-45e2-B786-76D4C1427533"), threading(apartment), vi_progid("AVSImagePaint3.ImageTextStatic3"), progid("AVSImagePaint3.ImageTextStatic3.1"), version(1.0), helpstring("ImageTextStatic3 Class")]
class ATL_NO_VTABLE ImageTextStatic3 : public IImageTextStatic3
{
protected:
// general
CGdiPlusInit initGdiPlus;
// painting formats
Painter::CBrush m_brush;
Painter::CFont m_font;
Painter::CFormat m_format;
Painter::CShadow m_shadow;
Painter::CEdgeText m_edge;
Painter::CTextureManager m_textures;
ImageStudio::Core::MediaData m_oMediaData;
// primary settings
long m_nRotateAngle;
// presets
CString m_sCurrentPresetName;
long m_nCurentPresetIndex;
CAtlArray<TextFormat> m_arrFormats;
protected:
ImageTextStatic3()
{
initGdiPlus.Init();
m_nRotateAngle = 0;
m_nCurentPresetIndex = 0;
m_sCurrentPresetName = "Preset";
}
~ImageTextStatic3()
{
Clear();
m_arrFormats.RemoveAll();
}
void Clear()
{
m_brush.Clear();
m_font.Clear();
m_format.Clear();
m_shadow.Clear();
m_edge.Clear();
m_textures.Clear();
}
Gdiplus::Brush* CreateBrush(GraphicsPath& path, Gdiplus::Color& color1, Gdiplus::Color& color2, int index, RectF& rectCharacter)
{
Brush* brush = NULL;
int k = 4;
if (Painter::c_BrushTypePathGradient1 == m_brush.Type)
{
Color colors[] = {color1, color1, color1, color1};
PathGradientBrush* pBrush = new PathGradientBrush(&path);
pBrush->SetSurroundColors(colors, &k);
pBrush->SetCenterColor(color2);
// pBrush->SetCenterPoint(PointF(rectCharacter.X + rectCharacter.Width - 1, rectCharacter.Y + rectCharacter.Height/2.));
brush = pBrush;
}
if (Painter::c_BrushTypePathGradient2 == m_brush.Type)
{
/*
// beg variant 1
PathGradientBrush* pBrush = new PathGradientBrush(&path);
Color colors1[] = {color1, color2, color2, color1};
Color colors2[] = {color2, color1, color1, color2};
if (index%2 == 0)
{
pBrush->SetSurroundColors(colors1, &k);
pBrush->SetCenterColor(color1);
}
if (index%2 == 1)
{
pBrush->SetSurroundColors(colors2, &k);
pBrush->SetCenterColor(color2);
}
// end variant 1
// beg variant 2
// LinearGradientBrush* pBrush = new Gdiplus::LinearGradientBrush(rectCharacter, color1, color2, LinearGradientModeHorizontal);
// Status s = pBrush->SetWrapMode(WrapModeClamp);
// end variant 2
// beg variant 3
// LinearGradientBrush* pBrush = new Gdiplus::LinearGradientBrush(rectCharacter, brushColor1, brushColor2, -180.F);
// pBrush->SetBlendBellShape(0.50f);
// Status s = pBrush->SetWrapMode(WrapModeClamp);
// end variant 3
// beg variant 4 gradient horizontal
Color colors[] = {color1, color2, color2, color1};
PathGradientBrush* pBrush = new PathGradientBrush(&path);
pBrush->SetSurroundColors(colors, &k);
pBrush->SetCenterColor(color1);
pBrush->SetCenterPoint(PointF(rectCharacter.X, rectCharacter.Y + rectCharacter.Height/2.));
// end variant 4
*/
// beg variant 5
LinearGradientBrush* pBrush = new Gdiplus::LinearGradientBrush(rectCharacter, color1, color2, LinearGradientModeHorizontal);
Status s = pBrush->SetWrapMode(WrapModeTileFlipX);
// end variant 5
/*
Color colors[] = {color2, color2, color2, color2};
PathGradientBrush* pBrush = new PathGradientBrush(&path);
pBrush->SetSurroundColors(colors, &k);
pBrush->SetCenterColor(color1);
*/
brush = pBrush;
}
return brush;
}
void DrawPathGradientText(Graphics* graph, BSTR Text, int length, RectF& rectDraw, RectF& StringBox)
{
Font* myFont = m_font.GetFont();
StringFormat* myStringFormat = m_format.GetStringFormat();
Gdiplus::Color color1((BYTE)m_brush.Alpha1, GetRValue(m_brush.Color1), GetGValue(m_brush.Color1), GetBValue(m_brush.Color1));
Gdiplus::Color color2((BYTE)m_brush.Alpha2, GetRValue(m_brush.Color2), GetGValue(m_brush.Color2), GetBValue(m_brush.Color2));
GraphicsPath path;
for(int index = 0; index < length; index++)
{
// get rect of current(index) character
RectF rectCharacter;
Painter::GetRectCurrentCharacter(graph, myStringFormat, myFont, Text, length, index, StringBox, rectCharacter);
// create path for rect and brush
path.AddRectangle(rectCharacter);
Brush* pBrush = CreateBrush(path, color1, color2, index, rectCharacter);
// draw text
// rectCharacter.Height = rectDraw.Height;
// rectCharacter.Y = rectDraw.Y;
// graph->DrawString(Text+index, 1, myFont, rectCharacter, myStringFormat, pBrush);
graph->DrawString(Text, length, myFont, rectDraw, myStringFormat, pBrush);
// graph->FillRectangle(pBrush, rectDraw);
// Pen blackPen(Color(255, 0, 0, 0), 3);
// graph->DrawRectangle(&blackPen, rectCharacter);
// graph->FillRectangle(myBrush, rectCharacter);
// delete brush and reset path
if (pBrush)
delete pBrush;
path.Reset();
}
}
Bitmap* CreateBitmap(int nWidth, int nHeight, BYTE* pPixels)
{
if (!pPixels || nWidth < 2 || nHeight < 2)
return NULL;
// variables
BITMAPINFO info;
// prepare header for the image
info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
info.bmiHeader.biWidth = nWidth;
info.bmiHeader.biHeight = nHeight;
info.bmiHeader.biBitCount = 32;
info.bmiHeader.biPlanes = 1;
info.bmiHeader.biClrImportant = 0;
info.bmiHeader.biClrUsed = 0;
info.bmiHeader.biCompression = 0;
info.bmiHeader.biXPelsPerMeter = 0;
info.bmiHeader.biYPelsPerMeter = 0;
info.bmiHeader.biSizeImage = 0;
return new Bitmap(&info, pPixels);
}
Bitmap* CreateBitmap(void** Image, BOOL bArray, ImageStudio::Core::MediaData& oMediaData)
{
if (!Image || !*Image)
return NULL;
// create bitmap
int nWidth = 0;
int nHeight = 0;
BYTE* pPixels = 0;
if (bArray)
{
int nChannels = 0;
pPixels = ImageStudioUtils::ExtractImage((SAFEARRAY**)Image, nWidth, nHeight, nChannels);
if (nChannels != 4)
return NULL;
}
else
{
if (!oMediaData.Create(*(IUnknown**)Image, FALSE) || !oMediaData.IsValidBGRA())
return NULL;
nWidth = oMediaData.GetWidth();
nHeight = oMediaData.GetHeight();
pPixels = oMediaData.GetBuffer();
*Image = oMediaData.GetMediaData(TRUE);
}
if (!pPixels)
return NULL;
return CreateBitmap(nWidth, nHeight, pPixels);
}
void Draw(void** Image, BSTR Text, long Left, long Top, long Right, long Bottom, BOOL bArray = TRUE)
{
// create bitmap
ImageStudio::Core::MediaData oMediaData;
Bitmap* pBitmap = CreateBitmap(Image, bArray, oMediaData);
if (!pBitmap)
return;
// create graphics
Graphics* Gr = new Graphics(pBitmap);
Gr->SetTextRenderingHint(TextRenderingHintAntiAlias);
Gr->SetSmoothingMode(SmoothingModeAntiAlias);
RectF rectDraw((REAL)Left, (REAL)Top, (REAL)(Right - Left), (REAL)(Bottom - Top));
// get lenght of string
CString sText; sText = Text;
int len = sText.GetLength();
// get bound rect for string
RectF StringBox;
Font* myFont = m_font.GetFont();
StringFormat* myStringFormat = m_format.GetStringFormat();
Gr->MeasureString(Text, len, myFont, rectDraw, myStringFormat, &StringBox);
// apply rotation of the image around center ponit
Matrix oTransform; oTransform.Reset();
PointF oTransformCenterPoint(StringBox.X + StringBox.Width/2, StringBox.Y + StringBox.Height/2);
oTransform.RotateAt(m_nRotateAngle, oTransformCenterPoint);
Gr->SetTransform(&oTransform);
// draw shadow
m_shadow.Draw(Gr, myFont, myStringFormat, Text, len, rectDraw);
// draw edge
m_edge.Draw(Gr, myFont, myStringFormat, Text, len, rectDraw);
// draw the text
if ((Painter::c_BrushTypePathGradient1 != m_brush.Type) && (Painter::c_BrushTypePathGradient2 != m_brush.Type))
{
Brush* myBrush = m_brush.GetBrush(&m_textures, &StringBox);
Gr->DrawString(Text, len, myFont, rectDraw, myStringFormat, myBrush);
}
else
DrawPathGradientText(Gr, Text, len, rectDraw, StringBox);
// delete bitmap
if (Gr)
delete Gr;
if (pBitmap)
delete pBitmap;
}
void DrawEllipse(void** Image, BSTR Text, long Left, long Top, long Right, long Bottom, double StartAngle, double SweepAngle, BOOL bArray = TRUE)
{
// create bitmap
ImageStudio::Core::MediaData oMediaData;
Bitmap* pBitmap = CreateBitmap(Image, bArray, oMediaData);
if (!pBitmap)
return;
// create graphics
Graphics* Gr = new Graphics(pBitmap);
Gr->SetTextRenderingHint(TextRenderingHintAntiAlias);
Gr->SetSmoothingMode(SmoothingModeAntiAlias);
// get lenght of string
CString sText; sText = Text;
int len = sText.GetLength();
// create ellipse path
GraphicsPath path; path.AddArc((REAL)Left, (REAL)Top, (REAL)(Right - Left), (REAL)(Bottom - Top), (REAL)StartAngle, (REAL)SweepAngle);
// draw ellipse text
Font* font = m_font.GetFont();
CTextToPath tp(path);
tp.SetAlignmentVertical(m_format.StringAlignmentVertical);
tp.SetAlignmentHorizontal(m_format.StringAlignmentHorizontal);
// tp.SetKerning(0.5);
tp.DrawText(Gr, font, &m_brush, &m_textures, &m_edge, &m_shadow, Text, len);
// tp.DrawLine(Gr);
// delete bitmap
if (Gr)
delete Gr;
if (pBitmap)
delete pBitmap;
}
void DrawPolyline(void** Image, SAFEARRAY** Array, BSTR Text, BOOL bArray = TRUE)
{
// check Polyline
if (!Array || !*Array)
return;
int nCount = (*Array)->rgsabound[0].cElements;
if (nCount % 2 || nCount < 4)
return;
nCount /= 2;
// create bitmap
ImageStudio::Core::MediaData oMediaData;
Bitmap* pBitmap = CreateBitmap(Image, bArray, oMediaData);
if (!pBitmap)
return;
// create graphics
Graphics* Gr = new Graphics(pBitmap);
Gr->SetTextRenderingHint(TextRenderingHintAntiAlias);
Gr->SetSmoothingMode(SmoothingModeAntiAlias);
// get lenght of string
CString sText; sText = Text;
int len = sText.GetLength();
// variables
PointF* pPoints = new PointF[nCount];
double* pDoubles = (double*)((*Array)->pvData);
// compose array of points to draw
for (int nIndex = 0; nIndex < nCount; ++nIndex, pDoubles += 2)
{
pPoints[nIndex].X = (REAL)pDoubles[0];
pPoints[nIndex].Y = (REAL)pDoubles[1];
}
// create polyline path
GraphicsPath path;
path.AddCurve(pPoints, nCount);
// draw polyline text
Font* font = m_font.GetFont();
CTextToPath tp(path);
tp.SetAlignmentVertical(m_format.StringAlignmentVertical);
tp.SetAlignmentHorizontal(m_format.StringAlignmentHorizontal);
// tp.SetKerning(0.5);
tp.DrawText(Gr, font, &m_brush, &m_textures, &m_edge, &m_shadow, Text, len);
// tp.DrawLine(Gr);
// delete bitmap and points
if (Gr)
delete Gr;
if (pBitmap)
delete pBitmap;
if (pPoints)
delete pPoints;
}
// get font style
void GetFontStyle(long fontStyle)
{
m_font.Bold = (fontStyle&1)? TRUE:FALSE;
m_font.Italic = (fontStyle&2)? TRUE:FALSE;
m_font.Underline = (fontStyle&4)? TRUE:FALSE;
m_font.Strikeout = (fontStyle&8)? TRUE:FALSE;
}
public:
// general
STDMETHOD(Draw)(SAFEARRAY** Image, BSTR Text, long Left, long Top, long Right, long Bottom)
{
Draw((void**)Image, Text, Left, Top, Right, Bottom, TRUE);
return S_OK;
}
STDMETHOD(DrawMedia)(IUnknown** Image, BSTR Text, long Left, long Top, long Right, long Bottom)
{
Draw((void**)Image, Text, Left, Top, Right, Bottom, FALSE);
return S_OK;
}
STDMETHOD(DrawEllipse)(SAFEARRAY** Image, BSTR Text, long Left, long Top, long Right, long Bottom, double StartAngle, double SweepAngle)
{
DrawEllipse((void**)Image, Text, Left, Top, Right, Bottom, StartAngle, SweepAngle, TRUE);
return S_OK;
}
STDMETHOD(DrawMediaEllipse)(IUnknown** Image, BSTR Text, long Left, long Top, long Right, long Bottom, double StartAngle, double SweepAngle)
{
DrawEllipse((void**)Image, Text, Left, Top, Right, Bottom, StartAngle, SweepAngle, FALSE);
return S_OK;
}
STDMETHOD(DrawPolyline)(SAFEARRAY** Image, SAFEARRAY** Array, BSTR Text)
{
DrawPolyline((void**)Image, Array, Text, TRUE);
return S_OK;
}
STDMETHOD(DrawMediaPolyline)(IUnknown** Image, SAFEARRAY** Array, BSTR Text)
{
DrawPolyline((void**)Image, Array, Text, FALSE);
return S_OK;
}
STDMETHOD(SavePresets)(BSTR path)
{
try
{
// store current preset
int nLastIndex = m_arrFormats.GetCount();
m_arrFormats.Add();
Gdiplus::Color brushColor1((BYTE)m_brush.Alpha1, GetRValue(m_brush.Color1), GetGValue(m_brush.Color1), GetBValue(m_brush.Color1));
Gdiplus::Color brushColor2((BYTE)m_brush.Alpha2, GetRValue(m_brush.Color2), GetGValue(m_brush.Color2), GetBValue(m_brush.Color2));
m_arrFormats[nLastIndex].m_nTextureAlpha = (BYTE)m_brush.TextureAlpha;
m_arrFormats[nLastIndex].m_cShadowColor = Gdiplus::Color((BYTE)m_shadow.Alpha, GetRValue(m_shadow.Color), GetGValue(m_shadow.Color), GetBValue(m_shadow.Color));
m_arrFormats[nLastIndex].m_nShadowBlur = m_shadow.BlurSize;
m_arrFormats[nLastIndex].m_nRotateAngle = m_nRotateAngle;
m_arrFormats[nLastIndex].m_sTextureFilePath = m_brush.TexturePath;
m_arrFormats[nLastIndex].m_bShadowVisible = m_shadow.Visible;
m_arrFormats[nLastIndex].m_nEdgeVisible = m_edge.Visible;
m_arrFormats[nLastIndex].m_nHatchType = m_brush.Type - Painter::c_BrushTypeHatch1;
m_arrFormats[nLastIndex].m_cFontHatchColor2 = brushColor2;
m_arrFormats[nLastIndex].m_cFontHatchColor1 = brushColor1;
m_arrFormats[nLastIndex].m_cFontGradColor2 = brushColor2;
m_arrFormats[nLastIndex].m_cFontGradColor1 = brushColor1;
m_arrFormats[nLastIndex].m_cFontColor = brushColor1;
m_arrFormats[nLastIndex].m_nEdgeDist = m_edge.Dist;
m_arrFormats[nLastIndex].m_cEdgeColor = Gdiplus::Color((BYTE)m_edge.Alpha, GetRValue(m_edge.Color), GetGValue(m_edge.Color), GetBValue(m_edge.Color));
m_arrFormats[nLastIndex].m_nShadowDistanceY = m_shadow.DistanceY;
m_arrFormats[nLastIndex].m_nShadowDistanceX = m_shadow.DistanceX;
m_arrFormats[nLastIndex].m_nBrushFaceColorType = m_brush.Type;
m_arrFormats[nLastIndex].m_nBrushFaceColorMode = m_brush.Type - Painter::c_BrushTypeHorizontal;
m_arrFormats[nLastIndex].m_nAlignVertical = m_format.StringAlignmentVertical;
m_arrFormats[nLastIndex].m_nAlignHorizontal = m_format.StringAlignmentHorizontal;
m_arrFormats[nLastIndex].m_sCurrentPresetName = m_sCurrentPresetName;
// add font
Font* myFont = m_font.GetFont();
m_arrFormats[nLastIndex].m_sFontName = m_font.Name;
m_arrFormats[nLastIndex].m_nFontSize = myFont->GetSize();
m_arrFormats[nLastIndex].m_nFontStyle = myFont->GetStyle();
// save all presets to file
XmlUtils::CXmlWriter oXmlWriter;
// open presets section
oXmlWriter.WriteNodeBegin("presets");
// write presets
for (int nIndex = 0; nIndex < m_arrFormats.GetCount(); nIndex++)
oXmlWriter.WriteString(m_arrFormats[nIndex].ToXmlString());
// close presets section
oXmlWriter.WriteNodeEnd("presets");
// write composed xml string to the file
CString sFileXml(path);
oXmlWriter.SaveToFile(sFileXml, TRUE);
}
catch (...)
{
return S_FALSE;
}
return S_OK;
}
STDMETHOD(LoadPresets)(BSTR path, VARIANT_BOOL append)
{
try
{
if (append == VARIANT_FALSE)
m_arrFormats.RemoveAll();
XmlUtils::CXmlReader oXmlReader;
if (!oXmlReader.OpenFromFile(CString(path)))
return S_FALSE;
oXmlReader.ReadRootNode("presets");
// all presets
oXmlReader.ReadNodeList("preset");
for (int nIndex = 0; nIndex < oXmlReader.GetLengthList(); nIndex++)
{
m_arrFormats.Add();
int r = m_arrFormats.GetCount();
m_arrFormats[r - 1].FromXmlString(oXmlReader.ReadNodeXml(nIndex));
}
}
catch (...)
{
return S_FALSE;
}
return S_OK;
}
STDMETHOD(GetPresetCount)(LONG* count)
{
*count = m_arrFormats.GetCount();
return S_OK;
}
STDMETHOD(GetPresetName)(long index, BSTR* name)
{
if (index >= 0 && index < m_arrFormats.GetCount())
*name = m_arrFormats[index].m_sCurrentPresetName.AllocSysString();
else
*name = L"error";
return S_OK;
}
STDMETHOD(DeletePreset)(BSTR path, long index)
{
try
{
XML::IXMLDOMDocumentPtr pDocument; pDocument.CreateInstance(CLSID_DOMDocument);
if (NULL == pDocument)
return S_FALSE;
if (VARIANT_FALSE == pDocument->load(path))
return S_FALSE;
XML::IXMLDOMElementPtr pRootNode = pDocument->selectSingleNode("presets");
if (NULL == pRootNode)
return S_FALSE;
XML::IXMLDOMNodeListPtr pNodeList = pRootNode->selectNodes("preset");
if (NULL == pNodeList || index < 0 || index >= pNodeList->Getlength())
return S_FALSE;
XML::IXMLDOMNodePtr pNode = pNodeList->item[index];
if (NULL == pNode)
return S_FALSE;
pRootNode->removeChild(pNode);
pDocument->save(path);
}
catch(...)
{
return S_FALSE;
}
return S_OK;
}
STDMETHOD(get_currentPresetName)(BSTR* pVal)
{
*pVal = m_sCurrentPresetName.AllocSysString();
return S_OK;
}
STDMETHOD(put_currentPresetName)(BSTR newVal)
{
m_sCurrentPresetName = newVal;
return S_OK;
}
STDMETHOD(get_currentPresetIndex)(long* pVal)
{
*pVal = m_nCurentPresetIndex;
return S_OK;
}
STDMETHOD(put_currentPresetIndex)(long newVal)
{
if (newVal < 0 || newVal >= m_arrFormats.GetCount())
return S_FALSE;
m_nCurentPresetIndex = newVal;
m_brush.TextureAlpha = m_arrFormats[m_nCurentPresetIndex].m_nTextureAlpha;
Color shadowColor = m_arrFormats[m_nCurentPresetIndex].m_cShadowColor;
m_shadow.Alpha = shadowColor.GetA();
m_shadow.Color = RGB(shadowColor.GetR(), shadowColor.GetG(), shadowColor.GetB());
m_shadow.BlurSize = m_arrFormats[m_nCurentPresetIndex].m_nShadowBlur;
m_nRotateAngle = m_arrFormats[m_nCurentPresetIndex].m_nRotateAngle;
m_brush.TexturePath = m_arrFormats[m_nCurentPresetIndex].m_sTextureFilePath;
m_shadow.Visible = m_arrFormats[m_nCurentPresetIndex].m_bShadowVisible;
m_edge.Visible = m_arrFormats[m_nCurentPresetIndex].m_nEdgeVisible;
m_edge.Dist = m_arrFormats[m_nCurentPresetIndex].m_nEdgeDist;
Color edgeColor = m_arrFormats[m_nCurentPresetIndex].m_cEdgeColor;
m_edge.Alpha = edgeColor.GetA();
m_edge.Color = RGB(edgeColor.GetR(), edgeColor.GetG(), edgeColor.GetB());
m_shadow.DistanceY = m_arrFormats[m_nCurentPresetIndex].m_nShadowDistanceY;
m_shadow.DistanceX = m_arrFormats[m_nCurentPresetIndex].m_nShadowDistanceX;
m_brush.Type = Painter::ConstantCompatible(m_arrFormats[m_nCurentPresetIndex].m_nBrushFaceColorType);
// int hatchType = m_arrFormats[m_nCurentPresetIndex].hatchType;
// int brushFaceColorMode = m_arrFormats[m_nCurentPresetIndex].brushFaceColorMode;
m_format.StringAlignmentVertical = m_arrFormats[m_nCurentPresetIndex].m_nAlignVertical;
m_format.StringAlignmentHorizontal = m_arrFormats[m_nCurentPresetIndex].m_nAlignHorizontal;
m_sCurrentPresetName = m_arrFormats[m_nCurentPresetIndex].m_sCurrentPresetName;
// add font
m_font.Name = m_arrFormats[m_nCurentPresetIndex].m_sFontName;
m_font.Size = m_arrFormats[m_nCurentPresetIndex].m_nFontSize;
GetFontStyle(m_arrFormats[m_nCurentPresetIndex].m_nFontStyle);
// retrieve brush color
if ((m_brush.Type >= Painter::c_BrushTypeHorizontal && m_brush.Type <= Painter::c_BrushTypeDiagonal2) ||
(m_brush.Type == Painter::c_BrushTypeCenter))
{
m_brush.Color1 = RGB(m_arrFormats[m_nCurentPresetIndex].m_cFontGradColor1.GetR(), m_arrFormats[m_nCurentPresetIndex].m_cFontGradColor1.GetG(), m_arrFormats[m_nCurentPresetIndex].m_cFontGradColor1.GetB());
m_brush.Alpha1 = m_arrFormats[m_nCurentPresetIndex].m_cFontGradColor1.GetA();
m_brush.Color2 = RGB(m_arrFormats[m_nCurentPresetIndex].m_cFontGradColor2.GetR(), m_arrFormats[m_nCurentPresetIndex].m_cFontGradColor2.GetG(), m_arrFormats[m_nCurentPresetIndex].m_cFontGradColor2.GetB());
m_brush.Alpha2 = m_arrFormats[m_nCurentPresetIndex].m_cFontGradColor2.GetA();
}
else if (m_brush.Type >= Painter::c_BrushTypeHatch1 && m_brush.Type <= Painter::c_BrushTypeHatch53)
{
m_brush.Color1 = RGB(m_arrFormats[m_nCurentPresetIndex].m_cFontHatchColor1.GetR(), m_arrFormats[m_nCurentPresetIndex].m_cFontHatchColor1.GetG(), m_arrFormats[m_nCurentPresetIndex].m_cFontHatchColor1.GetB());
m_brush.Alpha1 = m_arrFormats[m_nCurentPresetIndex].m_cFontHatchColor1.GetA();
m_brush.Color2 = RGB(m_arrFormats[m_nCurentPresetIndex].m_cFontHatchColor2.GetR(), m_arrFormats[m_nCurentPresetIndex].m_cFontHatchColor2.GetG(), m_arrFormats[m_nCurentPresetIndex].m_cFontHatchColor2.GetB());
m_brush.Alpha2 = m_arrFormats[m_nCurentPresetIndex].m_cFontHatchColor2.GetA();
}
else // if (m_brush.Type == Painter::c_BrushTypeSolid)
{
m_brush.Color1 = RGB(m_arrFormats[m_nCurentPresetIndex].m_cFontColor.GetR(), m_arrFormats[m_nCurentPresetIndex].m_cFontColor.GetG(), m_arrFormats[m_nCurentPresetIndex].m_cFontColor.GetB());
m_brush.Alpha1 = m_arrFormats[m_nCurentPresetIndex].m_cFontColor.GetA();
m_brush.Color2 = RGB(m_arrFormats[m_nCurentPresetIndex].m_cFontColor.GetR(), m_arrFormats[m_nCurentPresetIndex].m_cFontColor.GetG(), m_arrFormats[m_nCurentPresetIndex].m_cFontColor.GetB());
m_brush.Alpha2 = m_arrFormats[m_nCurentPresetIndex].m_cFontColor.GetA();
}
Clear();
return S_OK;
}
// brush
STDMETHOD(get_brushType)(long* pVal)
{
*pVal = m_brush.Type;
return S_OK;
}
STDMETHOD(put_brushType)(long newVal)
{
m_brush.Type = Painter::ConstantCompatible(newVal);
m_brush.Update();
return S_OK;
}
STDMETHOD(get_brushColor1)(long* pVal)
{
*pVal = m_brush.Color1;
return S_OK;
}
STDMETHOD(put_brushColor1)(long newVal)
{
m_brush.Color1 = newVal;
m_brush.Update();
return S_OK;
}
STDMETHOD(get_brushColor2)(long* pVal)
{
*pVal = m_brush.Color2;
return S_OK;
}
STDMETHOD(put_brushColor2)(long newVal)
{
m_brush.Color2 = newVal;
m_brush.Update();
return S_OK;
}
STDMETHOD(get_brushAlpha1)(long* pVal)
{
*pVal = m_brush.Alpha1;
return S_OK;
}
STDMETHOD(put_brushAlpha1)(long newVal)
{
m_brush.Alpha1 = newVal;
m_brush.Update();
return S_OK;
}
STDMETHOD(get_brushAlpha2)(long* pVal)
{
*pVal = m_brush.Alpha2;
return S_OK;
}
STDMETHOD(put_brushAlpha2)(long newVal)
{
m_brush.Alpha2 = newVal;
m_brush.Update();
return S_OK;
}
STDMETHOD(get_brushTexturePath)(BSTR* val)
{
*val = m_brush.TexturePath.AllocSysString();
return S_OK;
}
STDMETHOD(put_brushTexturePath)(BSTR val)
{
CString path(val);
path.MakeLower();
int index = m_textures.Add(path);
if (index < 0)
return S_OK;
m_brush.TexturePath = path;
m_brush.Update();
return S_OK;
}
STDMETHOD(get_brushTextureAlpha)(long* val)
{
*val = m_brush.TextureAlpha;
return S_OK;
}
STDMETHOD(put_brushTextureAlpha)(long val)
{
m_brush.TextureAlpha = val;
m_brush.Update();
return S_OK;
}
STDMETHOD(get_brushTextureMode)(long* pVal)
{
*pVal = m_brush.TextureMode;
return S_OK;
}
STDMETHOD(put_brushTextureMode)(long newVal)
{
m_brush.TextureMode = newVal;
m_brush.Update();
return S_OK;
}
STDMETHOD(put_brushTexture)(BSTR bstrName, SAFEARRAY** Image)
{
CString Name(bstrName);
Name.MakeLower();
int index = m_textures.Add(Name, *Image);
if (index < 0)
return S_OK;
m_brush.TexturePath = Name;
m_brush.Update();
return S_OK;
}
// font
STDMETHOD(get_fontName)(BSTR* pVal)
{
*pVal = m_font.Name.AllocSysString();
return S_OK;
}
STDMETHOD(put_fontName)(BSTR newVal)
{
m_font.Name = CString(newVal);
m_font.Update();
return S_OK;
}
STDMETHOD(get_fontSize)(DOUBLE* pVal)
{
*pVal = m_font.Size;
return S_OK;
}
STDMETHOD(put_fontSize)(DOUBLE newVal)
{
m_font.Size = newVal;
m_font.Update();
return S_OK;
}
STDMETHOD(get_fontBold)(VARIANT_BOOL* pVal)
{
*pVal = m_font.Bold ? VARIANT_TRUE : VARIANT_FALSE;
return S_OK;
}
STDMETHOD(put_fontBold)(VARIANT_BOOL newVal)
{
m_font.Bold = (newVal != VARIANT_FALSE);
m_font.Update();
return S_OK;
}
STDMETHOD(get_fontItalic)(VARIANT_BOOL* pVal)
{
*pVal = m_font.Italic ? VARIANT_TRUE : VARIANT_FALSE;
return S_OK;
}
STDMETHOD(put_fontItalic)(VARIANT_BOOL newVal)
{
m_font.Italic = (newVal != VARIANT_FALSE);
m_font.Update();
return S_OK;
}
STDMETHOD(get_fontUnderline)(VARIANT_BOOL* pVal)
{
*pVal = m_font.Underline ? VARIANT_TRUE : VARIANT_FALSE;
return S_OK;
}
STDMETHOD(put_fontUnderline)(VARIANT_BOOL newVal)
{
m_font.Underline = (newVal != VARIANT_FALSE);
m_font.Update();
return S_OK;
}
STDMETHOD(get_fontStrikeout)(VARIANT_BOOL* pVal)
{
*pVal = m_font.Strikeout ? VARIANT_TRUE : VARIANT_FALSE;
return S_OK;
}
STDMETHOD(put_fontStrikeout)(VARIANT_BOOL newVal)
{
m_font.Strikeout = (newVal != VARIANT_FALSE);
m_font.Update();
return S_OK;
}
// formats
STDMETHOD(get_formatAlignVertical)(long* pVal)
{
*pVal = m_format.StringAlignmentVertical;
return S_OK;
}
STDMETHOD(put_formatAlignVertical)(long newVal)
{
m_format.StringAlignmentVertical = newVal;
m_format.Update();
return S_OK;
}
STDMETHOD(get_formatAlignHorizontal)(long* pVal)
{
*pVal = m_format.StringAlignmentHorizontal;
return S_OK;
}
STDMETHOD(put_formatAlignHorizontal)(long newVal)
{
m_format.StringAlignmentHorizontal = newVal;
m_format.Update();
return S_OK;
}
STDMETHOD(get_formatRotate)(long* pVal)
{
*pVal = m_nRotateAngle;
return S_OK;
}
STDMETHOD(put_formatRotate)(long newVal)
{
m_nRotateAngle = newVal;
return S_OK;
}
// shadows
STDMETHOD(get_shadowVisible)(VARIANT_BOOL* pVal)
{
*pVal = m_shadow.Visible ? VARIANT_TRUE : VARIANT_FALSE;
return S_OK;
}
STDMETHOD(put_shadowVisible)(VARIANT_BOOL newVal)
{
m_shadow.Visible = (newVal == VARIANT_TRUE);
return S_OK;
}
STDMETHOD(get_shadowDistanceX)(long* pVal)
{
*pVal = m_shadow.DistanceX;
return S_OK;
}
STDMETHOD(put_shadowDistanceX)(long newVal)
{
m_shadow.DistanceX = newVal;
return S_OK;
}
STDMETHOD(get_shadowDistanceY)(long* pVal)
{
*pVal = m_shadow.DistanceY;
return S_OK;
}
STDMETHOD(put_shadowDistanceY)(long newVal)
{
m_shadow.DistanceY = newVal;
return S_OK;
}
STDMETHOD(get_shadowColor)(long* pVal)
{
*pVal = m_shadow.Color;
return S_OK;
}
STDMETHOD(put_shadowColor)(long newVal)
{
m_shadow.Color = newVal;
m_shadow.Update();
return S_OK;
}
STDMETHOD(get_shadowAlpha)(long* pVal)
{
*pVal = m_shadow.Alpha;
return S_OK;
}
STDMETHOD(put_shadowAlpha)(long newVal)
{
m_shadow.Alpha = newVal;
m_shadow.Update();
return S_OK;
}
STDMETHOD(get_shadowBlur)(long* pVal)
{
*pVal = m_shadow.BlurSize;
return S_OK;
}
STDMETHOD(put_shadowBlur)(long newVal)
{
m_shadow.BlurSize = newVal;
return S_OK;
}
// edges
STDMETHOD(get_edgeVisible)(long* pVal)
{
*pVal = m_edge.Visible;
return S_OK;
}
STDMETHOD(put_edgeVisible)(long newVal)
{
m_edge.Visible = newVal;
return S_OK;
}
STDMETHOD(get_edgeDistance)(long* pVal)
{
*pVal = m_edge.Dist;
return S_OK;
}
STDMETHOD(put_edgeDistance)(long newVal)
{
m_edge.Dist = newVal;
return S_OK;
}
STDMETHOD(get_edgeColor)(long* pVal)
{
*pVal = m_edge.Color;
return S_OK;
}
STDMETHOD(put_edgeColor)(long newVal)
{
m_edge.Color = newVal;
m_edge.Update();
return S_OK;
}
STDMETHOD(get_edgeAlpha)(long* pVal)
{
*pVal = m_edge.Alpha;
return S_OK;
}
STDMETHOD(put_edgeAlpha)(long newVal)
{
m_edge.Alpha = newVal;
m_edge.Update();
return S_OK;
}
STDMETHOD(SetFormat)(SAFEARRAY** Array)
{
if (!Array || !*Array)
return S_OK;
BYTE* buffer = (BYTE*)((*Array)->pvData);
if (!buffer)
return S_OK;
Painter::CStream stream;
stream.SetBuffer(buffer);
m_brush.Read(stream);
m_font.Read(stream);
m_format.Read(stream);
m_shadow.Read(stream);
m_edge.Read(stream);
return S_OK;
}
STDMETHOD(GetFormat)(SAFEARRAY** Array)
{
long size = m_brush.GetSize() + m_font.GetSize() + m_format.GetSize() + m_shadow.GetSize() + m_edge.GetSize();
SAFEARRAYBOUND bound;
bound.lLbound = 0;
bound.cElements = size;
*Array = SafeArrayCreate(VT_UI1, 1, &bound);
if (!*Array)
return S_OK;
BYTE* buffer = (BYTE*)((*Array)->pvData);
if (!buffer)
return S_OK;
Painter::CStream stream;
stream.SetBuffer(buffer);
m_brush.Write(stream);
m_font.Write(stream);
m_format.Write(stream);
m_shadow.Write(stream);
m_edge.Write(stream);
return S_OK;
}
};
Reference in New Issue View Git Blame Copy Permalink