pengjunjie/core
1
0
Fork 1
mirror of https://github.com/ONLYOFFICE/core.git synced 2026-07-19 22:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

operator= by string problem

Browse Source
This commit is contained in:
Vikulov Dmitry
2022-12-13 21:00:29 +03:00
parent 2e2258f369
commit 7aea6bf451
178 changed files with 1928 additions and 2243 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
OOXML/Base/Nullable.h
View File

@ -304,7 +304,7 @@ namespace NSCommon
{
RELEASEOBJECT(this->m_pPointer);
this->m_pPointer = new Type();
this->m_pPointer->_set(value);
this->m_pPointer->set(value);
}
void operator=(Type* pType)
{

4
OOXML/PPTXFormat/Limit/AlbumLayout.cpp
View File

@ -53,12 +53,12 @@ namespace PPTX
m_strValue = strValue;
}
}
BYTE AlbumLayout::GetBYTECode() const
unsigned char AlbumLayout::GetBYTECode() const
{
//not using yet
return 0;
}
void AlbumLayout::SetBYTECode(const BYTE& src)
void AlbumLayout::SetBYTECode(const unsigned char& src)
{
//not using yet
}

14
OOXML/PPTXFormat/Limit/AlbumLayout.h
View File

@ -30,23 +30,13 @@
*
*/
#pragma once
#include "BaseLimit.h"
namespace PPTX
{
namespace Limit
{
class AlbumLayout : public BaseLimit
{
public:
AlbumLayout();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
};
DEFINE_LIMIT_BASE(AlbumLayout)
} // namespace Limit
} // namespace PPTX

4
OOXML/PPTXFormat/Limit/AnimationDgmBuild.cpp
View File

@ -50,12 +50,12 @@ namespace PPTX
m_strValue = strValue;
}
}
BYTE AnimationDgmBuild::GetBYTECode() const
unsigned char AnimationDgmBuild::GetBYTECode() const
{
//not using yet
return 0;
}
void AnimationDgmBuild::SetBYTECode(const BYTE& src)
void AnimationDgmBuild::SetBYTECode(const unsigned char& src)
{
//not using yet
}

8
OOXML/PPTXFormat/Limit/AnimationDgmBuild.h
View File

@ -40,14 +40,12 @@ namespace PPTX
class AnimationDgmBuild : public BaseLimit
{
public:
AnimationDgmBuild();
_USE_STRING_OPERATOR
AnimationDgmBuild();
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

4
OOXML/PPTXFormat/Limit/BWMode.cpp
View File

@ -57,7 +57,7 @@ namespace PPTX
m_strValue = strValue;
}
}
BYTE BWMode::GetBYTECode() const
unsigned char BWMode::GetBYTECode() const
{
if (L"auto" == m_strValue) return 0;
if (L"black" == m_strValue) return 1;
@ -72,7 +72,7 @@ namespace PPTX
if (L"white" == m_strValue) return 10;
return 0;
}
void BWMode::SetBYTECode(const BYTE& src)
void BWMode::SetBYTECode(const unsigned char& src)
{
switch (src)
{

8
OOXML/PPTXFormat/Limit/BWMode.h
View File

@ -40,14 +40,12 @@ namespace PPTX
class BWMode : public BaseLimit
{
public:
BWMode();
_USE_STRING_OPERATOR
BWMode();
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

12
OOXML/PPTXFormat/Limit/BaseLimit.cpp
View File

@ -43,7 +43,9 @@ namespace PPTX
{
*this = oSrc;
}
BaseLimit::~BaseLimit() {}
BaseLimit::~BaseLimit()
{
}
BaseLimit& BaseLimit::operator=(const BaseLimit& oSrc)
{
m_strValue = oSrc.m_strValue;
@ -53,14 +55,6 @@ namespace PPTX
{
set(str);
}
void BaseLimit::_set(const std::wstring& strValue)
{
set(strValue);
}
std::wstring& BaseLimit::get()
{
return m_strValue;
}
const std::wstring& BaseLimit::get() const
{
return m_strValue;

29
OOXML/PPTXFormat/Limit/BaseLimit.h
View File

@ -31,14 +31,24 @@
*/
#pragma once
#include "../../Base/Base.h"
#include "../../../DesktopEditor/common/Types.h"
#include <string>
// TODO delete define
#define _USE_STRING_OPERATOR \
virtual void operator=(const std::wstring& value) \
{ \
set(value); \
}
virtual void operator=(const std::wstring& value) \
{ \
set(value); \
}
#define DEFINE_LIMIT_BASE(Class) \
class Class : public BaseLimit \
{ \
public: \
Class(); \
virtual void set(const std::wstring& strValue); \
virtual unsigned char GetBYTECode() const; \
virtual void SetBYTECode(const unsigned char& val); \
};
namespace PPTX
{
@ -55,13 +65,10 @@ namespace PPTX
void operator=(const std::wstring& str);
virtual void set(const std::wstring& strValue) = 0;
void _set(const std::wstring& strValue);
std::wstring& get();
const std::wstring& get() const;
virtual BYTE GetBYTECode() const = 0;
virtual void SetBYTECode(const BYTE& src) = 0;
virtual unsigned char GetBYTECode() const = 0;
virtual void SetBYTECode(const unsigned char& src) = 0;
protected:
std::wstring m_strValue;

4
OOXML/PPTXFormat/Limit/BevelType.cpp
View File

@ -44,7 +44,7 @@ namespace PPTX
{
m_strValue = strValue;
}
BYTE BevelType::GetBYTECode() const
unsigned char BevelType::GetBYTECode() const
{
if (L"angle" == m_strValue) return 0;
if (L"artDeco" == m_strValue) return 1;
@ -60,7 +60,7 @@ namespace PPTX
if (L"softRound" == m_strValue) return 11;
return 0;
}
void BevelType::SetBYTECode(const BYTE& val)
void BevelType::SetBYTECode(const unsigned char& val)
{
switch (val)
{

13
OOXML/PPTXFormat/Limit/BevelType.h
View File

@ -37,17 +37,6 @@ namespace PPTX
{
namespace Limit
{
class BevelType : public BaseLimit
{
public:
BevelType();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& val);
};
DEFINE_LIMIT_BASE(BevelType);
} // namespace Limit
} // namespace PPTX

4
OOXML/PPTXFormat/Limit/BlendMode.cpp
View File

@ -51,7 +51,7 @@ namespace PPTX
m_strValue = strValue;
}
}
BYTE BlendMode::GetBYTECode() const
unsigned char BlendMode::GetBYTECode() const
{
if (L"darken" == m_strValue) return 0;
if (L"lighten" == m_strValue) return 1;
@ -60,7 +60,7 @@ namespace PPTX
if (L"screen" == m_strValue) return 4;
return 4;
}
void BlendMode::SetBYTECode(const BYTE& val)
void BlendMode::SetBYTECode(const unsigned char& val)
{
switch(val)
{

13
OOXML/PPTXFormat/Limit/BlendMode.h
View File

@ -37,17 +37,6 @@ namespace PPTX
{
namespace Limit
{
class BlendMode : public BaseLimit
{
public:
BlendMode();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& val);
};
DEFINE_LIMIT_BASE(BlendMode)
} // namespace Limit
} // namespace PPTX

4
OOXML/PPTXFormat/Limit/BlipCompression.cpp
View File

@ -51,7 +51,7 @@ namespace PPTX
m_strValue = strValue;
}
}
BYTE BlipCompression::GetBYTECode() const
unsigned char BlipCompression::GetBYTECode() const
{
if (L"none" == m_strValue) return 0;
if (L"email" == m_strValue) return 1;
@ -60,7 +60,7 @@ namespace PPTX
if (L"screen" == m_strValue) return 4;
return 0;
}
void BlipCompression::SetBYTECode(const BYTE& val)
void BlipCompression::SetBYTECode(const unsigned char& val)
{
switch (val)
{

6
OOXML/PPTXFormat/Limit/BlipCompression.h
View File

@ -42,12 +42,10 @@ namespace PPTX
public:
BlipCompression();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& val);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& val);
};
} // namespace Limit
} // namespace PPTX

4
OOXML/PPTXFormat/Limit/CameraType.cpp
View File

@ -44,7 +44,7 @@ namespace PPTX
{
m_strValue = strValue;
}
BYTE CameraType::GetBYTECode() const
unsigned char CameraType::GetBYTECode() const
{
if (m_strValue == L"isometricBottomDown") return 0;
if (m_strValue == L"isometricBottomUp") return 1;
@ -110,7 +110,7 @@ namespace PPTX
if (m_strValue == L"perspectiveRight") return 61;
return 0;
}
void CameraType::SetBYTECode(const BYTE& val)
void CameraType::SetBYTECode(const unsigned char& val)
{
switch (val)
{

6
OOXML/PPTXFormat/Limit/CameraType.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
CameraType();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& val);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& val);
};
} // namespace Limit
} // namespace PPTX

18
OOXML/PPTXFormat/Limit/ChartBuild.cpp
View File

@ -38,26 +38,26 @@ namespace PPTX
{
ChartBuild::ChartBuild()
{
m_strValue = _T("allPts");
m_strValue = L"allPts";
}
void ChartBuild::set(const std::wstring& strValue)
{
if ((_T("allPts") == strValue) ||
(_T("category") == strValue) ||
(_T("gridLegend") == strValue) ||
(_T("ptInCategory") == strValue) ||
(_T("ptInSeries") == strValue) ||
(_T("series") == strValue))
if ((L"allPts" == strValue) ||
(L"category" == strValue) ||
(L"gridLegend" == strValue) ||
(L"ptInCategory" == strValue) ||
(L"ptInSeries" == strValue) ||
(L"series" == strValue))
{
m_strValue = strValue;
}
}
BYTE ChartBuild::GetBYTECode() const
unsigned char ChartBuild::GetBYTECode() const
{
//not using yet
return 0;
}
void ChartBuild::SetBYTECode(const BYTE& src)
void ChartBuild::SetBYTECode(const unsigned char& src)
{
//not using yet
}

6
OOXML/PPTXFormat/Limit/ChartBuild.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
ChartBuild();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

16
OOXML/PPTXFormat/Limit/ChartBuildType.cpp
View File

@ -38,25 +38,25 @@ namespace PPTX
{
ChartBuildType::ChartBuildType()
{
m_strValue = _T("allAtOnce");
m_strValue = L"allAtOnce";
}
void ChartBuildType::set(const std::wstring& strValue)
{
if ((_T("allAtOnce") == strValue) ||
(_T("category") == strValue) ||
(_T("categoryEl") == strValue) ||
(_T("series") == strValue) ||
(_T("seriesEl") == strValue))
if ((L"allAtOnce" == strValue) ||
(L"category" == strValue) ||
(L"categoryEl" == strValue) ||
(L"series" == strValue) ||
(L"seriesEl" == strValue))
{
m_strValue = strValue;
}
}
BYTE ChartBuildType::GetBYTECode() const
unsigned char ChartBuildType::GetBYTECode() const
{
//not using yet
return 0;
}
void ChartBuildType::SetBYTECode(const BYTE& src)
void ChartBuildType::SetBYTECode(const unsigned char& src)
{
//not using yet
}

6
OOXML/PPTXFormat/Limit/ChartBuildType.h
View File

@ -42,12 +42,10 @@ namespace PPTX
public:
ChartBuildType();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

114
OOXML/PPTXFormat/Limit/ColorSchemeIndex.cpp
View File

@ -38,122 +38,122 @@ namespace PPTX
{
ColorSchemeIndex::ColorSchemeIndex()
{
m_strValue = _T("accent1");
m_strValue = L"accent1";
}
void ColorSchemeIndex::set(const std::wstring& strValue)
{
if ((_T("accent1") == strValue) ||
(_T("accent2") == strValue) ||
(_T("accent3") == strValue) ||
(_T("accent4") == strValue) ||
(_T("accent5") == strValue) ||
(_T("accent6") == strValue) ||
(_T("dk1") == strValue) ||
(_T("dk2") == strValue) ||
(_T("folHlink") == strValue) ||
(_T("hlink") == strValue) ||
(_T("lt1") == strValue) ||
(_T("lt2") == strValue))
if ((L"accent1" == strValue) ||
(L"accent2" == strValue) ||
(L"accent3" == strValue) ||
(L"accent4" == strValue) ||
(L"accent5" == strValue) ||
(L"accent6" == strValue) ||
(L"dk1" == strValue) ||
(L"dk2" == strValue) ||
(L"folHlink" == strValue) ||
(L"hlink" == strValue) ||
(L"lt1" == strValue) ||
(L"lt2" == strValue))
{
m_strValue = strValue;
}
else
{
// word clrmap
if (_T("light1") == strValue)
m_strValue = _T("lt1");
else if (_T("light2") == strValue)
m_strValue = _T("lt2");
else if (_T("dark1") == strValue)
m_strValue = _T("dk1");
else if (_T("dark2") == strValue)
m_strValue = _T("dk2");
else if (_T("hyperlink") == strValue)
m_strValue = _T("hlink");
else if (_T("followedHyperlink") == strValue)
m_strValue = _T("folHlink");
if (L"light1" == strValue)
m_strValue = _T("lt1";
else if (L"light2" == strValue)
m_strValue = _T("lt2";
else if (L"dark1" == strValue)
m_strValue = _T("dk1";
else if (L"dark2" == strValue)
m_strValue = _T("dk2";
else if (L"hyperlink") == strValue)
m_strValue = _T("hlink";
else if (L"followedHyperlink" == strValue)
m_strValue = _T("folHlink";
}
}
BYTE ColorSchemeIndex::GetBYTECode() const
unsigned char ColorSchemeIndex::GetBYTECode() const
{
if (_T("accent1") == m_strValue)
if (L"accent1" == m_strValue)
return 0;
if (_T("accent2") == m_strValue)
if (L"accent2" == m_strValue)
return 1;
if (_T("accent3") == m_strValue)
if (L"accent3" == m_strValue)
return 2;
if (_T("accent4") == m_strValue)
if (L"accent4" == m_strValue)
return 3;
if (_T("accent5") == m_strValue)
if (L"accent5" == m_strValue)
return 4;
if (_T("accent6") == m_strValue)
if (L"accent6" == m_strValue)
return 5;
if (_T("bg1") == m_strValue)
if (L"bg1" == m_strValue)
return 6;
if (_T("bg2") == m_strValue)
if (L"bg2" == m_strValue)
return 7;
if (_T("dk1") == m_strValue)
if (L"dk1" == m_strValue)
return 8;
if (_T("dk2") == m_strValue)
if (L"dk2" == m_strValue)
return 9;
if (_T("folHlink") == m_strValue)
if (L"folHlink" == m_strValue)
return 10;
if (_T("hlink") == m_strValue)
if (L"hlink" == m_strValue)
return 11;
if (_T("lt1") == m_strValue)
if (L"lt1" == m_strValue)
return 12;
if (_T("lt2") == m_strValue)
if (L"lt2" == m_strValue)
return 13;
if (_T("phClr") == m_strValue)
if (L"phClr" == m_strValue)
return 14;
if (_T("tx1") == m_strValue)
if (L"tx1" == m_strValue)
return 15;
if (_T("tx2") == m_strValue)
if (L"tx2" == m_strValue)
return 16;
return 0;
}
void ColorSchemeIndex::SetBYTECode(const BYTE& val)
void ColorSchemeIndex::SetBYTECode(const unsigned char& val)
{
switch (val)
{
case 0:
m_strValue = _T("accent1");
m_strValue = L"accent1";
break;
case 1:
m_strValue = _T("accent2");
m_strValue = L"accent2";
break;
case 2:
m_strValue = _T("accent3");
m_strValue = L"accent3";
break;
case 3:
m_strValue = _T("accent4");
m_strValue = L"accent4";
break;
case 4:
m_strValue = _T("accent5");
m_strValue = L"accent5";
break;
case 5:
m_strValue = _T("accent6");
m_strValue = L"accent6";
break;
case 8:
m_strValue = _T("dk1");
m_strValue = L"dk1";
break;
case 9:
m_strValue = _T("dk2");
m_strValue = L"dk2";
break;
case 10:
m_strValue = _T("folHlink");
m_strValue = L"folHlink";
break;
case 11:
m_strValue = _T("hlink");
m_strValue = L"hlink";
break;
case 12:
m_strValue = _T("lt1");
m_strValue = L"lt1";
break;
case 13:
m_strValue = _T("lt2");
m_strValue = L"lt2";
break;
default:
m_strValue = _T("accent1");
m_strValue = L"accent1";
break;
}
}

7
OOXML/PPTXFormat/Limit/ColorSchemeIndex.h
View File

@ -30,6 +30,7 @@
*
*/
#pragma once
#include "BaseLimit.h"
namespace PPTX
@ -41,12 +42,10 @@ namespace PPTX
public:
ColorSchemeIndex();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& val);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& val);
};
} // namespace Limit
} // namespace PPTX

37
OOXML/PPTXFormat/Limit/CompoundLine.cpp
View File

@ -33,58 +33,57 @@
#include "CompoundLine.h"
namespace PPTX
{
namespace Limit
{
CompoundLine::CompoundLine()
{
m_strValue = _T("sng");
m_strValue = L"sng";
}
void CompoundLine::set(const std::wstring& strValue)
{
if ((_T("dbl") == strValue) ||
(_T("sng") == strValue) ||
(_T("thickThin") == strValue) ||
(_T("thinThick") == strValue) ||
(_T("tri") == strValue))
if ((L"dbl" == strValue) ||
(L"sng" == strValue) ||
(L"thickThin" == strValue) ||
(L"thinThick" == strValue) ||
(L"tri" == strValue))
{
m_strValue = strValue;
}
}
BYTE CompoundLine::GetBYTECode() const
unsigned char CompoundLine::GetBYTECode() const
{
if (_T("dbl") == m_strValue)
if (L"dbl" == m_strValue)
return 0;
if (_T("sng") == m_strValue)
if (L"sng" == m_strValue)
return 1;
if (_T("thickThin") == m_strValue)
if (L"thickThin" == m_strValue)
return 2;
if (_T("thinThick") == m_strValue)
if (L"thinThick" == m_strValue)
return 3;
if (_T("tri") == m_strValue)
if (L"tri" == m_strValue)
return 4;
return 1;
}
void CompoundLine::SetBYTECode(const BYTE& src)
void CompoundLine::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 0:
m_strValue = _T("dbl");
m_strValue = L"dbl";
break;
case 2:
m_strValue = _T("thickThin");
m_strValue = L"thickThin";
break;
case 3:
m_strValue = _T("thinThick");
m_strValue = L"thinThick";
break;
case 4:
m_strValue = _T("tri");
m_strValue = L"tri";
break;
default:
m_strValue = _T("sng");
m_strValue = L"sng";
break;
}
}

7
OOXML/PPTXFormat/Limit/CompoundLine.h
View File

@ -33,7 +33,6 @@
#include "BaseLimit.h"
namespace PPTX
{
namespace Limit
@ -42,13 +41,11 @@ namespace PPTX
{
public:
CompoundLine();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

4
OOXML/PPTXFormat/Limit/Conformance.cpp
View File

@ -47,13 +47,13 @@ namespace PPTX
m_strValue = strValue;
}
}
BYTE Conformance::GetBYTECode() const
unsigned char Conformance::GetBYTECode() const
{
if (L"strict" == m_strValue) return 0;
if (L"transitional" == m_strValue) return 1;
return 1;
}
void Conformance::SetBYTECode(const BYTE& src)
void Conformance::SetBYTECode(const unsigned char& src)
{
if (src == 0) m_strValue = L"strict";
else if (src == 1) m_strValue = L"transitional";

7
OOXML/PPTXFormat/Limit/Conformance.h
View File

@ -30,6 +30,7 @@
*
*/
#pragma once
#include "BaseLimit.h"
namespace PPTX
@ -41,12 +42,10 @@ namespace PPTX
public:
Conformance();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

12
OOXML/PPTXFormat/Limit/ContentStatus.cpp
View File

@ -38,25 +38,25 @@ namespace PPTX
{
ContentStatus::ContentStatus()
{
m_strValue = _T("Draft");
m_strValue = L"Draft";
}
void ContentStatus::set(const std::wstring& strValue)
{
if ((_T("Draft") == strValue) ||
(_T("Reviewed") == strValue) ||
(_T("Final") == strValue))
if ((L"Draft" == strValue) ||
(L"Reviewed" == strValue) ||
(L"Final" == strValue))
{
m_strValue = strValue;
}
}
BYTE ContentStatus::GetBYTECode() const
unsigned char ContentStatus::GetBYTECode() const
{
if (L"Draft" == m_strValue) return 0;
if (L"Reviewed" == m_strValue) return 1;
if (L"Final" == m_strValue) return 2;
return 1;
}
void ContentStatus::SetBYTECode(const BYTE& src)
void ContentStatus::SetBYTECode(const unsigned char& src)
{
if (src == 0) m_strValue = L"Draft";
else if (src == 1) m_strValue = L"Reviewed";

6
OOXML/PPTXFormat/Limit/ContentStatus.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
ContentStatus();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

12
OOXML/PPTXFormat/Limit/CornerDirectionVal.cpp
View File

@ -42,15 +42,15 @@ namespace PPTX
}
void CornerDirectionVal::set(const std::wstring& strValue)
{
if ((_T("ld") == strValue) ||
(_T("lu") == strValue) ||
(_T("rd") == strValue) ||
(_T("ru") == strValue))
if ((L"ld" == strValue) ||
(L"lu" == strValue) ||
(L"rd" == strValue) ||
(L"ru" == strValue))
{
m_strValue = strValue;
}
}
BYTE CornerDirectionVal::GetBYTECode() const
unsigned char CornerDirectionVal::GetBYTECode() const
{
if (L"ld" == m_strValue) return 0;
if (L"lu" == m_strValue) return 1;
@ -58,7 +58,7 @@ namespace PPTX
if (L"ru" == m_strValue) return 3;
return 0;
}
void CornerDirectionVal::SetBYTECode(const BYTE& src)
void CornerDirectionVal::SetBYTECode(const unsigned char& src)
{
switch (src)
{

6
OOXML/PPTXFormat/Limit/CornerDirectionVal.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
CornerDirectionVal();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

10
OOXML/PPTXFormat/Limit/DgmBuild.cpp
View File

@ -38,22 +38,22 @@ namespace PPTX
{
DgmBuild::DgmBuild()
{
m_strValue = _T("sp");
m_strValue = L"sp";
}
void DgmBuild::set(const std::wstring& strValue)
{
if ((_T("bg") == strValue) ||
(_T("sp") == strValue))
if ((L"bg" == strValue) ||
(L"sp" == strValue))
{
m_strValue = strValue;
}
}
BYTE DgmBuild::GetBYTECode() const
unsigned char DgmBuild::GetBYTECode() const
{
//not using yet
return 0;
}
void DgmBuild::SetBYTECode(const BYTE& src)
void DgmBuild::SetBYTECode(const unsigned char& src)
{
//not using yet
}

6
OOXML/PPTXFormat/Limit/DgmBuild.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
DgmBuild();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

40
OOXML/PPTXFormat/Limit/DgmBuildType.cpp
View File

@ -38,37 +38,37 @@ namespace PPTX
{
DgmBuildType::DgmBuildType()
{
m_strValue = _T("whole");
m_strValue = L"whole";
}
void DgmBuildType::set(const std::wstring& strValue)
{
if ((_T("allAtOnce") == strValue) ||
(_T("breadthByLvl") == strValue) ||
(_T("breadthByNode") == strValue) ||
(_T("ccw") == strValue) ||
(_T("ccwIn") == strValue) ||
(_T("ccwOut") == strValue) ||
(_T("cust") == strValue) ||
(_T("cw") == strValue) ||
(_T("cwIn") == strValue) ||
(_T("cwOut") == strValue) ||
(_T("depthByBranch") == strValue) ||
(_T("depthByNode") == strValue) ||
(_T("down") == strValue) ||
(_T("inByRing") == strValue) ||
(_T("outByRing") == strValue) ||
(_T("up") == strValue) ||
(_T("whole") == strValue))
if ((L"allAtOnce" == strValue) ||
(L"breadthByLvl" == strValue) ||
(L"breadthByNode" == strValue) ||
(L"ccw" == strValue) ||
(L"ccwIn" == strValue) ||
(L"ccwOut" == strValue) ||
(L"cust" == strValue) ||
(L"cw" == strValue) ||
(L"cwIn" == strValue) ||
(L"cwOut" == strValue) ||
(L"depthByBranch" == strValue) ||
(L"depthByNode" == strValue) ||
(L"down" == strValue) ||
(L"inByRing" == strValue) ||
(L"outByRing" == strValue) ||
(L"up" == strValue) ||
(L"whole" == strValue))
{
m_strValue = strValue;
}
}
BYTE DgmBuildType::GetBYTECode() const
unsigned char DgmBuildType::GetBYTECode() const
{
//not using yet
return 0;
}
void DgmBuildType::SetBYTECode(const BYTE& src)
void DgmBuildType::SetBYTECode(const unsigned char& src)
{
//not using yet
}

6
OOXML/PPTXFormat/Limit/DgmBuildType.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
DgmBuildType();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

14
OOXML/PPTXFormat/Limit/EffectContainerType.cpp
View File

@ -38,25 +38,25 @@ namespace PPTX
{
EffectContainerType::EffectContainerType()
{
m_strValue = _T("sib");
m_strValue = L"sib";
}
void EffectContainerType::set(const std::wstring& strValue)
{
if ((_T("sib") == strValue) ||
(_T("tree") == strValue))
if ((L"sib" == strValue) ||
(L"tree" == strValue))
{
m_strValue = strValue;
}
}
BYTE EffectContainerType::GetBYTECode() const
unsigned char EffectContainerType::GetBYTECode() const
{
if (_T("sib") == m_strValue)
if (L"sib" == m_strValue)
return 0;
if (_T("tree") == m_strValue)
if (L"tree" == m_strValue)
return 1;
return 0;
}
void EffectContainerType::SetBYTECode(const BYTE& val)
void EffectContainerType::SetBYTECode(const unsigned char& val)
{
if (val == 0) m_strValue = L"sib";
else m_strValue = L"tree";

6
OOXML/PPTXFormat/Limit/EffectContainerType.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
EffectContainerType();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& val);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& val);
};
} // namespace Limit
} // namespace PPTX

22
OOXML/PPTXFormat/Limit/EightDirectionVal.cpp
View File

@ -38,23 +38,23 @@ namespace PPTX
{
EightDirectionVal::EightDirectionVal()
{
m_strValue = _T("l");
m_strValue = L"l";
}
void EightDirectionVal::set(const std::wstring& strValue)
{
if ((_T("ld") == strValue) ||
(_T("lu") == strValue) ||
(_T("rd") == strValue) ||
(_T("ru") == strValue) ||
(_T("d") == strValue) ||
(_T("l") == strValue) ||
(_T("r") == strValue) ||
(_T("u") == strValue))
if ((L"ld" == strValue) ||
(L"lu" == strValue) ||
(L"rd" == strValue) ||
(L"ru" == strValue) ||
(L"d" == strValue) ||
(L"l" == strValue) ||
(L"r" == strValue) ||
(L"u" == strValue))
{
m_strValue = strValue;
}
}
BYTE EightDirectionVal::GetBYTECode() const
unsigned char EightDirectionVal::GetBYTECode() const
{
if (L"ld" == m_strValue) return 0;
if (L"lu" == m_strValue) return 1;
@ -66,7 +66,7 @@ namespace PPTX
if (L"u" == m_strValue) return 7;
return 0;
}
void EightDirectionVal::SetBYTECode(const BYTE& src)
void EightDirectionVal::SetBYTECode(const unsigned char& src)
{
switch (src)
{

6
OOXML/PPTXFormat/Limit/EightDirectionVal.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
EightDirectionVal();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

24
OOXML/PPTXFormat/Limit/FillPath.cpp
View File

@ -38,39 +38,39 @@ namespace PPTX
{
FillPath::FillPath()
{
m_strValue = _T("circle");
m_strValue = L"circle";
}
void FillPath::set(const std::wstring& strValue)
{
if ((_T("circle") == strValue) ||
(_T("rect") == strValue) ||
(_T("shape") == strValue))
if ((L"circle" == strValue) ||
(L"rect" == strValue) ||
(L"shape" == strValue))
{
m_strValue = strValue;
}
}
BYTE FillPath::GetBYTECode() const
unsigned char FillPath::GetBYTECode() const
{
if (_T("circle") == m_strValue)
if (L"circle" == m_strValue)
return 0;
if (_T("rect") == m_strValue)
if (L"rect" == m_strValue)
return 1;
if (_T("shape") == m_strValue)
if (L"shape" == m_strValue)
return 2;
return 0;
}
void FillPath::SetBYTECode(const BYTE& src)
void FillPath::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 0:
m_strValue = _T("circle");
m_strValue = L"circle";
break;
case 1:
m_strValue = _T("rect");
m_strValue = L"rect";
break;
case 2:
m_strValue = _T("shape");
m_strValue = L"shape";
break;
default:
break;

6
OOXML/PPTXFormat/Limit/FillPath.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
FillPath();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

30
OOXML/PPTXFormat/Limit/Flip.cpp
View File

@ -38,45 +38,45 @@ namespace PPTX
{
Flip::Flip()
{
m_strValue = _T("none");
m_strValue = L"none";
}
void Flip::set(const std::wstring& strValue)
{
if ((_T("none") == strValue) ||
(_T("x") == strValue) ||
(_T("xy") == strValue) ||
(_T("y") == strValue))
if ((L"none" == strValue) ||
(L"x" == strValue) ||
(L"xy" == strValue) ||
(L"y" == strValue))
{
m_strValue = strValue;
}
}
BYTE Flip::GetBYTECode() const
unsigned char Flip::GetBYTECode() const
{
if (_T("none") == m_strValue)
if (L"none" == m_strValue)
return 0;
if (_T("x") == m_strValue)
if (L"x" == m_strValue)
return 1;
if (_T("y") == m_strValue)
if (L"y" == m_strValue)
return 2;
if (_T("xy") == m_strValue)
if (L"xy" == m_strValue)
return 3;
return 0;
}
void Flip::SetBYTECode(const BYTE& src)
void Flip::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 0:
m_strValue = _T("none");
m_strValue = L"none";
break;
case 1:
m_strValue = _T("x");
m_strValue = L"x";
break;
case 2:
m_strValue = _T("y");
m_strValue = L"y";
break;
case 3:
m_strValue = _T("xy");
m_strValue = L"xy";
break;
default:
break;

6
OOXML/PPTXFormat/Limit/Flip.h
View File

@ -42,12 +42,10 @@ namespace PPTX
public:
Flip();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

38
OOXML/PPTXFormat/Limit/FontAlign.cpp
View File

@ -38,54 +38,54 @@ namespace PPTX
{
FontAlign::FontAlign()
{
m_strValue = _T("auto");
m_strValue = L"auto";
}
void FontAlign::set(const std::wstring& strValue)
{
if ((_T("auto") == strValue) ||
(_T("b") == strValue) ||
(_T("base") == strValue) ||
(_T("ctr") == strValue) ||
(_T("t") == strValue))
if ((L"auto" == strValue) ||
(L"b" == strValue) ||
(L"base" == strValue) ||
(L"ctr" == strValue) ||
(L"t" == strValue))
{
m_strValue = strValue;
}
}
BYTE FontAlign::GetBYTECode() const
unsigned char FontAlign::GetBYTECode() const
{
if (_T("auto") == m_strValue)
if (L"auto" == m_strValue)
return 0;
if (_T("b") == m_strValue)
if (L"b" == m_strValue)
return 1;
if (_T("base") == m_strValue)
if (L"base" == m_strValue)
return 2;
if (_T("ctr") == m_strValue)
if (L"ctr" == m_strValue)
return 3;
if (_T("t") == m_strValue)
if (L"t" == m_strValue)
return 4;
return 0;
}
void FontAlign::SetBYTECode(const BYTE& val)
void FontAlign::SetBYTECode(const unsigned char& val)
{
switch (val)
{
case 0:
m_strValue = _T("auto");
m_strValue = L"auto";
break;
case 1:
m_strValue = _T("b");
m_strValue = L"b";
break;
case 2:
m_strValue = _T("base");
m_strValue = L"base";
break;
case 3:
m_strValue = _T("ctr");
m_strValue = L"ctr";
break;
case 4:
m_strValue = _T("t");
m_strValue = L"t";
break;
default:
m_strValue = _T("auto");
m_strValue = L"auto";
break;
}
}

6
OOXML/PPTXFormat/Limit/FontAlign.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
FontAlign();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& val);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& val);
};
} // namespace Limit
} // namespace PPTX

24
OOXML/PPTXFormat/Limit/FontStyleIndex.cpp
View File

@ -38,39 +38,39 @@ namespace PPTX
{
FontStyleIndex::FontStyleIndex()
{
m_strValue = _T("none");
m_strValue = L"none";
}
void FontStyleIndex::set(const std::wstring& strValue)
{
if ((_T("major") == strValue) ||
(_T("minor") == strValue) ||
(_T("none") == strValue))
if ((L"major" == strValue) ||
(L"minor" == strValue) ||
(L"none" == strValue))
{
m_strValue = strValue;
}
}
BYTE FontStyleIndex::GetBYTECode() const
unsigned char FontStyleIndex::GetBYTECode() const
{
if (_T("major") == m_strValue)
if (L"major" == m_strValue)
return 0;
if (_T("minor") == m_strValue)
if (L"minor" == m_strValue)
return 1;
if (_T("none") == m_strValue)
if (L"none" == m_strValue)
return 2;
return 2;
}
void FontStyleIndex::SetBYTECode(const BYTE& src)
void FontStyleIndex::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 0:
m_strValue = _T("major");
m_strValue = L"major";
break;
case 1:
m_strValue = _T("minor");
m_strValue = L"minor";
break;
default:
m_strValue = _T("none");
m_strValue = L"none";
}
}
} // namespace Limit

6
OOXML/PPTXFormat/Limit/FontStyleIndex.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
FontStyleIndex();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

20
OOXML/PPTXFormat/Limit/FrameShape.cpp
View File

@ -38,27 +38,27 @@ namespace PPTX
{
FrameShape::FrameShape()
{
m_strValue = _T("frameStyle1");
m_strValue = L"frameStyle1";
}
void FrameShape::set(const std::wstring& strValue)
{
if ((_T("frameStyle1") == strValue) ||
(_T("frameStyle2") == strValue) ||
(_T("frameStyle3") == strValue) ||
(_T("frameStyle4") == strValue) ||
(_T("frameStyle5") == strValue) ||
(_T("frameStyle6") == strValue) ||
(_T("frameStyle7") == strValue))
if ((L"frameStyle1" == strValue) ||
(L"frameStyle2" == strValue) ||
(L"frameStyle3" == strValue) ||
(L"frameStyle4" == strValue) ||
(L"frameStyle5" == strValue) ||
(L"frameStyle6" == strValue) ||
(L"frameStyle7" == strValue))
{
m_strValue = strValue;
}
}
BYTE FrameShape::GetBYTECode() const
unsigned char FrameShape::GetBYTECode() const
{
//not using yet
return 0;
}
void FrameShape::SetBYTECode(const BYTE& src)
void FrameShape::SetBYTECode(const unsigned char& src)
{
//not using yet
}

6
OOXML/PPTXFormat/Limit/FrameShape.h
View File

@ -42,12 +42,10 @@ namespace PPTX
public:
FrameShape();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

18
OOXML/PPTXFormat/Limit/HorzOverflow.cpp
View File

@ -38,30 +38,30 @@ namespace PPTX
{
HorzOverflow::HorzOverflow()
{
m_strValue = _T("clip");
m_strValue = L"clip";
}
void HorzOverflow::set(const std::wstring& strValue)
{
if ((_T("clip") == strValue) ||
(_T("overflow") == strValue))
if ((L"clip" == strValue) ||
(L"overflow" == strValue))
{
m_strValue = strValue;
}
}
BYTE HorzOverflow::GetBYTECode() const
unsigned char HorzOverflow::GetBYTECode() const
{
if (_T("clip") == m_strValue)
if (L"clip" == m_strValue)
return 0;
if (_T("overflow") == m_strValue)
if (L"overflow" == m_strValue)
return 1;
return 0;
}
void HorzOverflow::SetBYTECode(const BYTE& src)
void HorzOverflow::SetBYTECode(const unsigned char& src)
{
if (1 == src)
m_strValue = _T("overflow");
m_strValue = L"overflow";
else
m_strValue = _T("clip");
m_strValue = L"clip";
}
} // namespace Limit
} // namespace PPTX

6
OOXML/PPTXFormat/Limit/HorzOverflow.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
HorzOverflow();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

4
OOXML/PPTXFormat/Limit/InOutDirectionVal.cpp
View File

@ -48,13 +48,13 @@ namespace PPTX
m_strValue = strValue;
}
}
BYTE InOutDirectionVal::GetBYTECode() const
unsigned char InOutDirectionVal::GetBYTECode() const
{
if (L"in" == m_strValue) return 0;
if (L"out" == m_strValue) return 1;
return 0;
}
void InOutDirectionVal::SetBYTECode(const BYTE& src)
void InOutDirectionVal::SetBYTECode(const unsigned char& src)
{
switch (src)
{

6
OOXML/PPTXFormat/Limit/InOutDirectionVal.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
InOutDirectionVal();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

4
OOXML/PPTXFormat/Limit/IterateType.cpp
View File

@ -49,14 +49,14 @@ namespace PPTX
m_strValue = strValue;
}
}
BYTE IterateType::GetBYTECode() const
unsigned char IterateType::GetBYTECode() const
{
if (L"el" == m_strValue) return 0;
if (L"lt" == m_strValue) return 1;
if (L"wd" == m_strValue) return 2;
return 0;
}
void IterateType::SetBYTECode(const BYTE& src)
void IterateType::SetBYTECode(const unsigned char& src)
{
switch (src)
{

6
OOXML/PPTXFormat/Limit/IterateType.h
View File

@ -42,12 +42,10 @@ namespace PPTX
public:
IterateType();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

4
OOXML/PPTXFormat/Limit/LastView.cpp
View File

@ -54,7 +54,7 @@ namespace PPTX
m_strValue = strValue;
}
}
BYTE LastView::GetBYTECode() const
unsigned char LastView::GetBYTECode() const
{
if (L"handoutView" == m_strValue) return 0;
if (L"notesMasterView" == m_strValue) return 1;
@ -66,7 +66,7 @@ namespace PPTX
if (L"sldView" == m_strValue) return 7;
return 6;
}
void LastView::SetBYTECode(const BYTE& src)
void LastView::SetBYTECode(const unsigned char& src)
{
switch (src)
{

6
OOXML/PPTXFormat/Limit/LastView.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
LastView();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

5
OOXML/PPTXFormat/Limit/LightRigType.cpp
View File

@ -44,7 +44,7 @@ namespace PPTX
{
m_strValue = strValue;
}
BYTE LightRigType::GetBYTECode() const
unsigned char LightRigType::GetBYTECode() const
{
if (L"balanced" == m_strValue) return 0;
if (L"brightRoom" == m_strValue) return 1;
@ -75,7 +75,7 @@ namespace PPTX
if (L"twoPt" == m_strValue) return 26;
return 0;
}
void LightRigType::SetBYTECode(const BYTE& val)
void LightRigType::SetBYTECode(const unsigned char& val)
{
switch (val)
{
@ -107,7 +107,6 @@ namespace PPTX
case 25: m_strValue = L"threePt"; break;
case 26: m_strValue = L"twoPt"; break;
default: m_strValue = L"balanced";
}
}
} // namespace Limit

6
OOXML/PPTXFormat/Limit/LightRigType.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
LightRigType();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& val);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& val);
};
} // namespace Limit
} // namespace PPTX

24
OOXML/PPTXFormat/Limit/LineCap.cpp
View File

@ -38,39 +38,39 @@ namespace PPTX
{
LineCap::LineCap()
{
m_strValue = _T("flat");
m_strValue = L"flat";
}
void LineCap::set(const std::wstring& strValue)
{
if ((_T("flat") == strValue) ||
(_T("rnd") == strValue) ||
(_T("sq") == strValue))
if ((L"flat" == strValue) ||
(L"rnd" == strValue) ||
(L"sq" == strValue))
{
m_strValue = strValue;
}
}
BYTE LineCap::GetBYTECode() const
unsigned char LineCap::GetBYTECode() const
{
if (_T("flat") == m_strValue)
if (L"flat" == m_strValue)
return 0;
if (_T("rnd") == m_strValue)
if (L"rnd" == m_strValue)
return 1;
if (_T("sq") == m_strValue)
if (L"sq" == m_strValue)
return 2;
return 0;
}
void LineCap::SetBYTECode(const BYTE& src)
void LineCap::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 1:
m_strValue = _T("rnd");
m_strValue = L"rnd");
break;
case 2:
m_strValue = _T("sq");
m_strValue = L"sq");
break;
default:
m_strValue = _T("flat");
m_strValue = L"flat");
break;
}
}

6
OOXML/PPTXFormat/Limit/LineCap.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
LineCap();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

24
OOXML/PPTXFormat/Limit/LineEndSize.cpp
View File

@ -38,39 +38,39 @@ namespace PPTX
{
LineEndSize::LineEndSize()
{
m_strValue = _T("med");
m_strValue = L"med";
}
void LineEndSize::set(const std::wstring& strValue)
{
if ((_T("lg") == strValue) ||
(_T("med") == strValue) ||
(_T("sm") == strValue))
if ((L"lg" == strValue) ||
(L"med" == strValue) ||
(L"sm" == strValue))
{
m_strValue = strValue;
}
}
BYTE LineEndSize::GetBYTECode() const
unsigned char LineEndSize::GetBYTECode() const
{
if (_T("lg") == m_strValue)
if (L"lg" == m_strValue)
return 0;
if (_T("med") == m_strValue)
if (L"med" == m_strValue)
return 1;
if (_T("sm") == m_strValue)
if (L"sm" == m_strValue)
return 2;
return 1;
}
void LineEndSize::SetBYTECode(const BYTE& src)
void LineEndSize::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 0:
m_strValue = _T("lg");
m_strValue = L"lg";
break;
case 1:
m_strValue = _T("med");
m_strValue = L"med";
break;
case 2:
m_strValue = _T("sm");
m_strValue = L"sm";
break;
default:
break;

7
OOXML/PPTXFormat/Limit/LineEndSize.h
View File

@ -33,7 +33,6 @@
#include "BaseLimit.h"
namespace PPTX
{
namespace Limit
@ -42,13 +41,11 @@ namespace PPTX
{
public:
LineEndSize();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

42
OOXML/PPTXFormat/Limit/LineEndType.cpp
View File

@ -38,57 +38,57 @@ namespace PPTX
{
LineEndType::LineEndType()
{
m_strValue = _T("none");
m_strValue = L"none";
}
void LineEndType::set(const std::wstring& strValue)
{
if ((_T("none") == strValue) ||
(_T("arrow") == strValue) ||
(_T("diamond") == strValue) ||
(_T("oval") == strValue) ||
(_T("stealth") == strValue) ||
(_T("triangle") == strValue))
if ((L"none" == strValue) ||
(L"arrow" == strValue) ||
(L"diamond" == strValue) ||
(L"oval" == strValue) ||
(L"stealth" == strValue) ||
(L"triangle" == strValue))
{
m_strValue = strValue;
}
}
BYTE LineEndType::GetBYTECode() const
unsigned char LineEndType::GetBYTECode() const
{
if (_T("none") == m_strValue)
if (L"none" == m_strValue)
return 0;
if (_T("arrow") == m_strValue)
if (L"arrow" == m_strValue)
return 1;
if (_T("diamond") == m_strValue)
if (L"diamond" == m_strValue)
return 2;
if (_T("oval") == m_strValue)
if (L"oval" == m_strValue)
return 3;
if (_T("stealth") == m_strValue)
if (L"stealth" == m_strValue)
return 4;
if (_T("triangle") == m_strValue)
if (L"triangle" == m_strValue)
return 5;
return 0;
}
void LineEndType::SetBYTECode(const BYTE& src)
void LineEndType::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 0:
m_strValue = _T("none");
m_strValue = L"none";
break;
case 1:
m_strValue = _T("arrow");
m_strValue = L"arrow";
break;
case 2:
m_strValue = _T("diamond");
m_strValue = L"diamond";
break;
case 3:
m_strValue = _T("oval");
m_strValue = L"oval";
break;
case 4:
m_strValue = _T("stealth");
m_strValue = L"stealth";
break;
case 5:
m_strValue = _T("triangle");
m_strValue = L"triangle";
break;
default:
break;

6
OOXML/PPTXFormat/Limit/LineEndType.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
LineEndType();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

4
OOXML/PPTXFormat/Limit/Material.cpp
View File

@ -44,7 +44,7 @@ namespace PPTX
{
m_strValue = strValue;
}
BYTE Material::GetBYTECode() const
unsigned char Material::GetBYTECode() const
{
if (L"clear" == m_strValue)
return 0;
@ -79,7 +79,7 @@ namespace PPTX
return 0;
}
void Material::SetBYTECode(const BYTE& val)
void Material::SetBYTECode(const unsigned char& val)
{
switch (val)
{

6
OOXML/PPTXFormat/Limit/Material.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
Material();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& val);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& val);
};
} // namespace Limit
} // namespace PPTX

24
OOXML/PPTXFormat/Limit/OnOff.cpp
View File

@ -38,39 +38,39 @@ namespace PPTX
{
OnOff::OnOff()
{
m_strValue = _T("def");
m_strValue = L"def";
}
void OnOff::set(const std::wstring& strValue)
{
if ((_T("on") == strValue) ||
(_T("off") == strValue) ||
(_T("def") == strValue))
if ((L"on" == strValue) ||
(L"off" == strValue) ||
(L"def" == strValue))
{
m_strValue = strValue;
}
}
BYTE OnOff::GetBYTECode() const
unsigned char OnOff::GetBYTECode() const
{
if (_T("on") == m_strValue)
if (L"on" == m_strValue)
return 0;
if (_T("off") == m_strValue)
if (L"off" == m_strValue)
return 1;
if (_T("def") == m_strValue)
if (L"def" == m_strValue)
return 2;
return 2;
}
void OnOff::SetBYTECode(const BYTE& src)
void OnOff::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 0:
m_strValue = _T("on");
m_strValue = L"on";
break;
case 1:
m_strValue = _T("off");
m_strValue = L"off";
break;
default:
m_strValue = _T("def");
m_strValue = L"def";
break;
}
}

6
OOXML/PPTXFormat/Limit/OnOff.h
View File

@ -42,12 +42,10 @@ namespace PPTX
public:
OnOff();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

16
OOXML/PPTXFormat/Limit/Orient.cpp
View File

@ -38,28 +38,28 @@ namespace PPTX
{
Orient::Orient()
{
m_strValue = _T("vert");
m_strValue = L"vert";
}
void Orient::set(const std::wstring& strValue)
{
if ((_T("horz") == strValue) ||
(_T("vert") == strValue))
if ((L"horz" == strValue) ||
(L"vert" == strValue))
{
m_strValue = strValue;
}
}
BYTE Orient::GetBYTECode() const
unsigned char Orient::GetBYTECode() const
{
if (_T("horz") == m_strValue)
if (L"horz" == m_strValue)
return 0;
return 1;
}
void Orient::SetBYTECode(const BYTE& src)
void Orient::SetBYTECode(const unsigned char& src)
{
if (0 == src)
m_strValue = _T("horz");
m_strValue = L"horz";
else
m_strValue = _T("vert");
m_strValue = L"vert";
}
} // namespace Limit
} // namespace PPTX

6
OOXML/PPTXFormat/Limit/Orient.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
Orient();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

14
OOXML/PPTXFormat/Limit/ParaBuildType.cpp
View File

@ -38,19 +38,19 @@ namespace PPTX
{
ParaBuildType::ParaBuildType()
{
m_strValue = _T("whole");
m_strValue = L"whole";
}
void ParaBuildType::set(const std::wstring& strValue)
{
if ((_T("allAtOnce") == strValue) ||
(_T("cust") == strValue) ||
(_T("p") == strValue) ||
(_T("whole") == strValue))
if ((L"allAtOnce" == strValue) ||
(L"cust" == strValue) ||
(L"p" == strValue) ||
(L"whole" == strValue))
{
m_strValue = strValue;
}
}
BYTE ParaBuildType::GetBYTECode() const
unsigned char ParaBuildType::GetBYTECode() const
{
if (L"allAtOnce" == m_strValue) return 0;
if (L"cust" == m_strValue) return 1;
@ -58,7 +58,7 @@ namespace PPTX
if (L"whole" == m_strValue) return 3;
return 0;
}
void ParaBuildType::SetBYTECode(const BYTE& src)
void ParaBuildType::SetBYTECode(const unsigned char& src)
{
switch (src)
{

6
OOXML/PPTXFormat/Limit/ParaBuildType.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
ParaBuildType();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

44
OOXML/PPTXFormat/Limit/PathFillMode.cpp
View File

@ -38,60 +38,60 @@ namespace PPTX
{
PathFillMode::PathFillMode()
{
m_strValue = _T("none");
m_strValue = L"none";
}
void PathFillMode::set(const std::wstring& strValue)
{
if ((_T("darken") == strValue) ||
(_T("darkenLess") == strValue) ||
(_T("lighten") == strValue) ||
(_T("lightenLess") == strValue) ||
(_T("none") == strValue) ||
(_T("norm") == strValue))
if ((L"darken" == strValue) ||
(L"darkenLess" == strValue) ||
(L"lighten" == strValue) ||
(L"lightenLess" == strValue) ||
(L"none" == strValue) ||
(L"norm" == strValue))
{
m_strValue = strValue;
}
}
BYTE PathFillMode::GetBYTECode() const
unsigned char PathFillMode::GetBYTECode() const
{
if (_T("darken") == m_strValue)
if (L"darken" == m_strValue)
return 0;
if (_T("darkenLess") == m_strValue)
if (L"darkenLess" == m_strValue)
return 1;
if (_T("lighten") == m_strValue)
if (L"lighten" == m_strValue)
return 2;
if (_T("lightenLess") == m_strValue)
if (L"lightenLess" == m_strValue)
return 3;
if (_T("none") == m_strValue)
if (L"none" == m_strValue)
return 4;
if (_T("norm") == m_strValue)
if (L"norm" == m_strValue)
return 5;
return 4;
}
void PathFillMode::SetBYTECode(const BYTE& src)
void PathFillMode::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 0:
m_strValue = _T("darken");
m_strValue = L"darken";
break;
case 1:
m_strValue = _T("darkenLess");
m_strValue = L"darkenLess";
break;
case 2:
m_strValue = _T("lighten");
m_strValue = L"lighten";
break;
case 3:
m_strValue = _T("lightenLess");
m_strValue = L"lightenLess";
break;
case 4:
m_strValue = _T("none");
m_strValue = L"none";
break;
case 5:
m_strValue = _T("norm");
m_strValue = L"norm";
break;
default:
m_strValue = _T("none");
m_strValue = L"none";
break;
}
}

6
OOXML/PPTXFormat/Limit/PathFillMode.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
PathFillMode();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

332
OOXML/PPTXFormat/Limit/PattFillVal.cpp
View File

@ -38,186 +38,186 @@ namespace PPTX
{
PattFillVal::PattFillVal()
{
m_strValue = _T("cross");
m_strValue = L"cross";
}
void PattFillVal::set(const std::wstring& strValue)
{
if ((_T("cross") == strValue) || //(Cross)
(_T("dashDnDiag") == strValue) || //(Dashed Downward Diagonal)
(_T("dashHorz") == strValue) || //(Dashed Horizontal)
(_T("dashUpDiag") == strValue) || //(Dashed Upward DIagonal)
(_T("dashVert") == strValue) || //(Dashed Vertical)
(_T("diagBrick") == strValue) || //(Diagonal Brick)
(_T("diagCross") == strValue) || //(Diagonal Cross)
(_T("divot") == strValue) || //(Divot)
(_T("dkDnDiag") == strValue) || //(Dark Downward Diagonal)
(_T("dkHorz") == strValue) || //(Dark Horizontal)
(_T("dkUpDiag") == strValue) || //(Dark Upward Diagonal)
(_T("dkVert") == strValue) || //(Dark Vertical)
(_T("dnDiag") == strValue) || //(Downward Diagonal)
(_T("dotDmnd") == strValue) || //(Dotted Diamond)
(_T("dotGrid") == strValue) || //(Dotted Grid)
(_T("horz") == strValue) || //(Horizontal)
(_T("horzBrick") == strValue) || //(Horizontal Brick)
(_T("lgCheck") == strValue) || //(Large Checker Board)
(_T("lgConfetti") == strValue) || //(Large Confetti)
(_T("lgGrid") == strValue) || //(Large Grid)
(_T("ltDnDiag") == strValue) || //(Light Downward Diagonal)
(_T("ltHorz") == strValue) || //(Light Horizontal)
(_T("ltUpDiag") == strValue) || //(Light Upward Diagonal)
(_T("ltVert") == strValue) || //(Light Vertical)
(_T("narHorz") == strValue) || //(Narrow Horizontal)
(_T("narVert") == strValue) || //(Narrow Vertical)
(_T("openDmnd") == strValue) || //(Open Diamond)
(_T("pct10") == strValue) || //(10%)
(_T("pct20") == strValue) || //(20%)
(_T("pct25") == strValue) || //(25%)
(_T("pct30") == strValue) || //(30%)
(_T("pct40") == strValue) || //(40%)
(_T("pct5") == strValue) || //(5%)
(_T("pct50") == strValue) || //(50%)
(_T("pct60") == strValue) || //(60%)
(_T("pct70") == strValue) || //(70%)
(_T("pct75") == strValue) || //(75%)
(_T("pct80") == strValue) || //(80%)
(_T("pct90") == strValue) || //(90%)
(_T("plaid") == strValue) || //(Plaid)
(_T("shingle") == strValue) || //(Shingle)
(_T("smCheck") == strValue) || //(Small Checker Board)
(_T("smConfetti") == strValue) || //(Small Confetti)
(_T("smGrid") == strValue) || //(Small Grid)
(_T("solidDmnd") == strValue) || //(Solid Diamond)
(_T("sphere") == strValue) || //(Sphere)
(_T("trellis") == strValue) || //(Trellis)
(_T("upDiag") == strValue) || //(Upward Diagonal)
(_T("vert") == strValue) || //(Vertical)
(_T("wave") == strValue) || //(Wave)
(_T("wdDnDiag") == strValue) || //(Wide Downward Diagonal)
(_T("wdUpDiag") == strValue) || //(Wide Upward Diagonal)
(_T("weave") == strValue) || //(Weave)
(_T("zigZag") == strValue))//(Zig Zag)
if ((L"cross" == strValue) || //(Cross)
(L"dashDnDiag" == strValue) || //(Dashed Downward Diagonal)
(L"dashHorz" == strValue) || //(Dashed Horizontal)
(L"dashUpDiag" == strValue) || //(Dashed Upward DIagonal)
(L"dashVert" == strValue) || //(Dashed Vertical)
(L"diagBrick" == strValue) || //(Diagonal Brick)
(L"diagCross" == strValue) || //(Diagonal Cross)
(L"divot" == strValue) || //(Divot)
(L"dkDnDiag" == strValue) || //(Dark Downward Diagonal)
(L"dkHorz" == strValue) || //(Dark Horizontal)
(L"dkUpDiag" == strValue) || //(Dark Upward Diagonal)
(L"dkVert" == strValue) || //(Dark Vertical)
(L"dnDiag" == strValue) || //(Downward Diagonal)
(L"dotDmnd" == strValue) || //(Dotted Diamond)
(L"dotGrid" == strValue) || //(Dotted Grid)
(L"horz" == strValue) || //(Horizontal)
(L"horzBrick" == strValue) || //(Horizontal Brick)
(L"lgCheck" == strValue) || //(Large Checker Board)
(L"lgConfetti" == strValue) || //(Large Confetti)
(L"lgGrid" == strValue) || //(Large Grid)
(L"ltDnDiag" == strValue) || //(Light Downward Diagonal)
(L"ltHorz" == strValue) || //(Light Horizontal)
(L"ltUpDiag" == strValue) || //(Light Upward Diagonal)
(L"ltVert" == strValue) || //(Light Vertical)
(L"narHorz" == strValue) || //(Narrow Horizontal)
(L"narVert" == strValue) || //(Narrow Vertical)
(L"openDmnd" == strValue) || //(Open Diamond)
(L"pct10" == strValue) || //(10%)
(L"pct20" == strValue) || //(20%)
(L"pct25" == strValue) || //(25%)
(L"pct30" == strValue) || //(30%)
(L"pct40" == strValue) || //(40%)
(L"pct5" == strValue) || //(5%)
(L"pct50" == strValue) || //(50%)
(L"pct60" == strValue) || //(60%)
(L"pct70" == strValue) || //(70%)
(L"pct75" == strValue) || //(75%)
(L"pct80" == strValue) || //(80%)
(L"pct90" == strValue) || //(90%)
(L"plaid" == strValue) || //(Plaid)
(L"shingle" == strValue) || //(Shingle)
(L"smCheck" == strValue) || //(Small Checker Board)
(L"smConfetti" == strValue) || //(Small Confetti)
(L"smGrid" == strValue) || //(Small Grid)
(L"solidDmnd" == strValue) || //(Solid Diamond)
(L"sphere" == strValue) || //(Sphere)
(L"trellis" == strValue) || //(Trellis)
(L"upDiag" == strValue) || //(Upward Diagonal)
(L"vert" == strValue) || //(Vertical)
(L"wave" == strValue) || //(Wave)
(L"wdDnDiag" == strValue) || //(Wide Downward Diagonal)
(L"wdUpDiag" == strValue) || //(Wide Upward Diagonal)
(L"weave" == strValue) || //(Weave)
(L"zigZag" == strValue))//(Zig Zag)
{
m_strValue = strValue;
}
}
BYTE PattFillVal::GetBYTECode() const
unsigned char PattFillVal::GetBYTECode() const
{
if (_T("cross") == m_strValue) return 0;
if (_T("dashDnDiag") == m_strValue) return 1;
if (_T("dashHorz") == m_strValue) return 2;
if (_T("dashUpDiag") == m_strValue) return 3;
if (_T("dashVert") == m_strValue) return 4;
if (_T("diagBrick") == m_strValue) return 5;
if (_T("diagCross") == m_strValue) return 6;
if (_T("divot") == m_strValue) return 7;
if (_T("dkDnDiag") == m_strValue) return 8;
if (_T("dkHorz") == m_strValue) return 9;
if (_T("dkUpDiag") == m_strValue) return 10;
if (_T("dkVert") == m_strValue) return 11;
if (_T("dnDiag") == m_strValue) return 12;
if (_T("dotDmnd") == m_strValue) return 13;
if (_T("dotGrid") == m_strValue) return 14;
if (_T("horz") == m_strValue) return 15;
if (_T("horzBrick") == m_strValue) return 16;
if (_T("lgCheck") == m_strValue) return 17;
if (_T("lgConfetti") == m_strValue) return 18;
if (_T("lgGrid") == m_strValue) return 19;
if (_T("ltDnDiag") == m_strValue) return 20;
if (_T("ltHorz") == m_strValue) return 21;
if (_T("ltUpDiag") == m_strValue) return 22;
if (_T("ltVert") == m_strValue) return 23;
if (_T("narHorz") == m_strValue) return 24;
if (_T("narVert") == m_strValue) return 25;
if (_T("openDmnd") == m_strValue) return 26;
if (_T("pct10") == m_strValue) return 27;
if (_T("pct20") == m_strValue) return 28;
if (_T("pct25") == m_strValue) return 29;
if (_T("pct30") == m_strValue) return 30;
if (_T("pct40") == m_strValue) return 31;
if (_T("pct5") == m_strValue) return 32;
if (_T("pct50") == m_strValue) return 33;
if (_T("pct60") == m_strValue) return 34;
if (_T("pct70") == m_strValue) return 35;
if (_T("pct75") == m_strValue) return 36;
if (_T("pct80") == m_strValue) return 37;
if (_T("pct90") == m_strValue) return 38;
if (_T("plaid") == m_strValue) return 39;
if (_T("shingle") == m_strValue) return 40;
if (_T("smCheck") == m_strValue) return 41;
if (_T("smConfetti") == m_strValue) return 42;
if (_T("smGrid") == m_strValue) return 43;
if (_T("solidDmnd") == m_strValue) return 44;
if (_T("sphere") == m_strValue) return 45;
if (_T("trellis") == m_strValue) return 46;
if (_T("upDiag") == m_strValue) return 47;
if (_T("vert") == m_strValue) return 48;
if (_T("wave") == m_strValue) return 49;
if (_T("wdDnDiag") == m_strValue) return 50;
if (_T("wdUpDiag") == m_strValue) return 51;
if (_T("weave") == m_strValue) return 52;
if (_T("zigZag") == m_strValue) return 53;
if (L"cross" == m_strValue) return 0;
if (L"dashDnDiag" == m_strValue) return 1;
if (L"dashHorz" == m_strValue) return 2;
if (L"dashUpDiag" == m_strValue) return 3;
if (L"dashVert" == m_strValue) return 4;
if (L"diagBrick" == m_strValue) return 5;
if (L"diagCross" == m_strValue) return 6;
if (L"divot" == m_strValue) return 7;
if (L"dkDnDiag" == m_strValue) return 8;
if (L"dkHorz" == m_strValue) return 9;
if (L"dkUpDiag" == m_strValue) return 10;
if (L"dkVert" == m_strValue) return 11;
if (L"dnDiag" == m_strValue) return 12;
if (L"dotDmnd" == m_strValue) return 13;
if (L"dotGrid" == m_strValue) return 14;
if (L"horz" == m_strValue) return 15;
if (L"horzBrick" == m_strValue) return 16;
if (L"lgCheck" == m_strValue) return 17;
if (L"lgConfetti" == m_strValue) return 18;
if (L"lgGrid" == m_strValue) return 19;
if (L"ltDnDiag" == m_strValue) return 20;
if (L"ltHorz" == m_strValue) return 21;
if (L"ltUpDiag" == m_strValue) return 22;
if (L"ltVert" == m_strValue) return 23;
if (L"narHorz" == m_strValue) return 24;
if (L"narVert" == m_strValue) return 25;
if (L"openDmnd" == m_strValue) return 26;
if (L"pct10" == m_strValue) return 27;
if (L"pct20" == m_strValue) return 28;
if (L"pct25" == m_strValue) return 29;
if (L"pct30" == m_strValue) return 30;
if (L"pct40" == m_strValue) return 31;
if (L"pct5" == m_strValue) return 32;
if (L"pct50" == m_strValue) return 33;
if (L"pct60" == m_strValue) return 34;
if (L"pct70" == m_strValue) return 35;
if (L"pct75" == m_strValue) return 36;
if (L"pct80" == m_strValue) return 37;
if (L"pct90" == m_strValue) return 38;
if (L"plaid" == m_strValue) return 39;
if (L"shingle" == m_strValue) return 40;
if (L"smCheck" == m_strValue) return 41;
if (L"smConfetti" == m_strValue) return 42;
if (L"smGrid" == m_strValue) return 43;
if (L"solidDmnd" == m_strValue) return 44;
if (L"sphere" == m_strValue) return 45;
if (L"trellis" == m_strValue) return 46;
if (L"upDiag" == m_strValue) return 47;
if (L"vert" == m_strValue) return 48;
if (L"wave" == m_strValue) return 49;
if (L"wdDnDiag" == m_strValue) return 50;
if (L"wdUpDiag" == m_strValue) return 51;
if (L"weave" == m_strValue) return 52;
if (L"zigZag" == m_strValue) return 53;
return 0;
}
void PattFillVal::SetBYTECode(const BYTE& src)
void PattFillVal::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 0: m_strValue = _T("cross"); break;
case 1: m_strValue = _T("dashDnDiag"); break;
case 2: m_strValue = _T("dashHorz"); break;
case 3: m_strValue = _T("dashUpDiag"); break;
case 4: m_strValue = _T("dashVert"); break;
case 5: m_strValue = _T("diagBrick"); break;
case 6: m_strValue = _T("diagCross"); break;
case 7: m_strValue = _T("divot"); break;
case 8: m_strValue = _T("dkDnDiag"); break;
case 9: m_strValue = _T("dkHorz"); break;
case 10: m_strValue = _T("dkUpDiag"); break;
case 11: m_strValue = _T("dkVert"); break;
case 12: m_strValue = _T("dnDiag"); break;
case 13: m_strValue = _T("dotDmnd"); break;
case 14: m_strValue = _T("dotGrid"); break;
case 15: m_strValue = _T("horz"); break;
case 16: m_strValue = _T("horzBrick"); break;
case 17: m_strValue = _T("lgCheck"); break;
case 18: m_strValue = _T("lgConfetti"); break;
case 19: m_strValue = _T("lgGrid"); break;
case 20: m_strValue = _T("ltDnDiag"); break;
case 21: m_strValue = _T("ltHorz"); break;
case 22: m_strValue = _T("ltUpDiag"); break;
case 23: m_strValue = _T("ltVert"); break;
case 24: m_strValue = _T("narHorz"); break;
case 25: m_strValue = _T("narVert"); break;
case 26: m_strValue = _T("openDmnd"); break;
case 27: m_strValue = _T("pct10"); break;
case 28: m_strValue = _T("pct20"); break;
case 29: m_strValue = _T("pct25"); break;
case 30: m_strValue = _T("pct30"); break;
case 31: m_strValue = _T("pct40"); break;
case 32: m_strValue = _T("pct5"); break;
case 33: m_strValue = _T("pct50"); break;
case 34: m_strValue = _T("pct60"); break;
case 35: m_strValue = _T("pct70"); break;
case 36: m_strValue = _T("pct75"); break;
case 37: m_strValue = _T("pct80"); break;
case 38: m_strValue = _T("pct90"); break;
case 39: m_strValue = _T("plaid"); break;
case 40: m_strValue = _T("shingle"); break;
case 41: m_strValue = _T("smCheck"); break;
case 42: m_strValue = _T("smConfetti"); break;
case 43: m_strValue = _T("smGrid"); break;
case 44: m_strValue = _T("solidDmnd"); break;
case 45: m_strValue = _T("sphere"); break;
case 46: m_strValue = _T("trellis"); break;
case 47: m_strValue = _T("upDiag"); break;
case 48: m_strValue = _T("vert"); break;
case 49: m_strValue = _T("wave"); break;
case 50: m_strValue = _T("wdDnDiag"); break;
case 51: m_strValue = _T("wdUpDiag"); break;
case 52: m_strValue = _T("weave"); break;
case 53: m_strValue = _T("zigZag"); break;
case 0: m_strValue = L"cross"; break;
case 1: m_strValue = L"dashDnDiag"; break;
case 2: m_strValue = L"dashHorz"; break;
case 3: m_strValue = L"dashUpDiag"; break;
case 4: m_strValue = L"dashVert"; break;
case 5: m_strValue = L"diagBrick"; break;
case 6: m_strValue = L"diagCross"; break;
case 7: m_strValue = L"divot"; break;
case 8: m_strValue = L"dkDnDiag"; break;
case 9: m_strValue = L"dkHorz"; break;
case 10: m_strValue = L"dkUpDiag"; break;
case 11: m_strValue = L"dkVert"; break;
case 12: m_strValue = L"dnDiag"; break;
case 13: m_strValue = L"dotDmnd"; break;
case 14: m_strValue = L"dotGrid"; break;
case 15: m_strValue = L"horz"; break;
case 16: m_strValue = L"horzBrick"; break;
case 17: m_strValue = L"lgCheck"; break;
case 18: m_strValue = L"lgConfetti"; break;
case 19: m_strValue = L"lgGrid"; break;
case 20: m_strValue = L"ltDnDiag"; break;
case 21: m_strValue = L"ltHorz"; break;
case 22: m_strValue = L"ltUpDiag"; break;
case 23: m_strValue = L"ltVert"; break;
case 24: m_strValue = L"narHorz"; break;
case 25: m_strValue = L"narVert"; break;
case 26: m_strValue = L"openDmnd"; break;
case 27: m_strValue = L"pct10"; break;
case 28: m_strValue = L"pct20"; break;
case 29: m_strValue = L"pct25"; break;
case 30: m_strValue = L"pct30"; break;
case 31: m_strValue = L"pct40"; break;
case 32: m_strValue = L"pct5"; break;
case 33: m_strValue = L"pct50"; break;
case 34: m_strValue = L"pct60"; break;
case 35: m_strValue = L"pct70"; break;
case 36: m_strValue = L"pct75"; break;
case 37: m_strValue = L"pct80"; break;
case 38: m_strValue = L"pct90"; break;
case 39: m_strValue = L"plaid"; break;
case 40: m_strValue = L"shingle"; break;
case 41: m_strValue = L"smCheck"; break;
case 42: m_strValue = L"smConfetti"; break;
case 43: m_strValue = L"smGrid"; break;
case 44: m_strValue = L"solidDmnd"; break;
case 45: m_strValue = L"sphere"; break;
case 46: m_strValue = L"trellis"; break;
case 47: m_strValue = L"upDiag"; break;
case 48: m_strValue = L"vert"; break;
case 49: m_strValue = L"wave"; break;
case 50: m_strValue = L"wdDnDiag"; break;
case 51: m_strValue = L"wdUpDiag"; break;
case 52: m_strValue = L"weave"; break;
case 53: m_strValue = L"zigZag"; break;
default:
m_strValue = _T("cross");
m_strValue = L"cross");
break;
}
}

6
OOXML/PPTXFormat/Limit/PattFillVal.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
PattFillVal();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

18
OOXML/PPTXFormat/Limit/PenAlign.cpp
View File

@ -38,30 +38,30 @@ namespace PPTX
{
PenAlign::PenAlign()
{
m_strValue = _T("ctr");
m_strValue = L"ctr";
}
void PenAlign::set(const std::wstring& strValue)
{
if ((_T("ctr") == strValue) ||
(_T("in") == strValue))
if ((L"ctr" == strValue) ||
(L"in" == strValue))
{
m_strValue = strValue;
}
}
BYTE PenAlign::GetBYTECode() const
unsigned char PenAlign::GetBYTECode() const
{
if (_T("ctr") == m_strValue)
if (L"ctr" == m_strValue)
return 0;
if (_T("in") == m_strValue)
if (L"in" == m_strValue)
return 1;
return 0;
}
void PenAlign::SetBYTECode(const BYTE& src)
void PenAlign::SetBYTECode(const unsigned char& src)
{
if (1 == src)
m_strValue = _T("in");
m_strValue = L"in";
else
m_strValue = _T("ctr");
m_strValue = L"ctr";
}
} // namespace Limit
} // namespace PPTX

7
OOXML/PPTXFormat/Limit/PenAlign.h
View File

@ -33,7 +33,6 @@
#include "BaseLimit.h"
namespace PPTX
{
namespace Limit
@ -42,13 +41,11 @@ namespace PPTX
{
public:
PenAlign();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

24
OOXML/PPTXFormat/Limit/PlaceholderSize.cpp
View File

@ -38,39 +38,39 @@ namespace PPTX
{
PlaceholderSize::PlaceholderSize()
{
m_strValue = _T("full");
m_strValue = L"full";
}
void PlaceholderSize::set(const std::wstring& strValue)
{
if ((_T("full") == strValue) ||
(_T("half") == strValue) ||
(_T("quarter") == strValue))
if ((L"full" == strValue) ||
(L"half" == strValue) ||
(L"quarter" == strValue))
{
m_strValue = strValue;
}
}
BYTE PlaceholderSize::GetBYTECode() const
unsigned char PlaceholderSize::GetBYTECode() const
{
if (_T("full") == m_strValue)
if (L"full" == m_strValue)
return 0;
if (_T("half") == m_strValue)
if (L"half" == m_strValue)
return 1;
if (_T("quarter") == m_strValue)
if (L"quarter" == m_strValue)
return 2;
return 0;
}
void PlaceholderSize::SetBYTECode(const BYTE& src)
void PlaceholderSize::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 1:
m_strValue = _T("half");
m_strValue = L"half";
break;
case 2:
m_strValue = _T("quarter");
m_strValue = L"quarter";
break;
default:
m_strValue = _T("full");
m_strValue = L"full";
break;
}
}

6
OOXML/PPTXFormat/Limit/PlaceholderSize.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
PlaceholderSize();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

136
OOXML/PPTXFormat/Limit/PlaceholderType.cpp
View File

@ -38,157 +38,157 @@ namespace PPTX
{
int GetPhType(const std::wstring& strType)
{
if (_T("body") == strType)
if (L"body" == strType)
return 0;
if (_T("chart") == strType)
if (L"chart" == strType)
return 1;
if (_T("clipArt") == strType)
if (L"clipArt" == strType)
return 2;
if (_T("ctrTitle") == strType)
if (L"ctrTitle" == strType)
return 15;
if (_T("dgm") == strType)
if (L"dgm" == strType)
return 4;
if (_T("dt") == strType)
if (L"dt" == strType)
return 5;
if (_T("ftr") == strType)
if (L"ftr" == strType)
return 6;
if (_T("hdr") == strType)
if (L"hdr" == strType)
return 7;
if (_T("media") == strType)
if (L"media" == strType)
return 8;
if (_T("obj") == strType)
if (L"obj" == strType)
return 9;
if (_T("pic") == strType)
if (L"pic" == strType)
return 10;
if (_T("sldImg") == strType)
if (L"sldImg" == strType)
return 11;
if (_T("sldNum") == strType)
if (L"sldNum" == strType)
return 12;
if (_T("subTitle") == strType)
if (L"subTitle" == strType)
return 0;
if (_T("tbl") == strType)
if (L"tbl" == strType)
return 14;
if (_T("title") == strType)
if (L"title" == strType)
return 15;
return 0;
}
PlaceholderType::PlaceholderType()
{
m_strValue = _T("obj");
m_strValue = L"obj");
}
void PlaceholderType::set(const std::wstring& strValue)
{
if ((_T("body") == strValue) ||
(_T("chart") == strValue) ||
(_T("clipArt") == strValue) ||
(_T("ctrTitle") == strValue) ||
(_T("dgm") == strValue) ||
(_T("dt") == strValue) ||
(_T("ftr") == strValue) ||
(_T("hdr") == strValue) ||
(_T("media") == strValue) ||
(_T("obj") == strValue) ||
(_T("pic") == strValue) ||
(_T("sldImg") == strValue) ||
(_T("sldNum") == strValue) ||
(_T("subTitle") == strValue) ||
(_T("tbl") == strValue) ||
(_T("title") == strValue))
if ((L"body" == strValue) ||
(L"chart" == strValue) ||
(L"clipArt" == strValue) ||
(L"ctrTitle" == strValue) ||
(L"dgm" == strValue) ||
(L"dt" == strValue) ||
(L"ftr" == strValue) ||
(L"hdr" == strValue) ||
(L"media" == strValue) ||
(L"obj" == strValue) ||
(L"pic" == strValue) ||
(L"sldImg" == strValue) ||
(L"sldNum" == strValue) ||
(L"subTitle" == strValue) ||
(L"tbl" == strValue) ||
(L"title" == strValue))
{
m_strValue = strValue;
}
}
BYTE PlaceholderType::GetBYTECode() const
unsigned char PlaceholderType::GetBYTECode() const
{
if (_T("body") == m_strValue)
if (L"body" == m_strValue)
return 0;
if (_T("chart") == m_strValue)
if (L"chart" == m_strValue)
return 1;
if (_T("clipArt") == m_strValue)
if (L"clipArt" == m_strValue)
return 2;
if (_T("ctrTitle") == m_strValue)
if (L"ctrTitle" == m_strValue)
return 3;
if (_T("dgm") == m_strValue)
if (L"dgm" == m_strValue)
return 4;
if (_T("dt") == m_strValue)
if (L"dt" == m_strValue)
return 5;
if (_T("ftr") == m_strValue)
if (L"ftr" == m_strValue)
return 6;
if (_T("hdr") == m_strValue)
if (L"hdr" == m_strValue)
return 7;
if (_T("media") == m_strValue)
if (L"media" == m_strValue)
return 8;
if (_T("obj") == m_strValue)
if (L"obj" == m_strValue)
return 9;
if (_T("pic") == m_strValue)
if (L"pic" == m_strValue)
return 10;
if (_T("sldImg") == m_strValue)
if (L"sldImg" == m_strValue)
return 11;
if (_T("sldNum") == m_strValue)
if (L"sldNum" == m_strValue)
return 12;
if (_T("subTitle") == m_strValue)
if (L"subTitle" == m_strValue)
return 13;
if (_T("tbl") == m_strValue)
if (L"tbl" == m_strValue)
return 14;
if (_T("title") == m_strValue)
if (L"title" == m_strValue)
return 15;
return 9;
}
void PlaceholderType::SetBYTECode(const BYTE& src)
void PlaceholderType::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 0:
m_strValue = _T("body");
m_strValue = L"body";
break;
case 1:
m_strValue = _T("chart");
m_strValue = L"chart";
break;
case 2:
m_strValue = _T("clipArt");
m_strValue = L"clipArt";
break;
case 3:
m_strValue = _T("ctrTitle");
m_strValue = L"ctrTitle";
break;
case 4:
m_strValue = _T("dgm");
m_strValue = L"dgm";
break;
case 5:
m_strValue = _T("dt");
m_strValue = L"dt";
break;
case 6:
m_strValue = _T("ftr");
m_strValue = L"ftr";
break;
case 7:
m_strValue = _T("hdr");
m_strValue = L"hdr";
break;
case 8:
m_strValue = _T("media");
m_strValue = L"media";
break;
case 9:
m_strValue = _T("obj");
m_strValue = L"obj";
break;
case 10:
m_strValue = _T("pic");
m_strValue = L"pic";
break;
case 11:
m_strValue = _T("sldImg");
m_strValue = L"sldImg";
break;
case 12:
m_strValue = _T("sldNum");
m_strValue = L"sldNum";
break;
case 13:
m_strValue = _T("subTitle");
m_strValue = L"subTitle";
break;
case 14:
m_strValue = _T("tbl");
m_strValue = L"tbl";
break;
case 15:
m_strValue = _T("title");
m_strValue = L"title";
break;
default:
m_strValue = _T("obj");
m_strValue = L"obj";
break;
}
}

7
OOXML/PPTXFormat/Limit/PlaceholderType.h
View File

@ -33,7 +33,6 @@
#include "BaseLimit.h"
namespace PPTX
{
namespace Limit
@ -44,13 +43,11 @@ namespace PPTX
{
public:
PlaceholderType();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

4
OOXML/PPTXFormat/Limit/PresetShadowVal.cpp
View File

@ -66,7 +66,7 @@ namespace PPTX
m_strValue = strValue;
}
}
BYTE PresetShadowVal::GetBYTECode() const
unsigned char PresetShadowVal::GetBYTECode() const
{
if (L"shdw1" == m_strValue) return 0;
if (L"shdw2" == m_strValue) return 1;
@ -91,7 +91,7 @@ namespace PPTX
return 0;
}
void PresetShadowVal::SetBYTECode(const BYTE& src)
void PresetShadowVal::SetBYTECode(const unsigned char& src)
{
switch (src)
{

6
OOXML/PPTXFormat/Limit/PresetShadowVal.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
PresetShadowVal();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

386
OOXML/PPTXFormat/Limit/PrstClrVal.cpp
View File

@ -38,210 +38,210 @@ namespace PPTX
{
PrstClrVal::PrstClrVal()
{
m_strValue = _T("black");
m_strValue = L"black";
}
void PrstClrVal::set(const std::wstring& strValue)
{
if ((_T("aliceBlue") == strValue) || // (Alice Blue Preset Color) Specifies a color with RGB value (240,248,255)
(_T("antiqueWhite") == strValue) || // (Antique White Preset Color) Specifies a color with RGB value (250,235,215)
(_T("aqua") == strValue) || // (Aqua Preset Color) Specifies a color with RGB value (0,255,255)
(_T("aquamarine") == strValue) || // (Aquamarine Preset Color) Specifies a color with RGB value (127,255,212)
(_T("azure") == strValue) || // (Azure Preset Color) Specifies a color with RGB value (240,255,255)
(_T("beige") == strValue) || // (Beige Preset Color) Specifies a color with RGB value (245,245,220)
(_T("bisque") == strValue) || // (Bisque Preset Color) Specifies a color with RGB value (255,228,196)
(_T("black") == strValue) || // (Black Preset Color) Specifies a color with RGB value (0,0,0)
(_T("blanchedAlmond") == strValue) || // (Blanched Almond Preset Color) Specifies a color with RGB value (255,235,205)
(_T("blue") == strValue) || // (Blue Preset Color) Specifies a color with RGB value (0,0,255)
(_T("blueViolet") == strValue) || // (Blue Violet Preset Color) Specifies a color with RGB value (138,43,226)
(_T("brown") == strValue) || // (Brown Preset Color) Specifies a color with RGB value (165,42,42)
(_T("burlyWood") == strValue) || // (Burly Wood Preset Color) Specifies a color with RGB value (222,184,135)
(_T("cadetBlue") == strValue) || // (Cadet Blue Preset Color) Specifies a color with RGB value (95,158,160)
(_T("chartreuse") == strValue) || // (Chartreuse Preset Color) Specifies a color with RGB value (127,255,0)
(_T("chocolate") == strValue) || // (Chocolate Preset Color) Specifies a color with RGB value (210,105,30)
(_T("coral") == strValue) || // (Coral Preset Color) Specifies a color with RGB value (255,127,80)
(_T("cornflowerBlue") == strValue) || // (Cornflower Blue Preset Color) Specifies a color with RGB value (100,149,237)
(_T("cornsilk") == strValue) || // (Cornsilk Preset Color) Specifies a color with RGB value (255,248,220)
(_T("crimson") == strValue) || // (Crimson Preset Color) Specifies a color with RGB value (220,20,60)
(_T("cyan") == strValue) || // (Cyan Preset Color) Specifies a color with RGB value (0,255,255)
(_T("darkBlue") == strValue) || // (Dark Blue Preset Color) Specifies a color with RGB value (0,0,139)
(_T("darkCyan") == strValue) || // (Dark Cyan Preset Color) Specifies a color with RGB value (0,139,139)
(_T("darkGoldenrod") == strValue) || // (Dark Goldenrod Preset Color) Specifies a color with RGB value (184,134,11)
(_T("darkGray") == strValue) || // (Dark Gray Preset Color) Specifies a color with RGB value (169,169,169)
(_T("darkGreen") == strValue) || // (Dark Green Preset Color) Specifies a color with RGB value (0,100,0)
(_T("darkGrey") == strValue) || // (Dark Gray Preset Color) Specifies a color with RGB value (169,169,169)
(_T("darkKhaki") == strValue) || // (Dark Khaki Preset Color) Specifies a color with RGB value (189,183,107)
(_T("darkMagenta") == strValue) || // (Dark Magenta Preset Color) Specifies a color with RGB value (139,0,139)
(_T("darkOliveGreen") == strValue) || // (Dark Olive Green Preset Color) Specifies a color with RGB value (85,107,47)
(_T("darkOrange") == strValue) || // (Dark Orange Preset Color) Specifies a color with RGB value (255,140,0)
(_T("darkOrchid") == strValue) || // (Dark Orchid Preset Color) Specifies a color with RGB value (153,50,204)
(_T("darkRed") == strValue) || // (Dark Red Preset Color) Specifies a color with RGB value (139,0,0)
(_T("darkSalmon") == strValue) || // (Dark Salmon Preset Color) Specifies a color with RGB value (233,150,122)
(_T("darkSeaGreen") == strValue) || // (Dark Sea Green Preset Color) Specifies a color with RGB value (143,188,143)
(_T("darkSlateBlue") == strValue) || // (Dark Slate Blue Preset Color) Specifies a color with RGB value (72,61,139)
(_T("darkSlateGray") == strValue) || // (Dark Slate Gray Preset Color) Specifies a color with RGB value (47,79,79)
(_T("darkSlateGrey") == strValue) || // (Dark Slate Gray Preset Color) Specifies a color with RGB value (47,79,79)
(_T("darkTurquoise") == strValue) || // (Dark Turquoise Preset Color) Specifies a color with RGB value (0,206,209)
(_T("darkViolet") == strValue) || // (Dark Violet Preset Color) Specifies a color with RGB value (148,0,211)
(_T("deepPink") == strValue) || // (Deep Pink Preset Color) Specifies a color with RGB value (255,20,147)
(_T("deepSkyBlue") == strValue) || // (Deep Sky Blue Preset Color) Specifies a color with RGB value (0,191,255)
(_T("dimGray") == strValue) || // (Dim Gray Preset Color) Specifies a color with RGB value (105,105,105)
(_T("dimGrey") == strValue) || // (Dim Gray Preset Color) Specifies a color with RGB value (105,105,105)
(_T("dkBlue") == strValue) || // (Dark Blue Preset Color) Specifies a color with RGB value (0,0,139)
(_T("dkCyan") == strValue) || // (Dark Cyan Preset Color) Specifies a color with RGB value (0,139,139)
(_T("dkGoldenrod") == strValue) || // (Dark Goldenrod Preset Color) Specifies a color with RGB value (184,134,11)
(_T("dkGray") == strValue) || // (Dark Gray Preset Color) Specifies a color with RGB value (169,169,169)
(_T("dkGreen") == strValue) || // (Dark Green Preset Color) Specifies a color with RGB value (0,100,0)
(_T("dkGrey") == strValue) || // (Dark Gray Preset Color) Specifies a color with RGB value (169,169,169)
(_T("dkKhaki") == strValue) || // (Dark Khaki Preset Color) Specifies a color with RGB value (189,183,107)
(_T("dkMagenta") == strValue) || // (Dark Magenta Preset Color) Specifies a color with RGB value (139,0,139)
(_T("dkOliveGreen") == strValue) || // (Dark Olive Green Preset Color) Specifies a color with RGB value (85,107,47)
(_T("dkOrange") == strValue) || // (Dark Orange Preset Color) Specifies a color with RGB value (255,140,0)
(_T("dkOrchid") == strValue) || // (Dark Orchid Preset Color) Specifies a color with RGB value (153,50,204)
(_T("dkRed") == strValue) || // (Dark Red Preset Color) Specifies a color with RGB value (139,0,0)
(_T("dkSalmon") == strValue) || // (Dark Salmon Preset Color) Specifies a color with RGB value (233,150,122)
(_T("dkSeaGreen") == strValue) || // (Dark Sea Green Preset Color) Specifies a color with RGB value (143,188,139)
(_T("dkSlateBlue") == strValue) || // (Dark Slate Blue Preset Color) Specifies a color with RGB value (72,61,139)
(_T("dkSlateGray") == strValue) || // (Dark Slate Gray Preset Color) Specifies a color with RGB value (47,79,79)
(_T("dkSlateGrey") == strValue) || // (Dark Slate Gray Preset Color) Specifies a color with RGB value (47,79,79)
(_T("dkTurquoise") == strValue) || // (Dark Turquoise Preset Color) Specifies a color with RGB value (0,206,209)
(_T("dkViolet") == strValue) || // (Dark Violet Preset Color) Specifies a color with RGB value (148,0,211)
(_T("dodgerBlue") == strValue) || // (Dodger Blue Preset Color) Specifies a color with RGB value (30,144,255)
(_T("firebrick") == strValue) || // (Firebrick Preset Color) Specifies a color with RGB value (178,34,34)
(_T("floralWhite") == strValue) || // (Floral White Preset Color) Specifies a color with RGB value (255,250,240)
(_T("forestGreen") == strValue) || // (Forest Green Preset Color) Specifies a color with RGB value (34,139,34)
(_T("fuchsia") == strValue) || // (Fuchsia Preset Color) Specifies a color with RGB value (255,0,255)
(_T("gainsboro") == strValue) || // (Gainsboro Preset Color) Specifies a color with RGB value (220,220,220)
(_T("ghostWhite") == strValue) || // (Ghost White Preset Color) Specifies a color with RGB value (248,248,255)
(_T("gold") == strValue) || // (Gold Preset Color) Specifies a color with RGB value (255,215,0)
(_T("goldenrod") == strValue) || // (Goldenrod Preset Color) Specifies a color with RGB value (218,165,32)
(_T("gray") == strValue) || // (Gray Preset Color) Specifies a color with RGB value (128,128,128)
(_T("green") == strValue) || // (Green Preset Color) Specifies a color with RGB value (0,128,0)
(_T("greenYellow") == strValue) || // (Green Yellow Preset Color) Specifies a color with RGB value (173,255,47)
(_T("grey") == strValue) || // (Gray Preset Color) Specifies a color with RGB value (128,128,128)
(_T("honeydew") == strValue) || // (Honeydew Preset Color) Specifies a color with RGB value (240,255,240)
(_T("hotPink") == strValue) || // (Hot Pink Preset Color) Specifies a color with RGB value (255,105,180)
(_T("indianRed") == strValue) || // (Indian Red Preset Color) Specifies a color with RGB value (205,92,92)
(_T("indigo") == strValue) || // (Indigo Preset Color) Specifies a color with RGB value (75,0,130)
(_T("ivory") == strValue) || // (Ivory Preset Color) Specifies a color with RGB value (255,255,240)
(_T("khaki") == strValue) || // (Khaki Preset Color) Specifies a color with RGB value (240,230,140)
(_T("lavender") == strValue) || // (Lavender Preset Color) Specifies a color with RGB value (230,230,250)
(_T("lavenderBlush") == strValue) || // (Lavender Blush Preset Color) Specifies a color with RGB value (255,240,245)
(_T("lawnGreen") == strValue) || // (Lawn Green Preset Color) Specifies a color with RGB value (124,252,0)
(_T("lemonChiffon") == strValue) || // (Lemon Chiffon Preset Color) Specifies a color with RGB value (255,250,205)
(_T("lightBlue") == strValue) || // (Light Blue Preset Color) Specifies a color with RGB value (173,216,230)
(_T("lightCoral") == strValue) || // (Light Coral Preset Color) Specifies a color with RGB value (240,128,128)
(_T("lightCyan") == strValue) || // (Light Cyan Preset Color) Specifies a color with RGB value (224,255,255)
(_T("lightGoldenrodYellow") == strValue) || // (Light Goldenrod Color) Yellow Preset Specifies a color with RGB value (250,250,210)
(_T("lightGray") == strValue) || // (Light Gray Preset Color) Specifies a color with RGB value (211,211,211)
(_T("lightGreen") == strValue) || // (Light Green Preset Color) Specifies a color with RGB value (144,238,144)
(_T("lightGrey") == strValue) || // (Light Gray Preset Color) Specifies a color with RGB value (211,211,211)
(_T("lightPink") == strValue) || // (Light Pink Preset Color) Specifies a color with RGB value (255,182,193)
(_T("lightSalmon") == strValue) || // (Light Salmon Preset Color) Specifies a color with RGB value (255,160,122)
(_T("lightSeaGreen") == strValue) || // (Light Sea Green Preset Color) Specifies a color with RGB value (32,178,170)
(_T("lightSkyBlue") == strValue) || // (Light Sky Blue Preset Color) Specifies a color with RGB value (135,206,250)
(_T("lightSlateGray") == strValue) || // (Light Slate Gray Preset Color) Specifies a color with RGB value (119,136,153)
(_T("lightSlateGrey") == strValue) || // (Light Slate Gray Preset Color) Specifies a color with RGB value (119,136,153)
(_T("lightSteelBlue") == strValue) || // (Light Steel Blue Preset Color) Specifies a color with RGB value (176,196,222)
(_T("lightYellow") == strValue) || // (Light Yellow Preset Color) Specifies a color with RGB value (255,255,224)
(_T("lime") == strValue) || // (Lime Preset Color) Specifies a color with RGB value (0,255,0)
(_T("limeGreen") == strValue) || // (Lime Green Preset Color) Specifies a color with RGB value (50,205,50)
(_T("linen") == strValue) || // (Linen Preset Color) Specifies a color with RGB value (250,240,230)
(_T("ltBlue") == strValue) || // (Light Blue Preset Color) Specifies a color with RGB value (173,216,230)
(_T("ltCoral") == strValue) || // (Light Coral Preset Color) Specifies a color with RGB value (240,128,128)
(_T("ltCyan") == strValue) || // (Light Cyan Preset Color) Specifies a color with RGB value (224,255,255)
(_T("ltGoldenrodYellow") == strValue) || // (Light Goldenrod Color) Yellow Preset Specifies a color with RGB value (250,250,120)
(_T("ltGray") == strValue) || // (Light Gray Preset Color) Specifies a color with RGB value (211,211,211)
(_T("ltGreen") == strValue) || // (Light Green Preset Color) Specifies a color with RGB value (144,238,144)
(_T("ltGrey") == strValue) || // (Light Gray Preset Color) Specifies a color with RGB value (211,211,211)
(_T("ltPink") == strValue) || // (Light Pink Preset Color) Specifies a color with RGB value (255,182,193)
(_T("ltSalmon") == strValue) || // (Light Salmon Preset Color) Specifies a color with RGB value (255,160,122)
(_T("ltSeaGreen") == strValue) || // (Light Sea Green Preset Color) Specifies a color with RGB value (32,178,170)
(_T("ltSkyBlue") == strValue) || // (Light Sky Blue Preset Color) Specifies a color with RGB value (135,206,250)
(_T("ltSlateGray") == strValue) || // (Light Slate Gray Preset Color) Specifies a color with RGB value (119,136,153)
(_T("ltSlateGrey") == strValue) || // (Light Slate Gray Preset Color) Specifies a color with RGB value (119,136,153)
(_T("ltSteelBlue") == strValue) || // (Light Steel Blue Preset Color) Specifies a color with RGB value (176,196,222)
(_T("ltYellow") == strValue) || // (Light Yellow Preset Color) Specifies a color with RGB value (255,255,224)
(_T("magenta") == strValue) || // (Magenta Preset Color) Specifies a color with RGB value (255,0,255)
(_T("maroon") == strValue) || // (Maroon Preset Color) Specifies a color with RGB value (128,0,0)
(_T("medAquamarine") == strValue) || // (Medium Aquamarine Preset Color) Specifies a color with RGB value (102,205,170)
(_T("medBlue") == strValue) || // (Medium Blue Preset Color) Specifies a color with RGB value (0,0,205)
(_T("mediumAquamarine") == strValue) || // (Medium Aquamarine Color) Preset Specifies a color with RGB value (102,205,170)
(_T("mediumBlue") == strValue) || // (Medium Blue Preset Color) Specifies a color with RGB value (0,0,205)
(_T("mediumOrchid") == strValue) || // (Medium Orchid Preset Color) Specifies a color with RGB value (186,85,211)
(_T("mediumPurple") == strValue) || // (Medium Purple Preset Color) Specifies a color with RGB value (147,112,219)
(_T("mediumSeaGreen") == strValue) || // (Medium Sea Green Preset Color) Specifies a color with RGB value (60,179,113)
(_T("mediumSlateBlue") == strValue) || // (Medium Slate Blue Preset Color) Specifies a color with RGB value (123,104,238)
(_T("mediumSpringGreen") == strValue) || // (Medium Spring Color) Green Preset Specifies a color with RGB value (0,250,154)
(_T("mediumTurquoise") == strValue) || // (Medium Turquoise Preset Color) Specifies a color with RGB value (72,209,204)
(_T("mediumVioletRed") == strValue) || // (Medium Violet Red Preset Color) Specifies a color with RGB value (199,21,133)
(_T("medOrchid") == strValue) || // (Medium Orchid Preset Color) Specifies a color with RGB value (186,85,211)
(_T("medPurple") == strValue) || // (Medium Purple Preset Color) Specifies a color with RGB value (147,112,219)
(_T("medSeaGreen") == strValue) || // (Medium Sea Green Preset Color) Specifies a color with RGB value (60,179,113)
(_T("medSlateBlue") == strValue) || // (Medium Slate Blue Preset Color) Specifies a color with RGB value (123,104,238)
(_T("medSpringGreen") == strValue) || // (Medium Spring Green Preset Color) Specifies a color with RGB value (0,250,154)
(_T("medTurquoise") == strValue) || // (Medium Turquoise Preset Color) Specifies a color with RGB value (72,209,204)
(_T("medVioletRed") == strValue) || // (Medium Violet Red Preset Color) Specifies a color with RGB value (199,21,133)
(_T("midnightBlue") == strValue) || // (Midnight Blue Preset Color) Specifies a color with RGB value (25,25,112)
(_T("mintCream") == strValue) || // (Mint Cream Preset Color) Specifies a color with RGB value (245,255,250)
(_T("mistyRose") == strValue) || // (Misty Rose Preset Color) Specifies a color with RGB value (255,228,225)
(_T("moccasin") == strValue) || // (Moccasin Preset Color) Specifies a color with RGB value (255,228,181)
(_T("navajoWhite") == strValue) || // (Navajo White Preset Color) Specifies a color with RGB value (255,222,173)
(_T("navy") == strValue) || // (Navy Preset Color) Specifies a color with RGB value (0,0,128)
(_T("oldLace") == strValue) || // (Old Lace Preset Color) Specifies a color with RGB value (253,245,230)
(_T("olive") == strValue) || // (Olive Preset Color) Specifies a color with RGB value (128,128,0)
(_T("oliveDrab") == strValue) || // (Olive Drab Preset Color) Specifies a color with RGB value (107,142,35)
(_T("orange") == strValue) || // (Orange Preset Color) Specifies a color with RGB value (255,165,0)
(_T("orangeRed") == strValue) || // (Orange Red Preset Color) Specifies a color with RGB value (255,69,0)
(_T("orchid") == strValue) || // (Orchid Preset Color) Specifies a color with RGB value (218,112,214)
(_T("paleGoldenrod") == strValue) || // (Pale Goldenrod Preset Color) Specifies a color with RGB value (238,232,170)
(_T("paleGreen") == strValue) || // (Pale Green Preset Color) Specifies a color with RGB value (152,251,152)
(_T("paleTurquoise") == strValue) || // (Pale Turquoise Preset Color) Specifies a color with RGB value (175,238,238)
(_T("paleVioletRed") == strValue) || // (Pale Violet Red Preset Color) Specifies a color with RGB value (219,112,147)
(_T("papayaWhip") == strValue) || // (Papaya Whip Preset Color) Specifies a color with RGB value (255,239,213)
(_T("peachPuff") == strValue) || // (Peach Puff Preset Color) Specifies a color with RGB value (255,218,185)
(_T("peru") == strValue) || // (Peru Preset Color) Specifies a color with RGB value (205,133,63)
(_T("pink") == strValue) || // (Pink Preset Color) Specifies a color with RGB value (255,192,203)
(_T("plum") == strValue) || // (Plum Preset Color) Specifies a color with RGB value (221,160,221)
(_T("powderBlue") == strValue) || // (Powder Blue Preset Color) Specifies a color with RGB value (176,224,230)
(_T("purple") == strValue) || // (Purple Preset Color) Specifies a color with RGB value (128,0,128)
(_T("red") == strValue) || // (Red Preset Color) Specifies a color with RGB value (255,0,0)
(_T("rosyBrown") == strValue) || // (Rosy Brown Preset Color) Specifies a color with RGB value (188,143,143)
(_T("royalBlue") == strValue) || // (Royal Blue Preset Color) Specifies a color with RGB value (65,105,225)
(_T("saddleBrown") == strValue) || // (Saddle Brown Preset Color) Specifies a color with RGB value (139,69,19)
(_T("salmon") == strValue) || // (Salmon Preset Color) Specifies a color with RGB value (250,128,114)
(_T("sandyBrown") == strValue) || // (Sandy Brown Preset Color) Specifies a color with RGB value (244,164,96)
(_T("seaGreen") == strValue) || // (Sea Green Preset Color) Specifies a color with RGB value (46,139,87)
(_T("seaShell") == strValue) || // (Sea Shell Preset Color) Specifies a color with RGB value (255,245,238)
(_T("sienna") == strValue) || // (Sienna Preset Color) Specifies a color with RGB value (160,82,45)
(_T("silver") == strValue) || // (Silver Preset Color) Specifies a color with RGB value (192,192,192)
(_T("skyBlue") == strValue) || // (Sky Blue Preset Color) Specifies a color with RGB value (135,206,235)
(_T("slateBlue") == strValue) || // (Slate Blue Preset Color) Specifies a color with RGB value (106,90,205)
(_T("slateGray") == strValue) || // (Slate Gray Preset Color) Specifies a color with RGB value (112,128,144)
(_T("slateGrey") == strValue) || // (Slate Gray Preset Color) Specifies a color with RGB value (112,128,144)
(_T("snow") == strValue) || // (Snow Preset Color) Specifies a color with RGB value (255,250,250)
(_T("springGreen") == strValue) || // (Spring Green Preset Color) Specifies a color with RGB value (0,255,127)
(_T("steelBlue") == strValue) || // (Steel Blue Preset Color) Specifies a color with RGB value (70,130,180)
(_T("tan") == strValue) || // (Tan Preset Color) Specifies a color with RGB value (210,180,140)
(_T("teal") == strValue) || // (Teal Preset Color) Specifies a color with RGB value (0,128,128)
(_T("thistle") == strValue) || // (Thistle Preset Color) Specifies a color with RGB value (216,191,216)
(_T("tomato") == strValue) || // (Tomato Preset Color) Specifies a color with RGB value (255,99,71)
(_T("turquoise") == strValue) || // (Turquoise Preset Color) Specifies a color with RGB value (64,224,208)
(_T("violet") == strValue) || // (Violet Preset Color) Specifies a color with RGB value (238,130,238)
(_T("wheat") == strValue) || // (Wheat Preset Color) Specifies a color with RGB value (245,222,179)
(_T("white") == strValue) || // (White Preset Color) Specifies a color with RGB value (255,255,255)
(_T("whiteSmoke") == strValue) || // (White Smoke Preset Color) Specifies a color with RGB value (245,245,245)
(_T("yellow") == strValue) || // (Yellow Preset Color) Specifies a color with RGB value (255,255,0)
(_T("yellowGreen") == strValue)) // (Yellow Green Preset Color) Specifies a color with RGB value (154,205,50)
if ((L"aliceBlue" == strValue) || // (Alice Blue Preset Color) Specifies a color with RGB value (240,248,255)
(L"antiqueWhite" == strValue) || // (Antique White Preset Color) Specifies a color with RGB value (250,235,215)
(L"aqua" == strValue) || // (Aqua Preset Color) Specifies a color with RGB value (0,255,255)
(L"aquamarine" == strValue) || // (Aquamarine Preset Color) Specifies a color with RGB value (127,255,212)
(L"azure" == strValue) || // (Azure Preset Color) Specifies a color with RGB value (240,255,255)
(L"beige" == strValue) || // (Beige Preset Color) Specifies a color with RGB value (245,245,220)
(L"bisque" == strValue) || // (Bisque Preset Color) Specifies a color with RGB value (255,228,196)
(L"black" == strValue) || // (Black Preset Color) Specifies a color with RGB value (0,0,0)
(L"blanchedAlmond" == strValue) || // (Blanched Almond Preset Color) Specifies a color with RGB value (255,235,205)
(L"blue" == strValue) || // (Blue Preset Color) Specifies a color with RGB value (0,0,255)
(L"blueViolet" == strValue) || // (Blue Violet Preset Color) Specifies a color with RGB value (138,43,226)
(L"brown" == strValue) || // (Brown Preset Color) Specifies a color with RGB value (165,42,42)
(L"burlyWood" == strValue) || // (Burly Wood Preset Color) Specifies a color with RGB value (222,184,135)
(L"cadetBlue" == strValue) || // (Cadet Blue Preset Color) Specifies a color with RGB value (95,158,160)
(L"chartreuse" == strValue) || // (Chartreuse Preset Color) Specifies a color with RGB value (127,255,0)
(L"chocolate" == strValue) || // (Chocolate Preset Color) Specifies a color with RGB value (210,105,30)
(L"coral" == strValue) || // (Coral Preset Color) Specifies a color with RGB value (255,127,80)
(L"cornflowerBlue" == strValue) || // (Cornflower Blue Preset Color) Specifies a color with RGB value (100,149,237)
(L"cornsilk" == strValue) || // (Cornsilk Preset Color) Specifies a color with RGB value (255,248,220)
(L"crimson" == strValue) || // (Crimson Preset Color) Specifies a color with RGB value (220,20,60)
(L"cyan" == strValue) || // (Cyan Preset Color) Specifies a color with RGB value (0,255,255)
(L"darkBlue" == strValue) || // (Dark Blue Preset Color) Specifies a color with RGB value (0,0,139)
(L"darkCyan" == strValue) || // (Dark Cyan Preset Color) Specifies a color with RGB value (0,139,139)
(L"darkGoldenrod" == strValue) || // (Dark Goldenrod Preset Color) Specifies a color with RGB value (184,134,11)
(L"darkGray" == strValue) || // (Dark Gray Preset Color) Specifies a color with RGB value (169,169,169)
(L"darkGreen" == strValue) || // (Dark Green Preset Color) Specifies a color with RGB value (0,100,0)
(L"darkGrey" == strValue) || // (Dark Gray Preset Color) Specifies a color with RGB value (169,169,169)
(L"darkKhaki" == strValue) || // (Dark Khaki Preset Color) Specifies a color with RGB value (189,183,107)
(L"darkMagenta" == strValue) || // (Dark Magenta Preset Color) Specifies a color with RGB value (139,0,139)
(L"darkOliveGreen" == strValue) || // (Dark Olive Green Preset Color) Specifies a color with RGB value (85,107,47)
(L"darkOrange" == strValue) || // (Dark Orange Preset Color) Specifies a color with RGB value (255,140,0)
(L"darkOrchid" == strValue) || // (Dark Orchid Preset Color) Specifies a color with RGB value (153,50,204)
(L"darkRed" == strValue) || // (Dark Red Preset Color) Specifies a color with RGB value (139,0,0)
(L"darkSalmon" == strValue) || // (Dark Salmon Preset Color) Specifies a color with RGB value (233,150,122)
(L"darkSeaGreen" == strValue) || // (Dark Sea Green Preset Color) Specifies a color with RGB value (143,188,143)
(L"darkSlateBlue" == strValue) || // (Dark Slate Blue Preset Color) Specifies a color with RGB value (72,61,139)
(L"darkSlateGray" == strValue) || // (Dark Slate Gray Preset Color) Specifies a color with RGB value (47,79,79)
(L"darkSlateGrey" == strValue) || // (Dark Slate Gray Preset Color) Specifies a color with RGB value (47,79,79)
(L"darkTurquoise" == strValue) || // (Dark Turquoise Preset Color) Specifies a color with RGB value (0,206,209)
(L"darkViolet" == strValue) || // (Dark Violet Preset Color) Specifies a color with RGB value (148,0,211)
(L"deepPink" == strValue) || // (Deep Pink Preset Color) Specifies a color with RGB value (255,20,147)
(L"deepSkyBlue" == strValue) || // (Deep Sky Blue Preset Color) Specifies a color with RGB value (0,191,255)
(L"dimGray" == strValue) || // (Dim Gray Preset Color) Specifies a color with RGB value (105,105,105)
(L"dimGrey" == strValue) || // (Dim Gray Preset Color) Specifies a color with RGB value (105,105,105)
(L"dkBlue" == strValue) || // (Dark Blue Preset Color) Specifies a color with RGB value (0,0,139)
(L"dkCyan" == strValue) || // (Dark Cyan Preset Color) Specifies a color with RGB value (0,139,139)
(L"dkGoldenrod" == strValue) || // (Dark Goldenrod Preset Color) Specifies a color with RGB value (184,134,11)
(L"dkGray" == strValue) || // (Dark Gray Preset Color) Specifies a color with RGB value (169,169,169)
(L"dkGreen" == strValue) || // (Dark Green Preset Color) Specifies a color with RGB value (0,100,0)
(L"dkGrey" == strValue) || // (Dark Gray Preset Color) Specifies a color with RGB value (169,169,169)
(L"dkKhaki" == strValue) || // (Dark Khaki Preset Color) Specifies a color with RGB value (189,183,107)
(L"dkMagenta" == strValue) || // (Dark Magenta Preset Color) Specifies a color with RGB value (139,0,139)
(L"dkOliveGreen" == strValue) || // (Dark Olive Green Preset Color) Specifies a color with RGB value (85,107,47)
(L"dkOrange" == strValue) || // (Dark Orange Preset Color) Specifies a color with RGB value (255,140,0)
(L"dkOrchid" == strValue) || // (Dark Orchid Preset Color) Specifies a color with RGB value (153,50,204)
(L"dkRed" == strValue) || // (Dark Red Preset Color) Specifies a color with RGB value (139,0,0)
(L"dkSalmon" == strValue) || // (Dark Salmon Preset Color) Specifies a color with RGB value (233,150,122)
(L"dkSeaGreen" == strValue) || // (Dark Sea Green Preset Color) Specifies a color with RGB value (143,188,139)
(L"dkSlateBlue" == strValue) || // (Dark Slate Blue Preset Color) Specifies a color with RGB value (72,61,139)
(L"dkSlateGray" == strValue) || // (Dark Slate Gray Preset Color) Specifies a color with RGB value (47,79,79)
(L"dkSlateGrey" == strValue) || // (Dark Slate Gray Preset Color) Specifies a color with RGB value (47,79,79)
(L"dkTurquoise" == strValue) || // (Dark Turquoise Preset Color) Specifies a color with RGB value (0,206,209)
(L"dkViolet" == strValue) || // (Dark Violet Preset Color) Specifies a color with RGB value (148,0,211)
(L"dodgerBlue" == strValue) || // (Dodger Blue Preset Color) Specifies a color with RGB value (30,144,255)
(L"firebrick" == strValue) || // (Firebrick Preset Color) Specifies a color with RGB value (178,34,34)
(L"floralWhite" == strValue) || // (Floral White Preset Color) Specifies a color with RGB value (255,250,240)
(L"forestGreen" == strValue) || // (Forest Green Preset Color) Specifies a color with RGB value (34,139,34)
(L"fuchsia" == strValue) || // (Fuchsia Preset Color) Specifies a color with RGB value (255,0,255)
(L"gainsboro" == strValue) || // (Gainsboro Preset Color) Specifies a color with RGB value (220,220,220)
(L"ghostWhite" == strValue) || // (Ghost White Preset Color) Specifies a color with RGB value (248,248,255)
(L"gold" == strValue) || // (Gold Preset Color) Specifies a color with RGB value (255,215,0)
(L"goldenrod" == strValue) || // (Goldenrod Preset Color) Specifies a color with RGB value (218,165,32)
(L"gray" == strValue) || // (Gray Preset Color) Specifies a color with RGB value (128,128,128)
(L"green" == strValue) || // (Green Preset Color) Specifies a color with RGB value (0,128,0)
(L"greenYellow" == strValue) || // (Green Yellow Preset Color) Specifies a color with RGB value (173,255,47)
(L"grey" == strValue) || // (Gray Preset Color) Specifies a color with RGB value (128,128,128)
(L"honeydew" == strValue) || // (Honeydew Preset Color) Specifies a color with RGB value (240,255,240)
(L"hotPink" == strValue) || // (Hot Pink Preset Color) Specifies a color with RGB value (255,105,180)
(L"indianRed" == strValue) || // (Indian Red Preset Color) Specifies a color with RGB value (205,92,92)
(L"indigo" == strValue) || // (Indigo Preset Color) Specifies a color with RGB value (75,0,130)
(L"ivory" == strValue) || // (Ivory Preset Color) Specifies a color with RGB value (255,255,240)
(L"khaki" == strValue) || // (Khaki Preset Color) Specifies a color with RGB value (240,230,140)
(L"lavender" == strValue) || // (Lavender Preset Color) Specifies a color with RGB value (230,230,250)
(L"lavenderBlush" == strValue) || // (Lavender Blush Preset Color) Specifies a color with RGB value (255,240,245)
(L"lawnGreen" == strValue) || // (Lawn Green Preset Color) Specifies a color with RGB value (124,252,0)
(L"lemonChiffon" == strValue) || // (Lemon Chiffon Preset Color) Specifies a color with RGB value (255,250,205)
(L"lightBlue" == strValue) || // (Light Blue Preset Color) Specifies a color with RGB value (173,216,230)
(L"lightCoral" == strValue) || // (Light Coral Preset Color) Specifies a color with RGB value (240,128,128)
(L"lightCyan" == strValue) || // (Light Cyan Preset Color) Specifies a color with RGB value (224,255,255)
(L"lightGoldenrodYellow" == strValue) || // (Light Goldenrod Color) Yellow Preset Specifies a color with RGB value (250,250,210)
(L"lightGray" == strValue) || // (Light Gray Preset Color) Specifies a color with RGB value (211,211,211)
(L"lightGreen" == strValue) || // (Light Green Preset Color) Specifies a color with RGB value (144,238,144)
(L"lightGrey" == strValue) || // (Light Gray Preset Color) Specifies a color with RGB value (211,211,211)
(L"lightPink" == strValue) || // (Light Pink Preset Color) Specifies a color with RGB value (255,182,193)
(L"lightSalmon" == strValue) || // (Light Salmon Preset Color) Specifies a color with RGB value (255,160,122)
(L"lightSeaGreen" == strValue) || // (Light Sea Green Preset Color) Specifies a color with RGB value (32,178,170)
(L"lightSkyBlue" == strValue) || // (Light Sky Blue Preset Color) Specifies a color with RGB value (135,206,250)
(L"lightSlateGray" == strValue) || // (Light Slate Gray Preset Color) Specifies a color with RGB value (119,136,153)
(L"lightSlateGrey" == strValue) || // (Light Slate Gray Preset Color) Specifies a color with RGB value (119,136,153)
(L"lightSteelBlue" == strValue) || // (Light Steel Blue Preset Color) Specifies a color with RGB value (176,196,222)
(L"lightYellow" == strValue) || // (Light Yellow Preset Color) Specifies a color with RGB value (255,255,224)
(L"lime" == strValue) || // (Lime Preset Color) Specifies a color with RGB value (0,255,0)
(L"limeGreen" == strValue) || // (Lime Green Preset Color) Specifies a color with RGB value (50,205,50)
(L"linen" == strValue) || // (Linen Preset Color) Specifies a color with RGB value (250,240,230)
(L"ltBlue" == strValue) || // (Light Blue Preset Color) Specifies a color with RGB value (173,216,230)
(L"ltCoral" == strValue) || // (Light Coral Preset Color) Specifies a color with RGB value (240,128,128)
(L"ltCyan" == strValue) || // (Light Cyan Preset Color) Specifies a color with RGB value (224,255,255)
(L"ltGoldenrodYellow" == strValue) || // (Light Goldenrod Color) Yellow Preset Specifies a color with RGB value (250,250,120)
(L"ltGray" == strValue) || // (Light Gray Preset Color) Specifies a color with RGB value (211,211,211)
(L"ltGreen" == strValue) || // (Light Green Preset Color) Specifies a color with RGB value (144,238,144)
(L"ltGrey" == strValue) || // (Light Gray Preset Color) Specifies a color with RGB value (211,211,211)
(L"ltPink" == strValue) || // (Light Pink Preset Color) Specifies a color with RGB value (255,182,193)
(L"ltSalmon" == strValue) || // (Light Salmon Preset Color) Specifies a color with RGB value (255,160,122)
(L"ltSeaGreen" == strValue) || // (Light Sea Green Preset Color) Specifies a color with RGB value (32,178,170)
(L"ltSkyBlue" == strValue) || // (Light Sky Blue Preset Color) Specifies a color with RGB value (135,206,250)
(L"ltSlateGray" == strValue) || // (Light Slate Gray Preset Color) Specifies a color with RGB value (119,136,153)
(L"ltSlateGrey" == strValue) || // (Light Slate Gray Preset Color) Specifies a color with RGB value (119,136,153)
(L"ltSteelBlue" == strValue) || // (Light Steel Blue Preset Color) Specifies a color with RGB value (176,196,222)
(L"ltYellow" == strValue) || // (Light Yellow Preset Color) Specifies a color with RGB value (255,255,224)
(L"magenta" == strValue) || // (Magenta Preset Color) Specifies a color with RGB value (255,0,255)
(L"maroon" == strValue) || // (Maroon Preset Color) Specifies a color with RGB value (128,0,0)
(L"medAquamarine" == strValue) || // (Medium Aquamarine Preset Color) Specifies a color with RGB value (102,205,170)
(L"medBlue" == strValue) || // (Medium Blue Preset Color) Specifies a color with RGB value (0,0,205)
(L"mediumAquamarine" == strValue) || // (Medium Aquamarine Color) Preset Specifies a color with RGB value (102,205,170)
(L"mediumBlue" == strValue) || // (Medium Blue Preset Color) Specifies a color with RGB value (0,0,205)
(L"mediumOrchid" == strValue) || // (Medium Orchid Preset Color) Specifies a color with RGB value (186,85,211)
(L"mediumPurple" == strValue) || // (Medium Purple Preset Color) Specifies a color with RGB value (147,112,219)
(L"mediumSeaGreen" == strValue) || // (Medium Sea Green Preset Color) Specifies a color with RGB value (60,179,113)
(L"mediumSlateBlue" == strValue) || // (Medium Slate Blue Preset Color) Specifies a color with RGB value (123,104,238)
(L"mediumSpringGreen" == strValue) || // (Medium Spring Color) Green Preset Specifies a color with RGB value (0,250,154)
(L"mediumTurquoise" == strValue) || // (Medium Turquoise Preset Color) Specifies a color with RGB value (72,209,204)
(L"mediumVioletRed" == strValue) || // (Medium Violet Red Preset Color) Specifies a color with RGB value (199,21,133)
(L"medOrchid" == strValue) || // (Medium Orchid Preset Color) Specifies a color with RGB value (186,85,211)
(L"medPurple" == strValue) || // (Medium Purple Preset Color) Specifies a color with RGB value (147,112,219)
(L"medSeaGreen" == strValue) || // (Medium Sea Green Preset Color) Specifies a color with RGB value (60,179,113)
(L"medSlateBlue" == strValue) || // (Medium Slate Blue Preset Color) Specifies a color with RGB value (123,104,238)
(L"medSpringGreen" == strValue) || // (Medium Spring Green Preset Color) Specifies a color with RGB value (0,250,154)
(L"medTurquoise" == strValue) || // (Medium Turquoise Preset Color) Specifies a color with RGB value (72,209,204)
(L"medVioletRed" == strValue) || // (Medium Violet Red Preset Color) Specifies a color with RGB value (199,21,133)
(L"midnightBlue" == strValue) || // (Midnight Blue Preset Color) Specifies a color with RGB value (25,25,112)
(L"mintCream" == strValue) || // (Mint Cream Preset Color) Specifies a color with RGB value (245,255,250)
(L"mistyRose" == strValue) || // (Misty Rose Preset Color) Specifies a color with RGB value (255,228,225)
(L"moccasin" == strValue) || // (Moccasin Preset Color) Specifies a color with RGB value (255,228,181)
(L"navajoWhite" == strValue) || // (Navajo White Preset Color) Specifies a color with RGB value (255,222,173)
(L"navy" == strValue) || // (Navy Preset Color) Specifies a color with RGB value (0,0,128)
(L"oldLace" == strValue) || // (Old Lace Preset Color) Specifies a color with RGB value (253,245,230)
(L"olive" == strValue) || // (Olive Preset Color) Specifies a color with RGB value (128,128,0)
(L"oliveDrab" == strValue) || // (Olive Drab Preset Color) Specifies a color with RGB value (107,142,35)
(L"orange" == strValue) || // (Orange Preset Color) Specifies a color with RGB value (255,165,0)
(L"orangeRed" == strValue) || // (Orange Red Preset Color) Specifies a color with RGB value (255,69,0)
(L"orchid" == strValue) || // (Orchid Preset Color) Specifies a color with RGB value (218,112,214)
(L"paleGoldenrod" == strValue) || // (Pale Goldenrod Preset Color) Specifies a color with RGB value (238,232,170)
(L"paleGreen" == strValue) || // (Pale Green Preset Color) Specifies a color with RGB value (152,251,152)
(L"paleTurquoise" == strValue) || // (Pale Turquoise Preset Color) Specifies a color with RGB value (175,238,238)
(L"paleVioletRed" == strValue) || // (Pale Violet Red Preset Color) Specifies a color with RGB value (219,112,147)
(L"papayaWhip" == strValue) || // (Papaya Whip Preset Color) Specifies a color with RGB value (255,239,213)
(L"peachPuff" == strValue) || // (Peach Puff Preset Color) Specifies a color with RGB value (255,218,185)
(L"peru" == strValue) || // (Peru Preset Color) Specifies a color with RGB value (205,133,63)
(L"pink" == strValue) || // (Pink Preset Color) Specifies a color with RGB value (255,192,203)
(L"plum" == strValue) || // (Plum Preset Color) Specifies a color with RGB value (221,160,221)
(L"powderBlue" == strValue) || // (Powder Blue Preset Color) Specifies a color with RGB value (176,224,230)
(L"purple" == strValue) || // (Purple Preset Color) Specifies a color with RGB value (128,0,128)
(L"red" == strValue) || // (Red Preset Color) Specifies a color with RGB value (255,0,0)
(L"rosyBrown" == strValue) || // (Rosy Brown Preset Color) Specifies a color with RGB value (188,143,143)
(L"royalBlue" == strValue) || // (Royal Blue Preset Color) Specifies a color with RGB value (65,105,225)
(L"saddleBrown" == strValue) || // (Saddle Brown Preset Color) Specifies a color with RGB value (139,69,19)
(L"salmon" == strValue) || // (Salmon Preset Color) Specifies a color with RGB value (250,128,114)
(L"sandyBrown" == strValue) || // (Sandy Brown Preset Color) Specifies a color with RGB value (244,164,96)
(L"seaGreen" == strValue) || // (Sea Green Preset Color) Specifies a color with RGB value (46,139,87)
(L"seaShell" == strValue) || // (Sea Shell Preset Color) Specifies a color with RGB value (255,245,238)
(L"sienna" == strValue) || // (Sienna Preset Color) Specifies a color with RGB value (160,82,45)
(L"silver" == strValue) || // (Silver Preset Color) Specifies a color with RGB value (192,192,192)
(L"skyBlue" == strValue) || // (Sky Blue Preset Color) Specifies a color with RGB value (135,206,235)
(L"slateBlue" == strValue) || // (Slate Blue Preset Color) Specifies a color with RGB value (106,90,205)
(L"slateGray" == strValue) || // (Slate Gray Preset Color) Specifies a color with RGB value (112,128,144)
(L"slateGrey" == strValue) || // (Slate Gray Preset Color) Specifies a color with RGB value (112,128,144)
(L"snow" == strValue) || // (Snow Preset Color) Specifies a color with RGB value (255,250,250)
(L"springGreen" == strValue) || // (Spring Green Preset Color) Specifies a color with RGB value (0,255,127)
(L"steelBlue" == strValue) || // (Steel Blue Preset Color) Specifies a color with RGB value (70,130,180)
(L"tan" == strValue) || // (Tan Preset Color) Specifies a color with RGB value (210,180,140)
(L"teal" == strValue) || // (Teal Preset Color) Specifies a color with RGB value (0,128,128)
(L"thistle" == strValue) || // (Thistle Preset Color) Specifies a color with RGB value (216,191,216)
(L"tomato" == strValue) || // (Tomato Preset Color) Specifies a color with RGB value (255,99,71)
(L"turquoise" == strValue) || // (Turquoise Preset Color) Specifies a color with RGB value (64,224,208)
(L"violet" == strValue) || // (Violet Preset Color) Specifies a color with RGB value (238,130,238)
(L"wheat" == strValue) || // (Wheat Preset Color) Specifies a color with RGB value (245,222,179)
(L"white" == strValue) || // (White Preset Color) Specifies a color with RGB value (255,255,255)
(L"whiteSmoke" == strValue) || // (White Smoke Preset Color) Specifies a color with RGB value (245,245,245)
(L"yellow" == strValue) || // (Yellow Preset Color) Specifies a color with RGB value (255,255,0)
(L"yellowGreen" == strValue)) // (Yellow Green Preset Color) Specifies a color with RGB value (154,205,50)
{
m_strValue = strValue;
}
}
BYTE PrstClrVal::GetBYTECode() const
unsigned char PrstClrVal::GetBYTECode() const
{
//not using
return 0;
}
void PrstClrVal::SetBYTECode(const BYTE& src)
void PrstClrVal::SetBYTECode(const unsigned char& src)
{
//not using
}

7
OOXML/PPTXFormat/Limit/PrstClrVal.h
View File

@ -30,6 +30,7 @@
*
*/
#pragma once
#include "BaseLimit.h"
namespace PPTX
@ -40,13 +41,11 @@ namespace PPTX
{
public:
PrstClrVal();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

74
OOXML/PPTXFormat/Limit/PrstDashVal.cpp
View File

@ -38,67 +38,67 @@ namespace PPTX
{
PrstDashVal::PrstDashVal()
{
m_strValue = _T("solid");
m_strValue = L"solid";
}
void PrstDashVal::set(const std::wstring& strValue)
{
if ((_T("dash") == strValue) ||
(_T("dashDot") == strValue) ||
(_T("dot") == strValue) ||
(_T("lgDash") == strValue) ||
(_T("lgDashDot") == strValue) ||
(_T("lgDashDotDot") == strValue) ||
(_T("solid") == strValue) ||
(_T("sysDash") == strValue) ||
(_T("sysDashDot") == strValue) ||
(_T("sysDashDotDot") == strValue) ||
(_T("sysDot") == strValue))
if ((L"dash" == strValue) ||
(L"dashDot" == strValue) ||
(L"dot" == strValue) ||
(L"lgDash" == strValue) ||
(L"lgDashDot" == strValue) ||
(L"lgDashDotDot" == strValue) ||
(L"solid" == strValue) ||
(L"sysDash" == strValue) ||
(L"sysDashDot" == strValue) ||
(L"sysDashDotDot" == strValue) ||
(L"sysDot" == strValue))
{
m_strValue = strValue;
}
}
BYTE PrstDashVal::GetBYTECode() const
unsigned char PrstDashVal::GetBYTECode() const
{
if (_T("dash") == m_strValue)
if (L"dash" == m_strValue)
return 0;
if (_T("dashDot") == m_strValue)
if (L"dashDot" == m_strValue)
return 1;
if (_T("dot") == m_strValue)
if (L"dot" == m_strValue)
return 2;
if (_T("lgDash") == m_strValue)
if (L"lgDash" == m_strValue)
return 3;
if (_T("lgDashDot") == m_strValue)
if (L"lgDashDot" == m_strValue)
return 4;
if (_T("lgDashDotDot") == m_strValue)
if (L"lgDashDotDot" == m_strValue)
return 5;
if (_T("solid") == m_strValue)
if (L"solid" == m_strValue)
return 6;
if (_T("sysDash") == m_strValue)
if (L"sysDash" == m_strValue)
return 7;
if (_T("sysDashDot") == m_strValue)
if (L"sysDashDot" == m_strValue)
return 8;
if (_T("sysDashDotDot") == m_strValue)
if (L"sysDashDotDot" == m_strValue)
return 9;
if (_T("sysDot") == m_strValue)
if (L"sysDot" == m_strValue)
return 10;
return 6;
}
void PrstDashVal::SetBYTECode(const BYTE& src)
void PrstDashVal::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 0: m_strValue = _T("dash"); break;
case 1: m_strValue = _T("dashDot"); break;
case 2: m_strValue = _T("dot"); break;
case 3: m_strValue = _T("lgDash"); break;
case 4: m_strValue = _T("lgDashDot"); break;
case 5: m_strValue = _T("lgDashDotDot"); break;
case 6: m_strValue = _T("solid"); break;
case 7: m_strValue = _T("sysDash"); break;
case 8: m_strValue = _T("sysDashDot"); break;
case 9: m_strValue = _T("sysDashDotDot"); break;
case 10: m_strValue = _T("sysDot"); break;
default: m_strValue = _T("solid"); break;
case 0: m_strValue = L"dash"; break;
case 1: m_strValue = L"dashDot"; break;
case 2: m_strValue = L"dot"; break;
case 3: m_strValue = L"lgDash"; break;
case 4: m_strValue = L"lgDashDot"; break;
case 5: m_strValue = L"lgDashDotDot"; break;
case 6: m_strValue = L"solid"; break;
case 7: m_strValue = L"sysDash"; break;
case 8: m_strValue = L"sysDashDot"; break;
case 9: m_strValue = L"sysDashDotDot"; break;
case 10: m_strValue = L"sysDot"; break;
default: m_strValue = L"solid"; break;
}
}
} // namespace Limit

6
OOXML/PPTXFormat/Limit/PrstDashVal.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
PrstDashVal();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

60
OOXML/PPTXFormat/Limit/RectAlign.cpp
View File

@ -38,75 +38,75 @@ namespace PPTX
{
RectAlign::RectAlign()
{
m_strValue = _T("tl");
m_strValue = L"tl");
}
void RectAlign::set(const std::wstring& strValue)
{
if ((_T("b") == strValue) ||
(_T("bl") == strValue) ||
(_T("br") == strValue) ||
(_T("ctr") == strValue) ||
(_T("l") == strValue) ||
(_T("r") == strValue) ||
(_T("t") == strValue) ||
(_T("tl") == strValue) ||
(_T("tr") == strValue))
if ((L"b" == strValue) ||
(L"bl" == strValue) ||
(L"br" == strValue) ||
(L"ctr" == strValue) ||
(L"l" == strValue) ||
(L"r" == strValue) ||
(L"t" == strValue) ||
(L"tl" == strValue) ||
(L"tr" == strValue))
{
m_strValue = strValue;
}
}
BYTE RectAlign::GetBYTECode() const
unsigned char RectAlign::GetBYTECode() const
{
if (_T("b") == m_strValue)
if (L"b" == m_strValue)
return 0;
if (_T("bl") == m_strValue)
if (L"bl" == m_strValue)
return 1;
if (_T("br") == m_strValue)
if (L"br" == m_strValue)
return 2;
if (_T("ctr") == m_strValue)
if (L"ctr" == m_strValue)
return 3;
if (_T("l") == m_strValue)
if (L"l" == m_strValue)
return 4;
if (_T("r") == m_strValue)
if (L"r" == m_strValue)
return 5;
if (_T("t") == m_strValue)
if (L"t" == m_strValue)
return 6;
if (_T("tl") == m_strValue)
if (L"tl" == m_strValue)
return 7;
if (_T("tr") == m_strValue)
if (L"tr" == m_strValue)
return 8;
return 7;
}
void RectAlign::SetBYTECode(const BYTE& src)
void RectAlign::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 0:
m_strValue = _T("b");
m_strValue = L"b";
break;
case 1:
m_strValue = _T("bl");
m_strValue = L"bl";
break;
case 2:
m_strValue = _T("br");
m_strValue = L"br";
break;
case 3:
m_strValue = _T("ctr");
m_strValue = L"ctr";
break;
case 4:
m_strValue = _T("l");
m_strValue = L"l";
break;
case 5:
m_strValue = _T("r");
m_strValue = L"r";
break;
case 6:
m_strValue = _T("t");
m_strValue = L"t";
break;
case 7:
m_strValue = _T("tl");
m_strValue = L"tl";
break;
case 8:
m_strValue = _T("tr");
m_strValue = L"tr";
break;
default:
break;

6
OOXML/PPTXFormat/Limit/RectAlign.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
RectAlign();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

4
OOXML/PPTXFormat/Limit/SchemeClrVal.cpp
View File

@ -63,7 +63,7 @@ namespace PPTX
m_strValue = strValue;
}
}
BYTE SchemeClrVal::GetBYTECode() const
unsigned char SchemeClrVal::GetBYTECode() const
{
if (L"accent1" == m_strValue) return 0;
if (L"accent2" == m_strValue) return 1;
@ -85,7 +85,7 @@ namespace PPTX
return 0;
}
void SchemeClrVal::SetBYTECode(const BYTE& code)
void SchemeClrVal::SetBYTECode(const unsigned char& code)
{
switch (code)
{

10
OOXML/PPTXFormat/Limit/SchemeClrVal.h
View File

@ -32,10 +32,6 @@
#pragma once
#include "BaseLimit.h"
#if !defined(_WIN32) && !defined (_WIN64)
#include "../../../DesktopEditor/common/Types.h"
#endif
namespace PPTX
{
@ -45,13 +41,11 @@ namespace PPTX
{
public:
SchemeClrVal();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& code);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& code);
};
} // namespace Limit
} // namespace PPTX

4
OOXML/PPTXFormat/Limit/ShapeType.cpp
View File

@ -233,12 +233,12 @@ namespace PPTX
m_strValue = strValue;
}
}
BYTE ShapeType::GetBYTECode() const
unsigned char ShapeType::GetBYTECode() const
{
//not using
return 0;
}
void ShapeType::SetBYTECode(const BYTE& src)
void ShapeType::SetBYTECode(const unsigned char& src)
{
//not using
}

6
OOXML/PPTXFormat/Limit/ShapeType.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
ShapeType();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

14
OOXML/PPTXFormat/Limit/SideDirectionVal.cpp
View File

@ -38,19 +38,19 @@ namespace PPTX
{
SideDirectionVal::SideDirectionVal()
{
m_strValue = _T("l");
m_strValue = L"l";
}
void SideDirectionVal::set(const std::wstring& strValue)
{
if ((_T("d") == strValue) ||
(_T("l") == strValue) ||
(_T("r") == strValue) ||
(_T("u") == strValue))
if ((L"d" == strValue) ||
(L"l" == strValue) ||
(L"r" == strValue) ||
(L"u" == strValue))
{
m_strValue = strValue;
}
}
BYTE SideDirectionVal::GetBYTECode() const
unsigned char SideDirectionVal::GetBYTECode() const
{
if (L"d" == m_strValue) return 4;
if (L"l" == m_strValue) return 5;
@ -58,7 +58,7 @@ namespace PPTX
if (L"u" == m_strValue) return 7;
return 0;
}
void SideDirectionVal::SetBYTECode(const BYTE& src)
void SideDirectionVal::SetBYTECode(const unsigned char& src)
{
switch (src)
{

6
OOXML/PPTXFormat/Limit/SideDirectionVal.h
View File

@ -42,12 +42,10 @@ namespace PPTX
public:
SideDirectionVal();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

222
OOXML/PPTXFormat/Limit/SlideLayoutType.cpp
View File

@ -39,130 +39,130 @@ namespace PPTX
{
SlideLayoutType::SlideLayoutType()
{
m_strValue = _T("blank");
m_strValue = L"blank";
}
void SlideLayoutType::set(const std::wstring& strValue)
{
if ((strValue == _T("blank")) ||
(_T("chart") == strValue) ||
(_T("chartAndTx") == strValue) ||
(_T("clipArtAndTx") == strValue) ||
(_T("clipArtAndVertTx") == strValue) ||
(_T("cust") == strValue) ||
(_T("dgm") == strValue) ||
(_T("fourObj") == strValue) ||
(_T("mediaAndTx") == strValue) ||
(_T("obj") == strValue) ||
(_T("objAndTwoObj") == strValue) ||
(_T("objAndTx") == strValue) ||
(_T("objOnly") == strValue) ||
(_T("objOverTx") == strValue) ||
(_T("objTx") == strValue) ||
(_T("picTx") == strValue) ||
(_T("secHead") == strValue) ||
(_T("tbl") == strValue) ||
(_T("title") == strValue) ||
(_T("titleOnly") == strValue) ||
(_T("twoColTx") == strValue) ||
(_T("twoObj") == strValue) ||
(_T("twoObjAndObj") == strValue) ||
(_T("twoObjAndTx") == strValue) ||
(_T("twoObjOverTx") == strValue) ||
(_T("twoTxTwoObj") == strValue) ||
(_T("tx") == strValue) ||
(_T("txAndChart") == strValue) ||
(_T("txAndClipArt") == strValue) ||
(_T("txAndMedia") == strValue) ||
(_T("txAndObj") == strValue) ||
(_T("txAndTwoObj") == strValue) ||
(_T("txOverObj") == strValue) ||
(_T("vertTitleAndTx") == strValue) ||
(_T("vertTitleAndTxOverChart") == strValue) ||
(_T("vertTx") == strValue))
if ((strValue == L"blank") ||
(L"chart" == strValue) ||
(L"chartAndTx" == strValue) ||
(L"clipArtAndTx" == strValue) ||
(L"clipArtAndVertTx" == strValue) ||
(L"cust" == strValue) ||
(L"dgm" == strValue) ||
(L"fourObj" == strValue) ||
(L"mediaAndTx" == strValue) ||
(L"obj" == strValue) ||
(L"objAndTwoObj" == strValue) ||
(L"objAndTx" == strValue) ||
(L"objOnly" == strValue) ||
(L"objOverTx" == strValue) ||
(L"objTx" == strValue) ||
(L"picTx" == strValue) ||
(L"secHead" == strValue) ||
(L"tbl" == strValue) ||
(L"title" == strValue) ||
(L"titleOnly" == strValue) ||
(L"twoColTx" == strValue) ||
(L"twoObj" == strValue) ||
(L"twoObjAndObj" == strValue) ||
(L"twoObjAndTx" == strValue) ||
(L"twoObjOverTx" == strValue) ||
(L"twoTxTwoObj" == strValue) ||
(L"tx" == strValue) ||
(L"txAndChart" == strValue) ||
(L"txAndClipArt" == strValue) ||
(L"txAndMedia" == strValue) ||
(L"txAndObj" == strValue) ||
(L"txAndTwoObj" == strValue) ||
(L"txOverObj" == strValue) ||
(L"vertTitleAndTx" == strValue) ||
(L"vertTitleAndTxOverChart" == strValue) ||
(L"vertTx" == strValue))
{
m_strValue = strValue;
}
}
BYTE SlideLayoutType::GetBYTECode() const
unsigned char SlideLayoutType::GetBYTECode() const
{
if (_T("blank") == m_strValue) return 0;
if (_T("chart") == m_strValue) return 1;
if (_T("chartAndTx") == m_strValue) return 2;
if (_T("clipArtAndTx") == m_strValue) return 3;
if (_T("clipArtAndVertTx") == m_strValue) return 4;
if (_T("cust") == m_strValue) return 5;
if (_T("dgm") == m_strValue) return 6;
if (_T("fourObj") == m_strValue) return 7;
if (_T("mediaAndTx") == m_strValue) return 8;
if (_T("obj") == m_strValue) return 9;
if (_T("objAndTwoObj") == m_strValue) return 10;
if (_T("objAndTx") == m_strValue) return 11;
if (_T("objOnly") == m_strValue) return 12;
if (_T("objOverTx") == m_strValue) return 13;
if (_T("objTx") == m_strValue) return 14;
if (_T("picTx") == m_strValue) return 15;
if (_T("secHead") == m_strValue) return 16;
if (_T("tbl") == m_strValue) return 17;
if (_T("title") == m_strValue) return 18;
if (_T("titleOnly") == m_strValue) return 19;
if (_T("twoColTx") == m_strValue) return 20;
if (_T("twoObj") == m_strValue) return 21;
if (_T("twoObjAndObj") == m_strValue) return 22;
if (_T("twoObjAndTx") == m_strValue) return 23;
if (_T("twoObjOverTx") == m_strValue) return 24;
if (_T("twoTxTwoObj") == m_strValue) return 25;
if (_T("tx") == m_strValue) return 26;
if (_T("txAndChart") == m_strValue) return 27;
if (_T("txAndClipArt") == m_strValue) return 28;
if (_T("txAndMedia") == m_strValue) return 29;
if (_T("txAndObj") == m_strValue) return 30;
if (_T("txAndTwoObj") == m_strValue) return 31;
if (_T("txOverObj") == m_strValue) return 32;
if (_T("vertTitleAndTx") == m_strValue) return 33;
if (_T("vertTitleAndTxOverChart") == m_strValue) return 34;
if (_T("vertTx") == m_strValue) return 35;
if (L"blank" == m_strValue) return 0;
if (L"chart" == m_strValue) return 1;
if (L"chartAndTx" == m_strValue) return 2;
if (L"clipArtAndTx" == m_strValue) return 3;
if (L"clipArtAndVertTx" == m_strValue) return 4;
if (L"cust" == m_strValue) return 5;
if (L"dgm" == m_strValue) return 6;
if (L"fourObj" == m_strValue) return 7;
if (L"mediaAndTx" == m_strValue) return 8;
if (L"obj" == m_strValue) return 9;
if (L"objAndTwoObj" == m_strValue) return 10;
if (L"objAndTx" == m_strValue) return 11;
if (L"objOnly" == m_strValue) return 12;
if (L"objOverTx" == m_strValue) return 13;
if (L"objTx" == m_strValue) return 14;
if (L"picTx" == m_strValue) return 15;
if (L"secHead" == m_strValue) return 16;
if (L"tbl" == m_strValue) return 17;
if (L"title" == m_strValue) return 18;
if (L"titleOnly" == m_strValue) return 19;
if (L"twoColTx" == m_strValue) return 20;
if (L"twoObj" == m_strValue) return 21;
if (L"twoObjAndObj" == m_strValue) return 22;
if (L"twoObjAndTx" == m_strValue) return 23;
if (L"twoObjOverTx" == m_strValue) return 24;
if (L"twoTxTwoObj" == m_strValue) return 25;
if (L"tx" == m_strValue) return 26;
if (L"txAndChart" == m_strValue) return 27;
if (L"txAndClipArt" == m_strValue) return 28;
if (L"txAndMedia" == m_strValue) return 29;
if (L"txAndObj" == m_strValue) return 30;
if (L"txAndTwoObj" == m_strValue) return 31;
if (L"txOverObj" == m_strValue) return 32;
if (L"vertTitleAndTx" == m_strValue) return 33;
if (L"vertTitleAndTxOverChart" == m_strValue) return 34;
if (L"vertTx" == m_strValue) return 35;
return 0;
}
void SlideLayoutType::SetBYTECode(const BYTE& src)
void SlideLayoutType::SetBYTECode(const unsigned char& src)
{
switch (src)
{
case 0: { m_strValue = _T("blank"); break; }
case 1: { m_strValue = _T("chart"); break; }
case 2: { m_strValue = _T("chartAndTx"); break; }
case 3: { m_strValue = _T("clipArtAndTx"); break; }
case 4: { m_strValue = _T("clipArtAndVertTx"); break; }
case 5: { m_strValue = _T("cust"); break; }
case 6: { m_strValue = _T("dgm"); break; }
case 7: { m_strValue = _T("fourObj"); break; }
case 8: { m_strValue = _T("mediaAndTx"); break; }
case 9: { m_strValue = _T("obj"); break; }
case 10: { m_strValue = _T("objAndTwoObj"); break; }
case 11: { m_strValue = _T("objAndTx"); break; }
case 12: { m_strValue = _T("objOnly"); break; }
case 13: { m_strValue = _T("objOverTx"); break; }
case 14: { m_strValue = _T("objTx"); break; }
case 15: { m_strValue = _T("picTx"); break; }
case 16: { m_strValue = _T("secHead"); break; }
case 17: { m_strValue = _T("tbl"); break; }
case 18: { m_strValue = _T("title"); break; }
case 19: { m_strValue = _T("titleOnly"); break; }
case 20: { m_strValue = _T("twoColTx"); break; }
case 21: { m_strValue = _T("twoObj"); break; }
case 22: { m_strValue = _T("twoObjAndObj"); break; }
case 23: { m_strValue = _T("twoObjAndTx"); break; }
case 24: { m_strValue = _T("twoObjOverTx"); break; }
case 25: { m_strValue = _T("twoTxTwoObj"); break; }
case 26: { m_strValue = _T("tx"); break; }
case 27: { m_strValue = _T("txAndChart"); break; }
case 28: { m_strValue = _T("txAndClipArt"); break; }
case 29: { m_strValue = _T("txAndMedia"); break; }
case 30: { m_strValue = _T("txAndObj"); break; }
case 31: { m_strValue = _T("txAndTwoObj"); break; }
case 32: { m_strValue = _T("txOverObj"); break; }
case 33: { m_strValue = _T("vertTitleAndTx"); break; }
case 34: { m_strValue = _T("vertTitleAndTxOverChart"); break; }
case 35: { m_strValue = _T("vertTx"); break; }
case 0: { m_strValue = L"blank"; break; }
case 1: { m_strValue = L"chart"; break; }
case 2: { m_strValue = L"chartAndTx"; break; }
case 3: { m_strValue = L"clipArtAndTx"; break; }
case 4: { m_strValue = L"clipArtAndVertTx"; break; }
case 5: { m_strValue = L"cust"; break; }
case 6: { m_strValue = L"dgm"; break; }
case 7: { m_strValue = L"fourObj"; break; }
case 8: { m_strValue = L"mediaAndTx"; break; }
case 9: { m_strValue = L"obj"; break; }
case 10: { m_strValue = L"objAndTwoObj"; break; }
case 11: { m_strValue = L"objAndTx"; break; }
case 12: { m_strValue = L"objOnly"; break; }
case 13: { m_strValue = L"objOverTx"; break; }
case 14: { m_strValue = L"objTx"; break; }
case 15: { m_strValue = L"picTx"; break; }
case 16: { m_strValue = L"secHead"; break; }
case 17: { m_strValue = L"tbl"; break; }
case 18: { m_strValue = L"title"; break; }
case 19: { m_strValue = L"titleOnly"; break; }
case 20: { m_strValue = L"twoColTx"; break; }
case 21: { m_strValue = L"twoObj"; break; }
case 22: { m_strValue = L"twoObjAndObj"; break; }
case 23: { m_strValue = L"twoObjAndTx"; break; }
case 24: { m_strValue = L"twoObjOverTx"; break; }
case 25: { m_strValue = L"twoTxTwoObj"; break; }
case 26: { m_strValue = L"tx"; break; }
case 27: { m_strValue = L"txAndChart"; break; }
case 28: { m_strValue = L"txAndClipArt"; break; }
case 29: { m_strValue = L"txAndMedia"; break; }
case 30: { m_strValue = L"txAndObj"; break; }
case 31: { m_strValue = L"txAndTwoObj"; break; }
case 32: { m_strValue = L"txOverObj"; break; }
case 33: { m_strValue = L"vertTitleAndTx"; break; }
case 34: { m_strValue = L"vertTitleAndTxOverChart"; break; }
case 35: { m_strValue = L"vertTx"; break; }
default:
break;
}

6
OOXML/PPTXFormat/Limit/SlideLayoutType.h
View File

@ -41,13 +41,11 @@ namespace PPTX
{
public:
SlideLayoutType();
_USE_STRING_OPERATOR
virtual void set(const std::wstring& strValue);
virtual BYTE GetBYTECode() const;
virtual void SetBYTECode(const BYTE& src);
virtual unsigned char GetBYTECode() const;
virtual void SetBYTECode(const unsigned char& src);
};
} // namespace Limit
} // namespace PPTX

104
OOXML/PPTXFormat/Limit/SlideSize.cpp
View File

@ -38,73 +38,73 @@ namespace PPTX
{
SlideSize::SlideSize()
{
m_strValue = _T("screen4x3");
m_strValue = L"screen4x3";
}
void SlideSize::set(const std::wstring& strValue)
{
if ((_T("35mm") == strValue) ||
(_T("A3") == strValue) ||
(_T("A4") == strValue) ||
(_T("B4ISO") == strValue) ||
(_T("B4JIS") == strValue) ||
(_T("B5ISO") == strValue) ||
(_T("B5JIS") == strValue) ||
(_T("banner") == strValue) ||
(_T("custom") == strValue) ||
(_T("hagakiCard") == strValue) ||
(_T("ledger") == strValue) ||
(_T("letter") == strValue) ||
(_T("overhead") == strValue) ||
(_T("screen16x10") == strValue) ||
(_T("screen16x9") == strValue) ||
(_T("screen4x3") == strValue))
if ((L"35mm" == strValue) ||
(L"A3" == strValue) ||
(L"A4" == strValue) ||
(L"B4ISO" == strValue) ||
(L"B4JIS" == strValue) ||
(L"B5ISO" == strValue) ||
(L"B5JIS" == strValue) ||
(L"banner" == strValue) ||
(L"custom" == strValue) ||
(L"hagakiCard" == strValue) ||
(L"ledger" == strValue) ||
(L"letter" == strValue) ||
(L"overhead" == strValue) ||
(L"screen16x10" == strValue) ||
(L"screen16x9" == strValue) ||
(L"screen4x3" == strValue))
{
m_strValue = strValue;
}
}
BYTE SlideSize::GetBYTECode() const
unsigned char SlideSize::GetBYTECode() const
{
if (_T("35mm") == m_strValue) return 0;
if (_T("A3") == m_strValue) return 1;
if (_T("A4") == m_strValue) return 2;
if (_T("B4ISO") == m_strValue) return 3;
if (_T("B4JIS") == m_strValue) return 4;
if (_T("B5ISO") == m_strValue) return 5;
if (_T("B5JIS") == m_strValue) return 6;
if (_T("banner") == m_strValue) return 7;
if (_T("custom") == m_strValue) return 8;
if (_T("hagakiCard") == m_strValue) return 9;
if (_T("ledger") == m_strValue) return 10;
if (_T("letter") == m_strValue) return 11;
if (_T("overhead") == m_strValue) return 12;
if (_T("screen16x10") == m_strValue) return 13;
if (_T("screen16x9") == m_strValue) return 14;
if (_T("screen4x3") == m_strValue) return 15;
if (L"35mm" == m_strValue) return 0;
if (L"A3" == m_strValue) return 1;
if (L"A4" == m_strValue) return 2;
if (L"B4ISO" == m_strValue) return 3;
if (L"B4JIS" == m_strValue) return 4;
if (L"B5ISO" == m_strValue) return 5;
if (L"B5JIS" == m_strValue) return 6;
if (L"banner" == m_strValue) return 7;
if (L"custom" == m_strValue) return 8;
if (L"hagakiCard" == m_strValue) return 9;
if (L"ledger" == m_strValue) return 10;
if (L"letter" == m_strValue) return 11;
if (L"overhead" == m_strValue) return 12;
if (L"screen16x10" == m_strValue) return 13;
if (L"screen16x9" == m_strValue) return 14;
if (L"screen4x3" == m_strValue) return 15;
return 15;
}
void SlideSize::SetBYTECode(const BYTE& type)
void SlideSize::SetBYTECode(const unsigned char& type)
{
switch (type)
{
case 0: m_strValue = _T("35mm"); break;
case 1: m_strValue = _T("A3"); break;
case 2: m_strValue = _T("A4"); break;
case 3: m_strValue = _T("B4ISO"); break;
case 4: m_strValue = _T("B4JIS"); break;
case 5: m_strValue = _T("B5ISO"); break;
case 6: m_strValue = _T("B5JIS"); break;
case 7: m_strValue = _T("banner"); break;
case 8: m_strValue = _T("custom"); break;
case 9: m_strValue = _T("hagakiCard"); break;
case 10: m_strValue = _T("ledger"); break;
case 11: m_strValue = _T("letter"); break;
case 12: m_strValue = _T("overhead"); break;
case 13: m_strValue = _T("screen16x10"); break;
case 14: m_strValue = _T("screen16x9"); break;
case 15: m_strValue = _T("screen4x3"); break;
case 0: m_strValue = L"35mm"; break;
case 1: m_strValue = L"A3"; break;
case 2: m_strValue = L"A4"; break;
case 3: m_strValue = L"B4ISO"; break;
case 4: m_strValue = L"B4JIS"; break;
case 5: m_strValue = L"B5ISO"; break;
case 6: m_strValue = L"B5JIS"; break;
case 7: m_strValue = L"banner"; break;
case 8: m_strValue = L"custom"; break;
case 9: m_strValue = L"hagakiCard"; break;
case 10: m_strValue = L"ledger"; break;
case 11: m_strValue = L"letter"; break;
case 12: m_strValue = L"overhead"; break;
case 13: m_strValue = L"screen16x10"; break;
case 14: m_strValue = L"screen16x9"; break;
case 15: m_strValue = L"screen4x3"; break;
default:
m_strValue = _T("screen4x3");
m_strValue = L"screen4x3";
}
}
} // namespace Limit

Some files were not shown because too many files have changed in this diff Show More