mirror of
https://github.com/fadden/ciderpress.git
synced 2024-11-23 11:33:58 +00:00
bb24f51ccb
We weren't doing a MOR-to-UNI conversion on the sub-volume name, so HFS volumes with non-ASCII characters didn't look right. This also relocates the character-conversion code to a new source file. It's currently part of the reformat lib, though it arguably belongs in util (but that would introduce a new dependency between reformat and util).
959 lines
25 KiB
C++
959 lines
25 KiB
C++
/*
|
|
* CiderPress
|
|
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
|
|
* See the file LICENSE for distribution terms.
|
|
*/
|
|
/*
|
|
* Reformatter base class implementation.
|
|
*/
|
|
#include "StdAfx.h"
|
|
#include "ReformatBase.h"
|
|
#include <math.h>
|
|
|
|
|
|
/*
|
|
* ==========================================================================
|
|
* ReformatText
|
|
* ==========================================================================
|
|
*/
|
|
|
|
/*
|
|
* Set the output format and buffer.
|
|
*
|
|
* Clears our work buffer pointer so we don't free it.
|
|
*/
|
|
void ReformatText::SetResultBuffer(ReformatOutput* pOutput, bool multiFont)
|
|
{
|
|
char* buf;
|
|
long len;
|
|
fExpBuf.SeizeBuffer(&buf, &len);
|
|
pOutput->SetTextBuf(buf, len, true);
|
|
|
|
if (pOutput->GetTextBuf() == NULL) {
|
|
/*
|
|
* Force "raw" mode if there's no output. This can happen if we,
|
|
* say, try to format an empty file as a hex dump. We never
|
|
* produce any output, so no buffer gets allocated.
|
|
*
|
|
* We set the mode to "raw" so that applications can assume that
|
|
* results of type "text" actually have text to look at -- though
|
|
* it's possible the length will be zero, we promise that there'll
|
|
* be a buffer there. I'm not sure it's important to do this,
|
|
* but it does reduce the #of situations in which we have to
|
|
* worry about NULL pointers.
|
|
*/
|
|
pOutput->SetOutputKind(ReformatOutput::kOutputRaw);
|
|
LOGI("ReformatText returning a null pointer");
|
|
} else {
|
|
if (fUseRTF)
|
|
pOutput->SetOutputKind(ReformatOutput::kOutputRTF);
|
|
else
|
|
pOutput->SetOutputKind(ReformatOutput::kOutputText);
|
|
}
|
|
|
|
if (fUseRTF && multiFont)
|
|
pOutput->SetMultipleFontsFlag(true);
|
|
}
|
|
|
|
/*
|
|
* Output the RTF header.
|
|
*
|
|
* The color table is the standard MS Word color table, except that entry
|
|
* #17 (dark grey) has been lightened from (51,51,51) because it's nearly
|
|
* indistinguishable from black on the screen.
|
|
*
|
|
* The default font is Courier New (\f0) at 10 points (\fs20).
|
|
*/
|
|
void ReformatText::RTFBegin(int flags)
|
|
{
|
|
// static const char* rtfHdr =
|
|
//"{\\rtf1\\ansi\\ansicpg1252\\deff0\\deflang1033{\\fonttbl{\\f0\\fmodern\\fprq1\\fcharset0 Courier New;}}\r\n"
|
|
//"\\viewkind4\\uc1\\pard\\f0\\fs20 ";
|
|
|
|
static const char* rtfHdrStart =
|
|
"{\\rtf1\\ansi\\ansicpg1252\\deff0\\deflang1033\\deflangfe1033{\\fonttbl"
|
|
"{\\f0\\fmodern\\fprq1\\fcharset0 Courier New;}"
|
|
"{\\f1\\froman\\fprq2\\fcharset0 Times New Roman;}"
|
|
"{\\f2\\fswiss\\fprq2\\fcharset0 Arial;}"
|
|
"{\\f3\\froman\\fprq2\\fcharset2 Symbol;}"
|
|
"}\r\n";
|
|
|
|
static const char* rtfColorTable =
|
|
"{\\colortbl;"
|
|
"\\red0\\green0\\blue0;\\red0\\green0\\blue255;\\red0\\green255\\blue255;\\red0\\green255\\blue0;"
|
|
"\\red255\\green0\\blue255;\\red255\\green0\\blue0;\\red255\\green255\\blue0;\\red255\\green255\\blue255;"
|
|
"\\red0\\green0\\blue128;\\red0\\green128\\blue128;\\red0\\green128\\blue0;\r\n"
|
|
"\\red128\\green0\\blue128;\\red128\\green0\\blue0;\\red128\\green128\\blue0;\\red128\\green128\\blue128;"
|
|
"\\red192\\green192\\blue192;\\red64\\green64\\blue64;\\red255\\green153\\blue0;}\r\n";
|
|
|
|
static const char* rtfHdrEnd =
|
|
"\\viewkind4\\uc1\\pard\\f0\\fs20 ";
|
|
|
|
if (fUseRTF) {
|
|
BufPrintf("%s", rtfHdrStart);
|
|
if ((flags & kRTFFlagColorTable) != 0)
|
|
BufPrintf("%s", rtfColorTable);
|
|
BufPrintf("%s", rtfHdrEnd);
|
|
}
|
|
|
|
fPointSize = 10;
|
|
}
|
|
|
|
/*
|
|
* Output the RTF footer.
|
|
*/
|
|
void ReformatText::RTFEnd(void)
|
|
{
|
|
if (fUseRTF) BufPrintf("}\r\n%c", '\0');
|
|
}
|
|
|
|
/*
|
|
* Output RTF paragraph definition marker. Do this every time we change some
|
|
* aspect of paragraph formatting, such as margins or justification.
|
|
*/
|
|
void ReformatText::RTFSetPara(void)
|
|
{
|
|
if (!fUseRTF)
|
|
return;
|
|
|
|
BufPrintf("\\pard\\nowidctlpar");
|
|
|
|
if (fLeftMargin != 0 || fRightMargin != 0) {
|
|
/* looks like RTF thinks we're getting 12 chars per inch? */
|
|
if (fLeftMargin != 0)
|
|
BufPrintf("\\li%d",
|
|
(int) (fLeftMargin * (kRTFUnitsPerInch/12)));
|
|
if (fLeftMargin != 0)
|
|
BufPrintf("\\ri%d",
|
|
(int) (fRightMargin * (kRTFUnitsPerInch/12)));
|
|
}
|
|
|
|
switch (fJustified) {
|
|
case kJustifyLeft: break;
|
|
case kJustifyRight: BufPrintf("\\qr"); break;
|
|
case kJustifyCenter: BufPrintf("\\qc"); break;
|
|
case kJustifyFull: BufPrintf("\\qj"); break;
|
|
default:
|
|
assert(false);
|
|
break;
|
|
}
|
|
|
|
// Ideally we'd suppress this if the next thing is an RTF
|
|
// formatting command, esp. "\\par".
|
|
BufPrintf(" ");
|
|
}
|
|
|
|
/*
|
|
* Output a new paragraph marker.
|
|
*
|
|
* If you're producing RTF output, this is the right way to output an
|
|
* end-of-line character.
|
|
*/
|
|
void ReformatText::RTFNewPara(void)
|
|
{
|
|
if (fUseRTF)
|
|
BufPrintf("\\par\r\n");
|
|
else
|
|
BufPrintf("\r\n");
|
|
}
|
|
|
|
|
|
/*
|
|
* Insert a page break. This isn't supported by the Rich Edit control,
|
|
* so it won't appear in CiderPress or WordPad, but it will come out in
|
|
* Microsoft Word if you extract to a file.
|
|
*/
|
|
void ReformatText::RTFPageBreak(void)
|
|
{
|
|
if (fUseRTF)
|
|
BufPrintf("\\page ");
|
|
}
|
|
|
|
/*
|
|
* RTF tab character.
|
|
*/
|
|
void ReformatText::RTFTab(void)
|
|
{
|
|
if (fUseRTF)
|
|
BufPrintf("\\tab ");
|
|
}
|
|
|
|
/*
|
|
* Minor formatting.
|
|
*/
|
|
void ReformatText::RTFBoldOn(void)
|
|
{
|
|
if (fBoldEnabled)
|
|
return;
|
|
if (fUseRTF) {
|
|
BufPrintf("\\b ");
|
|
fBoldEnabled = true;
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFBoldOff(void)
|
|
{
|
|
if (!fBoldEnabled)
|
|
return;
|
|
if (fUseRTF) {
|
|
BufPrintf("\\b0 ");
|
|
fBoldEnabled = false;
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFItalicOn(void)
|
|
{
|
|
if (fItalicEnabled)
|
|
return;
|
|
if (fUseRTF) {
|
|
BufPrintf("\\i ");
|
|
fItalicEnabled = true;
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFItalicOff(void)
|
|
{
|
|
if (!fItalicEnabled)
|
|
return;
|
|
if (fUseRTF) {
|
|
BufPrintf("\\i0 ");
|
|
fItalicEnabled = false;
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFUnderlineOn(void)
|
|
{
|
|
if (fUnderlineEnabled)
|
|
return;
|
|
if (fUseRTF) {
|
|
BufPrintf("\\ul ");
|
|
fUnderlineEnabled = true;
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFUnderlineOff(void)
|
|
{
|
|
if (!fUnderlineEnabled)
|
|
return;
|
|
if (fUseRTF) {
|
|
BufPrintf("\\ulnone ");
|
|
fUnderlineEnabled = false;
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFOutlineOn(void)
|
|
{
|
|
if (fOutlineEnabled)
|
|
return;
|
|
if (fUseRTF) {
|
|
BufPrintf("\\outl ");
|
|
fOutlineEnabled = true;
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFOutlineOff(void)
|
|
{
|
|
if (!fOutlineEnabled)
|
|
return;
|
|
if (fUseRTF) {
|
|
BufPrintf("\\outl0 ");
|
|
fOutlineEnabled = false;
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFShadowOn(void)
|
|
{
|
|
if (fShadowEnabled)
|
|
return;
|
|
if (fUseRTF) {
|
|
BufPrintf("\\shad ");
|
|
fShadowEnabled = true;
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFShadowOff(void)
|
|
{
|
|
if (!fShadowEnabled)
|
|
return;
|
|
if (fUseRTF) {
|
|
BufPrintf("\\shad0 ");
|
|
fShadowEnabled = false;
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFSubscriptOn(void)
|
|
{
|
|
if (fSubscriptEnabled)
|
|
return;
|
|
if (fUseRTF) {
|
|
BufPrintf("\\sub ");
|
|
fSubscriptEnabled = true;
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFSubscriptOff(void)
|
|
{
|
|
if (!fSubscriptEnabled)
|
|
return;
|
|
if (fUseRTF) {
|
|
BufPrintf("\\nosupersub ");
|
|
fSubscriptEnabled = false;
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFSuperscriptOn(void)
|
|
{
|
|
if (fSuperscriptEnabled)
|
|
return;
|
|
if (fUseRTF) {
|
|
BufPrintf("\\super ");
|
|
fSuperscriptEnabled = true;
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFSuperscriptOff(void)
|
|
{
|
|
if (!fSuperscriptEnabled)
|
|
return;
|
|
if (fUseRTF) {
|
|
BufPrintf("\\nosupersub ");
|
|
fSuperscriptEnabled = false;
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFSetColor(TextColor color)
|
|
{
|
|
if (color == fTextColor)
|
|
return;
|
|
if (fUseRTF) {
|
|
BufPrintf("\\cf%d ", color);
|
|
fTextColor = color;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Change paragraph formatting.
|
|
*/
|
|
void ReformatText::RTFParaLeft(void)
|
|
{
|
|
if (fJustified != kJustifyLeft) {
|
|
fJustified = kJustifyLeft;
|
|
RTFSetPara();
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFParaRight(void)
|
|
{
|
|
if (fJustified != kJustifyRight) {
|
|
fJustified = kJustifyRight;
|
|
RTFSetPara();
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFParaCenter(void)
|
|
{
|
|
if (fJustified != kJustifyCenter) {
|
|
fJustified = kJustifyCenter;
|
|
RTFSetPara();
|
|
}
|
|
}
|
|
|
|
void ReformatText::RTFParaJustify(void)
|
|
{
|
|
if (fJustified != kJustifyFull) {
|
|
fJustified = kJustifyFull;
|
|
RTFSetPara();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Page margins, in 1/10th inches.
|
|
*/
|
|
void ReformatText::RTFLeftMargin(int margin)
|
|
{
|
|
//LOGI("+++ Left margin now %d", margin);
|
|
fLeftMargin = margin;
|
|
RTFSetPara();
|
|
}
|
|
|
|
void ReformatText::RTFRightMargin(int margin)
|
|
{
|
|
//LOGI("+++ Right margin now %d", margin);
|
|
fRightMargin = margin;
|
|
RTFSetPara();
|
|
}
|
|
|
|
/*
|
|
* Switch to a different font size.
|
|
*/
|
|
void ReformatText::RTFSetFontSize(int points)
|
|
{
|
|
if (fUseRTF && fPointSize != points)
|
|
BufPrintf("\\fs%d ", points * 2);
|
|
fPointSize = points;
|
|
}
|
|
/*
|
|
* Switch to a different font.
|
|
*/
|
|
void ReformatText::RTFSetFont(RTFFont font)
|
|
{
|
|
if (fUseRTF)
|
|
BufPrintf("\\f%d ", font);
|
|
}
|
|
|
|
/*
|
|
* Set the font by specifying a IIgs QuickDraw II font family number.
|
|
*/
|
|
void ReformatText::RTFSetGSFont(uint16_t family)
|
|
{
|
|
float newMult;
|
|
|
|
if (!fUseRTF)
|
|
return;
|
|
|
|
/*
|
|
* Apple II fonts seem to be about 1.5x in a WYSIWYG way, except
|
|
* for Times, which is about 1:1.
|
|
*/
|
|
switch (family) {
|
|
case kGSFontTimes:
|
|
RTFSetFont(kFontTimesRoman);
|
|
newMult = 0.9f;
|
|
break;
|
|
case kGSFontNewYork:
|
|
RTFSetFont(kFontTimesRoman);
|
|
newMult = 1.1f;
|
|
break;
|
|
|
|
case kGSFontSymbol:
|
|
RTFSetFont(kFontSymbol);
|
|
newMult = 1.0f;
|
|
break;
|
|
|
|
case kGSFontMonaco:
|
|
RTFSetFont(kFontCourierNew);
|
|
newMult = 0.80f;
|
|
break;
|
|
case kGSFontCourier:
|
|
case kGSFontPCMonospace:
|
|
case kGSFontAppleM:
|
|
case kGSFontGenesys:
|
|
RTFSetFont(kFontCourierNew);
|
|
newMult = 1.5f;
|
|
break;
|
|
|
|
case kGSFontClassical:
|
|
case kGSFontGenoa:
|
|
case kGSFontWestern:
|
|
RTFSetFont(kFontArial);
|
|
newMult = 0.80f;
|
|
break;
|
|
case kGSFontChicago:
|
|
case kGSFontVenice:
|
|
case kGSFontGeneva:
|
|
case kGSFontStarfleet:
|
|
case kGSFontUnknown1:
|
|
case kGSFontUnknown2:
|
|
RTFSetFont(kFontArial);
|
|
newMult = 1.0f;
|
|
break;
|
|
case kGSFontLondon:
|
|
case kGSFontAthens:
|
|
case kGSFontSanFran:
|
|
case kGSFontShaston:
|
|
case kGSFontToronto:
|
|
case kGSFontCairo:
|
|
case kGSFontLosAngeles:
|
|
case kGSFontHelvetica:
|
|
case kGSFontTaliesin:
|
|
RTFSetFont(kFontArial);
|
|
newMult = 1.5f;
|
|
break;
|
|
default:
|
|
LOGI("Unrecognized font family 0x%04x, using Arial", family);
|
|
RTFSetFont(kFontArial);
|
|
newMult = 1.0f;
|
|
break;
|
|
}
|
|
|
|
if (newMult != fGSFontSizeMult) {
|
|
fGSFontSizeMult = newMult;
|
|
RTFSetGSFontSize(fPreMultPointSize);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Set the font size of a IIgs font. We factor the size multiplier in.
|
|
*
|
|
* BUG: we should track the state of the "underline" mode, and turn it
|
|
* on and off based on the font size (8-point fonts aren't underlined).
|
|
*/
|
|
void ReformatText::RTFSetGSFontSize(int points)
|
|
{
|
|
RTFSetFontSize((int) roundf(points * fGSFontSizeMult));
|
|
|
|
fPreMultPointSize = points;
|
|
}
|
|
|
|
/*
|
|
* Set bold/italic/underline etc.
|
|
*
|
|
* Note that "Teach" does not show underlining on text that is 8 points
|
|
* or smaller. We have to emulate this behavior or some documents, such
|
|
* as ModZap's "MZ.Manual", look terrible.
|
|
*
|
|
* Set the font size before calling here.
|
|
*
|
|
* Some characters, such as '=' in Shaston 8, look the same in
|
|
* bold as they do in plain. This doesn't hold true for Windows
|
|
* fonts, so we're going to look different in some circumstances.
|
|
*/
|
|
void ReformatText::RTFSetGSFontStyle(uint8_t qdStyle)
|
|
{
|
|
if (!fUseRTF)
|
|
return;
|
|
|
|
if ((qdStyle & kQDStyleBold) != 0) {
|
|
RTFBoldOn();
|
|
} else {
|
|
RTFBoldOff();
|
|
}
|
|
if ((qdStyle & kQDStyleItalic) != 0) {
|
|
RTFItalicOn();
|
|
} else {
|
|
RTFItalicOff();
|
|
}
|
|
if ((qdStyle & kQDStyleUnderline) != 0 && fPreMultPointSize > 8) {
|
|
RTFUnderlineOn();
|
|
} else {
|
|
RTFUnderlineOff();
|
|
}
|
|
if ((qdStyle & kQDStyleOutline) != 0) {
|
|
RTFOutlineOn();
|
|
} else {
|
|
RTFOutlineOff();
|
|
}
|
|
if ((qdStyle & kQDStyleShadow) != 0) {
|
|
RTFShadowOn();
|
|
} else {
|
|
RTFShadowOff();
|
|
}
|
|
if ((qdStyle & kQDStyleSuperscript) != 0) {
|
|
RTFSuperscriptOn();
|
|
} else {
|
|
RTFSuperscriptOff();
|
|
}
|
|
if ((qdStyle & kQDStyleSubscript) != 0) {
|
|
RTFSubscriptOn();
|
|
} else {
|
|
RTFSubscriptOff();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
void
|
|
ReformatText::RTFProportionalOn(void) {
|
|
if (fUseRTF)
|
|
BufPrintf("\\f%d ", kFontTimesRoman);
|
|
}
|
|
void
|
|
ReformatText::RTFProportionalOff(void) {
|
|
if (fUseRTF)
|
|
BufPrintf("\\f%d ", kFontCourierNew);
|
|
}
|
|
#endif
|
|
|
|
|
|
/*
|
|
* Convert the EOL markers in a buffer. The output is written to the work
|
|
* buffer. The input buffer may be CR, LF, or CRLF.
|
|
*
|
|
* If "stripHiBits" is set, the high bit of each character is cleared before
|
|
* the value is considered.
|
|
*/
|
|
void ReformatText::ConvertEOL(const uint8_t* srcBuf, long srcLen,
|
|
bool stripHiBits)
|
|
{
|
|
/* Compatibility - assume we're not stripping nulls */
|
|
ConvertEOL(srcBuf, srcLen, stripHiBits, false);
|
|
}
|
|
|
|
/*
|
|
* Convert the EOL markers in a buffer. The output is written to the work
|
|
* buffer. The input buffer may be CR, LF, or CRLF.
|
|
*
|
|
* If "stripHiBits" is set, the high bit of each character is cleared before
|
|
* the value is considered.
|
|
*2
|
|
* If "stripNulls" is true, no null values will make it through.
|
|
*/
|
|
void ReformatText::ConvertEOL(const uint8_t* srcBuf, long srcLen,
|
|
bool stripHiBits, bool stripNulls)
|
|
{
|
|
uint8_t ch;
|
|
int mask;
|
|
|
|
assert(!fUseRTF); // else we have to use RTFPrintChar
|
|
|
|
if (stripHiBits)
|
|
mask = 0x7f;
|
|
else
|
|
mask = 0xff;
|
|
|
|
/*
|
|
* Could probably speed this up by taking things a line at a time,
|
|
* but this is fast enough and much more straightforward.
|
|
*/
|
|
while (srcLen) {
|
|
ch = (*srcBuf++) & mask;
|
|
srcLen--;
|
|
|
|
if (ch == '\r') {
|
|
/* got CR, check for CRLF */
|
|
if (srcLen != 0 && ((*srcBuf) & mask) == '\n') {
|
|
srcBuf++;
|
|
srcLen--;
|
|
}
|
|
BufPrintf("\r\n");
|
|
} else if (ch == '\n') {
|
|
BufPrintf("\r\n");
|
|
} else {
|
|
/* Strip out null bytes if requested */
|
|
if ((stripNulls && ch != 0x00) || !stripNulls)
|
|
BufPrintf("%c", ch);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Write a hex dump into the buffer.
|
|
*/
|
|
void ReformatText::BufHexDump(const uint8_t* srcBuf, long srcLen)
|
|
{
|
|
const uint8_t* origSrcBuf = srcBuf;
|
|
char chBuf[17];
|
|
int i, remLen;
|
|
|
|
ASSERT(srcBuf != NULL);
|
|
ASSERT(srcLen >= 0);
|
|
|
|
chBuf[16] = '\0';
|
|
|
|
while (srcLen > 0) {
|
|
BufPrintf("%08lx: ", srcBuf - origSrcBuf);
|
|
|
|
if (srcLen >= 16) {
|
|
if (!fUseRTF) {
|
|
/* the really easy (and relatively fast) way */
|
|
BufPrintf("%02x %02x %02x %02x %02x %02x %02x %02x "
|
|
"%02x %02x %02x %02x %02x %02x %02x %02x ",
|
|
srcBuf[0], srcBuf[1], srcBuf[2], srcBuf[3],
|
|
srcBuf[4], srcBuf[5], srcBuf[6], srcBuf[7],
|
|
srcBuf[8], srcBuf[9], srcBuf[10], srcBuf[11],
|
|
srcBuf[12], srcBuf[13], srcBuf[14], srcBuf[15]);
|
|
} else {
|
|
/* the fairly easy (and fairly fast) way */
|
|
RTFBoldOn();
|
|
BufPrintf("%02x %02x %02x %02x ",
|
|
srcBuf[0], srcBuf[1], srcBuf[2], srcBuf[3]);
|
|
RTFBoldOff();
|
|
BufPrintf("%02x %02x %02x %02x ",
|
|
srcBuf[4], srcBuf[5], srcBuf[6], srcBuf[7]);
|
|
RTFBoldOn();
|
|
BufPrintf("%02x %02x %02x %02x ",
|
|
srcBuf[8], srcBuf[9], srcBuf[10], srcBuf[11]);
|
|
RTFBoldOff();
|
|
BufPrintf("%02x %02x %02x %02x ",
|
|
srcBuf[12], srcBuf[13], srcBuf[14], srcBuf[15]);
|
|
}
|
|
} else {
|
|
/* the not-so-easy (and not-so-fast) way */
|
|
remLen = srcLen;
|
|
|
|
for (i = 0; i < remLen; i++) {
|
|
if (i == 0 || i == 8)
|
|
RTFBoldOn();
|
|
else if (i == 4 || i == 12)
|
|
RTFBoldOff();
|
|
BufPrintf("%02x ", srcBuf[i]);
|
|
}
|
|
RTFBoldOff();
|
|
for ( ; i < 16; i++)
|
|
BufPrintf(" ");
|
|
|
|
/* blank out the char buf, since we're only filling part in */
|
|
for (i = 0; i < 16; i++)
|
|
chBuf[i] = ' ';
|
|
}
|
|
|
|
bool hosed = false;
|
|
remLen = srcLen;
|
|
if (remLen > 16)
|
|
remLen = 16;
|
|
int i;
|
|
for (i = 0; i < remLen; i++) {
|
|
chBuf[i] = PrintableChar(srcBuf[i]);
|
|
if (fUseRTF &&
|
|
(chBuf[i] == '\\' || chBuf[i] == '{' || chBuf[i] == '}'))
|
|
{
|
|
hosed = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!hosed) {
|
|
BufPrintf(" %s", chBuf);
|
|
} else {
|
|
/* escaped chars in RTF mode; have to do this one the hard way */
|
|
ASSERT(fUseRTF);
|
|
BufPrintf(" ");
|
|
for (i = 0; i < remLen; i++) {
|
|
RTFPrintChar(srcBuf[i]);
|
|
}
|
|
}
|
|
|
|
RTFNewPara();
|
|
|
|
srcBuf += 16;
|
|
srcLen -= 16;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* ==========================================================================
|
|
* ReformatGraphics
|
|
* ==========================================================================
|
|
*/
|
|
|
|
/*
|
|
* Initialize the Apple II color palette, used for Hi-Res and DHR
|
|
* conversions. Could also be used for lo-res mode.
|
|
*/
|
|
void ReformatGraphics::InitPalette(void)
|
|
{
|
|
ASSERT(kPaletteSize == 16);
|
|
|
|
static const RGBQUAD stdPalette[kPaletteSize] = {
|
|
/* blue, green, red, reserved */
|
|
{ 0x00, 0x00, 0x00 }, // $0 black
|
|
{ 0x33, 0x00, 0xdd }, // $1 red (magenta)
|
|
{ 0x99, 0x00, 0x00 }, // $2 dark blue
|
|
{ 0xdd, 0x22, 0xdd }, // $3 purple (violet)
|
|
{ 0x22, 0x77, 0x00 }, // $4 dark green
|
|
{ 0x55, 0x55, 0x55 }, // $5 grey1 (dark)
|
|
{ 0xff, 0x22, 0x22 }, // $6 medium blue
|
|
{ 0xff, 0xaa, 0x66 }, // $7 light blue
|
|
{ 0x00, 0x55, 0x88 }, // $8 brown
|
|
{ 0x00, 0x66, 0xff }, // $9 orange
|
|
{ 0xaa, 0xaa, 0xaa }, // $A grey2 (light)
|
|
{ 0x88, 0x99, 0xff }, // $B pink
|
|
{ 0x00, 0xdd, 0x11 }, // $C green (a/k/a light green)
|
|
{ 0x00, 0xff, 0xff }, // $D yellow
|
|
{ 0x99, 0xff, 0x44 }, // $E aqua
|
|
{ 0xff, 0xff, 0xff }, // $F white
|
|
};
|
|
|
|
memcpy(fPalette, stdPalette, sizeof(fPalette));
|
|
}
|
|
|
|
/*
|
|
* Stuff out DIB into the output fields, and set the appropriate flags.
|
|
*/
|
|
void ReformatGraphics::SetResultBuffer(ReformatOutput* pOutput, MyDIBitmap* pDib)
|
|
{
|
|
ASSERT(pOutput != NULL);
|
|
ASSERT(pDib != NULL);
|
|
pOutput->SetOutputKind(ReformatOutput::kOutputBitmap);
|
|
pOutput->SetDIB(pDib);
|
|
}
|
|
|
|
/*
|
|
* Unpack the Apple PackBytes format.
|
|
*
|
|
* Format is:
|
|
* <flag><data> ...
|
|
*
|
|
* Flag values (first 6 bits of flag byte):
|
|
* 00xxxxxx: (0-63) 1 to 64 bytes follow, all different
|
|
* 01xxxxxx: (0-63) 1 to 64 repeats of next byte
|
|
* 10xxxxxx: (0-63) 1 to 64 repeats of next 4 bytes
|
|
* 11xxxxxx: (0-63) 1 to 64 repeats of next byte taken as 4 bytes
|
|
* (as in 10xxxxxx case)
|
|
*
|
|
* Pass the destination buffer in "dst", source buffer in "src", source
|
|
* length in "srcLen", and expected sizes of output in "dstRem".
|
|
*
|
|
* Returns 0 on success, nonzero if the buffer is overfilled or underfilled.
|
|
*/
|
|
int ReformatGraphics::UnpackBytes(uint8_t* dst, const uint8_t* src,
|
|
long dstRem, long srcLen)
|
|
{
|
|
while (srcLen > 0) {
|
|
uint8_t flag = *src++;
|
|
int count = (flag & 0x3f) +1;
|
|
uint8_t val;
|
|
uint8_t valSet[4];
|
|
int i;
|
|
|
|
srcLen--;
|
|
|
|
switch (flag & 0xc0) {
|
|
case 0x00:
|
|
for (i = 0; i < count; i++) {
|
|
if (srcLen == 0 || dstRem == 0) {
|
|
LOGI(" SHR unpack overrun1 (srcLen=%ld dstRem=%ld)",
|
|
srcLen, dstRem);
|
|
return -1;
|
|
}
|
|
*dst++ = *src++;
|
|
srcLen--;
|
|
dstRem--;
|
|
}
|
|
break;
|
|
case 0x40:
|
|
//if (count != 3 || count != 5 || count != 6 || count != 7) {
|
|
// LOGI(" SHR unpack funky len %d?", count);
|
|
//}
|
|
if (srcLen == 0) {
|
|
LOGI(" SHR unpack underrun2");
|
|
return -1;
|
|
}
|
|
val = *src++;
|
|
srcLen--;
|
|
for (i = 0; i < count; i++) {
|
|
if (dstRem == 0) {
|
|
LOGI(" SHR unpack overrun2 (srcLen=%d, i=%d of %d)",
|
|
srcLen, i, count);
|
|
return -1;
|
|
}
|
|
*dst++ = val;
|
|
dstRem--;
|
|
}
|
|
break;
|
|
case 0x80:
|
|
if (srcLen < 4) {
|
|
LOGI(" SHR unpack underrun3");
|
|
return -1;
|
|
}
|
|
valSet[0] = *src++;
|
|
valSet[1] = *src++;
|
|
valSet[2] = *src++;
|
|
valSet[3] = *src++;
|
|
srcLen -= 4;
|
|
for (i = 0; i < count; i++) {
|
|
if (dstRem < 4) {
|
|
LOGI(" SHR unpack overrun3 (srcLen=%ld dstRem=%ld)",
|
|
srcLen, dstRem);
|
|
return -1;
|
|
}
|
|
*dst++ = valSet[0];
|
|
*dst++ = valSet[1];
|
|
*dst++ = valSet[2];
|
|
*dst++ = valSet[3];
|
|
dstRem -= 4;
|
|
}
|
|
break;
|
|
case 0xc0:
|
|
if (srcLen == 0) {
|
|
LOGI(" SHR unpack underrun4");
|
|
return -1;
|
|
}
|
|
val = *src++;
|
|
srcLen--;
|
|
for (i = 0; i < count; i++) {
|
|
if (dstRem < 4) {
|
|
LOGI(" SHR unpack overrun4 (srcLen=%ld dstRem=%ld count=%d)",
|
|
srcLen, dstRem, count);
|
|
return -1;
|
|
}
|
|
*dst++ = val;
|
|
*dst++ = val;
|
|
*dst++ = val;
|
|
*dst++ = val;
|
|
dstRem -= 4;
|
|
}
|
|
break;
|
|
default:
|
|
ASSERT(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
ASSERT(srcLen == 0);
|
|
|
|
/* require that we completely fill the buffer */
|
|
if (dstRem != 0) {
|
|
LOGI(" SHR unpack dstRem at %d", dstRem);
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Unpack Macintosh PackBits format. See Technical Note TN1023.
|
|
*
|
|
* Read a byte.
|
|
* If the high bit is set, count is 2s complement +1 (i.e. count = (-byte)+1).
|
|
* Read the next byte, then write that byte 'count' times.
|
|
* If the high bit is clear, count is 1+value (i.e. count = byte+1). Read and
|
|
* copy that many bytes.
|
|
* After "destLen" bytes have been written, return (even if in the middle of
|
|
* a run).
|
|
*
|
|
* NOTE: if the count byte is 0x80, Apple says it's an invalid value and
|
|
* should be skipped over. Use the following byte as the count byte. This
|
|
* is probably because PackBits is only supposed to crunch 127 bytes, though
|
|
* that suggests 0x81 and 0x7f are also impossible.
|
|
*
|
|
* We have to watch for underruns on the input and overruns on the output.
|
|
*/
|
|
void ReformatGraphics::UnPackBits(const uint8_t** pSrcBuf, long* pSrcLen,
|
|
uint8_t** pOutPtr, long dstLen, uint8_t xorVal)
|
|
{
|
|
const uint8_t* srcBuf = *pSrcBuf;
|
|
long length = *pSrcLen;
|
|
uint8_t* outPtr = *pOutPtr;
|
|
int pixByte = 0;
|
|
|
|
while (pixByte < dstLen && length > 0) {
|
|
uint8_t countByte;
|
|
int count;
|
|
|
|
countByte = *srcBuf++;
|
|
length--;
|
|
if (countByte & 0x80) {
|
|
/* RLE string */
|
|
uint8_t ch;
|
|
count = (countByte ^ 0xff)+1 +1;
|
|
ch = *srcBuf++;
|
|
length--;
|
|
while (count-- && pixByte < dstLen) {
|
|
*outPtr++ = ch ^ xorVal;
|
|
pixByte++;
|
|
}
|
|
} else {
|
|
/* series of bytes */
|
|
count = countByte +1;
|
|
while (count && pixByte < dstLen && length > 0) {
|
|
*outPtr++ = *srcBuf++ ^ xorVal;
|
|
count--;
|
|
length--;
|
|
pixByte++;
|
|
}
|
|
}
|
|
}
|
|
if (pixByte != 72) {
|
|
/* can happen if we run out of input early */
|
|
LOGI(" MP unexpected pixByte=%d", pixByte);
|
|
/* keep going */
|
|
}
|
|
|
|
*pSrcBuf = srcBuf;
|
|
*pSrcLen = length;
|
|
*pOutPtr = outPtr;
|
|
}
|