/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
*
|
* This file is part of xlslib -- A multiplatform, C/C++ library
|
* for dynamic generation of Excel(TM) files.
|
*
|
* Copyright 2004 Yeico S. A. de C. V. All Rights Reserved.
|
* Copyright 2008-2014 David Hoerl All Rights Reserved.
|
*
|
* Redistribution and use in source and binary forms, with or without modification, are
|
* permitted provided that the following conditions are met:
|
*
|
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
* conditions and the following disclaimer.
|
*
|
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
* of conditions and the following disclaimer in the documentation and/or other materials
|
* provided with the distribution.
|
*
|
* THIS SOFTWARE IS PROVIDED BY David Hoerl ''AS IS'' AND ANY EXPRESS OR IMPLIED
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL David Hoerl OR
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
*
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
#include "../xlslib/record.h"
|
#include "../xlslib/note.h"
|
#include "../xlslib/globalrec.h"
|
#include "../xlslib/datast.h"
|
#include "../xlslib/rectypes.h"
|
|
using namespace xlslib_core;
|
using namespace xlslib_strings;
|
|
static unsigned char draw001[18] = { 0xbf, 0x00, 0x08, 0x00, 0x08, 0x00, 0x81,
|
0x01, 0x09, 0x00, 0x00, 0x08, 0xc0, 0x01, 0x40, 0x00, 0x00, 0x08,
|
};
|
static unsigned char draw002[16] = { 0x0d, 0x00, 0x00, 0x08, 0x0c, 0x00, 0x00,
|
0x08, 0x17, 0x00, 0x00, 0x08, 0xf7, 0x00, 0x00, 0x10,
|
};
|
|
static unsigned char draw101[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
};
|
static unsigned char draw102[6] = { 0xBF, 0x00, 0x20, 0x00, 0x20, 0x00,
|
};
|
|
/*
|
*********************************
|
* note_t class implementation
|
*********************************
|
*/
|
note_t::note_t(CGlobalRecords& gRecords, unsigned32_t rowval, unsigned32_t colval, const std::string& auth, const std::string& msg, xf_t* pxfval) :
|
cell_t(gRecords, rowval, colval, pxfval),
|
author(),
|
text(),
|
noteRec(),
|
fillColor(0x08000050),
|
idx(0)
|
{
|
gRecords.char2str16(auth, this->author);
|
gRecords.char2str16(msg, this->text);
|
Finalize((unsigned16_t)rowval, (unsigned16_t)colval);
|
}
|
|
note_t::note_t(CGlobalRecords& gRecords, unsigned32_t rowval, unsigned32_t colval, const ustring& auth, const ustring& msg, xf_t* pxfval) :
|
cell_t(gRecords, rowval, colval, pxfval),
|
author(),
|
text(),
|
noteRec(),
|
fillColor(0x08000050),
|
idx(0)
|
{
|
gRecords.wide2str16(auth, this->author);
|
gRecords.wide2str16(msg, this->text);
|
Finalize((unsigned16_t)rowval, (unsigned16_t)colval);
|
}
|
|
#ifndef __FRAMEWORK__
|
note_t::note_t(CGlobalRecords& gRecords, unsigned32_t rowval, unsigned32_t colval, const u16string& auth, const u16string& msg, xf_t* pxfval) :
|
cell_t(gRecords, rowval, colval, pxfval),
|
author(auth),
|
text(msg),
|
noteRec(),
|
fillColor(0x08000050),
|
idx(0)
|
{
|
Finalize((unsigned16_t)rowval, (unsigned16_t)colval);
|
}
|
#endif
|
|
void note_t::Finalize(unsigned16_t rowval, unsigned16_t colval)
|
{
|
size_t alen = author.length();
|
if(alen == 0 || alen > 54) {
|
xchar16_t warning[] = { 'A', 'u', 't', 'h', 'o', 'r', ' ', 'M', 'u', 's', 't', ' ', 'B', 'e', ' ', '1', ' ', 't', 'o', ' ', '5', '4', 'c', 'h', 'a', 'r', 's', ' ', 'l', 'o', 'n', 'g', 0};
|
author.assign(warning);
|
alen = author.length();
|
}
|
size_t tlen = text.length();
|
if(tlen == 0 || tlen > 2048) {
|
xchar16_t warning[] = { 'T', 'e', 'x', 't', ' ', 'M', 'u', 's', 't', ' ', 'B', 'e', ' ', '1', ' ', 't', 'o', ' ', '2', '0', '4', '8', 'c', 'h', 'a', 'r', 's', ' ', 'l', 'o', 'n', 'g', 0};
|
text.assign(warning);
|
tlen = text.length();
|
}
|
|
size_t totalLen = alen + tlen + 2;
|
size_t count = totalLen/11;
|
bool lastIsNL = false;
|
for(size_t i=0; i<tlen; ++i) {
|
if(text[i] == '\n') {
|
count += lastIsNL ? 2 : 1;
|
lastIsNL = true;
|
} else {
|
lastIsNL = false;
|
}
|
}
|
unsigned16_t lines = (unsigned16_t)(1 /* for author */ + (count+1)/2 /* measured average chars/column width */ + 1 /* final partial line */);
|
|
unsigned16_t cols = 2;
|
while(lines > 20) {
|
cols *= 2;
|
lines /= 2;
|
}
|
|
noteRec.Flag = (unsigned16_t)0x3;
|
noteRec.Col1 = colval+(unsigned16_t)1;
|
noteRec.DX1 = (unsigned16_t)0xCD;
|
noteRec.Row1 = rowval;
|
noteRec.DY1 = (unsigned16_t)0x27;
|
noteRec.Col2 = colval+(unsigned16_t)1 + cols;
|
noteRec.DX2 = (unsigned16_t)0x7B;
|
noteRec.Row2 = rowval+lines;
|
noteRec.DY2 = (unsigned16_t)0x3B;
|
}
|
|
static size_t dumpDrawData(CRecord *data, unsigned16_t rec, unsigned16_t instance, unsigned16_t type, unsigned32_t len, size_t arr_len, const unsigned8_t *arr)
|
{
|
unsigned16_t val = rec & 0x000F;
|
val |= instance << 4;
|
data->AddValue16(val);
|
data->AddValue16(type);
|
|
size_t len_position = data->GetDataSize();
|
data->AddValue32(len);
|
|
if(arr_len) {
|
data->AddDataArray(arr, arr_len);
|
}
|
|
return len_position;
|
}
|
static void drawDataOPID(CRecord *data, unsigned16_t opid, unsigned32_t val)
|
{
|
data->AddValue16(opid);
|
data->AddValue32(val);
|
}
|
|
|
static const uint32_t drawingSize = 8 + 128; // header, 120 is the main blob, 8 is the trailing blob
|
|
void note_t::dumpDrawingContainer(CRecord *data, unsigned16_t sheetIndex, unsigned32_t& currentSPIDidx, uint32_t noteCount) const
|
{
|
uint32_t thisDrawingExtra = 40 + 8; //
|
uint32_t completeDrawingSize = 8/*f002*/ + 16/*f008*/ + thisDrawingExtra/*first one*/ + drawingSize*noteCount/*every note*/;
|
dumpDrawData(data, 0xf, 0x0, 0xf002, completeDrawingSize, 0, NULL /* len=0 */ ) ; // OfficeArtDgContainer
|
dumpDrawData(data, 0x0, 0x1, 0xf008, 8, 0, NULL /* len=0 */ ) ; // OfficeArtFDG - spidCur needs to be set
|
data->AddValue32(noteCount+1); // csp (4 bytes): An unsigned integer that specifies the number of shapes in this drawing
|
data->AddValue32(CGlobalRecords::MakeSPID(sheetIndex, currentSPIDidx)+noteCount); // spidCur (4 bytes): An MSOSPID structure, as defined in section 2.1.2, that specifies the shape identifier of the last shape in this drawing
|
dumpDrawData(data, 0xF, 0x0, 0xF003, thisDrawingExtra+drawingSize*noteCount, 0, NULL /* len=0 */ ) ; // OfficeArtSpgrContainer
|
dumpDrawData(data, 0xF, 0x0, 0xF004, 40, 0, NULL /* len=0 */ ) ; // OfficeArtSpContainer
|
dumpDrawData(data, 0x1, 0x0, 0xF009, 16, 16, draw101 /* len=16 */ ) ; // OfficeArtFSPGR
|
dumpDrawData(data, 0x2, 0x0, 0xF00A, 8, 0, NULL /* len=0 */ ) ; // OfficeArtFSP
|
data->AddValue32(CGlobalRecords::MakeSPID(sheetIndex, currentSPIDidx++));
|
data->AddValue32(0x05);
|
}
|
|
void note_t::dumpDrawingText(CRecord *data, unsigned16_t sheetIndex, unsigned32_t& currentSPIDidx) const
|
{
|
dumpDrawData(data, 0xF, 0x0, 0xF004, drawingSize-8, 0, NULL /* len=0 */ ) ; // OfficeArtSpContainer
|
dumpDrawData(data, 0x2, 0xCA, 0xF00A, 8, 0, NULL /* len=0 */ ) ; // OfficeArtFSP
|
data->AddValue32(CGlobalRecords::MakeSPID(sheetIndex, currentSPIDidx++));
|
data->AddValue32(0x0A00);
|
dumpDrawData(data, 0x3, 0x8, 0xF00B, 48, 0, NULL /* len=48 */ ) ; // OfficeArtFOPT
|
drawDataOPID(data, 0x0085, 0x00000001);
|
drawDataOPID(data, 0x00BF, 0x000A0008);
|
drawDataOPID(data, 0x0158, 0x00000000);
|
drawDataOPID(data, 0x0181, fillColor);
|
drawDataOPID(data, 0x0183, 0x08000050);
|
drawDataOPID(data, 0x01BF, 0x00100010);
|
drawDataOPID(data, 0x023F, 0x00030003);
|
drawDataOPID(data, 0x03BF, 0x00020002);
|
dumpDrawData(data, 0x3, 0x1, 0xF122, 6, 6, draw102 /* len=6 */ ) ; // OfficeArtTertiaryFOPT
|
dumpDrawData(data, 0x0, 0x0, 0xF010, 18, 0, NULL /* len=18 */ ) ; // msofbtClientAnchor (was draw104)
|
data->AddValue16(noteRec.Flag);
|
data->AddValue16(noteRec.Col1);
|
data->AddValue16(noteRec.DX1);
|
data->AddValue16(noteRec.Row1);
|
data->AddValue16(noteRec.DY1);
|
data->AddValue16(noteRec.Col2);
|
data->AddValue16(noteRec.DX2);
|
data->AddValue16(noteRec.Row2);
|
data->AddValue16(noteRec.DY2);
|
dumpDrawData(data, 0x0, 0x0, 0xF011, 0, 0, NULL /* len=0 */ ) ; // msofbtClientData
|
}
|
|
void note_t::MakeDrawing(CRecord *data, unsigned32_t& currentSPID, unsigned16_t sheetIndex, unsigned16_t notesInThisSheet) const
|
{
|
xlslib_strings::u16string fullStr = author;
|
fullStr.append(1, (unsigned16_t)':');
|
fullStr.append(1, (unsigned16_t)'\n');
|
unsigned16_t authorLen = (unsigned16_t)fullStr.length();
|
fullStr.append(text);
|
unsigned16_t totalLen = (unsigned16_t)fullStr.length();
|
|
// All the records below
|
data->Inflate(4 + (idx == 0 ? 90 : 0) + drawingSize + 30 + 16 + 22 + 4+2+totalLen*(CGlobalRecords::IsASCII(fullStr)?1:2) + 28);
|
|
data->SetRecordType(RECTYPE_MSODRAWING);
|
|
if(idx == 0) {
|
dumpDrawingContainer(data, sheetIndex, currentSPID, notesInThisSheet);
|
}
|
dumpDrawingText(data, sheetIndex, currentSPID);
|
|
size_t offset = data->GetDataSize();
|
data->SetRecordLength(offset - RECORD_HEADER_SIZE);
|
|
#if 0
|
OBJ from Apple 'Numbers', so we dont need to create a GUID for the item
|
ID: 005Dh OBJ (Describes a Graphic Object)
|
Size: 26
|
OBJ ft=0x15 cb=0x12 ot=0x19 idx=0x3 flags= len=4 0x00 0x00
|
#endif
|
|
data->AddValue16(RECTYPE_OBJ);
|
data->AddValue16(26);
|
|
data->AddValue16(0x15); // ft
|
data->AddValue16(0x12); // cb
|
data->AddValue16(0x19); // ot
|
data->AddValue16(idx+1); // id
|
data->AddValue16(0x6011); // flag bitfield
|
|
data->AddValue32(0); // must be 0
|
data->AddValue32(0); // must be 0
|
data->AddValue32(0); // must be 0
|
|
data->AddValue32(0); // must be 0
|
|
|
data->AddValue16(RECTYPE_MSODRAWING);
|
data->AddValue16(8);
|
dumpDrawData(data, 0x0, 0x0, 0xF00D, 0, 0, NULL /* len=0 */ ) ; // msofbtClientTextbox
|
|
#if 0
|
ID: 01B6h TXO (Text Object)
|
Size: 18
|
TXO: grbit=0x0212 rot=0x0000 chText=0x0013 cbRuns=0x0018
|
#endif
|
|
data->AddValue16(RECTYPE_TXO);
|
data->AddValue16(18);
|
|
data->AddValue16(0x0212); // grbit
|
data->AddValue16(0); // rot
|
data->AddFixedDataArray(0, 6); // reserved
|
data->AddValue16(totalLen); // chText - len of text, first CONTINUE
|
data->AddValue16(8*3); // cbRuns - len or runs, second CONTINUE. Always 3
|
data->AddFixedDataArray(0, 4); // reserved
|
|
data->AddValue16(RECTYPE_CONTINUE);
|
offset = data->GetDataSize();
|
data->AddValue16(0);
|
|
size_t stringStart = data->GetDataSize();
|
data->AddUnicodeString(fullStr, CRecord::NOLEN_FLAGS_UNICODE);
|
data->SetValueAt16((unsigned16_t)(data->GetDataSize() - stringStart), (unsigned)offset);
|
|
data->AddValue16(RECTYPE_CONTINUE);
|
data->AddValue16(3*8);
|
|
data->AddValue16(0); // text index
|
data->AddValue16(0x1); // text font
|
data->AddValue32(0); // unknown
|
|
data->AddValue16(authorLen); // text index
|
data->AddValue16(0x0); // text font
|
data->AddValue32(0); // unknown
|
|
data->AddValue16(totalLen); // text index
|
data->AddValue16(0); // text font
|
data->AddValue32(0); // unknown
|
}
|
|
note_t::~note_t()
|
{
|
}
|
|
size_t note_t::GetSize(void) const
|
{
|
return 12;
|
}
|
|
CUnit* note_t::GetData(CDataStorage &datastore) const
|
{
|
return datastore.MakeCNote(*this); // NOTE: this pointer HAS to be deleted elsewhere.
|
}
|
|
/*
|
*********************************
|
* CNote class implementation
|
*********************************
|
*
|
*/
|
void CNote::MakeDrawingGroup(CRecord *data, unsigned32_t count, const sheet_notes *notes)
|
{
|
size_t curr_offset;
|
|
data->Inflate(82 + count*8);
|
data->SetRecordType(RECTYPE_MSODRAWINGGROUP);
|
|
size_t f000_len = dumpDrawData(data, 0xf, 0x0, 0xf000, 0, 0, NULL /* len=0 */ ); // OfficeArtDggContainer
|
|
// Need to get he max spid, which is the last sheet combined with the number of notes
|
#if 0
|
spidMax (4 bytes): An MSOSPID structure, as defined in section 2.1.2, specifying the current maximum shape identifier that is used in any drawing. This value MUST be less than 0x03FFD7FF.
|
cidcl (4 bytes): An unsigned integer that specifies the number of OfficeArtIDCL records, as defined in section 2.2.46, + 1. This value MUST be less than 0x0FFFFFFF.
|
cspSaved (4 bytes): An unsigned integer specifying the total number of shapes that have been saved in all of the drawings.
|
cdgSaved (4 bytes): An unsigned integer specifying the total number of drawings that have been saved in the file.
|
#endif
|
|
size_t f006_offset = data->GetDataSize();
|
size_t f006_len = dumpDrawData(data, 0x0, 0x0, 0xf006, 0, 0, NULL /* len=0 */ );
|
|
struct sheet_notes last_sheet = notes[count-1]; // last one
|
unsigned32_t spid = CGlobalRecords::MakeSPID(last_sheet.sheet_idx, last_sheet.sheet_notes);
|
data->AddValue32(spid); // spidMax
|
data->AddValue32(count+1); // cidcl
|
|
size_t cspSaved_offset = data->GetDataSize();
|
data->AddValue32(0); // cspSaved
|
|
data->AddValue32(count); // cdgSaved
|
|
unsigned32_t total = 0;
|
for(unsigned32_t i=0; i<count; ++i) {
|
struct sheet_notes sn = notes[i];
|
|
total += sn.sheet_notes;
|
|
data->AddValue32(i+1); // dgid
|
data->AddValue32(1 + sn.sheet_notes); // cspidCur
|
}
|
data->SetValueAt32(count + total, (unsigned)cspSaved_offset);
|
|
curr_offset = data->GetDataSize();
|
data->SetValueAt32((unsigned)(curr_offset - f006_offset - 8), (unsigned)f006_len);
|
|
dumpDrawData(data, 0x3, 0x3, 0xf00b, 18, 18, draw001 /* len=18 */ ) ; // OfficeArtFOPT
|
dumpDrawData(data, 0x0, 0x4, 0xf11e, 16, 16, draw002 /* len=16 */ ) ; // OfficeArtSplitMenuColorContainer
|
|
curr_offset = data->GetDataSize();
|
data->SetValueAt32((unsigned)(curr_offset - 8 - RECORD_HEADER_SIZE), (unsigned)f000_len);
|
data->SetRecordLength(curr_offset-RECORD_HEADER_SIZE);
|
}
|
|
CNote::CNote(CDataStorage &datastore, const note_t& notedef) :
|
CRecord(datastore)
|
{
|
bool isAscii = CGlobalRecords::IsASCII(notedef.GetAuthor());
|
Inflate(4 + 2 + 2 + 2 + 2 + 2 + 1 + notedef.GetAuthor().size() * (isAscii ? 1 : 2) );
|
|
SetRecordType(RECTYPE_NOTE);
|
AddValue16((unsigned16_t)notedef.GetRow());
|
AddValue16((unsigned16_t)notedef.GetCol());
|
AddValue16(0); // grBit
|
AddValue16(notedef.GetIndex()+1);
|
AddUnicodeString(notedef.GetAuthor(), LEN2_FLAGS_UNICODE);
|
AddValue8(0);
|
|
SetRecordLength(GetDataSize()-RECORD_HEADER_SIZE);
|
}
|
CNote::~CNote()
|
{
|
}
|
