void ChromeClient::scroll(const IntSize& delta, const IntRect& rectToScroll, const IntRect& clipRect)
{
m_adjustmentWatcher.updateAdjustmentsFromScrollbarsLater();
#if USE(ACCELERATED_COMPOSITING)
AcceleratedCompositingContext* compositingContext = m_webView->priv->acceleratedCompositingContext.get();
if (compositingContext->enabled()) {
ASSERT(!rectToScroll.isEmpty());
ASSERT(delta.width() || delta.height());
compositingContext->scrollNonCompositedContents(rectToScroll, delta);
return;
}
#endif
m_rectsToScroll.append(rectToScroll);
m_scrollOffsets.append(delta);
// The code to calculate the scroll repaint region is originally from WebKit2.
// Get the part of the dirty region that is in the scroll rect.
Region dirtyRegionInScrollRect = intersect(rectToScroll, m_dirtyRegion);
if (!dirtyRegionInScrollRect.isEmpty()) {
// There are parts of the dirty region that are inside the scroll rect.
// We need to subtract them from the region, move them and re-add them.
m_dirtyRegion.subtract(rectToScroll);
// Move the dirty parts.
Region movedDirtyRegionInScrollRect = intersect(translate(dirtyRegionInScrollRect, delta), rectToScroll);
// And add them back.
m_dirtyRegion.unite(movedDirtyRegionInScrollRect);
}
// Compute the scroll repaint region. We ensure that we are not subtracting areas
// that we've scrolled from outside the viewport from the repaint region.
IntRect onScreenScrollRect = rectToScroll;
onScreenScrollRect.intersect(IntRect(IntPoint(), enclosingIntRect(pageRect()).size()));
Region scrollRepaintRegion = subtract(rectToScroll, translate(onScreenScrollRect, delta));
m_dirtyRegion.unite(scrollRepaintRegion);
m_displayTimer.startOneShot(0);
}
QPixmap KoPAPage::generateThumbnail( const QSize& size )
{
// don't paint null pixmap
if ( size.isEmpty() ) // either width or height is <= 0
return QPixmap();
KoZoomHandler zoomHandler;
const KoPageLayout & layout = pageLayout();
KoPAUtil::setZoom( layout, size, zoomHandler );
QRect pageRect( KoPAUtil::pageRect( layout, size, zoomHandler ) );
QPixmap pixmap( size.width(), size.height() );
pixmap.fill( Qt::white );
QPainter painter( &pixmap );
painter.setClipRect( pageRect );
painter.setRenderHint( QPainter::Antialiasing );
painter.translate( pageRect.topLeft() );
paintPage( painter, zoomHandler );
return pixmap;
}
wxRect wxPrinterDCImpl::GetPaperRect() const
{
wxCoord w, h;
GetOwner()->GetSize(&w, &h);
wxRect pageRect(0, 0, w, h);
wxOSXPrintData *native = (wxOSXPrintData*) m_printData.GetNativeData() ;
OSStatus err = noErr ;
PMRect rPaper;
err = PMGetAdjustedPaperRect(native->GetPageFormat(), &rPaper);
if ( err != noErr )
return pageRect;
wxSize ppi = GetOwner()->GetPPI();
rPaper.right *= (ppi.x / 72.0);
rPaper.bottom *= (ppi.y / 72.0);
rPaper.left *= (ppi.x / 72.0);
rPaper.top *= (ppi.y / 72.0);
return wxRect(wxCoord(rPaper.left), wxCoord(rPaper.top),
wxCoord(rPaper.right - rPaper.left), wxCoord(rPaper.bottom - rPaper.top));
}
void KWCanvasBase::clipToDocument(const KoShape *shape, QPointF &move) const
{
Q_ASSERT(shape);
const QPointF absPos = shape->absolutePosition();
const QPointF destination = absPos + move;
qreal bottomOfPage = 0.0;
KWPage page;
foreach (const KWPage &p, m_document->pageManager()->pages()) {
bottomOfPage += p.height();
if (bottomOfPage >= absPos.y())
page = p;
if (bottomOfPage >= destination.y()) {
page = p;
break;
}
}
if (!page.isValid()) { // shape was not in any page to begin with, can't propose anything sane...
move.setX(0);
move.setY(0);
return;
}
QRectF pageRect(page.rect().adjusted(5, 5, -5, -5));
QPainterPath path(shape->absoluteTransformation(0).map(shape->outline()));
QRectF shapeBounds = path.boundingRect();
shapeBounds.moveTopLeft(shapeBounds.topLeft() + move);
if (!shapeBounds.intersects(pageRect)) {
if (shapeBounds.left() > pageRect.right()) // need to move to the left some
move.setX(move.x() + (pageRect.right() - shapeBounds.left()));
else if (shapeBounds.right() < pageRect.left()) // need to move to the right some
move.setX(move.x() + pageRect.left() - shapeBounds.right());
if (shapeBounds.top() > pageRect.bottom()) // need to move up some
move.setY(move.y() + (pageRect.bottom() - shapeBounds.top()));
else if (shapeBounds.bottom() < pageRect.top()) // need to move down some
move.setY(move.y() + pageRect.top() - shapeBounds.bottom());
}
// Also make sure any anchoring restrictions are adhered to
KWFrameLayout::proposeShapeMove(shape, move, page);
}
void ChromeClientJS::scroll(const IntSize& delta, const IntRect& rectToScroll, const IntRect& clipRect)
{
webkitTrace();
if (m_view->m_private->acceleratedContext && m_view->m_private->acceleratedContext->enabled()) {
ASSERT(!rectToScroll.isEmpty());
ASSERT(delta.width() || delta.height());
m_view->m_private->acceleratedContext->scrollNonCompositedContents(rectToScroll, delta);
return;
}
m_rectsToScroll.append(rectToScroll);
m_scrollOffsets.append(delta);
// The code to calculate the scroll repaint region is originally from WebKit2.
// Get the part of the dirty region that is in the scroll rect.
Region dirtyRegionInScrollRect = intersect(rectToScroll, m_dirtyRegion);
if (!dirtyRegionInScrollRect.isEmpty()) {
// There are parts of the dirty region that are inside the scroll rect.
// We need to subtract them from the region, move them and re-add them.
Region dirtyRegion = Region(m_dirtyRegion);
dirtyRegion.subtract(rectToScroll);
m_dirtyRegion = dirtyRegion.bounds();
// Move the dirty parts.
Region movedDirtyRegionInScrollRect = intersect(translate(dirtyRegionInScrollRect, delta), rectToScroll);
// And add them back.
m_dirtyRegion.unite(movedDirtyRegionInScrollRect.bounds());
}
// Compute the scroll repaint region. We ensure that we are not subtracting areas
// that we've scrolled from outside the viewport from the repaint region.
IntRect onScreenScrollRect = rectToScroll;
onScreenScrollRect.intersect(IntRect(IntPoint(), enclosingIntRect(pageRect()).size()));
Region scrollRepaintRegion = subtract(rectToScroll, translate(onScreenScrollRect, delta));
m_dirtyRegion.unite(scrollRepaintRegion.bounds());
m_displayTimer.startOneShot(0);
}
void KPrPdfPrintJob::startPrinting(RemovePolicy removePolicy)
{
int fromPage = m_printer.fromPage() > 0 ? m_printer.fromPage() - 1: 0;
int toPage = m_printer.toPage() > 0 ? m_printer.toPage() - 1: m_pages.size() - 1;
Q_ASSERT( fromPage >= 0 && fromPage < m_pages.size() );
Q_ASSERT( toPage >= 0 && toPage < m_pages.size() );
KoZoomHandler zoomHandler;
zoomHandler.setResolution( m_printer.resolution(), m_printer.resolution() );
m_printer.setFullPage(true);
const KoPageLayout & firstLayout = m_pages.at(fromPage)->pageLayout();
m_printer.setPaperSize(QSizeF(firstLayout.width,firstLayout.height),QPrinter::Millimeter);
QPainter painter( &m_printer );
for ( int i = fromPage; i <= toPage; ++i ) {
KoPAPageBase *page = m_pages.at(i);
const KoPageLayout & layout = page->pageLayout();
m_printer.setPaperSize(QSizeF(layout.width,layout.height),QPrinter::Millimeter);
QSize size = m_printer.pageRect().size();
painter.save();
if (i != fromPage) {
m_printer.newPage();
}
KoPAUtil::setZoom(layout, size, zoomHandler);
QRect pageRect(KoPAUtil::pageRect( layout, size, zoomHandler));
painter.setClipRect( pageRect );
painter.setRenderHint( QPainter::Antialiasing );
painter.translate( pageRect.topLeft() );
m_pageProvider->setPageData(i + 1, page);
page->paintPage( painter, zoomHandler );
painter.restore();
}
if ( removePolicy == DeleteWhenDone ) {
deleteLater();
}
}
int QtopiaPrintEngine::metric(QPaintDevice::PaintDeviceMetric metricType) const
{
int val;
QRect r = d_func()->fullPage ? paperRect() : pageRect();
switch (metricType) {
case QPaintDevice::PdmWidth:
val = r.width();
break;
case QPaintDevice::PdmHeight:
val = r.height();
break;
case QPaintDevice::PdmDpiX:
val = d_func()->resolution;
break;
case QPaintDevice::PdmDpiY:
val = d_func()->resolution;
break;
case QPaintDevice::PdmPhysicalDpiX:
case QPaintDevice::PdmPhysicalDpiY:
val = QT_QWS_PRINTER_DEFAULT_DPI;
break;
case QPaintDevice::PdmWidthMM:
val = qRound(r.width()*25.4/d_func()->resolution);
break;
case QPaintDevice::PdmHeightMM:
val = qRound(r.height()*25.4/d_func()->resolution);
break;
case QPaintDevice::PdmNumColors:
val = 2;
break;
case QPaintDevice::PdmDepth:
val = 1;
break;
default:
qWarning("QtopiaPrintEngine::metric: Invalid metric command");
return 0;
}
return val;
}
//----------------------------------------------------------------------------
void Guido2Image::writeImage( QGuidoPainter * guidoPainter, const Params& p)
{
int page = p.pageIndex;
if (page < 0) page = 0;
else if ( page > guidoPainter->pageCount() ) page = guidoPainter->pageCount();
QRectF pictureRect = Guido2Image::getPictureRect( guidoPainter, page, p.sizeConstraints, p.zoom );
QPaintDevice * paintDevice = Guido2Image::getPaintDevice( pictureRect );
QPainter painter(paintDevice);
painter.setRenderHint( QPainter::Antialiasing );
if ( page )
guidoPainter->draw(&painter, page, pictureRect.toRect());
else
{
int pageCoordinateIncrement = 0;
for (int page = 1 ; page <= guidoPainter->pageCount() ; page++ )
{
int pageIncrementedDimension;
int x, y, width, height;
QSizeF pageSize = guidoPainter->pageSizeMM(page) * p.zoom;
pageIncrementedDimension = pageSize.width();
width = pageIncrementedDimension;
height = pictureRect.height();
x = pageCoordinateIncrement;
y = 0;
QRect pageRect( x , y , width , height );
guidoPainter->draw( &painter , page , pageRect , QRect() );
pageCoordinateIncrement += pageIncrementedDimension;
}
}
painter.end();
Guido2Image::save (paintDevice, p);
delete paintDevice;
}
// TODO create a lot of fancy options for printing
// e.g. print also notes
// For now we print to the center of the page honoring the margins
// The page is zoomed to be as big as possible
void KoPAPrintJob::startPrinting(RemovePolicy removePolicy)
{
int fromPage = m_printer.fromPage() ? m_printer.fromPage() - 1: 0;
int toPage = m_printer.toPage() ? m_printer.toPage() - 1: m_pages.size() - 1;
Q_ASSERT( fromPage >= 0 && fromPage < m_pages.size() );
Q_ASSERT( toPage >= 0 && toPage < m_pages.size() );
KoZoomHandler zoomHandler;
zoomHandler.setResolution( m_printer.resolution(), m_printer.resolution() );
QSize size = m_printer.pageRect().size();
QPainter painter( &m_printer );
for ( int i = fromPage; i <= toPage; ++i ) {
painter.save();
if (i != fromPage) {
m_printer.newPage();
}
KoPAPageBase * page = m_pages.at(i);
const KoPageLayout & layout = page->pageLayout();
KoPAUtil::setZoom( layout, size, zoomHandler );
QRect pageRect( KoPAUtil::pageRect( layout, size, zoomHandler ) );
painter.setClipRect( pageRect );
painter.setRenderHint( QPainter::Antialiasing );
painter.translate( pageRect.topLeft() );
page->paintPage( painter, zoomHandler );
painter.restore();
}
if ( removePolicy == DeleteWhenDone ) {
deleteLater();
}
}
void PrintContext::computePageRectsWithPageSizeInternal(const FloatSize& pageSizeInPixels, bool allowInlineDirectionTiling)
{
if (!m_frame->document() || !m_frame->view() || !m_frame->document()->renderView())
return;
RenderView* view = m_frame->document()->renderView();
IntRect docRect = view->documentRect();
int pageWidth = pageSizeInPixels.width();
int pageHeight = pageSizeInPixels.height();
bool isHorizontal = view->style()->isHorizontalWritingMode();
int docLogicalHeight = isHorizontal ? docRect.height() : docRect.width();
int pageLogicalHeight = isHorizontal ? pageHeight : pageWidth;
int pageLogicalWidth = isHorizontal ? pageWidth : pageHeight;
int inlineDirectionStart;
int inlineDirectionEnd;
int blockDirectionStart;
int blockDirectionEnd;
if (isHorizontal) {
if (view->style()->isFlippedBlocksWritingMode()) {
blockDirectionStart = docRect.maxY();
blockDirectionEnd = docRect.y();
} else {
blockDirectionStart = docRect.y();
blockDirectionEnd = docRect.maxY();
}
inlineDirectionStart = view->style()->isLeftToRightDirection() ? docRect.x() : docRect.maxX();
inlineDirectionEnd = view->style()->isLeftToRightDirection() ? docRect.maxX() : docRect.x();
} else {
if (view->style()->isFlippedBlocksWritingMode()) {
blockDirectionStart = docRect.maxX();
blockDirectionEnd = docRect.x();
} else {
blockDirectionStart = docRect.x();
blockDirectionEnd = docRect.maxX();
}
inlineDirectionStart = view->style()->isLeftToRightDirection() ? docRect.y() : docRect.maxY();
inlineDirectionEnd = view->style()->isLeftToRightDirection() ? docRect.maxY() : docRect.y();
}
unsigned pageCount = ceilf((float)docLogicalHeight / pageLogicalHeight);
for (unsigned i = 0; i < pageCount; ++i) {
int pageLogicalTop = blockDirectionEnd > blockDirectionStart ?
blockDirectionStart + i * pageLogicalHeight :
blockDirectionStart - (i + 1) * pageLogicalHeight;
if (allowInlineDirectionTiling) {
for (int currentInlinePosition = inlineDirectionStart;
inlineDirectionEnd > inlineDirectionStart ? currentInlinePosition < inlineDirectionEnd : currentInlinePosition > inlineDirectionEnd;
currentInlinePosition += (inlineDirectionEnd > inlineDirectionStart ? pageLogicalWidth : -pageLogicalWidth)) {
int pageLogicalLeft = inlineDirectionEnd > inlineDirectionStart ? currentInlinePosition : currentInlinePosition - pageLogicalWidth;
IntRect pageRect(pageLogicalLeft, pageLogicalTop, pageLogicalWidth, pageLogicalHeight);
if (!isHorizontal)
pageRect = pageRect.transposedRect();
m_pageRects.append(pageRect);
}
} else {
int pageLogicalLeft = inlineDirectionEnd > inlineDirectionStart ? inlineDirectionStart : inlineDirectionStart - pageLogicalWidth;
IntRect pageRect(pageLogicalLeft, pageLogicalTop, pageLogicalWidth, pageLogicalHeight);
if (!isHorizontal)
pageRect = pageRect.transposedRect();
m_pageRects.append(pageRect);
}
}
}
QVariant QtopiaPrintEngine::property(PrintEnginePropertyKey key) const
{
Q_D(const QtopiaPrintEngine);
QVariant ret;
switch (key) {
case PPK_CollateCopies:
ret = d->collateCopies;
break;
case PPK_ColorMode:
ret = d->colorMode;
break;
case PPK_Creator:
ret = d->creator;
break;
case PPK_DocumentName:
ret = d->docName;
break;
case PPK_FullPage:
ret = d->fullPage;
break;
case PPK_CopyCount: // fallthrough
case PPK_NumberOfCopies:
ret = d->numCopies;
break;
case PPK_SupportsMultipleCopies:
ret = false;
break;
case PPK_Orientation:
ret = d->orientation;
break;
case PPK_OutputFileName:
ret = d->outputFileName;
break;
case PPK_PageOrder:
ret = d->pageOrder;
break;
case PPK_PageRect:
ret = pageRect();
break;
case PPK_PaperSize:
ret = d->paperSize;
break;
case PPK_PaperRect:
ret = paperRect();
break;
case PPK_PaperSource:
ret = d->paperSource;
break;
case PPK_PrinterName:
ret = d->printerName;
break;
case PPK_PrinterProgram:
ret = d->printProgram;
break;
case PPK_Resolution:
ret = d->resolution;
break;
case PPK_SupportedResolutions:
ret = QList<QVariant>() << QT_QWS_PRINTER_DEFAULT_DPI;
break;
default:
break;
}
return ret;
}
void AP_FormatFrame_preview::draw(void)
{
GR_Painter painter(m_gc);
UT_sint32 iWidth = m_gc->tlu (getWindowWidth());
UT_sint32 iHeight = m_gc->tlu (getWindowHeight());
UT_Rect pageRect(m_gc->tlu(7), m_gc->tlu(7), iWidth - m_gc->tlu(14), iHeight - m_gc->tlu(14));
painter.fillRect(GR_Graphics::CLR3D_Background, 0, 0, iWidth, iHeight);
painter.clearArea(pageRect.left, pageRect.top, pageRect.width, pageRect.height);
UT_RGBColor tmpCol;
UT_RGBColor black(0, 0, 0);
m_gc->setLineWidth(m_gc->tlu(1));
int border = m_gc->tlu(20);
int cornerLength = m_gc->tlu(5);
//
// Draw the cell background
//
const gchar * pszBGCol = NULL;
if(m_pFormatFrame->getImage())
{
GR_Image * pImg = m_pFormatFrame->getImage();
FG_Graphic * pFG = m_pFormatFrame->getGraphic();
const char * szName = pFG->getDataId();
const UT_ByteBuf * pBB = static_cast<FG_GraphicRaster *>(pFG)->getBuffer();
if(pFG->getType() == FGT_Raster)
{
pImg = static_cast<GR_Image *>(
m_gc->createNewImage( szName,
pBB, pFG->getMimeType(),
pageRect.width - 2*border,
pageRect.height - 2*border,
GR_Image::GRT_Raster));
}
else
{
pImg = static_cast<GR_Image *>(
m_gc->createNewImage( szName,
pBB, pFG->getMimeType(),
pageRect.width - 2*border,
pageRect.height - 2*border,
GR_Image::GRT_Vector));
}
UT_Rect rec(pageRect.left + border, pageRect.top + border,
pageRect.width - 2*border, pageRect.height - 2*border);
painter.drawImage(pImg,pageRect.left + border, pageRect.top + border);
delete pImg;
}
else
{
m_pFormatFrame->getPropVector().getProp(static_cast<const gchar *>("background-color"), pszBGCol);
if (pszBGCol && *pszBGCol)
{
UT_parseColor(pszBGCol, tmpCol);
painter.fillRect(tmpCol, pageRect.left + border, pageRect.top + border, pageRect.width - 2*border, pageRect.height - 2*border);
}
}
//
// Draw the cell corners
//
m_gc->setColor(UT_RGBColor(127,127,127));
// top left corner
painter.drawLine(pageRect.left + border - cornerLength, pageRect.top + border,
pageRect.left + border, pageRect.top + border);
painter.drawLine(pageRect.left + border, pageRect.top + border - cornerLength,
pageRect.left + border, pageRect.top + border);
// top right corner
painter.drawLine(pageRect.left + pageRect.width - border + cornerLength, pageRect.top + border,
pageRect.left + pageRect.width - border, pageRect.top + border);
painter.drawLine(pageRect.left + pageRect.width - border, pageRect.top + border - cornerLength,
pageRect.left + pageRect.width - border, pageRect.top + border);
// bottom left corner
painter.drawLine(pageRect.left + border - cornerLength, pageRect.top + pageRect.height - border,
pageRect.left + border, pageRect.top + pageRect.height - border);
painter.drawLine(pageRect.left + border, pageRect.top + pageRect.height - border + cornerLength,
pageRect.left + border, pageRect.top + pageRect.height - border);
// bottom right corner
painter.drawLine(pageRect.left + pageRect.width - border + cornerLength, pageRect.top + pageRect.height - border,
pageRect.left + pageRect.width - border, pageRect.top + pageRect.height - border);
painter.drawLine(pageRect.left + pageRect.width - border, pageRect.top + pageRect.height - border + cornerLength,
pageRect.left + pageRect.width - border, pageRect.top + pageRect.height - border);
//
// Draw the cell borders
//
// right border
if (m_pFormatFrame->getRightToggled())
{
UT_sint32 linestyle = m_pFormatFrame->borderLineStyleRight();
if (linestyle == LS_DOTTED)
m_gc->setLineProperties(1, GR_Graphics::JOIN_MITER, GR_Graphics::CAP_BUTT, GR_Graphics::LINE_DOTTED);
else if (linestyle == LS_DASHED)
m_gc->setLineProperties(1, GR_Graphics::JOIN_MITER, GR_Graphics::CAP_BUTT, GR_Graphics::LINE_ON_OFF_DASH);
else
m_gc->setLineProperties(1, GR_Graphics::JOIN_MITER, GR_Graphics::CAP_BUTT, GR_Graphics::LINE_SOLID);
m_gc->setColor(m_pFormatFrame->borderColorRight());
UT_sint32 iRightThickness = UT_convertToLogicalUnits(m_pFormatFrame->getBorderThicknessRight().utf8_str());
m_gc->setLineWidth(iRightThickness);
painter.drawLine(pageRect.left + pageRect.width - border, pageRect.top + border,
pageRect.left + pageRect.width - border, pageRect.top + pageRect.height - border);
}
// left border
if (m_pFormatFrame->getLeftToggled())
{
UT_sint32 linestyle = m_pFormatFrame->borderLineStyleLeft();
if (linestyle == LS_DOTTED)
m_gc->setLineProperties(1, GR_Graphics::JOIN_MITER, GR_Graphics::CAP_BUTT, GR_Graphics::LINE_DOTTED);
else if (linestyle == LS_DASHED)
m_gc->setLineProperties(1, GR_Graphics::JOIN_MITER, GR_Graphics::CAP_BUTT, GR_Graphics::LINE_ON_OFF_DASH);
else
m_gc->setLineProperties(1, GR_Graphics::JOIN_MITER, GR_Graphics::CAP_BUTT, GR_Graphics::LINE_SOLID);
m_gc->setColor(m_pFormatFrame->borderColorLeft());
UT_sint32 iLeftThickness = UT_convertToLogicalUnits(m_pFormatFrame->getBorderThicknessLeft().utf8_str());
m_gc->setLineWidth(iLeftThickness);
painter.drawLine(pageRect.left + border, pageRect.top + border,
pageRect.left + border, pageRect.top + pageRect.height - border);
}
// top border
if (m_pFormatFrame->getTopToggled())
{
UT_sint32 linestyle = m_pFormatFrame->borderLineStyleTop();
if (linestyle == LS_DOTTED)
m_gc->setLineProperties(1, GR_Graphics::JOIN_MITER, GR_Graphics::CAP_BUTT, GR_Graphics::LINE_DOTTED);
else if (linestyle == LS_DASHED)
m_gc->setLineProperties(1, GR_Graphics::JOIN_MITER, GR_Graphics::CAP_BUTT, GR_Graphics::LINE_ON_OFF_DASH);
else
m_gc->setLineProperties(1, GR_Graphics::JOIN_MITER, GR_Graphics::CAP_BUTT, GR_Graphics::LINE_SOLID);
m_gc->setColor(m_pFormatFrame->borderColorTop());
UT_sint32 iTopThickness = UT_convertToLogicalUnits(m_pFormatFrame->getBorderThicknessTop().utf8_str());
m_gc->setLineWidth(iTopThickness);
painter.drawLine(pageRect.left + border, pageRect.top + border,
pageRect.left + pageRect.width - border, pageRect.top + border);
}
// bottom border
if (m_pFormatFrame->getBottomToggled())
{
UT_sint32 linestyle = m_pFormatFrame->borderLineStyleBottom();
if (linestyle == LS_DOTTED)
m_gc->setLineProperties(1, GR_Graphics::JOIN_MITER, GR_Graphics::CAP_BUTT, GR_Graphics::LINE_DOTTED);
else if (linestyle == LS_DASHED)
m_gc->setLineProperties(1, GR_Graphics::JOIN_MITER, GR_Graphics::CAP_BUTT, GR_Graphics::LINE_ON_OFF_DASH);
else
m_gc->setLineProperties(1, GR_Graphics::JOIN_MITER, GR_Graphics::CAP_BUTT, GR_Graphics::LINE_SOLID);
m_gc->setColor(m_pFormatFrame->borderColorBottom());
UT_sint32 iBottomThickness = UT_convertToLogicalUnits(m_pFormatFrame->getBorderThicknessBottom().utf8_str());
m_gc->setLineWidth(iBottomThickness);
painter.drawLine(pageRect.left + border, pageRect.top + pageRect.height - border,
pageRect.left + pageRect.width - border, pageRect.top + pageRect.height - border);
}
}
void AP_FormatTable_preview::draw(const UT_Rect *clip)
{
UT_UNUSED(clip);
GR_Painter painter(m_gc);
UT_sint32 iWidth = m_gc->tlu (getWindowWidth());
UT_sint32 iHeight = m_gc->tlu (getWindowHeight());
UT_Rect pageRect(m_gc->tlu(7), m_gc->tlu(7), iWidth - m_gc->tlu(14), iHeight - m_gc->tlu(14));
painter.fillRect(GR_Graphics::CLR3D_Background, 0, 0, iWidth, iHeight);
painter.clearArea(pageRect.left, pageRect.top, pageRect.width, pageRect.height);
UT_RGBColor tmpCol;
UT_RGBColor black(0, 0, 0);
m_gc->setLineWidth(m_gc->tlu(1));
int border = m_gc->tlu(20);
int cornerLength = m_gc->tlu(5);
//
// Draw the cell background
//
const gchar * pszBGCol = NULL;
if(m_pFormatTable->getImage())
{
GR_Image * pImg = m_pFormatTable->getImage();
FG_Graphic * pFG = m_pFormatTable->getGraphic();
const char * szName = pFG->getDataId();
const UT_ByteBuf * pBB = pFG->getBuffer();
if(pFG->getType() == FGT_Raster)
{
pImg = static_cast<GR_Image *>(
m_gc->createNewImage( szName,
pBB, pFG->getMimeType(),
pageRect.width - 2*border,
pageRect.height - 2*border,
GR_Image::GRT_Raster));
}
else
{
pImg = static_cast<GR_Image *>(
m_gc->createNewImage( szName,
pBB, pFG->getMimeType(),
pageRect.width - 2*border,
pageRect.height - 2*border,
GR_Image::GRT_Vector));
}
UT_Rect rec(pageRect.left + border, pageRect.top + border,
pageRect.width - 2*border, pageRect.height - 2*border);
painter.drawImage(pImg,pageRect.left + border, pageRect.top + border);
delete pImg;
}
else
{
m_pFormatTable->getPropVector().getProp(static_cast<const gchar *>("background-color"), pszBGCol);
if (pszBGCol && *pszBGCol)
{
UT_parseColor(pszBGCol, tmpCol);
painter.fillRect(tmpCol, pageRect.left + border, pageRect.top + border, pageRect.width - 2*border, pageRect.height - 2*border);
}
}
//
// Draw the cell corners
//
m_gc->setColor(UT_RGBColor(127,127,127));
// top left corner
painter.drawLine(pageRect.left + border - cornerLength, pageRect.top + border,
pageRect.left + border, pageRect.top + border);
painter.drawLine(pageRect.left + border, pageRect.top + border - cornerLength,
pageRect.left + border, pageRect.top + border);
// top right corner
painter.drawLine(pageRect.left + pageRect.width - border + cornerLength, pageRect.top + border,
pageRect.left + pageRect.width - border, pageRect.top + border);
painter.drawLine(pageRect.left + pageRect.width - border, pageRect.top + border - cornerLength,
pageRect.left + pageRect.width - border, pageRect.top + border);
// bottom left corner
painter.drawLine(pageRect.left + border - cornerLength, pageRect.top + pageRect.height - border,
pageRect.left + border, pageRect.top + pageRect.height - border);
painter.drawLine(pageRect.left + border, pageRect.top + pageRect.height - border + cornerLength,
pageRect.left + border, pageRect.top + pageRect.height - border);
// bottom right corner
painter.drawLine(pageRect.left + pageRect.width - border + cornerLength, pageRect.top + pageRect.height - border,
pageRect.left + pageRect.width - border, pageRect.top + pageRect.height - border);
painter.drawLine(pageRect.left + pageRect.width - border, pageRect.top + pageRect.height - border + cornerLength,
pageRect.left + pageRect.width - border, pageRect.top + pageRect.height - border);
//
// Draw the cell borders
//
// top border
if (m_pFormatTable->getTopToggled())
{
const gchar * pszTopColor = NULL;
m_pFormatTable->getPropVector().getProp("top-color", pszTopColor);
if (pszTopColor)
{
UT_parseColor(pszTopColor, tmpCol);
m_gc->setColor(tmpCol);
}
else
m_gc->setColor(black);
const gchar * pszTopThickness = NULL;
m_pFormatTable->getPropVector().getProp("top-thickness", pszTopThickness);
if(pszTopThickness)
{
UT_sint32 iTopThickness = UT_convertToLogicalUnits(pszTopThickness);
m_gc->setLineWidth(iTopThickness);
}
else
{
m_gc->setLineWidth(m_gc->tlu(1));
}
painter.drawLine(pageRect.left + border, pageRect.top + border,
pageRect.left + pageRect.width - border, pageRect.top + border);
}
// left border
if (m_pFormatTable->getLeftToggled())
{
const gchar * pszLeftColor = NULL;
m_pFormatTable->getPropVector().getProp("left-color", pszLeftColor);
if (pszLeftColor)
{
UT_parseColor(pszLeftColor, tmpCol);
m_gc->setColor(tmpCol);
}
else
m_gc->setColor(black);
const gchar * pszLeftThickness = NULL;
m_pFormatTable->getPropVector().getProp("left-thickness", pszLeftThickness);
if(pszLeftThickness)
{
UT_sint32 iLeftThickness = UT_convertToLogicalUnits(pszLeftThickness);
m_gc->setLineWidth(iLeftThickness);
}
else
{
m_gc->setLineWidth(m_gc->tlu(1));
}
painter.drawLine(pageRect.left + border, pageRect.top + border,
pageRect.left + border, pageRect.top + pageRect.height - border);
}
// right border
if (m_pFormatTable->getRightToggled())
{
const gchar * pszRightColor = NULL;
m_pFormatTable->getPropVector().getProp("right-color", pszRightColor);
if (pszRightColor)
{
UT_parseColor(pszRightColor, tmpCol);
m_gc->setColor(tmpCol);
}
else
m_gc->setColor(black);
const gchar * pszRightThickness = NULL;
m_pFormatTable->getPropVector().getProp("right-thickness", pszRightThickness);
if(pszRightThickness)
{
UT_sint32 iRightThickness = UT_convertToLogicalUnits(pszRightThickness);
m_gc->setLineWidth(iRightThickness);
}
else
{
m_gc->setLineWidth(m_gc->tlu(1));
}
painter.drawLine(pageRect.left + pageRect.width - border, pageRect.top + border,
pageRect.left + pageRect.width - border, pageRect.top + pageRect.height - border);
}
// bottom border
if (m_pFormatTable->getBottomToggled())
{
const gchar * pszBottomColor = NULL;
m_pFormatTable->getPropVector().getProp("bot-color", pszBottomColor);
if (pszBottomColor)
{
UT_parseColor(pszBottomColor, tmpCol);
m_gc->setColor(tmpCol);
}
else
m_gc->setColor(black);
const gchar * pszBotThickness = NULL;
m_pFormatTable->getPropVector().getProp("bot-thickness", pszBotThickness);
if(pszBotThickness)
{
UT_sint32 iBotThickness = UT_convertToLogicalUnits(pszBotThickness);
m_gc->setLineWidth(iBotThickness);
}
else
{
m_gc->setLineWidth(m_gc->tlu(1));
}
painter.drawLine(pageRect.left + border, pageRect.top + pageRect.height - border,
pageRect.left + pageRect.width - border, pageRect.top + pageRect.height - border);
}
}
bool KPrPageLayouts::loadOdf( KoPALoadingContext & context )
{
QHash<QString, KoXmlElement*> layouts = context.odfLoadingContext().stylesReader().presentationPageLayouts();
QHash<QString, KoXmlElement*>::iterator it( layouts.begin() );
// TODO need to use the correct page size
// we should check which layouts are already loaded
const QMap<QString, KoPAMasterPage *> & masterPages = context.masterPages();
if ( ! masterPages.isEmpty() ) {
KoPageLayout & layout = masterPages.begin().value()->pageLayout();
QRectF pageRect( 0, 0, layout.width, layout.height );
for ( ; it != layouts.end(); ++it ) {
KPrPageLayout * pageLayout = new KPrPageLayout();
if ( pageLayout->loadOdf( *( it.value() ), pageRect ) ) {
QMap<KPrPageLayoutWrapper, KPrPageLayout *>::const_iterator it( m_pageLayouts.constFind( KPrPageLayoutWrapper( pageLayout ) ) );
if ( it != m_pageLayouts.constEnd() ) {
delete pageLayout;
}
else {
m_pageLayouts.insert( KPrPageLayoutWrapper( pageLayout ), pageLayout );
}
}
else {
delete pageLayout;
}
}
}
// handel default styles
layouts = context.odfLoadingContext().defaultStylesReader().presentationPageLayouts();
it = layouts.begin();
QList<KPrPageLayout *> defaultLayouts;
for ( ; it != layouts.end(); ++it ) {
KPrPageLayout * pageLayout = new KPrPageLayout();
// this is not used but needed
QRectF pageRect( 0, 0, 800, 600 );
if ( pageLayout->loadOdf( *( it.value() ), pageRect ) ) {
defaultLayouts.append( pageLayout );
}
else {
delete pageLayout;
}
}
QList<KPrPageLayout *> documentLayouts = m_pageLayouts.values();
qSort( documentLayouts.begin(), documentLayouts.end(), compareLayouts );
qSort( defaultLayouts.begin(), defaultLayouts.end(), compareLayouts );
QList<KPrPageLayout *>::const_iterator docIt = documentLayouts.constBegin();
QList<KPrPageLayout *>::const_iterator defaultIt = defaultLayouts.constBegin();
while ( defaultIt != defaultLayouts.constEnd() ) {
if ( docIt == documentLayouts.constEnd() || compareLayouts( *defaultIt, *docIt ) ) {
m_pageLayouts.insert( KPrPageLayoutWrapper( *defaultIt ), *defaultIt );
++defaultIt;
}
else if ( compareLayouts( *docIt, *defaultIt ) ) {
++docIt;
}
else {
// it already exist
++docIt;
++defaultIt;
}
}
return true;
}
void PrintContext::computePageRectsWithPageSizeInternal(
const FloatSize& pageSizeInPixels) {
if (!m_frame->document() || !m_frame->view() ||
m_frame->document()->layoutViewItem().isNull())
return;
LayoutViewItem view = m_frame->document()->layoutViewItem();
IntRect docRect = view.documentRect();
int pageWidth = pageSizeInPixels.width();
// We scaled with floating point arithmetic and need to ensure results like
// 13329.99 are treated as 13330 so that we don't mistakenly assign an extra
// page for the stray pixel.
int pageHeight = pageSizeInPixels.height() + LayoutUnit::epsilon();
bool isHorizontal = view.style()->isHorizontalWritingMode();
int docLogicalHeight = isHorizontal ? docRect.height() : docRect.width();
int pageLogicalHeight = isHorizontal ? pageHeight : pageWidth;
int pageLogicalWidth = isHorizontal ? pageWidth : pageHeight;
int inlineDirectionStart;
int inlineDirectionEnd;
int blockDirectionStart;
int blockDirectionEnd;
if (isHorizontal) {
if (view.style()->isFlippedBlocksWritingMode()) {
blockDirectionStart = docRect.maxY();
blockDirectionEnd = docRect.y();
} else {
blockDirectionStart = docRect.y();
blockDirectionEnd = docRect.maxY();
}
inlineDirectionStart =
view.style()->isLeftToRightDirection() ? docRect.x() : docRect.maxX();
inlineDirectionEnd =
view.style()->isLeftToRightDirection() ? docRect.maxX() : docRect.x();
} else {
if (view.style()->isFlippedBlocksWritingMode()) {
blockDirectionStart = docRect.maxX();
blockDirectionEnd = docRect.x();
} else {
blockDirectionStart = docRect.x();
blockDirectionEnd = docRect.maxX();
}
inlineDirectionStart =
view.style()->isLeftToRightDirection() ? docRect.y() : docRect.maxY();
inlineDirectionEnd =
view.style()->isLeftToRightDirection() ? docRect.maxY() : docRect.y();
}
unsigned pageCount = ceilf((float)docLogicalHeight / pageLogicalHeight);
for (unsigned i = 0; i < pageCount; ++i) {
int pageLogicalTop =
blockDirectionEnd > blockDirectionStart
? blockDirectionStart + i * pageLogicalHeight
: blockDirectionStart - (i + 1) * pageLogicalHeight;
int pageLogicalLeft = inlineDirectionEnd > inlineDirectionStart
? inlineDirectionStart
: inlineDirectionStart - pageLogicalWidth;
IntRect pageRect(pageLogicalLeft, pageLogicalTop, pageLogicalWidth,
pageLogicalHeight);
if (!isHorizontal)
pageRect = pageRect.transposedRect();
m_pageRects.append(pageRect);
}
}
void DocumentWidget::paintEvent(QPaintEvent *e)
{
#ifdef DEBUG_DOCUMENTWIDGET
kdDebug(1223) << "DocumentWidget::paintEvent() called" << endl;
#endif
// Check if this widget is really visible to the user. If not, there
// is nothing to do. Remark: if we don't do this, then under QT
// 3.2.3 the following happens: when the user changes the zoom
// value, all those widgets are updated which the user has EVER
// seen, not just those that are visible at the moment. If the
// document contains several thousand pages, it is easily possible
// that this means that a few hundred of these are re-painted (which
// takes substantial time) although perhaps only three widgets are
// visible and *should* be updated. I believe this is some error in
// QT, but I am not positive about that ---Stefan Kebekus.
if (!isVisible())
{
//kdDebug() << "widget of page " << pageNr << " is not visible. Abort rendering" << endl;
kapp->processEvents();
return;
}
QPainter p(this);
p.setClipRegion(e->region());
// Paint a black border around the widget
p.setRasterOp(Qt::CopyROP);
p.setBrush(NoBrush);
p.setPen(Qt::black);
QRect outlineRect = pageRect();
outlineRect.addCoords(-1, -1, 1, 1);
p.drawRect(outlineRect);
// Paint page shadow
QColor backgroundColor = colorGroup().mid();
// (Re-)generate the Pixmaps for the shadow corners, if necessary
if (backgroundColor != backgroundColorForCorners)
{
backgroundColorForCorners = backgroundColor;
QImage tmp(4, 4, 32);
for(int x=0; x<4; x++)
for(int y=0; y<4; y++)
tmp.setPixel(x, y, backgroundColor.light(bottom_right_corner[x+4*y]).rgb() );
BRShadow->convertFromImage(tmp);
for(int x=0; x<4; x++)
for(int y=0; y<4; y++)
tmp.setPixel(x, y, backgroundColor.light(bottom_left_corner[x+4*y]).rgb() );
BLShadow->convertFromImage(tmp);
URShadow->convertFromImage(tmp.mirror(true, true));
}
// Draw right and bottom shadows
for(int i=0; i<4; i++)
{
p.setPen(backgroundColor.light(shadow_strip[i]));
// Right shadow
p.drawLine(pageSize().width()+i+2, 8, pageSize().width()+i+2, pageSize().height()+2);
// Bottom shadow
p.drawLine(8, pageSize().height()+i+2, pageSize().width()+2, pageSize().height()+i+2);
}
// Draw shadow corners
p.drawPixmap(pageSize().width()+2, pageSize().height()+2, *BRShadow);
p.drawPixmap(4, pageSize().height()+2, *BLShadow);
p.drawPixmap(pageSize().width()+2, 4, *URShadow);
// Draw corners
p.fillRect(0, pageSize().height()+2, 4, 4, backgroundColor);
p.fillRect(pageSize().width()+2, 0, 4, 4, backgroundColor);
if (!documentCache->isPageCached(pageNr, pageSize()))
{
QRect destRect = e->rect().intersect(pageRect());
if (KVSPrefs::changeColors() && KVSPrefs::renderMode() == KVSPrefs::EnumRenderMode::Paper)
p.fillRect(destRect, KVSPrefs::paperColor());
else
p.fillRect(destRect, Qt::white);
// Draw busy indicator.
// Im not really sure if this is a good idea.
// While it is nice to see an indication that something is happening for pages which
// take long to redraw, it gets quite annoing for fast redraws.
// TODO: Disable or find something less distractiong.
p.drawPixmap(10, 10, *busyIcon);
if (!pixmapRequested)
{
// Request page pixmap.
pixmapRequested = true;
QTimer::singleShot(50, this, SLOT(delayedRequestPage()));
}
return;
}
RenderedDocumentPagePixmap *pageData = documentCache->getPage(pageNr);
if (pageData == 0) {
#ifdef DEBUG_DOCUMENTWIDGET
kdDebug(1223) << "DocumentWidget::paintEvent: no documentPage generated" << endl;
#endif
return;
}
QMemArray<QRect> damagedRects = e->region().rects();
for (unsigned int i = 0; i < damagedRects.count(); i++)
{
// Paint the page where it intersects with the damaged area.
QRect destRect = damagedRects[i].intersect(pageRect());
// The actual page starts at point (1,1) because of the outline.
// Therefore we need to shift the destination rectangle.
QRect pixmapRect = destRect;
pixmapRect.moveBy(-1,-1);
if (KVSPrefs::changeColors() && KVSPrefs::renderMode() != KVSPrefs::EnumRenderMode::Paper)
{
// Paint widget contents with accessibility changes.
QPixmap pdpix = pageData->accessiblePixmap();
bitBlt ( this, destRect.topLeft(), &pdpix, pixmapRect, CopyROP);
}
else
{
// Paint widget contents
bitBlt ( this, destRect.topLeft(), pageData, pixmapRect, CopyROP);
}
}
// Underline hyperlinks
if (KVSPrefs::underlineLinks() == KVSPrefs::EnumUnderlineLinks::Enabled ||
KVSPrefs::underlineLinks() == KVSPrefs::EnumUnderlineLinks::OnlyOnHover)
{
int h = 2; // Height of line.
for(int i = 0; i < (int)pageData->hyperLinkList.size(); i++)
{
if (KVSPrefs::underlineLinks() == KVSPrefs::EnumUnderlineLinks::OnlyOnHover &&
i != indexOfUnderlinedLink)
continue;
int x = pageData->hyperLinkList[i].box.left();
int w = pageData->hyperLinkList[i].box.width();
int y = pageData->hyperLinkList[i].baseline;
QRect hyperLinkRect(x, y, w, h);
if (hyperLinkRect.intersects(e->rect()))
{
#ifdef DEBUG_DOCUMENTWIDGET
kdDebug(1223) << "Underline hyperlink \"" << pageData->hyperLinkList[i].linkText << "\"" << endl;
#endif
p.fillRect(x, y, w, h, KGlobalSettings::linkColor());
}
}
}
// Paint flashing frame, if appropriate
if (animationCounter > 0 && animationCounter < 10)
{
int gbChannel = 255 - (9-animationCounter)*28;
p.setPen(QPen(QColor(255, gbChannel, gbChannel), 3));
p.drawRect(linkFlashRect());
}
// Mark selected text.
TextSelection selection = documentCache->selectedText();
if ((selection.getPageNumber() != 0) && (selection.getPageNumber() == pageNr))
{
if (selectionNeedsUpdating)
{
//The zoom value has changed, therefore we need to recalculate
//the selected region.
selectedRegion = pageData->selectedRegion(selection);
selectionNeedsUpdating = false;
}
p.setPen(NoPen);
p.setBrush(white);
p.setRasterOp(Qt::XorROP);
QMemArray<QRect> selectionRects = selectedRegion.rects();
for (unsigned int i = 0; i < selectionRects.count(); i++)
p.drawRect(selectionRects[i]);
}
// Draw scroll Guide
if (scrollGuide >= 0)
{
// Don't draw over the page shadow
p.setClipRegion(e->region().intersect(pageRect()));
p.setRasterOp(Qt::CopyROP);
p.setPen(Qt::red);
p.drawLine(1, scrollGuide, pageSize().width(), scrollGuide);
}
}
