Parent Elements

workbook (§3.2.27)

Attributes

Description

lockRevision (Lock Revisions)

Specifies a boolean value that indicates whether the workbook is locked for revisions.

The possible values for this attribute are defined by the XML Schema boolean datatype.

lockStructure (Lock Structure)

Specifies a boolean value that indicates whether structure of workbook is locked.

A value of on, 1, or true indicates the structure of the workbook is locked. Worksheets in the workbook can't be moved, deleted, hidden, unhidden, or renamed, and new worksheets can't be inserted.

A value of off, 0, or false indicates the structure of the workbook is not locked.

The default value for this attribute is false.

The possible values for this attribute are defined by the XML Schema boolean datatype.

lockWindows (Lock Windows)

Specifies a boolean value that indicates whether the windows that comprise the workbook are locked.

A value of on, 1, or true indicates the workbook windows are locked. Windows are the same size and position each time the workbook is opened.

A value of off, 0, or false indicates the workbook windows are not locked.

The default value for this attribute is false.

The possible values for this attribute are defined by the XML Schema boolean datatype.

revisionsPassword (Revisions Password)

Specifies the hash of the password required for unlocking revisions in this workbook. The hash is generated from an 8-bit wide character. 16-bit Unicode characters must be converted down to 8 bits before the hash is computed, using the following logic:

For SpreadsheetML password hash purposes, Unicode UTF-16 input code points are converted to an “ansi” single or double byte code page from the following list:

Code points with no representation in the target code page are replaced with Unicode character 0x3f (?).

The necessary mapping tables can be found at the following location: http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WindowsBestFit/ .

Code pages 932, 936, 949, and 950 are “Double Byte” code pages. The remainder of the “ANSI” code pages supported by windows are “Single Byte” code pages.

For single byte code pages each Unicode code point is replaced by a single byte or 0x3f if an appropriate character doesn’t exist in the code page.

For double byte code pages, each Unicode code point is replaced by either a single byte, or a two byte sequence, depending on the input character, or 0x3f if an appropriate character doesn’t exist in the code page. In our tables the target is a single byte sequence if the most significant byte is 0x00, otherwise it is a double byte sequence, with the lead byte being the most significant byte.

To convert, first check if conversion is being done to a single or double byte code page and load the appropriate WCTABLE code page table.

For each input WCHAR, look up the code point in the WCTABLE. There are 3 possibilities: Not found, single byte, or double byte.

If the input WCHAR is not found, append 0x3f and continue to the next WCHAR.

If the result is a single byte, check to make sure the entry in the MBTABLE matches the input. If it matches, append the single byte to the output. If it does not match, append 0x3f to the output.

If the result is a double byte,check to make sure the entry in the DBCSENTRY table for the appropriate lead byte matches the input WCHAR. If it matches, append the lead byte and trail byte to the output. If it does not match, append 0x3f to the output.

The following pueudocode describes how this conversion should be done:

int WideCharToMultiByte(WCHAR* wszInput, byte* szOutput)
{
// Remember output start so we can return length
byte* szOutputStart = szOutput;

// Ask the system for the current ANSI code page, which
// on windows is a system setting.
int iCodePage = GetCurrentAnsiCodePage();

// Load Code Page Tables
// This will depend on how the code pages are represented on
// the target machine. TABLECLASS represents some abstract
// representation of this structure here.
TABLECLASS pTables = LoadCodePageTables(iCodePage);

bool bDoubleByte = false;
if (iCodePage == 932 ||
iCodePage == 936 ||
iCodePage == 949 ||
iCodePage == 950)
bDoubleByte = true;

while (*wszInput != 0)
{
if (bDoubleByte)
szOutput = AppendDoubleByte(pTables, *wszInput, szOutput);
else
szOutput = AppendSingleByte(pTables, *wszInput, szOutput);

// Read next input WCHAR
wszInput++;
}

// Null terminate the output
*szOutput = 0;

// Return output length
return szOutput – szOutputStart;
}

byte* AppendSingleByte(TABLECLASS pTables, WCHAR wcIn, byte* szOutput)
{
// Look up byte that we want to append.
byte bOut = pTables->LookUpSingleByte(wcIn);

// Make sure that bOut matches the input, otherwise use ?
// (ie: no best fit behavior allowed)
if (wcIn != pTables->LookUpWideChar(bOut))
bOut = 0x3f;

*szOutput = bOut;
szOutput++;
return szOutput;
}

byte* AppendDoubleByte(TABLECLASS pTables, WCHAR wcIn, byte* szOutput)
{
// Look up bytes that we want to append.
UINT16 bytesOut = pTables->LookUpDoubleByte(wcIn);

// See if it is a single or double byte sequence
if (bytesOut & 0xFF00)
{
// It is a double byte sequence
// Make sure that bytesOut matches the input, otherwise use ?
// (ie: no best fit behavior allowed)
if (wcIn != pTables->LookUpWideChar(bytesOut))
{
// Use ?, it will be added below
bytesOut = 0x003f;
}
else
{
// It matched, use the lead byte we found
// trail byte will be added below
*szOutput = bytesOut >> 8;
szOutput++;
}
else
{
// It is a single byte sequence
// Make sure that bytesOut matches the input, otherwise use ?
// (ie: no best fit behavior allowed)
if (wcIn != pTables->LookUpWideChar(bytesOut & 0xFF))
bytesOut = 0x003f;
}

// Add the single or trail byte
*szOutput = bytesOut & 0xFF;
szOutput++;

return szOutput;
}

class pTables
{
// Construction depends on how you choose to store & load the
// table files

byte LookUpSingleByte(WCHAR wcIn)
{
// How you access the table depends on your storage mechanism.
// Look up the line in WCTABLE where the first column matches wcIn,
// and then return the byte value from the second column.
if (exists WCTABLE{wcIn})
return WCTABLE{wcIn}.SecondColumn;

// If it doesn’t exist, return ?
return 0x3f;
}

UINT16 LookUpDoubleByte(WCHAR wcIn)
{
// How you access the table depends on your storage mechanism.
// Look up the line in WCTABLE where the first column matches wcIn,
// and then return the double byte value from the second column.
if (exists WCTABLE{wcIn})
return WCTABLE{wcIn}.SecondColumn;

// If it doesn’t exist, return ?
return 0x003f;
}

// Overload that looks up wide chars from single byte code points.
WCHAR LookUpWideChar(byte bIn)
{
// How you access the table depends on your storage mechanism.
// Look up the line in MBTABLE where the first column matches bIn,
// and then return the WCHAR value from the second column.
if (exists MBTABLE{bIn})
return MBTABLE{bIn}.SecondColumn;

// If it doesn’t exist, return ?
return 0x003f;
}

// Overload that looks up wide chars from double byte code points
WCHAR LookUpWideChar(UINT16 bytesIn)
{
// How you access the table depends on your storage mechanism.
// First find the DBCSTABLE where the LeadByte matches
// the lead (most significant) input byte.
if (exists DBCSTABLE{bytesIn >> 8))
{
DbcsTable = DBCSTABLE{bytesIn >> 8);

// Look up the line in DbcsTable where the first column
// matches the input trail (least significant) byte,
// and then return the WCHAR value from the second column.
if (exists DbcsTable{bytesIn & 0xFF})
return DbcsTable{bytesIn & 0xFF}.SecondColumn;
}

// Either the lead byte table or specific trail byte
// doesn’t exist in the table, return ?
return 0x003f;
}
}

The resulting value is hashed using the algorithm defined below.

[Note: An example algorithm to hash the resulting single-byte user input into the value stored is as follows:

// Function Input:

// szPassword: NULL terminated C-Style string

// cchPassword: The number of characters in szPassword (not including the NULL terminator)

WORD GetPasswordHash(const CHAR *szPassword, int cchPassword) {

WORD wPasswordHash;

const CHAR *pch;

wPasswordHash = 0;

if (cchPassword > 0)

{

pch = &szPassword[cchPassword];

while (pch-- != szPassword)

{

wPasswordHash = ((wPasswordHash >> 14) & 0x01) | ((wPasswordHash << 1) & 0x7fff);

wPasswordHash ^= *pch;

}

wPasswordHash ^= (0x8000 | ('N' << 8) | 'K');

}

return(wPasswordHash);

}

end note]

The possible values for this attribute are defined by the ST_UnsignedShortHex simple type (§3.18.87).

workbookPassword (Workbook Password)

Specifies the hash of the password required for unlocking revisions in this workbook. The hash is generated from an 8-bit wide character. 16-bit Unicode characters must be converted down to 8 bits before the hash is computed, using the following logic:

For SpreadsheetML password hash purposes, Unicode UTF-16 input code points are converted to an “ansi” single or double byte code page using the logic defined in the preceding revisionsPassword attribute.

The resulting value is hashed using the algorithm defined below.

[Note: An example algorithm to hash the user input into the value stored is as follows:

// Function Input:

// szPassword: NULL terminated C-Style string

// cchPassword: The number of characters in szPassword (not including the NULL terminator)

WORD GetPasswordHash(const CHAR *szPassword, int cchPassword) {

WORD wPasswordHash;

const CHAR *pch;

wPasswordHash = 0;

if (cchPassword > 0)

{

pch = &szPassword[cchPassword];

while (pch-- != szPassword)

{

wPasswordHash = ((wPasswordHash >> 14) & 0x01) | ((wPasswordHash << 1) & 0x7fff);

wPasswordHash ^= *pch;

}

wPasswordHash ^= (0x8000 | ('N' << 8) | 'K');

}

return(wPasswordHash);

}

end note]

The possible values for this attribute are defined by the ST_UnsignedShortHex simple type (§3.18.87).