pugi::xml_node SvgPrinter::writeHeader(pugi::xml_document &doc)
{
pugi::xml_node rootNode = doc.append_child("svg");
rootNode.append_attribute("xmlns") = "http://www.w3.org/2000/svg";
rootNode.append_attribute("xmlns:xlink") = "http://www.w3.org/1999/xlink";
rootNode.append_attribute("xmlns:ev") = "http://www.w3.org/2001/xml-events";
rootNode.append_attribute("version") = "1.1";
rootNode.append_attribute("baseProfile") = "full";
if(!m_settings.width().empty()) {
rootNode.append_attribute("width") = m_settings.width().c_str();
}
if(!m_settings.height().empty()) {
rootNode.append_attribute("height") = m_settings.height().c_str();
}
DRect box = m_clsAttr ? m_clsAttr->boundingBox() : m_attr.boundingBox();
double margin = m_settings.margin();
std::stringstream is;
is << (box.p1().m_x - margin);
is << " " << (box.p1().m_y - margin);
is << " " << (box.width() + 2*margin);
is << " " << (box.height() + 2*margin);
rootNode.append_attribute("viewBox") = is.str().c_str();
pugi::xml_node style_node = rootNode.append_child("style");
style_node.text() = (".font_style {font: " + std::to_string(m_settings.fontSize()) + "px monospace;}").c_str();
return rootNode;
}
DRect CAView::getCenter()
{
DRect rect = this->getFrame();
rect.origin = ccpAdd(rect.origin, ccpMult(rect.size, 0.5f));
rect.setCenter(true);
return rect;
}
void CAListView::recoveryCollectionCell()
{
DRect rect = this->getBounds();
rect.origin = getContentOffset();
rect.origin.y -= rect.size.height * 0.1f;
rect.size.height *= 1.2f;
std::map<unsigned int, CAListViewCell*>::iterator itr;
for (itr = m_mpUsedListCells.begin(); itr != m_mpUsedListCells.end(); itr++)
{
CAListViewCell* cell = itr->second;
CC_CONTINUE_IF(cell == NULL);
DRect cellRect = cell->getFrame();
CC_CONTINUE_IF(rect.intersectsRect(cellRect));
m_mpFreedListCells[cell->getReuseIdentifier()].pushBack(cell);
cell->removeFromSuperview();
cell->resetListViewCell();
itr->second = NULL;
m_vpUsedListCells.eraseObject(cell);
CAView* line = m_pUsedLines[itr->first];
CC_CONTINUE_IF(line == NULL);
m_pFreedLines.pushBack(line);
line->removeFromSuperview();
m_pUsedLines[itr->first] = NULL;
}
}
void CAAutoCollectionView::updateSectionHeaderAndFooterRects()
{
DRect rect = this->getBounds();
rect.origin = getContentOffset();
for (int i = 0; i < m_rCollectionViewSection.size(); i++)
{
CollectionViewSection& cvs = m_rCollectionViewSection[i];
CC_CONTINUE_IF(!rect.intersectsRect(cvs.rSectionRect));
CAView* header = cvs.pSectionHeaderView;
CAView* footer = cvs.pSectionFooterView;
float headerHeight = cvs.nSectionHeaderHeight;
float footerHeight = cvs.nSectionFooterHeight;
if (header && m_bAlwaysTopSectionHeader)
{
DPoint p1 = rect.origin;
p1.y = MAX(p1.y, cvs.rSectionRect.origin.y);
p1.y = MIN(p1.y, cvs.rSectionRect.origin.y + cvs.rSectionRect.size.height
- headerHeight - footerHeight);
header->setFrameOrigin(p1);
}
if (footer && m_bAlwaysBottomSectionFooter)
{
DPoint p2 = DPointZero;
p2.y = MIN(rect.origin.y + this->getBounds().size.height - footerHeight,
cvs.rSectionRect.origin.y + cvs.rSectionRect.size.height - footerHeight);
p2.y = MAX(p2.y, cvs.rSectionRect.origin.y + headerHeight);
footer->setFrameOrigin(p2);
}
}
}
bool DRect::intersectsRect(const DRect& rect) const
{
return !( getMaxX() < rect.getMinX()
|| rect.getMaxX() < getMinX()
|| getMaxY() < rect.getMinY()
|| rect.getMaxY() < getMinY());
}
void CATextField::setMarginLeft(int var)
{
m_iMarginLeft = var;
DRect r = this->getBounds();
r.InflateRect(-m_iMarginLeft, 0, -m_iMarginRight, 0);
((CATextFieldWin32*)m_pTextField)->setFrame(r);
delayShowImage();
}
void CATextField::setContentSize(const DSize& contentSize)
{
CAView::setContentSize(contentSize);
if (m_pTextField)
{
DRect r = this->getBounds();
r.InflateRect(-m_iMarginLeft, 0, -m_iMarginRight, 0);
((CATextFieldWin32*)m_pTextField)->setFrame(r);
}
}
void CAListView::loadCell()
{
DRect rect = this->getBounds();
rect.origin = getContentOffset();
rect.origin.y -= rect.size.height * 0.1f;
rect.origin.x -= rect.size.width * 0.1f;
rect.size.width *= 1.2f;
rect.size.height *= 1.2f;
std::map<unsigned int, CAListViewCell*>::iterator itr;
for (itr = m_mpUsedListCells.begin(); itr != m_mpUsedListCells.end(); itr++)
{
CC_CONTINUE_IF(itr->second != NULL);
unsigned int index = itr->first;
DRect cellRect = m_rIndexRects[index];
CC_CONTINUE_IF(!rect.intersectsRect(cellRect));
CAListViewCell* cell = m_pListViewDataSource->listViewCellAtIndex(this, cellRect.size, index);
if (cell)
{
cell->m_nIndex = index;
cell->updateDisplayedAlpha(this->getAlpha());
addSubview(cell);
cell->setFrame(cellRect);
m_mpUsedListCells[index] = cell;
m_vpUsedListCells.pushBack(cell);
}
if (m_pSelectedListCells.count(index))
{
cell->setControlState(CAControlStateSelected);
}
if (m_pListViewDataSource)
{
m_pListViewDataSource->listViewWillDisplayCellAtIndex(this, cell, index);
}
CAView* view = this->dequeueReusableLine();
DRect lineRect = m_rLineRects[index];
if (view == NULL)
{
view = CAView::createWithFrame(lineRect, m_obSeparatorColor);
}
m_pUsedLines[index] = view;
this->insertSubview(view, 1);
view->setFrame(lineRect);
}
}
void DPolyline::normalize(DPoint src, DPoint tgt)
{
if (empty())
return;
unify();
ListIterator<DPoint> iter, next, onext;
DPoint pCur = src;
DPoint pNext;
DPoint pNextNext;
for (iter = begin(); iter.valid(); ++iter) {
for( ; ; ) {
if (!iter.valid())
break;
next = iter;
pNext = *next;
next++;
if (!next.valid()) {
pNextNext = tgt;
}
else
pNextNext = *next;
DSegment s1(pCur, pNext);
DSegment s2(pNext, pNextNext);
DRect r (pCur, pNextNext);
// is *next on the way from *iter to *onext?
if (s1.slope() == s2.slope() && r.contains(pNext)) {
del(iter);
iter = next;
}
else
break; /* while */
}
if (iter.valid())
pCur = *iter;
else
break;
}
}
// deletes all points, which are not facets
void DPolygon::normalize()
{
unify();
ListIterator<DPoint> iter, next;
for (iter = begin(); iter.valid(); ++iter) {
for( ; ; ) {
next = cyclicSucc(iter);
DSegment s1 = segment(iter);
DSegment s2 = segment(next);
DRect r (*iter, *cyclicSucc(next));
if (s1.slope() == s2.slope() && r.contains(*next))
del(next);
else
break; // while
}
}
}
void CATextView::setContentSize(const DSize& contentSize)
{
CAView::setContentSize(contentSize);
if (m_pBackgroundView)
{
m_pBackgroundView->setFrame(this->getBounds());
}
if (m_pShowImageView)
{
m_pShowImageView->setFrame(this->getBounds());
}
if (m_pTextView)
{
DRect r = this->getBounds();
r.InflateRect(-5);
((CATextViewWin32*)m_pTextView)->setFrame(r);
}
}
void CACollectionView::updateSectionHeaderAndFooterRects()
{
DRect rect = this->getBounds();
rect.origin = getContentOffset();
std::vector<DRect>::iterator itr;
for (itr = m_rSectionRects.begin(); itr != m_rSectionRects.end(); itr++)
{
CC_CONTINUE_IF(!rect.intersectsRect(*itr));
int i = (int)(itr - m_rSectionRects.begin());
CAView* header = NULL;
CAView* footer = NULL;
float headerHeight = 0;
float footerHeight = 0;
if (m_pSectionHeaderViews.find(i) != m_pSectionHeaderViews.end())
{
header = m_pSectionHeaderViews[i];
headerHeight = m_pSectionHeaderViews[i]->getFrame().size.height;
}
if (m_pSectionFooterViews.find(i) != m_pSectionFooterViews.end())
{
footer = m_pSectionFooterViews[i];
footerHeight = m_pSectionFooterViews[i]->getFrame().size.height;
}
if (header && m_bAlwaysTopSectionHeader)
{
DPoint p1 = rect.origin;
p1.y = MAX(p1.y, itr->origin.y);
p1.y = MIN(p1.y, itr->origin.y + itr->size.height
- headerHeight - footerHeight);
header->setFrameOrigin(p1);
}
if (footer && m_bAlwaysBottomSectionFooter)
{
DPoint p2 = DPointZero;
p2.y = MIN(rect.origin.y + this->getBounds().size.height - footerHeight,
itr->origin.y + itr->size.height - footerHeight);
p2.y = MAX(p2.y, itr->origin.y + headerHeight);
footer->setFrameOrigin(p2);
}
}
}
void DRect::unite(const DRect &r)
{
if ( !r.isValid() ) return;
if ( !isValid() ) {
*this = r;
return;
}
_left = kMin(_left, r._left);
_right = kMax(_right, r._right);
_top = kMin(_top, r._top);
_bottom = kMax(_bottom, r._bottom);
}
void CACollectionView::loadCollectionCell()
{
DRect rect = this->getBounds();
rect.origin = getContentOffset();
rect.origin.y -= rect.size.height * 0.1f;
rect.size.height *= 1.2f;
std::map<CAIndexPath3E, CACollectionViewCell*>::iterator itr;
for (itr = m_mpUsedCollectionCells.begin(); itr != m_mpUsedCollectionCells.end(); itr++)
{
CC_CONTINUE_IF(itr->second != NULL);
CAIndexPath3E r = itr->first;
DRect cellRect = m_rUsedCollectionCellRects[r];
CC_CONTINUE_IF(!rect.intersectsRect(cellRect));
CACollectionViewCell* cell = m_pCollectionViewDataSource->collectionCellAtIndex(this, cellRect.size, r.section, r.row, r.item);
if (cell)
{
cell->m_nSection = r.section;
cell->m_nRow = r.row;
cell->m_nItem = r.item;
cell->updateDisplayedAlpha(this->getAlpha());
this->addSubview(cell);
cell->setFrame(cellRect);
itr->second = cell;
m_vpUsedCollectionCells.pushBack(cell);
if (m_pSelectedCollectionCells.count(r))
{
cell->setControlStateSelected();
}
if (m_pCollectionViewDataSource)
{
m_pCollectionViewDataSource->collectionViewWillDisplayCellAtIndex(this, cell, r.section, r.row, r.item);
}
}
}
}
void init(SDL_Renderer* renderer)
{
input_show_debug_rect = false;
worldMap.Load("test.map");
//worldMap.NewMap(32, 32);
reset_view();
tileset = IMG_LoadTexture(renderer, "tileset.png");
SDL_QueryTexture(tileset, NULL, NULL, &tilesetRect.get()->w, &tilesetRect.get()->h);
TILESET_WIDTH = tilesetRect.get()->w / tileSizeX;
TILESET_HEIGHT = tilesetRect.get()->h / tileSizeY;
TILES_EDITOR[0] = getTileIndex(0, 0, TILESET_WIDTH);
TILES_EDITOR[1] = getTileIndex(0, 6, TILESET_WIDTH);
TILES_EDITOR[2] = getTileIndex(4, 11, TILESET_WIDTH);
TILES_EDITOR[3] = getTileIndex(4, 8, TILESET_WIDTH);
TILES_EDITOR[4] = getTileIndex(8, 12, TILESET_WIDTH);
for (int i = 0; i < NB_TILES_EDITOR; i++) {
std::cout << "editor[" << i << "]= " << TILES_EDITOR[i] << "\n";
}
}
void CACollectionView::recoveryCollectionCell()
{
DRect rect = this->getBounds();
rect.origin = getContentOffset();
rect.origin.y -= rect.size.height * 0.1f;
rect.size.height *= 1.2f;
std::map<CAIndexPath3E, CACollectionViewCell*>::iterator itr;
for (itr = m_mpUsedCollectionCells.begin(); itr != m_mpUsedCollectionCells.end(); itr++)
{
CACollectionViewCell* cell = itr->second;
CC_CONTINUE_IF(cell == NULL);
DRect cellRect = cell->getFrame();
CC_CONTINUE_IF(rect.intersectsRect(cellRect));
m_mpFreedCollectionCells[cell->getReuseIdentifier()].pushBack(cell);
cell->removeFromSuperview();
cell->resetCollectionViewCell();
itr->second = NULL;
m_vpUsedCollectionCells.eraseObject(cell);
}
}
bool DRect::equals(const DRect& rect) const
{
if (fabsf(this->getMinX() - rect.getMinX()) >= 0.01f)
{
return false;
}
if (fabsf(this->getMaxX() - rect.getMaxX()) >= 0.01f)
{
return false;
}
if (fabsf(this->getMinY() - rect.getMinY()) >= 0.01f)
{
return false;
}
if (fabsf(this->getMaxY() - rect.getMaxY()) >= 0.01f)
{
return false;
}
return true;
}
// deletes all points, which are not facets
void DPolyline::normalize()
{
unify();
ListIterator<DPoint> iter, next, onext;
for (iter = begin(); iter.valid(); ++iter) {
for( ; ; ) {
next = iter; next++;
if (!next.valid()) break;
onext = next, onext++;
if (!onext.valid()) break;
DSegment s1((*iter), (*next));
DSegment s2((*next), (*onext));
DRect r ((*iter), (*onext));
// is *next on the way from *iter to *onext?
if (s1.slope() == s2.slope() && r.contains(*next))
del(next);
else
break; /* while */
}
}
}
DRect::DRect(const DRect& other)
:m_bCenter(other.isCenter())
{
setRect(other.origin.x, other.origin.y, other.size.width, other.size.height);
}
void CACollectionView::reloadData()
{
CC_RETURN_IF(m_pCollectionViewDataSource == NULL);
this->reloadViewSizeData();
this->removeAllSubviews();
DRect winRect = this->getBounds();
winRect.origin = getContentOffset();
float width = winRect.size.width;
int y = 0;
if (m_nCollectionHeaderHeight > 0 && m_pCollectionHeaderView)
{
m_pCollectionHeaderView->setDisplayRange(true);
m_pCollectionHeaderView->setFrame(DRect(0, y, width, m_nCollectionHeaderHeight));
addSubview(m_pCollectionHeaderView);
y += m_nCollectionHeaderHeight;
}
;
int begin = (int)m_rSectionRects.size();
m_rSectionRects.resize(m_rSectionRects.size() + m_nSections);
for (int i = 0; i < m_nSections; i++)
{
unsigned int iSectionHeaderHeight = m_nSectionHeaderHeights.at(i);
DRect sectionHeaderRect = DRect(0, y, width, iSectionHeaderHeight);
if (iSectionHeaderHeight>0)
{
CAView* pSectionHeaderView = m_pCollectionViewDataSource->collectionViewSectionViewForHeaderInSection(this, sectionHeaderRect.size, i);
if (pSectionHeaderView != NULL)
{
pSectionHeaderView->setDisplayRange(true);
pSectionHeaderView->setFrame(sectionHeaderRect);
insertSubview(pSectionHeaderView, 1);
m_pSectionHeaderViews[i] = pSectionHeaderView;
y += iSectionHeaderHeight;
}
}
y += m_nVertInterval;
unsigned int rowCount = m_nRowsInSections.at(i);
for (int j = 0; j < rowCount; j++)
{
int iHeight = m_nRowHeightss.at(i).at(j);
unsigned int itemCount = m_pCollectionViewDataSource->numberOfItemsInRowsInSection(this, i, j);
unsigned int cellWidth = 0;
if (itemCount>0)
{
cellWidth = (width - m_nHoriInterval) / itemCount - m_nHoriInterval;
}
for (int k = 0; k < itemCount; k++)
{
CAIndexPath3E indexPath = CAIndexPath3E(i, j, k);
DRect cellRect = DRect(m_nHoriInterval + (cellWidth + m_nHoriInterval)*k, y, cellWidth, iHeight);
m_rUsedCollectionCellRects[indexPath] = cellRect;
std::pair<std::map<CAIndexPath3E, CACollectionViewCell*>::iterator, bool> itrResult =
m_mpUsedCollectionCells.insert(std::make_pair(indexPath, (CACollectionViewCell*)NULL));
CC_CONTINUE_IF(!winRect.intersectsRect(cellRect));
CACollectionViewCell* cell = m_pCollectionViewDataSource->collectionCellAtIndex(this, cellRect.size, i, j, k);
if (cell)
{
addSubview(cell);
cell->setFrame(cellRect);
cell->m_nSection = i;
cell->m_nRow = j;
cell->m_nItem = k;
itrResult.first->second = cell;
m_vpUsedCollectionCells.pushBack(cell);
if (m_pCollectionViewDataSource)
{
m_pCollectionViewDataSource->collectionViewWillDisplayCellAtIndex(this, cell, i, j, k);
}
}
}
y += (iHeight + m_nVertInterval);
}
unsigned int iSectionFooterHeight = m_nSectionFooterHeights.at(i);
DRect sectionFooterRect = DRect(0, y, width, iSectionFooterHeight);
if (iSectionFooterHeight > 0)
{
CAView* pSectionFooterView = m_pCollectionViewDataSource->collectionViewSectionViewForFooterInSection(this, sectionFooterRect.size, i);
if (pSectionFooterView != NULL)
{
pSectionFooterView->setDisplayRange(true);
pSectionFooterView->setFrame(sectionFooterRect);
insertSubview(pSectionFooterView, 1);
m_pSectionFooterViews[i] = pSectionFooterView;
y += iSectionFooterHeight;
}
}
DRect sectionRect = sectionHeaderRect;
sectionRect.size.height = sectionFooterRect.origin.y
+ sectionFooterRect.size.height
- sectionHeaderRect.origin.y;
m_rSectionRects[begin + i] = sectionRect;
}
if (m_nCollectionFooterHeight > 0 && m_pCollectionFooterView)
{
m_pCollectionFooterView->setFrame(DRect(0, y, width, m_nCollectionFooterHeight));
addSubview(m_pCollectionFooterView);
y += m_nCollectionFooterHeight;
}
this->updateSectionHeaderAndFooterRects();
this->layoutPullToRefreshView();
this->startDeaccelerateScroll();
}
void CAView::visit()
{
CC_RETURN_IF(!m_bVisible);
kmGLPushMatrix();
this->transform();
bool isScissor = (bool)glIsEnabled(GL_SCISSOR_TEST);
DRect restoreScissorRect = DRectZero;
if (isScissor)
{
GLfloat params[4];
glGetFloatv(GL_SCISSOR_BOX, params);
restoreScissorRect = DRect(params[0], params[1], params[2], params[3]);
}
if (!m_bDisplayRange)
{
kmMat4 modelview;
kmGLGetMatrix(KM_GL_MODELVIEW, &modelview);
kmMat4 tm;
kmMat4Identity(&tm);
tm.mat[12] = m_obContentSize.width;
tm.mat[13] = m_obContentSize.height;
kmMat4 tm2;
kmMat4Multiply(&tm2, &modelview, &tm);
DPoint point = DPoint(modelview.mat[12], modelview.mat[13]);
static CAApplication* application = CAApplication::getApplication();
if (application->getProjection() == CAApplication::P3D)
{
point = ccpAdd(point, application->getWinSize() / 2);
}
DSize size = DSize(tm2.mat[12] - modelview.mat[12], tm2.mat[13] - modelview.mat[13]);
DRect frame = DRect(point.x, point.y, size.width, size.height);
if (isScissor)
{
float x1 = MAX(s_dip_to_px(frame.getMinX()), restoreScissorRect.getMinX());
float y1 = MAX(s_dip_to_px(frame.getMinY()), restoreScissorRect.getMinY());
float x2 = MIN(s_dip_to_px(frame.getMaxX()) + 0.5f, restoreScissorRect.getMaxX());
float y2 = MIN(s_dip_to_px(frame.getMaxY()) + 0.5f, restoreScissorRect.getMaxY());
float width = MAX(x2-x1, 0);
float height = MAX(y2-y1, 0);
glScissor(x1, y1, width, height);
}
else
{
glEnable(GL_SCISSOR_TEST);
glScissor(s_dip_to_px(frame.origin.x),
s_dip_to_px(frame.origin.y),
s_dip_to_px(frame.size.width) + 0.5f,
s_dip_to_px(frame.size.height) + 0.5f);
}
}
this->sortAllSubviews();
CAVector<CAView*>::iterator itr=m_obSubviews.begin();
while (itr!=m_obSubviews.end())
{
CC_BREAK_IF((*itr)->m_nZOrder >= 0);
(*itr)->visit();
itr++;
}
this->draw();
while (itr!=m_obSubviews.end())
{
(*itr)->visit();
itr++;
}
//m_uOrderOfArrival = 0;
if (!m_bDisplayRange)
{
if (isScissor)
{
glScissor(restoreScissorRect.origin.x,
restoreScissorRect.origin.y ,
restoreScissorRect.size.width,
restoreScissorRect.size.height);
}
else
{
glDisable(GL_SCISSOR_TEST);
}
}
kmGLPopMatrix();
}
void _DPlane<T>::draw(const DRect &rect, T color)
{
for(int i=rect.top(); i <= rect.bottom(); i++)
{
if(i >= 0 && i < _DMatrix<T>::rows() && rect.left() >= 0 && rect.left() < _DMatrix<T>::cols())
(*this)[i][rect.left()] = color;
if(i >= 0 && i < _DMatrix<T>::rows() && rect.right() >= 0 && rect.right() < _DMatrix<T>::cols())
(*this)[i][rect.right()] = color;
}
for(int j=rect.left(); j <= rect.right(); j++)
{
if(rect.top() >= 0 && rect.top() < _DMatrix<T>::rows() && j >= 0 && j < _DMatrix<T>::cols())
(*this)[rect.top()][j] = color;
if(rect.bottom() >= 0 && rect.bottom() < _DMatrix<T>::rows() && j >= 0 && j < _DMatrix<T>::cols())
(*this)[rect.bottom()][j] = color;
}
}
DRect::DRect(const DRect& other)
:m_eType(other.isType())
{
setRect(other.origin.x, other.origin.y, other.size.width, other.size.height);
}
KoFilter::ConversionStatus PdfImport::convert(const QCString& from,
const QCString& to)
{
// check for proper conversion
if ( to!="application/x-kword" || from!="application/pdf" )
return KoFilter::NotImplemented;
// read file
KoFilter::ConversionStatus result
= _doc.init(m_chain->inputFile(), QString::null, QString::null);
if ( result!=KoFilter::OK ) return result;
// options dialog
{
Dialog dialog(_doc.nbPages(), _doc.isEncrypted(), 0);
dialog.exec();
if ( dialog.result()==QDialog::Rejected )
return KoFilter::UserCancelled;
_options = dialog.options();
}
// progress dialog
KProgressDialog pd(0, "progress_dialog", i18n("PDF Import"),
i18n("Initializing..."), true);
pd.setMinimumDuration(0);
pd.progressBar()->setTotalSteps( _options.range.nbPages()*2 );
pd.progressBar()->setValue(1);
qApp->processEvents();
// if passwords : reread file
if ( !_options.ownerPassword.isEmpty()
|| !_options.userPassword.isEmpty() ) {
result = _doc.init(m_chain->inputFile(), _options.ownerPassword,
_options.userPassword);
if ( result!=KoFilter::OK ) return result;
}
// data
KoPageLayout page;
DRect rect = _doc.paperSize(page.format);
kdDebug(30516) << "paper size: " << rect.toString() << endl;
page.orientation = _doc.paperOrientation();
Data data(m_chain, rect, page, _options);
_doc.initDevice(data);
// treat pages
QTime time;
time.start();
SelectionRangeIterator it(_options.range);
for (uint k=0; k<2; k++) {
bool first = ( k==0 );
data.pageIndex = 0;
if ( !first ) _doc.init();
for (it.toFirst(); it.current()!=it.end(); it.next()) {
QString s = (first ? i18n("First pass: page #%1...")
: i18n("Second pass: page #%1..."));
pd.setLabel( s.arg(it.current()) );
qApp->processEvents();
if (pd.wasCancelled()) return KoFilter::UserCancelled;
kdDebug(30516) << "-- " << "pass #" << k
<< " treat page: " << it.current()
<< "----------------" << endl;
if (first) _doc.treatPage( it.current() );
else _doc.dumpPage(data.pageIndex);
pd.progressBar()->advance(1);
data.pageIndex++;
}
}
data.endDump();
kdDebug(30516) << "treatement elapsed=" << time.elapsed() << endl;
// output
KoStoreDevice* out = m_chain->storageFile("root", KoStore::Write);
if( !out ) {
kdError(30516) << "Unable to open output file!" << endl;
return KoFilter::StorageCreationError;
}
// kdDebug(30516) << data.document().toCString() << endl;
QCString cstr = data.document().toCString();
out->writeBlock(cstr, cstr.length());
out->close();
treatInfoDocument();
return KoFilter::OK;
}
