mirror of
https://github.com/ONLYOFFICE/core.git
synced 2026-07-11 08:22:08 +08:00
1051 lines
28 KiB
C++
1051 lines
28 KiB
C++
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2023
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
#ifndef WORKSHEET_H
|
|
#define WORKSHEET_H
|
|
|
|
#include "Biff12RecordBase.h"
|
|
namespace XLSB {
|
|
|
|
class RowRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen >= 12)
|
|
{
|
|
DWORD row = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
DWORD style = CBinaryBiff12StreamReader::GetDword(p + 4);
|
|
WORD height = CBinaryBiff12StreamReader::GetWord(p + 8);
|
|
WORD grbits = CBinaryBiff12StreamReader::GetWord(p + 10);
|
|
|
|
bool outline = (grbits & 0x0700) != 0; // 8 levels of outline
|
|
bool resized = (grbits & 0x2000) != 0;
|
|
bool hidden = (grbits & 0x1000) != 0;
|
|
|
|
CHAR s[256];
|
|
sprintf(s, "\tinfo : row=%d, height=%.2f, style=%d, outline=%s, resize=%s, hidden=%s\r\n",
|
|
row,
|
|
float(height) / 20,
|
|
style,
|
|
outline ? "true":"false",
|
|
resized ? "true":"false",
|
|
hidden ? "true":"false");
|
|
std::cout<<(s);
|
|
}
|
|
else
|
|
{
|
|
std::cout<<("\tinfo : invalid row record length\r\n");
|
|
}
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "row";
|
|
}
|
|
};
|
|
|
|
class BlankRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen >= 8)
|
|
{
|
|
DWORD col = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
DWORD style = CBinaryBiff12StreamReader::GetDword(p + 4);
|
|
|
|
CHAR s[256];
|
|
sprintf(s, "\t\tinfo : col=%d, style=%d, v:blank\r\n",
|
|
col,
|
|
style);
|
|
std::cout<<(s);
|
|
|
|
}
|
|
else
|
|
{
|
|
std::cout<<("\t\tinfo : invalid blank record length\r\n");
|
|
}
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "blank";
|
|
}
|
|
};
|
|
|
|
class NumRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen >= 12)
|
|
{
|
|
DWORD col = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
DWORD style = CBinaryBiff12StreamReader::GetDword(p + 4);
|
|
double f = CBinaryBiff12StreamReader::GetFloat(p + 8);
|
|
|
|
CHAR s[256];
|
|
sprintf(s, "\t\tinfo : col=%d, style=%d, v:float=%.6g\r\n",
|
|
col,
|
|
style,
|
|
f);
|
|
std::cout<<(s);
|
|
|
|
}
|
|
else
|
|
{
|
|
std::cout<<("\t\tinfo : invalid num record length\r\n");
|
|
}
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "num";
|
|
}
|
|
};
|
|
|
|
class BoolErrRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen >= 9)
|
|
{
|
|
DWORD col = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
DWORD style = CBinaryBiff12StreamReader::GetDword(p + 4);
|
|
BYTE b = CBinaryBiff12StreamReader::GetByte(p + 8);
|
|
|
|
CHAR s[256];
|
|
sprintf(s, "\t\tinfo : col=%d, style=%d, v:boolerr=%d\r\n",
|
|
col,
|
|
style,
|
|
b);
|
|
std::cout<<(s);
|
|
}
|
|
else
|
|
{
|
|
std::cout<<("\t\tinfo : invalid boolerr record length\r\n");
|
|
}
|
|
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "boolErr";
|
|
}
|
|
};
|
|
|
|
class BoolRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen >= 9)
|
|
{
|
|
DWORD col = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
DWORD style = CBinaryBiff12StreamReader::GetDword(p + 4);
|
|
BYTE b = CBinaryBiff12StreamReader::GetByte(p + 8);
|
|
|
|
CHAR s[256];
|
|
sprintf(s, "\t\tinfo : col=%d, style=%d, v:bool=%s\r\n",
|
|
col,
|
|
style,
|
|
b?"true":"false");
|
|
std::cout<<(s);
|
|
}
|
|
else
|
|
{
|
|
std::cout<<("\t\tinfo : invalid bool record length\r\n");
|
|
}
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "bool";
|
|
}
|
|
};
|
|
|
|
class FloatRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen >= 16)
|
|
{
|
|
DWORD col = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
DWORD style = CBinaryBiff12StreamReader::GetDword(p + 4);
|
|
double f = CBinaryBiff12StreamReader::GetDouble(p + 8);
|
|
|
|
CHAR s[256];
|
|
sprintf(s, "\t\tinfo : col=%d, style=%d, v:float=%.10g\r\n",
|
|
col,
|
|
style,
|
|
f);
|
|
std::cout<<(s);
|
|
}
|
|
else
|
|
{
|
|
std::cout<<("\t\tinfo : invalid float record length\r\n");
|
|
}
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "float";
|
|
}
|
|
};
|
|
|
|
class StringRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen >= 12)
|
|
{
|
|
DWORD col = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
DWORD style = CBinaryBiff12StreamReader::GetDword(p + 4);
|
|
DWORD sharedstring_index = CBinaryBiff12StreamReader::GetDword(p + 8);
|
|
|
|
WCHAR s[256];
|
|
std::wstring sharedString;
|
|
}
|
|
/*if (sharedstring_index < w._vecSharedStrings.size())
|
|
{
|
|
|
|
sharedString = w._vecSharedStrings[sharedstring_index];
|
|
|
|
swprintf(s, sizeof(s), L"\t\tinfo : col=%d, style=%d, v:stringindex=%d v:string=%s\r\n",
|
|
col,
|
|
style,
|
|
sharedstring_index,
|
|
sharedString.empty() ? L"" : sharedString.c_str());
|
|
}
|
|
else {
|
|
|
|
swprintf(s, sizeof(s), L"\t\terror : col=%d, style=%d, v:stringindex=%d unknown\r\n",
|
|
col,
|
|
style,
|
|
sharedstring_index);
|
|
}
|
|
|
|
std::cout<<(s);
|
|
}
|
|
else
|
|
{
|
|
std::cout<<("\t\tinfo : invalid string record length\r\n");
|
|
}*/
|
|
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "string";
|
|
}
|
|
};
|
|
|
|
class FormulaStringRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen >= 22)
|
|
{
|
|
DWORD col = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
DWORD style = CBinaryBiff12StreamReader::GetDword(p + 4);
|
|
DWORD lenStr = CBinaryBiff12StreamReader::GetDword(p + 8);
|
|
|
|
std::wstring str = CBinaryBiff12StreamReader::GetString(p + 12, lenStr);
|
|
|
|
WORD grbits = CBinaryBiff12StreamReader::GetWord(p + 12 + 2 * lenStr);
|
|
bool bCalcOnOpen = (grbits & 0x0010) != 0;
|
|
|
|
DWORD lenFormula = CBinaryBiff12StreamReader::GetDword(p + 12 + 2 * lenStr + 2/*grbits*/);
|
|
|
|
// formula ptg tokens follow between
|
|
// p + 12 + 2 * lenStr + 2/*grbits*/ + 4
|
|
// and
|
|
// p + 12 + 2 * lenStr + 2/*grbits*/ + 4 + lenFormula
|
|
|
|
WCHAR s[256];
|
|
swprintf(s, sizeof(s), L"\t\tinfo : col=%d, style=%d, formula v:calcOnOpen=%s v:string=%s v:lenStr=%d, v:lenFormula=%d\r\n",
|
|
col,
|
|
style,
|
|
bCalcOnOpen ? L"true" : L"false",
|
|
str.c_str(),
|
|
lenStr,
|
|
lenFormula);
|
|
std::cout<<(s);
|
|
}
|
|
else
|
|
{
|
|
std::cout<<("\t\tinfo : invalid string formula record length\r\n");
|
|
}
|
|
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "formulaString";
|
|
}
|
|
};
|
|
|
|
class FormulaFloatRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen >= 24)
|
|
{
|
|
DWORD col = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
DWORD style = CBinaryBiff12StreamReader::GetDword(p + 4);
|
|
double d = CBinaryBiff12StreamReader::GetDouble(p + 8);
|
|
|
|
WORD grbits = CBinaryBiff12StreamReader::GetWord(p + 16);
|
|
bool bCalcOnOpen = (grbits & 0x0010) != 0;
|
|
|
|
DWORD lenFormula = CBinaryBiff12StreamReader::GetDword(p + 16 + 2/*grbits*/);
|
|
|
|
// formula ptg tokens follow between
|
|
// p + 16 + 2/*grbits*/ + 4
|
|
// and
|
|
// p + 16 + 2/*grbits*/ + 4 + lenFormula
|
|
|
|
CHAR s[256];
|
|
sprintf(s, "\t\tinfo : col=%d, style=%d, formula v:calcOnOpen=%s v:float=%.10g v:lenFormula=%d\r\n",
|
|
col,
|
|
style,
|
|
bCalcOnOpen ? L"true" : L"false",
|
|
d,
|
|
lenFormula);
|
|
std::cout<<(s);
|
|
}
|
|
else
|
|
{
|
|
std::cout<<("\t\tinfo : invalid float formula record length\r\n");
|
|
}
|
|
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "formulaFloat";
|
|
}
|
|
};
|
|
|
|
class FormulaBoolRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen >= 19)
|
|
{
|
|
DWORD col = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
DWORD style = CBinaryBiff12StreamReader::GetDword(p + 4);
|
|
BYTE b = CBinaryBiff12StreamReader::GetByte(p + 8);
|
|
|
|
WORD grbits = CBinaryBiff12StreamReader::GetWord(p + 9);
|
|
bool bCalcOnOpen = (grbits & 0x0010) != 0;
|
|
|
|
DWORD lenFormula = CBinaryBiff12StreamReader::GetDword(p + 9 + 2/*grbits*/);
|
|
|
|
// formula ptg tokens follow between
|
|
// p + 9 + 2/*grbits*/ + 4
|
|
// and
|
|
// p + 9 + 2/*grbits*/ + 4 + lenFormula
|
|
|
|
CHAR s[256];
|
|
sprintf(s, "\t\tinfo : col=%d, style=%d, formula v:calcOnOpen=%s v:bool=%s v:lenFormula=%d\r\n",
|
|
col,
|
|
style,
|
|
bCalcOnOpen ? "true" : "false",
|
|
b ? "true":"false",
|
|
lenFormula);
|
|
std::cout<<(s);
|
|
}
|
|
else
|
|
{
|
|
std::cout<<("\t\tinfo : invalid bool formula record length\r\n");
|
|
}
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "formulaBool";
|
|
}
|
|
};
|
|
|
|
class FormulaBoolErrRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen >= 19)
|
|
{
|
|
DWORD col = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
DWORD style = CBinaryBiff12StreamReader::GetDword(p + 4);
|
|
BYTE b = CBinaryBiff12StreamReader::GetByte(p + 8);
|
|
|
|
WORD grbits = CBinaryBiff12StreamReader::GetWord(p + 9);
|
|
bool bCalcOnOpen = (grbits & 0x0010) != 0;
|
|
|
|
DWORD lenFormula = CBinaryBiff12StreamReader::GetDword(p + 9 + 2/*grbits*/);
|
|
|
|
// formula ptg tokens follow between
|
|
// p + 9 + 2/*grbits*/ + 4
|
|
// and
|
|
// p + 9 + 2/*grbits*/ + 4 + lenFormula
|
|
|
|
CHAR s[256];
|
|
sprintf(s, "\t\tinfo : col=%d, style=%d, formula v:calcOnOpen=%s v:boolerr=%d v:lenFormula=%d\r\n",
|
|
col,
|
|
style,
|
|
bCalcOnOpen ? "true" : "false",
|
|
b,
|
|
lenFormula);
|
|
std::cout<<(s);
|
|
}
|
|
else
|
|
{
|
|
std::cout<<("\t\tinfo : invalid boolerr formula record length\r\n");
|
|
}
|
|
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "formulaBoolErr";
|
|
}
|
|
};
|
|
|
|
class ColRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen >= 18)
|
|
{
|
|
DWORD colmin = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
DWORD colmax = CBinaryBiff12StreamReader::GetDword(p + 4);
|
|
DWORD width = CBinaryBiff12StreamReader::GetDword(p + 8);
|
|
DWORD style = CBinaryBiff12StreamReader::GetDword(p + 12);
|
|
|
|
WORD grbits = CBinaryBiff12StreamReader::GetWord(p + 16);
|
|
bool outline = (grbits & 0x0700) != 0; // 8 levels of outline
|
|
bool resized = (grbits & 0x0002) != 0;
|
|
bool hidden = (grbits & 0x0001) != 0;
|
|
|
|
CHAR s[256];
|
|
sprintf(s, "\tinfo : colmin=%d, colmax=%d, width=%.2f, style=%d, outline=%s, resize=%s, hidden=%s\r\n",
|
|
colmin,
|
|
colmax,
|
|
float(width) / 256,
|
|
style,
|
|
outline ? "true":"false",
|
|
resized ? "true":"false",
|
|
hidden ? "true":"false");
|
|
std::cout<<(s);
|
|
}
|
|
else
|
|
{
|
|
std::cout<<("\tinfo : invalid col record length\r\n");
|
|
}
|
|
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "col";
|
|
}
|
|
};
|
|
|
|
class WorksheetRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "worksheet";
|
|
}
|
|
};
|
|
|
|
class WorksheetEndRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "/worksheet";
|
|
}
|
|
};
|
|
|
|
class SheetViewsRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "sheetViews";
|
|
}
|
|
};
|
|
|
|
class SheetViewsEndRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "/sheetViews";
|
|
}
|
|
};
|
|
|
|
class SheetViewRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "sheetView";
|
|
}
|
|
};
|
|
|
|
class SheetViewEndRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "/sheetView";
|
|
}
|
|
};
|
|
|
|
class SheetDataRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "sheetData";
|
|
}
|
|
};
|
|
|
|
class SheetDataEndRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "/sheetData";
|
|
}
|
|
};
|
|
|
|
class SheetPRRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
std::cout<<("\tinfo : <tabColor rgb=.../>\r\n\tinfo : <outlinePr showOutlineSymbols=.../>\r\n\tinfo : <pageSetUpPr .../>\r\n\tinfo : </sheetPr>\r\n");
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "sheetPr";
|
|
}
|
|
};
|
|
|
|
class DimensionRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen < 16)
|
|
{
|
|
std::cout<<("\tinfo : invalid dimension record length\r\n");
|
|
return;
|
|
}
|
|
|
|
DWORD r1 = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
DWORD r2 = CBinaryBiff12StreamReader::GetDword(p + 4);
|
|
DWORD c1 = CBinaryBiff12StreamReader::GetDword(p + 8);
|
|
DWORD c2 = CBinaryBiff12StreamReader::GetDword(p + 12);
|
|
|
|
CHAR s[256];
|
|
sprintf(s, "\tinfo : r1=%d, c1=%d, r2=%d, c2=%d\r\n", r1, c1, r2, c2);
|
|
std::cout<<(s);
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "dimension";
|
|
}
|
|
};
|
|
|
|
class SelectionRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "selection";
|
|
}
|
|
};
|
|
|
|
class ColsRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "cols";
|
|
}
|
|
};
|
|
|
|
class ColsEndRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "/cols";
|
|
}
|
|
};
|
|
|
|
class PageMarginsRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "pageMargins";
|
|
}
|
|
};
|
|
|
|
class PrintOptionsRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "printOptions";
|
|
}
|
|
};
|
|
|
|
class PageSetupRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "pageSetup";
|
|
}
|
|
};
|
|
|
|
class HeaderFooterRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "headerFooter";
|
|
}
|
|
};
|
|
|
|
class SheetFormatPRRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "sheetFormatPr";
|
|
}
|
|
};
|
|
|
|
class DrawingRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen < 4)
|
|
{
|
|
std::cout<<("\tinfo : invalid drawing record length\r\n");
|
|
return;
|
|
}
|
|
|
|
DWORD lenStr = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
std::wstring sRId = CBinaryBiff12StreamReader::GetString(p + 4, lenStr);
|
|
|
|
WCHAR s[256];
|
|
swprintf(s, sizeof(s), L"\tinfo : r:id=%s r:id:lenStr=%d\r\n",
|
|
sRId.c_str(),
|
|
lenStr);
|
|
std::cout<<(s);
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "drawing";
|
|
}
|
|
};
|
|
|
|
class LegacyDrawingRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen < 4)
|
|
{
|
|
std::cout<<("\tinfo : invalid legacy drawing record length\r\n");
|
|
return;
|
|
}
|
|
|
|
DWORD lenStr = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
std::wstring sRId = CBinaryBiff12StreamReader::GetString(p + 4, lenStr);
|
|
|
|
WCHAR s[256];
|
|
swprintf(s, sizeof(s), L"\tinfo : r:id=%s r:id:lenStr=%d\r\n",
|
|
sRId.c_str(),
|
|
lenStr);
|
|
std::cout<<(s);
|
|
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "legacyDrawing";
|
|
}
|
|
};
|
|
|
|
class OLEObjectsRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "oleObjects";
|
|
}
|
|
};
|
|
|
|
class OLEObjectRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen < 18)
|
|
{
|
|
std::cout<<("\tinfo : invalid oleobject record length\r\n");
|
|
return;
|
|
}
|
|
|
|
DWORD shapeid = CBinaryBiff12StreamReader::GetDword(p + 8);
|
|
DWORD lenProgId = CBinaryBiff12StreamReader::GetDword(p + 14);
|
|
std::wstring sProgId = CBinaryBiff12StreamReader::GetString(p + 14 + 4, lenProgId);
|
|
DWORD lenRId = CBinaryBiff12StreamReader::GetDword(p + 14 + 4 + 2 * lenProgId);
|
|
std::wstring sRId = CBinaryBiff12StreamReader::GetString(p + 14 + 4 + 2 * lenProgId + 4, lenRId);
|
|
|
|
WCHAR s[386];
|
|
swprintf(s, sizeof(s), L"\tinfo : shapeId=%d progId=%s progId:lenStr=%d r:id=%s r:id:lenStr=%d\r\n",
|
|
shapeid,
|
|
sProgId.c_str(),
|
|
lenProgId,
|
|
sRId.c_str(),
|
|
lenRId);
|
|
std::cout<<(s);
|
|
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "oleObject";
|
|
}
|
|
};
|
|
|
|
class OLEObjectsEndRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "/oleObjects";
|
|
}
|
|
};
|
|
|
|
|
|
class TablePartsRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "tableParts";
|
|
}
|
|
};
|
|
|
|
class TablePartRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen < 4)
|
|
{
|
|
std::cout<<("\tinfo : invalid tablePart record length\r\n");
|
|
return;
|
|
}
|
|
|
|
DWORD lenStr = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
std::wstring sRId = CBinaryBiff12StreamReader::GetString(p + 4, lenStr);
|
|
|
|
WCHAR s[256];
|
|
swprintf(s, sizeof(s), L"\tinfo : r:id=%s r:id:lenStr=%d\r\n",
|
|
sRId.c_str(),
|
|
lenStr);
|
|
std::cout<<(s);
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "tablePart";
|
|
}
|
|
};
|
|
|
|
class TablePartsEndRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "/tableParts";
|
|
}
|
|
};
|
|
|
|
class ConditionalFormattingRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "conditionalFormatting";
|
|
}
|
|
};
|
|
|
|
class ConditionalFormattingEndRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "/conditionalFormatting";
|
|
}
|
|
};
|
|
|
|
class CFRuleRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "cfRule";
|
|
}
|
|
};
|
|
|
|
class CFRuleEndRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "/cfRule";
|
|
}
|
|
};
|
|
|
|
class IconSetRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "iconSet";
|
|
}
|
|
};
|
|
|
|
class IconSetEndRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "/iconSet";
|
|
}
|
|
};
|
|
|
|
class DataBarRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "dataBar";
|
|
}
|
|
};
|
|
|
|
class DataBarEndRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "/dataBar";
|
|
}
|
|
};
|
|
|
|
class ColorScaleRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "colorScale";
|
|
}
|
|
};
|
|
|
|
class ColorScaleEndRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "/colorScale";
|
|
}
|
|
};
|
|
|
|
class CFVORecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "cfvo";
|
|
}
|
|
};
|
|
|
|
class HyperlinkRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
if (reclen < 20)
|
|
{
|
|
std::cout<<("\tinfo : invalid hyperlink record length\r\n");
|
|
return;
|
|
}
|
|
|
|
DWORD r1 = CBinaryBiff12StreamReader::GetDword(p + 0);
|
|
DWORD r2 = CBinaryBiff12StreamReader::GetDword(p + 4);
|
|
DWORD c1 = CBinaryBiff12StreamReader::GetDword(p + 8);
|
|
DWORD c2 = CBinaryBiff12StreamReader::GetDword(p + 12);
|
|
|
|
DWORD lenRId = CBinaryBiff12StreamReader::GetDword(p + 16);
|
|
std::wstring sRId = CBinaryBiff12StreamReader::GetString(p + 20, lenRId);
|
|
|
|
WCHAR s[256];
|
|
swprintf(s, sizeof(s), L"\tinfo : r1=%d, c1=%d, r2=%d, c2=%d, rId=%s lenRId=%d\r\n",
|
|
r1,
|
|
c1,
|
|
r2,
|
|
c2,
|
|
sRId.c_str(),
|
|
lenRId);
|
|
std::cout<<(s);
|
|
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "hyperlink";
|
|
}
|
|
};
|
|
|
|
class ColorRecord : public CBiff12RecordBase
|
|
{
|
|
void Read(LPBYTE p, DWORD recid, DWORD reclen)
|
|
{
|
|
}
|
|
|
|
std::string GetTag()
|
|
{
|
|
return "color";
|
|
}
|
|
};
|
|
}
|
|
#endif
|