mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-07-14 03:46:15 +08:00
6093b1ad72
git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@62729 954022d7-b5bf-4e40-9824-e11837661b57
583 lines
13 KiB
C++
583 lines
13 KiB
C++
#include "WmfPlayer.h"
|
|
#include "WmfFile.h"
|
|
|
|
namespace MetaFile
|
|
{
|
|
CWmfPlayer::CWmfPlayer(CWmfFile* pFile) : m_pFile(pFile)
|
|
{
|
|
CWmfDC* pDC = new CWmfDC();
|
|
if (!pDC)
|
|
{
|
|
pFile->SetError();
|
|
return;
|
|
}
|
|
|
|
m_pDC = pDC;
|
|
m_vDCStack.push_back(pDC);
|
|
m_ushIndex = 0;
|
|
};
|
|
CWmfPlayer::~CWmfPlayer()
|
|
{
|
|
for (int nIndex = 0; nIndex < m_vDCStack.size(); nIndex++)
|
|
{
|
|
CWmfDC* pDC = m_vDCStack.at(nIndex);
|
|
delete pDC;
|
|
}
|
|
m_vDCStack.clear();
|
|
|
|
for (CWmfObjectMap::iterator oIterator = m_mObjects.begin(); oIterator != m_mObjects.end(); oIterator++)
|
|
{
|
|
CWmfObjectBase* pOldObject = oIterator->second;
|
|
delete pOldObject;
|
|
}
|
|
m_mObjects.clear();
|
|
}
|
|
void CWmfPlayer::Clear()
|
|
{
|
|
for (int nIndex = 0; nIndex < m_vDCStack.size(); nIndex++)
|
|
{
|
|
CWmfDC* pDC = m_vDCStack.at(nIndex);
|
|
delete pDC;
|
|
}
|
|
m_vDCStack.clear();
|
|
|
|
for (CWmfObjectMap::iterator oIterator = m_mObjects.begin(); oIterator != m_mObjects.end(); oIterator++)
|
|
{
|
|
CWmfObjectBase* pOldObject = oIterator->second;
|
|
delete pOldObject;
|
|
}
|
|
m_mObjects.clear();
|
|
|
|
CWmfDC* pDC = new CWmfDC();
|
|
if (!pDC)
|
|
{
|
|
m_pFile->SetError();
|
|
return;
|
|
}
|
|
|
|
m_pDC = pDC;
|
|
m_vDCStack.push_back(pDC);
|
|
m_ushIndex = 0;
|
|
m_vAvailableIndexes.clear();
|
|
}
|
|
CWmfDC* CWmfPlayer::SaveDC()
|
|
{
|
|
if (!m_pDC)
|
|
{
|
|
m_pFile->SetError();
|
|
return NULL;
|
|
}
|
|
|
|
CWmfDC* pNewDC = m_pDC->Copy();
|
|
if (!pNewDC)
|
|
{
|
|
m_pFile->SetError();
|
|
return NULL;
|
|
}
|
|
|
|
m_vDCStack.push_back(pNewDC);
|
|
m_pDC = pNewDC;
|
|
return pNewDC;
|
|
}
|
|
CWmfDC* CWmfPlayer::RestoreDC()
|
|
{
|
|
if (m_vDCStack.size() <= 1)
|
|
{
|
|
m_pFile->SetError();
|
|
return m_pDC;
|
|
}
|
|
|
|
CWmfDC* pDC = m_vDCStack.at(m_vDCStack.size() - 1);
|
|
m_vDCStack.pop_back();
|
|
delete pDC;
|
|
|
|
pDC = m_vDCStack.at(m_vDCStack.size() - 1);
|
|
m_pDC = pDC;
|
|
return m_pDC;
|
|
}
|
|
CWmfDC* CWmfPlayer::GetDC()
|
|
{
|
|
return m_pDC;
|
|
}
|
|
void CWmfPlayer::RegisterObject(CWmfObjectBase* pObject)
|
|
{
|
|
// Íàéäåì íàèìåíüøèé äîñòóïíûé èíäåêñ
|
|
unsigned short ushIndex = m_ushIndex;
|
|
int nAvailableIndex = -1;
|
|
if (m_vAvailableIndexes.size() > 0)
|
|
{
|
|
for (std::size_t nIterator = 0; nIterator != m_vAvailableIndexes.size(); ++nIterator)
|
|
{
|
|
if (ushIndex > m_vAvailableIndexes[nIterator])
|
|
{
|
|
ushIndex = m_vAvailableIndexes[nIterator];
|
|
nAvailableIndex = (int)nIterator;
|
|
}
|
|
}
|
|
}
|
|
|
|
CWmfObjectMap::const_iterator oPos = m_mObjects.find(ushIndex);
|
|
if (m_mObjects.end() != oPos)
|
|
{
|
|
CWmfObjectBase* pOldObject = oPos->second;
|
|
delete pOldObject;
|
|
m_mObjects.erase(ushIndex);
|
|
}
|
|
|
|
m_mObjects.insert(std::pair<unsigned int, CWmfObjectBase*>(ushIndex, pObject));
|
|
|
|
if (-1 != nAvailableIndex)
|
|
m_vAvailableIndexes.erase(m_vAvailableIndexes.begin() + nAvailableIndex);
|
|
|
|
if (ushIndex == m_ushIndex)
|
|
m_ushIndex++;
|
|
}
|
|
void CWmfPlayer::SelectObject(unsigned short ushIndex)
|
|
{
|
|
CWmfObjectMap::const_iterator oPos = m_mObjects.find(ushIndex);
|
|
if (m_mObjects.end() != oPos)
|
|
{
|
|
CWmfObjectBase* pObject = oPos->second;
|
|
|
|
|
|
switch (pObject->GetType())
|
|
{
|
|
case WMF_OBJECT_BRUSH: m_pDC->SetBrush((CWmfBrush*)pObject); break;
|
|
case WMF_OBJECT_FONT: m_pDC->SetFont((CWmfFont*)pObject); break;
|
|
case WMF_OBJECT_PEN: m_pDC->SetPen((CWmfPen*)pObject); break;
|
|
case WMF_OBJECT_PALETTE: m_pDC->SetPalette((CWmfPalette*)pObject); break;
|
|
case WMF_OBJECT_REGION: m_pDC->SetRegion((CWmfRegion*)pObject); break;
|
|
}
|
|
}
|
|
}
|
|
void CWmfPlayer::SelectPalette(unsigned short ushIndex)
|
|
{
|
|
CWmfObjectMap::const_iterator oPos = m_mObjects.find(ushIndex);
|
|
if (m_mObjects.end() != oPos)
|
|
{
|
|
CWmfObjectBase* pObject = oPos->second;
|
|
if (WMF_OBJECT_PALETTE == pObject->GetType())
|
|
m_pDC->SetPalette((CWmfPalette*)pObject);
|
|
}
|
|
}
|
|
void CWmfPlayer::DeleteObject(unsigned short ushIndex)
|
|
{
|
|
CWmfObjectMap::const_iterator oPos = m_mObjects.find(ushIndex);
|
|
if (m_mObjects.end() != oPos)
|
|
{
|
|
CWmfObjectBase* pObject = oPos->second;
|
|
|
|
for (int nIndex = 0; nIndex < m_vDCStack.size(); nIndex++)
|
|
{
|
|
CWmfDC* pDC = m_vDCStack.at(nIndex);
|
|
|
|
switch (pObject->GetType())
|
|
{
|
|
case WMF_OBJECT_BRUSH: pDC->RemoveBrush((CWmfBrush*)pObject); break;
|
|
case WMF_OBJECT_FONT: pDC->RemoveFont((CWmfFont*)pObject); break;
|
|
case WMF_OBJECT_PEN: pDC->RemovePen((CWmfPen*)pObject); break;
|
|
case WMF_OBJECT_PALETTE: pDC->RemovePalette((CWmfPalette*)pObject); break;
|
|
case WMF_OBJECT_REGION: pDC->RemoveRegion((CWmfRegion*)pObject); break;
|
|
}
|
|
}
|
|
|
|
delete pObject;
|
|
m_mObjects.erase(ushIndex);
|
|
}
|
|
|
|
if (ushIndex < m_ushIndex)
|
|
{
|
|
if (std::find(m_vAvailableIndexes.begin(), m_vAvailableIndexes.end(), ushIndex) != m_vAvailableIndexes.end())
|
|
{
|
|
// Äàííûé èíäåêñ óæå åñòü â ñïèñêå äîñòóïíûõ
|
|
}
|
|
else
|
|
{
|
|
m_vAvailableIndexes.push_back(ushIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
CWmfDC::CWmfDC()
|
|
{
|
|
m_pBrush = &m_oDefaultBrush;
|
|
m_pPen = &m_oDefaultPen;
|
|
m_pPalette = NULL;
|
|
m_pFont = NULL;
|
|
m_pRegion = NULL;
|
|
m_ushMapMode = MM_TEXT;
|
|
m_dPixelWidth = 1;
|
|
m_dPixelHeight = 1;
|
|
m_oWindow.Init();
|
|
m_oViewport.Init();
|
|
m_oTextColor.Set(0, 0, 0);
|
|
m_oTextBgColor.Set(255, 255, 255);
|
|
m_oCurPos.Set(0, 0);
|
|
m_ushTextBgMode = OPAQUE;
|
|
m_ushLayout = LAYOUT_LTR;
|
|
m_ushPolyFillMode = ALTERNATE;
|
|
m_ushRop2Mode = R2_COPYPEN;
|
|
m_ushStretchBltMode = COLORONCOLOR;
|
|
m_ushTextAlign = TA_TOP | TA_LEFT | TA_NOUPDATECP;
|
|
m_ushCharSpacing = 0;
|
|
m_oTransform.Init();
|
|
}
|
|
CWmfDC::~CWmfDC()
|
|
{
|
|
|
|
}
|
|
CWmfDC* CWmfDC::Copy()
|
|
{
|
|
CWmfDC* pNewDC = new CWmfDC();
|
|
if (!pNewDC)
|
|
return NULL;
|
|
|
|
pNewDC->m_pBrush = (m_pBrush == &m_oDefaultBrush ? &pNewDC->m_oDefaultBrush : m_pBrush);
|
|
pNewDC->m_pPen = (m_pPen == &m_oDefaultPen ? &pNewDC->m_oDefaultPen : m_pPen);
|
|
pNewDC->m_pPalette = m_pPalette;
|
|
pNewDC->m_pFont = m_pFont;
|
|
pNewDC->m_pRegion = m_pRegion;
|
|
pNewDC->m_ushMapMode = m_ushMapMode;
|
|
pNewDC->m_dPixelWidth = m_dPixelWidth;
|
|
pNewDC->m_dPixelHeight = m_dPixelHeight;
|
|
pNewDC->m_oWindow.Copy(m_oWindow);
|
|
pNewDC->m_oViewport.Copy(m_oViewport);
|
|
pNewDC->m_oTextColor = m_oTextColor;
|
|
pNewDC->m_oTextBgColor = m_oTextBgColor;
|
|
pNewDC->m_oCurPos = m_oCurPos;
|
|
pNewDC->m_ushTextBgMode = m_ushTextBgMode;
|
|
pNewDC->m_ushLayout = m_ushLayout;
|
|
pNewDC->m_ushPolyFillMode = m_ushPolyFillMode;
|
|
pNewDC->m_ushRop2Mode = m_ushRop2Mode;
|
|
pNewDC->m_ushStretchBltMode = m_ushStretchBltMode;
|
|
pNewDC->m_ushTextAlign = m_ushTextAlign;
|
|
pNewDC->m_ushCharSpacing = m_ushCharSpacing;
|
|
pNewDC->m_oTransform.Init();
|
|
pNewDC->m_oClip = m_oClip;
|
|
|
|
return pNewDC;
|
|
}
|
|
void CWmfDC::SetBrush(CWmfBrush* pBrush)
|
|
{
|
|
m_pBrush = pBrush;
|
|
}
|
|
void CWmfDC::RemoveBrush(CWmfBrush* pBrush)
|
|
{
|
|
if (pBrush == m_pBrush)
|
|
m_pBrush = NULL;
|
|
}
|
|
CWmfBrush* CWmfDC::GetBrush()
|
|
{
|
|
return m_pBrush;
|
|
}
|
|
void CWmfDC::SetPen(CWmfPen* pPen)
|
|
{
|
|
m_pPen = pPen;
|
|
}
|
|
void CWmfDC::RemovePen(CWmfPen* pPen)
|
|
{
|
|
if (m_pPen == pPen)
|
|
m_pPen = NULL;
|
|
}
|
|
CWmfPen* CWmfDC::GetPen()
|
|
{
|
|
return m_pPen;
|
|
}
|
|
void CWmfDC::SetPalette(CWmfPalette* pPalette)
|
|
{
|
|
m_pPalette = pPalette;
|
|
}
|
|
void CWmfDC::RemovePalette(CWmfPalette* pPalette)
|
|
{
|
|
if (m_pPalette == pPalette)
|
|
m_pPalette = NULL;
|
|
}
|
|
CWmfPalette* CWmfDC::GetPalette()
|
|
{
|
|
return m_pPalette;
|
|
}
|
|
void CWmfDC::SetFont(CWmfFont* pFont)
|
|
{
|
|
m_pFont = pFont;
|
|
}
|
|
void CWmfDC::RemoveFont(CWmfFont* pFont)
|
|
{
|
|
if (m_pFont == pFont)
|
|
m_pFont = NULL;
|
|
}
|
|
CWmfFont* CWmfDC::GetFont()
|
|
{
|
|
return m_pFont;
|
|
}
|
|
void CWmfDC::SetRegion(CWmfRegion* pRegion)
|
|
{
|
|
m_pRegion = pRegion;
|
|
}
|
|
void CWmfDC::RemoveRegion(CWmfRegion* pRegion)
|
|
{
|
|
if (m_pRegion == pRegion)
|
|
m_pRegion = NULL;
|
|
}
|
|
CWmfRegion* CWmfDC::GetRegion()
|
|
{
|
|
return m_pRegion;
|
|
}
|
|
void CWmfDC::SetMapMode(unsigned short ushMapMode)
|
|
{
|
|
m_ushMapMode = ushMapMode;
|
|
|
|
UpdatePixelMetrics();
|
|
return;
|
|
|
|
switch (m_ushMapMode)
|
|
{
|
|
case MM_TEXT: // 1 unit = 1pt
|
|
{
|
|
SetPixelWidth(1);
|
|
SetPixelHeight(1);
|
|
break;
|
|
}
|
|
case MM_LOMETRIC: // 1 unit = 0.1mm
|
|
{
|
|
double dPixel = 0.1 * 72 / 25.4;
|
|
SetPixelWidth(dPixel);
|
|
SetPixelHeight(dPixel);
|
|
break;
|
|
}
|
|
case MM_HIMETRIC: // 1 unit = 0.01mm
|
|
{
|
|
double dPixel = 0.01 * 72 / 25.4;
|
|
SetPixelWidth(dPixel);
|
|
SetPixelHeight(dPixel);
|
|
break;
|
|
}
|
|
case MM_LOENGLISH: // 1 unit = 0.01 inch
|
|
{
|
|
double dPixel = 0.01 * 72;
|
|
SetPixelWidth(dPixel);
|
|
SetPixelHeight(dPixel);
|
|
break;
|
|
}
|
|
case MM_HIENGLISH: // 1 unit = 0.001 inch
|
|
{
|
|
double dPixel = 0.001 * 72;
|
|
SetPixelWidth(dPixel);
|
|
SetPixelHeight(dPixel);
|
|
break;
|
|
}
|
|
case MM_TWIPS: // 1 unit = 1/1440 inch
|
|
{
|
|
SetPixelWidth(0.05);
|
|
SetPixelHeight(0.05);
|
|
break;
|
|
}
|
|
case MM_ISOTROPIC:
|
|
case MM_ANISOTROPIC:
|
|
{
|
|
UpdatePixelMetrics();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
unsigned int CWmfDC::GetMapMode()
|
|
{
|
|
return m_ushMapMode;
|
|
}
|
|
double CWmfDC::GetPixelWidth()
|
|
{
|
|
return m_dPixelWidth;
|
|
}
|
|
double CWmfDC::GetPixelHeight()
|
|
{
|
|
return m_dPixelHeight;
|
|
}
|
|
void CWmfDC::SetPixelWidth(double dW)
|
|
{
|
|
m_dPixelWidth = dW;
|
|
}
|
|
void CWmfDC::SetPixelHeight(double dH)
|
|
{
|
|
m_dPixelHeight = dH;
|
|
}
|
|
TWmfWindow* CWmfDC::GetWindow()
|
|
{
|
|
return &m_oWindow;
|
|
}
|
|
void CWmfDC::SetWindowOrg(short shX, short shY)
|
|
{
|
|
m_oWindow.x = shX;
|
|
m_oWindow.y = shY;
|
|
UpdatePixelMetrics();
|
|
}
|
|
void CWmfDC::SetWindowExt(short shW, short shH)
|
|
{
|
|
m_oWindow.w = shW;
|
|
m_oWindow.h = shH;
|
|
UpdatePixelMetrics();
|
|
}
|
|
void CWmfDC::SetWindowOff(short shX, short shY)
|
|
{
|
|
m_oWindow.x += shX;
|
|
m_oWindow.y += shY;
|
|
UpdatePixelMetrics();
|
|
}
|
|
void CWmfDC::SetWindowScale(double dX, double dY)
|
|
{
|
|
m_oWindow.w = (short)(m_oWindow.w * dX);
|
|
m_oWindow.h = (short)(m_oWindow.h * dY);
|
|
UpdatePixelMetrics();
|
|
}
|
|
TWmfWindow* CWmfDC::GetViewport()
|
|
{
|
|
return &m_oViewport;
|
|
}
|
|
void CWmfDC::SetViewportOrg(short shX, short shY)
|
|
{
|
|
m_oViewport.x = shX;
|
|
m_oViewport.y = shY;
|
|
UpdatePixelMetrics();
|
|
}
|
|
void CWmfDC::SetViewportExt(short shW, short shH)
|
|
{
|
|
m_oViewport.w = shW;
|
|
m_oViewport.h = shH;
|
|
UpdatePixelMetrics();
|
|
}
|
|
void CWmfDC::SetViewportOff(short shX, short shY)
|
|
{
|
|
m_oViewport.x += shX;
|
|
m_oViewport.y += shY;
|
|
UpdatePixelMetrics();
|
|
}
|
|
void CWmfDC::SetViewportScale(double dX, double dY)
|
|
{
|
|
m_oViewport.w = (short)(m_oViewport.w * dX);
|
|
m_oViewport.h = (short)(m_oViewport.h * dY);
|
|
UpdatePixelMetrics();
|
|
}
|
|
bool CWmfDC::UpdatePixelMetrics()
|
|
{
|
|
unsigned short ushMapMode = m_ushMapMode;
|
|
if (MM_ISOTROPIC == ushMapMode)
|
|
{
|
|
if (0 == m_oWindow.w || 0 == m_oViewport.w)
|
|
return false;
|
|
|
|
double dPixel = (double)m_oViewport.w / (double)m_oWindow.w;
|
|
SetPixelHeight(dPixel);
|
|
SetPixelWidth(dPixel);
|
|
}
|
|
else// if (MM_ANISOTROPIC == ushMapMode)
|
|
{
|
|
double dPixelX = (double)m_oViewport.w / (double)m_oWindow.w;
|
|
double dPixelY = (double)m_oViewport.h / (double)m_oWindow.h;
|
|
|
|
SetPixelWidth(dPixelX);
|
|
SetPixelHeight(dPixelY);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
void CWmfDC::SetTextColor(TWmfColor& oColor)
|
|
{
|
|
m_oTextColor = oColor;
|
|
}
|
|
TWmfColor& CWmfDC::GetTextColor()
|
|
{
|
|
return m_oTextColor;
|
|
}
|
|
void CWmfDC::SetTextBgColor(TWmfColor& oColor)
|
|
{
|
|
m_oTextBgColor = oColor;
|
|
}
|
|
TWmfColor& CWmfDC::GetTextBgColor()
|
|
{
|
|
return m_oTextBgColor;
|
|
}
|
|
TWmfPointS& CWmfDC::GetCurPos()
|
|
{
|
|
return m_oCurPos;
|
|
}
|
|
void CWmfDC::SetCurPos(TWmfPointS& oPoint)
|
|
{
|
|
m_oCurPos = oPoint;
|
|
}
|
|
void CWmfDC::SetCurPos(short shX, short shY)
|
|
{
|
|
m_oCurPos.x = shX;
|
|
m_oCurPos.y = shY;
|
|
}
|
|
void CWmfDC::SetTextBgMode(unsigned short ushMode)
|
|
{
|
|
m_ushTextBgMode = ushMode;
|
|
}
|
|
unsigned short CWmfDC::GetTextBgMode()
|
|
{
|
|
return m_ushTextBgMode;
|
|
}
|
|
void CWmfDC::SetLayout(unsigned short ushLayout)
|
|
{
|
|
m_ushLayout = ushLayout;
|
|
}
|
|
unsigned short CWmfDC::GetLayout()
|
|
{
|
|
return m_ushLayout;
|
|
}
|
|
void CWmfDC::SetPolyFillMode(unsigned short ushMode)
|
|
{
|
|
m_ushPolyFillMode = ushMode;
|
|
}
|
|
unsigned short CWmfDC::GetPolyFillMode()
|
|
{
|
|
return m_ushPolyFillMode;
|
|
}
|
|
void CWmfDC::SetRop2Mode(unsigned short ushMode)
|
|
{
|
|
m_ushRop2Mode = ushMode;
|
|
}
|
|
unsigned short CWmfDC::GetRop2Mode()
|
|
{
|
|
return m_ushRop2Mode;
|
|
}
|
|
void CWmfDC::SetStretchBltMode(unsigned short ushMode)
|
|
{
|
|
m_ushStretchBltMode = ushMode;
|
|
}
|
|
unsigned short CWmfDC::GetStretchBltMode()
|
|
{
|
|
return m_ushStretchBltMode;
|
|
}
|
|
void CWmfDC::SetTextAlign(unsigned short ushTextAlign)
|
|
{
|
|
m_ushTextAlign = ushTextAlign;
|
|
}
|
|
unsigned short CWmfDC::GetTextAlign()
|
|
{
|
|
return m_ushTextAlign;
|
|
}
|
|
void CWmfDC::SetCharSpacing(unsigned short ushCharSpacing)
|
|
{
|
|
m_ushCharSpacing = ushCharSpacing;
|
|
}
|
|
unsigned short CWmfDC::GetCharSpacing()
|
|
{
|
|
return m_ushCharSpacing;
|
|
}
|
|
TXForm* CWmfDC::GetTransform()
|
|
{
|
|
return &m_oTransform;
|
|
}
|
|
TXForm* CWmfDC::GetInverseTransform()
|
|
{
|
|
return &m_oTransform;
|
|
}
|
|
unsigned int CWmfDC::GetMiterLimit()
|
|
{
|
|
return 0;
|
|
}
|
|
CWmfClip* CWmfDC::GetClip()
|
|
{
|
|
return &m_oClip;
|
|
}
|
|
} |