onbcode/meos-2024
1
0
Fork 0
Code Issues 1 Pull Requests Wiki Activity
v3.9.1437
meos-2024/code/printer.cpp
Erik Melin 16272ffa20 MeOS version 3.9.1437 Update 1
2023-05-14 22:03:57 +02:00

878 lines
24 KiB
C++
Raw Permalink Blame History

/************************************************************************
MeOS - Orienteering Software
Copyright (C) 2009-2023 Melin Software HB
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Melin Software HB - software@melin.nu - www.melin.nu
Eksoppsvägen 16, SE-75646 UPPSALA, Sweden
************************************************************************/
#include "stdafx.h"
#include <commdlg.h>
#include "gdioutput.h"
#include "oEvent.h"
#include "meos_util.h"
#include "Table.h"
#include "gdifonts.h"
#include "Printer.h"
#include "gdiimpl.h"
#include <algorithm>
#include "meosexception.h"
extern gdioutput *gdi_main;
static bool bPrint;
const double inchmmk=2.54;
BOOL CALLBACK AbortProc(HDC, int iError)
{
if (iError==0)
return bPrint;
else
{
bPrint=false;
return false;
}
}
#define WM_SETPAGE WM_USER+423
BOOL CALLBACK AbortPrintJob(HWND hDlg, UINT message, WPARAM wParam, LPARAM) {
return false;
}
PrinterObject::PrinterObject() {
hDC=0;
hDevMode=0;
hDevNames=0;
nPagesPrinted=0;
nPagesPrintedTotal=0;
onlyChanged=true;
memset(&ds, 0, sizeof(ds));
memset(&DevMode, 0, sizeof(DevMode));
}
PrinterObject::PrinterObject(const PrinterObject &po) {
hDC=0;
hDevMode=po.hDevMode;
hDevNames=po.hDevNames;
if (hDevMode)
GlobalLock(hDevMode);
if (hDevNames)
GlobalLock(hDevNames);
nPagesPrinted=0;
nPagesPrintedTotal=0;
onlyChanged=true;
memcpy(&ds, &po.ds, sizeof(ds));
memcpy(&DevMode, &po.DevMode, sizeof(DevMode));
}
void PrinterObject::operator=(const PrinterObject &po)
{
hDC = 0;///???po.hDC;
hDevMode=po.hDevMode;
hDevNames=po.hDevNames;
if (hDevMode)
GlobalLock(hDevMode);
if (hDevNames)
GlobalLock(hDevNames);
nPagesPrinted = po.nPagesPrinted;
nPagesPrintedTotal = po.nPagesPrintedTotal;
onlyChanged = po.onlyChanged;
memcpy(&ds, &po.ds, sizeof(ds));
memcpy(&DevMode, &po.DevMode, sizeof(DevMode));
}
PrinterObject::~PrinterObject()
{
if (hDC)
DeleteDC(hDC);
freePrinter();
}
void gdioutput::printPage(PrinterObject &po, const PageInfo &pageInfo, RenderedPage &page)
{
if (po.hDC)
SelectObject(po.hDC, GetStockObject(DC_BRUSH));
for (size_t k = 0; k < page.text.size(); k++) {
// Use transformed coordinates
page.text[k].ti.xp = (int)page.text[k].xp;
page.text[k].ti.yp = (int)page.text[k].yp;
RenderString(page.text[k].ti, po.hDC);
}
for (size_t k = 0; k < page.rectangles.size(); k++) {
renderRectangle(po.hDC, 0, page.rectangles[k]);
}
if (pageInfo.printHeader) {
TextInfo t;
t.yp = po.ds.MarginY;
t.xp = po.ds.PageX - po.ds.MarginX;
t.text = pageInfo.pageInfo(page);
t.format=textRight|fontSmall;
RenderString(t, po.hDC);
}
}
void gdioutput::printSetup(PrinterObject &po)
{
destroyPrinterDC(po);
PRINTDLG pd;
memset(&pd, 0, sizeof(pd));
pd.lStructSize = sizeof(PRINTDLG);
pd.hDevMode = po.hDevMode;
pd.hDevNames = po.hDevNames;
pd.Flags = PD_RETURNDC|PD_USEDEVMODECOPIESANDCOLLATE|PD_PRINTSETUP;
pd.hwndOwner = hWndAppMain;
pd.hDC = (HDC) po.hDC;
pd.nFromPage = 1;
pd.nToPage = 1;
pd.nMinPage = 1;
pd.nMaxPage = 1;
pd.nCopies = 1;
pd.hInstance = (HINSTANCE) NULL;
pd.lCustData = 0L;
pd.lpfnPrintHook = (LPPRINTHOOKPROC) NULL;
pd.lpfnSetupHook = (LPSETUPHOOKPROC) NULL;
pd.lpPrintTemplateName = (LPCWSTR) NULL;
pd.lpSetupTemplateName = (LPCWSTR) NULL;
pd.hPrintTemplate = (HANDLE) NULL;
pd.hSetupTemplate = (HANDLE) NULL;
int iret=PrintDlg(&pd);
if (iret==false) {
int error = CommDlgExtendedError();
if (error!=0) {
char sb[127];
sprintf_s(sb, "Printing Error Code=%d", error);
//MessageBox(hWnd, sb, NULL, MB_OK);
alert(sb);
po.freePrinter();
po.hDC = 0;
}
return;
}
else {
//Save settings!
po.hDevMode = pd.hDevMode;
po.hDevNames = pd.hDevNames;
po.hDC=pd.hDC;
DEVNAMES *dn=(LPDEVNAMES)GlobalLock(pd.hDevNames);
if (dn) {
DEVMODE *dm=(LPDEVMODE)GlobalLock(pd.hDevMode);
if (dm) {
po.DevMode=*dm;
po.DevMode.dmSize=sizeof(po.DevMode);
}
po.Driver=(wchar_t *)(dn)+dn->wDriverOffset;//XXX WCS
po.Device=(wchar_t *)(dn)+dn->wDeviceOffset;
//GlobalUnlock(pd.hDevMode);
}
//GlobalUnlock(pd.hDevNames);
}
}
void gdioutput::print(pEvent oe, Table *t, bool printMeOSHeader, bool noMargin, bool respectPageBreak) {
PageInfo pageInfo;
pageInfo.printHeader = printMeOSHeader;
pageInfo.noPrintMargin = noMargin;
setWaitCursor(true);
PRINTDLG pd;
PrinterObject &po = *po_default;
po.printedPages.clear();//Don't remember
pd.lStructSize = sizeof(PRINTDLG);
pd.hDevMode = po.hDevMode;
pd.hDevNames = po.hDevNames;
pd.Flags = PD_RETURNDC;
pd.hwndOwner = hWndAppMain;
pd.hDC = (HDC)NULL;
pd.nFromPage = 1;
pd.nToPage = 1;
pd.nMinPage = 1;
pd.nMaxPage = 1;
pd.nCopies = 1;
pd.hInstance = (HINSTANCE)NULL;
pd.lCustData = 0L;
pd.lpfnPrintHook = (LPPRINTHOOKPROC)NULL;
pd.lpfnSetupHook = (LPSETUPHOOKPROC)NULL;
pd.lpPrintTemplateName = (LPCWSTR)NULL;
pd.lpSetupTemplateName = (LPCWSTR)NULL;
pd.hPrintTemplate = (HANDLE)NULL;
pd.hSetupTemplate = (HANDLE)NULL;
int iret = PrintDlg(&pd);
if (iret == false) {
int error = CommDlgExtendedError();
if (error != 0) {
char sb[128];
sprintf_s(sb, "Printing Error Code=%d", error);
alert(sb);
po.freePrinter();
po.hDC = 0;
}
return;
}
setWaitCursor(true);
//Save settings!
po.freePrinter();
po.hDevMode = pd.hDevMode;
po.hDevNames = pd.hDevNames;
po.hDC = pd.hDC;
if (t)
t->print(*this, po.hDC, 20, 0);
DEVNAMES *dn = (LPDEVNAMES)GlobalLock(pd.hDevNames);
if (dn) {
DEVMODE *dm = (LPDEVMODE)GlobalLock(pd.hDevMode);
if (dm) {
po.DevMode = *dm;
po.DevMode.dmSize = sizeof(po.DevMode);
}
po.Driver = (wchar_t *)(dn)+dn->wDriverOffset;//XXX WCS
po.Device = (wchar_t *)(dn)+dn->wDeviceOffset;
//GlobalUnlock(pd.hDevMode);
//GlobalUnlock(pd.hDevNames);
}
doPrint(po, pageInfo, oe, respectPageBreak);
// Delete the printer DC.
DeleteDC(pd.hDC);
po.hDC = 0;
}
void gdioutput::print(PrinterObject &po, pEvent oe, bool printMeOSHeader, bool noMargin, bool respectPageBreak)
{
if (isTestMode) {
if (!cmdAnswers.empty()) {
string ans = cmdAnswers.front();
cmdAnswers.pop_front();
if (ans == "print")
return;
}
throw std::exception("Printing error");
}
PageInfo pageInfo;
pageInfo.printHeader = printMeOSHeader;
pageInfo.noPrintMargin = noMargin;
if (po.hDevMode==0) {
//if (po.Driver.empty()) {
PRINTDLG pd;
pd.lStructSize = sizeof(PRINTDLG);
pd.hDevMode = 0;
pd.hDevNames = 0;
pd.Flags = PD_RETURNDEFAULT;
pd.hwndOwner = hWndAppMain;
pd.hDC = (HDC) NULL;
pd.nFromPage = 1;
pd.nToPage = 1;
pd.nMinPage = 1;
pd.nMaxPage = 1;
pd.nCopies = 1;
pd.hInstance = (HINSTANCE) NULL;
pd.lCustData = 0L;
pd.lpfnPrintHook = (LPPRINTHOOKPROC) NULL;
pd.lpfnSetupHook = (LPSETUPHOOKPROC) NULL;
pd.lpPrintTemplateName = (LPCWSTR) NULL;
pd.lpSetupTemplateName = (LPCWSTR) NULL;
pd.hPrintTemplate = (HANDLE) NULL;
pd.hSetupTemplate = (HANDLE) NULL;
int iret=PrintDlg(&pd);
if (iret==false) {
int error=CommDlgExtendedError();
if (error!=0) {
char sb[128];
sprintf_s(sb, "Printing Error Code=%d", error);
alert(sb);
po.hDC = 0;
}
return;
}
po.freePrinter();
po.hDevMode = pd.hDevMode;
po.hDevNames = pd.hDevNames;
DEVNAMES *dn=(LPDEVNAMES)GlobalLock(pd.hDevNames);
if (dn) {
DEVMODE *dm=(LPDEVMODE)GlobalLock(pd.hDevMode);
if (dm) {
po.DevMode=*dm;
po.DevMode.dmSize=sizeof(po.DevMode);
}
po.Driver=(wchar_t *)(dn)+dn->wDriverOffset; //XXX WCS
po.Device=(wchar_t *)(dn)+dn->wDeviceOffset;
po.hDC=CreateDC(po.Driver.c_str(), po.Device.c_str(), NULL, dm);
GlobalUnlock(pd.hDevMode);
}
GlobalUnlock(pd.hDevNames);
}
else if (po.hDC==0) {
po.hDC = CreateDC(po.Driver.c_str(), po.Device.c_str(), NULL, &po.DevMode);
}
doPrint(po, pageInfo, oe, respectPageBreak);
}
void gdioutput::destroyPrinterDC(PrinterObject &po)
{
if (po.hDC) {
// Delete the printer DC.
DeleteDC(po.hDC);
po.hDC=0;
}
}
bool gdioutput::startDoc(PrinterObject &po)
{
// Initialize the members of a DOCINFO structure.
DOCINFO di;
int nError;
di.cbSize = sizeof(DOCINFO);
wchar_t sb[256];
swprintf_s(sb, L"MeOS");
di.lpszDocName = sb;
di.lpszOutput = (LPTSTR) NULL;
di.lpszDatatype = (LPTSTR) NULL;
di.fwType = 0; // Begin a print job by calling the StartDoc function.
nError = StartDoc(po.hDC, &di);
if (nError <= 0) {
nError=GetLastError();
DeleteDC(po.hDC);
po.hDC=0;
if (nError == ERROR_CANCELLED)
return false;
wstring err = L"Printing failed (X: Y) Z#StartDoc#"+ itow(nError) + L"#" + getErrorMessage(nError);
throw meosException(err);
//sprintf_s(sb, "Window's StartDoc API returned with error code %d,", nError);
//alert("StartDoc error: " + getErrorMessage(nError));
//return false;
}
return true;
}
bool gdioutput::doPrint(PrinterObject &po, PageInfo &pageInfo, pEvent oe, bool respectPageBreak)
{
setWaitCursor(true);
if (!po.hDC)
return false;
set<__int64> myPages;
po.nPagesPrinted=0;
PrinterObject::DATASET &ds=po.ds;
//Do the printing
int xsize = GetDeviceCaps(po.hDC, HORZSIZE);
int ysize = GetDeviceCaps(po.hDC, VERTSIZE);
int physX = GetDeviceCaps(po.hDC, PHYSICALWIDTH);
int physY = GetDeviceCaps(po.hDC, PHYSICALHEIGHT);
int physOffsetX = GetDeviceCaps(po.hDC, PHYSICALOFFSETX);
int physOffsetY = GetDeviceCaps(po.hDC, PHYSICALOFFSETY);
// Retrieve the number of pixels-per-logical-inch in the
// horizontal and vertical directions for the printer upon which
// the bitmap will be printed.
int xtot = GetDeviceCaps(po.hDC, HORZRES);
int ytot = GetDeviceCaps(po.hDC, VERTRES);
SetMapMode(po.hDC, MM_ISOTROPIC);
const bool limitSize = xsize > 100;
int PageXMax=limitSize ? max(512, MaxX) : MaxX;
int PageYMax=(ysize*PageXMax)/xsize;
SetWindowExtEx(po.hDC, int(PageXMax*1.05), int(PageYMax*1.05), 0);
SetViewportExtEx(po.hDC, xtot, ytot, NULL);
// xPrint = ((mm / xsize) * physX - physOff) / xtot * PageXMax*1.05
// xPrint = mm * (physX * PageXMax * 1.05) / (xsize*xtot) - physOff * (PageXMax * 1.05/xtot)
pageInfo.xMM2PrintC = double(physX * PageXMax * 1.05) / double(xsize*xtot);
pageInfo.xMM2PrintK = double(-physOffsetX) * (PageXMax * 1.05/xtot);
pageInfo.yMM2PrintC = double(physY * PageYMax * 1.05) / double(ysize*ytot);
pageInfo.yMM2PrintK = double(-physOffsetY) * (PageYMax * 1.05/ytot);
ds.PageX = PageXMax;
ds.PageY = PageYMax;
ds.MarginX = pageInfo.noPrintMargin ? (limitSize ? PageXMax/30: 5) : PageXMax/25;
ds.MarginY = pageInfo.noPrintMargin ? 5 : 20;
ds.Scale=1;
ds.LastPage=false;
int sOffsetY = OffsetY;
int sOffsetX = OffsetX;
OffsetY = 0;
OffsetX = 0;
pageInfo.topMargin = float(ds.MarginY * 2);
pageInfo.scaleX = 1.0f;
pageInfo.scaleY = 1.0f;
pageInfo.leftMargin = float(ds.MarginX);
pageInfo.bottomMargin = float(ds.MarginY);
pageInfo.pageY = float(PageYMax);
vector<RenderedPage> pages;
pageInfo.renderPages(TL, Rectangles, false, respectPageBreak, pages);
vector<int> toPrint;
for (size_t k = 0; k < pages.size(); k++) {
if (!po.onlyChanged || po.printedPages.count(pages[k].checkSum)==0) {
toPrint.push_back(k);
po.nPagesPrinted++;
po.nPagesPrintedTotal++;
}
myPages.insert(pages[k].checkSum);
}
int nPagesToPrint=toPrint.size();
if (nPagesToPrint>0) {
if (!startDoc(po)) {
return false;
}
for (size_t k = 0; k < toPrint.size(); k++) {
int nError = StartPage(po.hDC);
if (nError <= 0) {
nError=GetLastError();
EndDoc(po.hDC);
DeleteDC(po.hDC);
po.hDC=0;
po.freePrinter();
OffsetY = sOffsetY;
OffsetX = sOffsetX;
alert(L"StartPage error: " + getErrorMessage(nError));
return false;
}
printPage(po, pageInfo, pages[toPrint[k]]);
EndPage(po.hDC);
}
int nError = EndDoc(po.hDC);
OffsetY = sOffsetY;
OffsetX = sOffsetX;
if (nError <= 0) {
nError=GetLastError();
DeleteDC(po.hDC);
po.hDC=0;
alert(L"EndDoc error: " + getErrorMessage(nError));
return false;
}
}
po.printedPages.swap(myPages);
return true;
}
UINT_PTR CALLBACK PagePaintHook(HWND, UINT uiMsg, WPARAM wParam, LPARAM lParam) {
return false;
}
void PageSetup(HWND hWnd, PrinterObject &po)
{
PrinterObject::DATASET &ds=po.ds;
PAGESETUPDLG pd;
memset(&pd, 0, sizeof(pd));
pd.lStructSize=sizeof(pd);
pd.hwndOwner=hWnd;
// pd.hDevMode=po.hDevMode;
// pd.hDevNames=po.hDevNames;
pd.Flags=PSD_MARGINS|PSD_ENABLEPAGEPAINTHOOK|PSD_INHUNDREDTHSOFMILLIMETERS;
pd.lpfnPagePaintHook=PagePaintHook;
pd.rtMargin.left=int(ds.pMgLeft*float(ds.pWidth_mm)+0.5)*100;
pd.rtMargin.right=int(ds.pMgRight*float(ds.pWidth_mm)+0.5)*100;
pd.rtMargin.top=int(ds.pMgTop*float(ds.pHeight_mm)+0.5)*100;
pd.rtMargin.bottom=int(ds.pMgBottom*float(ds.pHeight_mm)+0.5)*100;
if (PageSetupDlg(&pd))
{
RECT rtMargin=pd.rtMargin;
if (pd.Flags & PSD_INHUNDREDTHSOFMILLIMETERS)
{
rtMargin.top=long(rtMargin.top/inchmmk);
rtMargin.bottom=long(rtMargin.bottom/inchmmk);
rtMargin.right=long(rtMargin.right/inchmmk);
rtMargin.left=long(rtMargin.left/inchmmk);
}
po.hDevMode=pd.hDevMode;
po.hDevNames=pd.hDevNames;
DEVMODE *dm=(LPDEVMODE)GlobalLock(pd.hDevMode);
if (dm)
{/*
if (dm->dmFields&DM_COLOR)
{
/*if (dm->dmColor==DMCOLOR_MONOCHROME)
ds.bPrintColour=false;
else
ds.bPrintColour=true;
}*/
}
DEVNAMES *dn=(LPDEVNAMES)GlobalLock(pd.hDevNames);
if (dn)
{
wchar_t *driver=(wchar_t *)(dn)+dn->wDriverOffset;//WCS
wchar_t *device=(wchar_t *)(dn)+dn->wDeviceOffset;
HDC hDC=CreateDC(driver, device, NULL, dm);
if (hDC)
{
ds.pWidth_mm=GetDeviceCaps(hDC, HORZSIZE);
ds.pHeight_mm=GetDeviceCaps(hDC, VERTSIZE);
ds.pMgLeft=inchmmk*rtMargin.left/float(ds.pWidth_mm)/100.;
ds.pMgRight=inchmmk*rtMargin.right/float(ds.pWidth_mm)/100.;
ds.pMgTop=inchmmk*rtMargin.top/float(ds.pHeight_mm)/100.;
ds.pMgBottom=inchmmk*rtMargin.bottom/float(ds.pHeight_mm)/100.;
DeleteDC(hDC);
}
}
}
}
void PrinterObject::freePrinter() {
if (hDevNames)
GlobalUnlock(hDevNames);
hDevNames = 0;
if (hDevMode)
GlobalUnlock(hDevMode);
hDevMode = 0;
}
//Uses format, text, xp and yp
void RenderedPage::calculateCS(const TextInfo &text)
{
if (gdioutput::skipTextRender(text.format) ||
text.text.empty())
return;
DWORD localCS=0;
DWORD localCS2=0;
for(DWORD i=0; i<text.text.size(); i++){
localCS+=(BYTE(text.text[i])<<(i%24))*(i*i+text.yp);
localCS2+=(BYTE(text.text[i])<<(i%23))*(i+17)*(i+text.xp);
}
localCS+=(text.format*10000000+text.xp+text.yp*1000);
checkSum += __int64(localCS) + (__int64(localCS2)<<32);
}
struct PrintItemInfo {
PrintItemInfo(int yp, const BaseInfo *obj) : yp(yp), obj(obj) {}
int yp;
const BaseInfo *obj;
bool operator<(const PrintItemInfo &other) const {
return yp < other.yp;
}
bool isNewPage() const {
const TextInfo *ti = dynamic_cast<const TextInfo *>(obj);
return ti && (ti->format == pageNewPage || ti->format == pageNewChapter);
}
bool isNewChapter() const {
const TextInfo *ti = dynamic_cast<const TextInfo *>(obj);
return ti && ti->format == pageNewChapter;
}
bool isNoPrint() const {
const TextInfo *ti = dynamic_cast<const TextInfo *>(obj);
return ti && gdioutput::skipTextRender(ti->format);
}
};
void PageInfo::renderPages(const list<TextInfo> &tl,
const list<RectangleInfo> &rects,
bool invertHeightY,
bool respectPageBreak,
vector<RenderedPage> &pages) {
const PageInfo &pi = *this;
TIList::const_iterator it;
pages.clear();
if (tl.empty())
return;
int currentYP = 0;
vector<PrintItemInfo> indexedTL;
indexedTL.reserve(tl.size() + rects.size());
int top = 1000;
float minX = 1000;
currentYP = tl.front().yp;
bool needSort = false;
for (it=tl.begin();it!=tl.end(); ++it) {
const TextInfo &text = *it;
if (text.format == 10)
continue;
if (!text.isFormatInfo()) {
if (currentYP > text.yp) {
needSort = true;
}
minX = min(minX, (float)it->textRect.left);
top = min(top, text.yp);
}
currentYP = text.yp;
indexedTL.push_back(PrintItemInfo(currentYP, &text));
}
for (list<RectangleInfo>::const_iterator rit = rects.begin(); rit != rects.end(); ++rit) {
needSort = true;
top = min<int>(top, rit->getRect().top);
indexedTL.push_back(PrintItemInfo(rit->getRect().top, &*rit));
}
if (needSort)
stable_sort(indexedTL.begin(), indexedTL.end());
bool startChapter = true;
bool addPage = true;
bool wasOrphan = false;
int offsetY = 0;
int desiredChapterStartY = 0;
wstring infoText;
int extraLimit = 0;
for (size_t k = 0; k < indexedTL.size(); k++) {
const TextInfo *tlp = dynamic_cast<const TextInfo *>(indexedTL[k].obj);
if (tlp == 0) {
const RectangleInfo *ri = dynamic_cast<const RectangleInfo *>(indexedTL[k].obj);
assert(ri && !pages.empty());
if (!ri || pages.empty())
throw std::exception("Unexpected type");
pages.back().rectangles.push_back(*ri);
RectangleInfo &r = pages.back().rectangles.back();
///xxxx
r.rc.left = LONG((r.rc.left - minX) * pi.scaleX + pi.leftMargin);
r.rc.right = LONG((r.rc.right - minX) * pi.scaleX + pi.leftMargin);
int off = invertHeightY ? (r.rc.bottom - r.rc.top) : 0;
r.rc.top = LONG((r.rc.top + offsetY + off) * pi.scaleY + pi.topMargin);
r.rc.bottom = LONG((r.rc.bottom + offsetY + off) * pi.scaleY + pi.topMargin);
continue;
}
if (tlp->format == pagePageInfo) {
infoText = tlp->text;
if (!pages.empty() && pages.back().info.empty())
pages.back().info = infoText;
}
if (addPage) {
wasOrphan = false;
addPage = false;
pages.push_back(RenderedPage());
pages.back().nPage = pages.size();
pages.back().info = infoText;
pages.back().startChapter = startChapter;
if (k == 0) {
offsetY = 0;
desiredChapterStartY = tlp->yp;
}
else if (startChapter) {
offsetY = desiredChapterStartY - tlp->yp + extraLimit;
}
else
offsetY = -tlp->yp + extraLimit;
extraLimit = 0;
startChapter = false;
}
if (gdioutput::skipTextRender(tlp->format))
continue;
pages.back().text.push_back(PrintTextInfo(*tlp));
PrintTextInfo &text = pages.back().text.back();
text.ti.yp += offsetY;
text.ti.highlight=0;
text.ti.hasCapture=0;
text.ti.active=0;
text.ti.callBack=0;
text.ti.hasTimer=false;
if (text.ti.absPrintX > 0) {
text.xp = float(text.ti.absPrintX * pi.xMM2PrintC + pi.xMM2PrintK);
text.yp = float(text.ti.absPrintY * pi.yMM2PrintC + pi.yMM2PrintK);
}
else {
text.xp = (text.ti.xp - minX) * pi.scaleX + pi.leftMargin;
int off = invertHeightY ? (text.ti.textRect.bottom - text.ti.textRect.top) : 0;
text.yp = (text.ti.yp + off) * pi.scaleY + pi.topMargin;
}
pages.back().calculateCS(text.ti);
#ifdef _DEBUG
static wchar_t breakbuff[8] = L"1429586";
if (text.ti.text == breakbuff) {
text.ti.text.empty(); // Break when hitting symbol
}
#endif
if (k + 1 < indexedTL.size() && tlp->yp != indexedTL[k+1].yp) {
size_t j = k + 1;
while (j + 1 < indexedTL.size() && indexedTL[j].isNoPrint() && !indexedTL[j].isNewPage())
j++;
// Required new page
if (indexedTL[j].isNewPage()) {
k++;
if (respectPageBreak) {
addPage = true;
startChapter = indexedTL[j].isNewChapter();
extraLimit = indexedTL[j].obj->getExtraInt();
infoText.clear();
continue;
}
}
map<int, int> forwardyp;
while ( j < indexedTL.size() && forwardyp.size() < 3) {
if (!indexedTL[j].isNewPage() && !indexedTL[j].isNoPrint()) {
if (forwardyp.count(indexedTL[j].yp) == 0 || indexedTL[j].isNewPage())
forwardyp[indexedTL[j].yp] = j;
}
j++;
}
int ix = 0;
float lastSize = GDIImplFontSet::baseSize(tlp->format, 1.0);
bool nextIsHead = false;
bool firstCanBreak = true;
for (map<int,int>::iterator it = forwardyp.begin(); it != forwardyp.end(); ++it, ++ix) {
const TextInfo *tlpItSecond = dynamic_cast<const TextInfo *>(indexedTL[it->second].obj);
if (!tlpItSecond)
continue;
float y = (max<int>(tlpItSecond->textRect.bottom, indexedTL[it->second].yp) + offsetY) * pi.scaleY + pi.topMargin;
float size = GDIImplFontSet::baseSize(tlpItSecond->format, 1.0);
bool over = y > pi.pageY - pi.bottomMargin;
bool canBreak = tlpItSecond->lineBreakPrioity >= 0;
if (ix == 0 && lastSize < size)
nextIsHead = true;
if (ix == 0 && !canBreak)
firstCanBreak = false; // First can break;
if (ix > 0 && firstCanBreak && canBreak)
firstCanBreak = false; // There is a more suitable break later
if (over) {
if (addPage && ix == 1 && lastSize < size && !wasOrphan) {
wasOrphan = true;
addPage = false; // Keep this line on this page. Orphan, next is head.
break;
}
if (ix == 0 && forwardyp.size()>1) { // forwardyp.size()>1 -> more than one lines left
if (!canBreak) {
if (!wasOrphan) {
wasOrphan = true;
break; // Skip breaking here.
}
wasOrphan = false;
}
addPage = true;
}
else if (ix > 0 && !canBreak && firstCanBreak) {
addPage = true; // Use this as a suitable break
}
else if (nextIsHead) {
addPage = true;
}
}
lastSize = size;
}
}
}
nPagesTotal = pages.size();
}
wstring PageInfo::pageInfo(const RenderedPage &page) const {
if (printHeader) {
wchar_t bf[256];
if (nPagesTotal > 1) {
if (!page.info.empty())
swprintf_s(bf, L"MeOS %s, %s, (%d/%d)", getLocalTime().c_str(),
page.info.c_str(), page.nPage, nPagesTotal);
else
swprintf_s(bf, L"MeOS %s, (%d/%d)", getLocalTime().c_str(), page.nPage, nPagesTotal);
}
else {
if (!page.info.empty())
swprintf_s(bf, L"MeOS %s, %s", getLocalTime().c_str(), page.info.c_str());
else
swprintf_s(bf, L"MeOS %s", getLocalTime().c_str());
}
return bf;
}
else return L"";
}
Reference in New Issue View Git Blame Copy Permalink