void ImageWindow::paintEvent(QPaintEvent *event)
{
QString timestamp;
QLabel::paintEvent(event);
QString timeFormat("hh:mm:ss:zzz");
QString dateFormat("ddd MMMM d yyyy");
QPainter painter(this);
QRect dr = drawingRect();
if (m_idle)
painter.fillRect(dr, Qt::Dense2Pattern);
if (m_selected) {
QPen pen(Qt::green, 3);
painter.setPen(pen);
painter.drawRect(dr);
}
if (!m_showDate && !m_showTime && !m_showName)
return;
painter.setPen(m_textColor);
int fontHeight = dr.height() / 20;
if (fontHeight < 8)
fontHeight = 8;
else if (fontHeight > 12)
fontHeight = 12;
painter.setFont(QFont("Arial", fontHeight));
if (m_showName)
painter.drawText(dr.left() + 4, dr.top() + fontHeight + 2, m_name);
if (m_showTime || m_showDate) {
if (dr.width() < 160) {
// only room for one, choose time over date
if (m_showDate && m_showTime)
timestamp = m_displayTime.toString(timeFormat);
else if (m_showDate)
timestamp = m_displayDate.toString(dateFormat);
else
timestamp = m_displayTime.toString(timeFormat);
}
else if (!m_showDate) {
timestamp = m_displayTime.toString(timeFormat);
}
else if (!m_showTime) {
timestamp = m_displayDate.toString(dateFormat);
}
else {
timestamp = m_displayDate.toString(dateFormat) + " " + m_displayTime.toString(timeFormat);
}
painter.drawText(dr.left() + 4, dr.bottom() - 2, timestamp);
}
}
void Interface::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
{
// draw a gradient background
QLinearGradient gradient(0, 0, 0, boundingRect().height());
if(m_drawHover)
{
gradient.setColorAt(0, color().lighter(110));
}
else
{
gradient.setColorAt(0, color());
}
int penWidth;
if(m_selected)
{
penWidth = SELECTED_PEN_WIDTH;
painter->setPen(QPen(QBrush(Qt::SolidPattern), penWidth));
}
else
{
penWidth = BORDER_PEN_WIDTH;
painter->setPen(QPen(QBrush(Qt::SolidPattern), penWidth));
}
gradient.setColorAt(1, Qt::white);
QBrush gradientBrush(gradient);
painter->setBrush(gradientBrush);
QRect drawingRect(boundingRect().x() + penWidth / 2, boundingRect().y() + penWidth / 2, boundingRect().width() - penWidth, boundingRect().height() - penWidth);
painter->drawRoundedRect(drawingRect, 5, 5);
// draw the name
// FIXME: figure out how to make the font hinting look optimal
painter->setPen(QPen());
painter->setFont(*m_font);
painter->drawText(drawingRect, Qt::AlignCenter, name());
}
void
gfxXlibNativeRenderer::Draw(gfxContext* ctx, nsIntSize size,
PRUint32 flags, Screen *screen, Visual *visual,
DrawOutput* result)
{
if (result) {
result->mSurface = NULL;
result->mUniformAlpha = false;
result->mUniformColor = false;
}
bool drawIsOpaque = (flags & DRAW_IS_OPAQUE) != 0;
gfxMatrix matrix = ctx->CurrentMatrix();
// We can only draw direct or onto a copied background if pixels align and
// native drawing is compatible with the current operator. (The matrix is
// actually also pixel-exact for flips and right-angle rotations, which
// would permit copying the background but not drawing direct.)
bool matrixIsIntegerTranslation = !matrix.HasNonIntegerTranslation();
bool canDrawOverBackground = matrixIsIntegerTranslation &&
ctx->CurrentOperator() == gfxContext::OPERATOR_OVER;
// The padding of 0.5 for non-pixel-exact transformations used here is
// the same as what _cairo_pattern_analyze_filter uses.
const gfxFloat filterRadius = 0.5;
gfxRect affectedRect(0.0, 0.0, size.width, size.height);
if (!matrixIsIntegerTranslation) {
// The filter footprint means that the affected rectangle is a
// little larger than the drawingRect;
affectedRect.Inflate(filterRadius);
NATIVE_DRAWING_NOTE("FALLBACK: matrix not integer translation");
} else if (!canDrawOverBackground) {
NATIVE_DRAWING_NOTE("FALLBACK: unsupported operator");
}
// Clipping to the region affected by drawing allows us to consider only
// the portions of the clip region that will be affected by drawing.
gfxRect clipExtents;
{
gfxContextAutoSaveRestore autoSR(ctx);
ctx->Clip(affectedRect);
clipExtents = ctx->GetClipExtents();
if (clipExtents.IsEmpty())
return; // nothing to do
if (canDrawOverBackground &&
DrawDirect(ctx, size, flags, screen, visual))
return;
}
nsIntRect drawingRect(nsIntPoint(0, 0), size);
// Drawing need only be performed within the clip extents
// (and padding for the filter).
if (!matrixIsIntegerTranslation) {
// The source surface may need to be a little larger than the clip
// extents due to the filter footprint.
clipExtents.Inflate(filterRadius);
}
clipExtents.RoundOut();
nsIntRect intExtents(PRInt32(clipExtents.X()),
PRInt32(clipExtents.Y()),
PRInt32(clipExtents.Width()),
PRInt32(clipExtents.Height()));
drawingRect.IntersectRect(drawingRect, intExtents);
gfxPoint offset(drawingRect.x, drawingRect.y);
DrawingMethod method;
nsRefPtr<gfxASurface> target = ctx->CurrentSurface();
nsRefPtr<gfxXlibSurface> tempXlibSurface =
CreateTempXlibSurface(target, drawingRect.Size(),
canDrawOverBackground, flags, screen, visual,
&method);
if (!tempXlibSurface)
return;
if (drawingRect.Size() != size || method == eCopyBackground) {
// Only drawing a portion, or copying background,
// so won't return a result.
result = NULL;
}
nsRefPtr<gfxContext> tmpCtx;
if (!drawIsOpaque) {
tmpCtx = new gfxContext(tempXlibSurface);
if (method == eCopyBackground) {
tmpCtx->SetOperator(gfxContext::OPERATOR_SOURCE);
tmpCtx->SetSource(target, -(offset + matrix.GetTranslation()));
// The copy from the tempXlibSurface to the target context should
// use operator SOURCE, but that would need a mask to bound the
// operation. Here we only copy opaque backgrounds so operator
// OVER will behave like SOURCE masked by the surface.
NS_ASSERTION(tempXlibSurface->GetContentType()
== gfxASurface::CONTENT_COLOR,
"Don't copy background with a transparent surface");
} else {
tmpCtx->SetOperator(gfxContext::OPERATOR_CLEAR);
}
tmpCtx->Paint();
}
if (!DrawOntoTempSurface(tempXlibSurface, -drawingRect.TopLeft())) {
return;
}
if (method != eAlphaExtraction) {
ctx->SetSource(tempXlibSurface, offset);
ctx->Paint();
if (result) {
result->mSurface = tempXlibSurface;
/* fill in the result with what we know, which is really just what our
assumption was */
result->mUniformAlpha = true;
result->mColor.a = 1.0;
}
return;
}
nsRefPtr<gfxImageSurface> blackImage =
CopyXlibSurfaceToImage(tempXlibSurface, gfxASurface::ImageFormatARGB32);
tmpCtx->SetDeviceColor(gfxRGBA(1.0, 1.0, 1.0));
tmpCtx->SetOperator(gfxContext::OPERATOR_SOURCE);
tmpCtx->Paint();
DrawOntoTempSurface(tempXlibSurface, -drawingRect.TopLeft());
nsRefPtr<gfxImageSurface> whiteImage =
CopyXlibSurfaceToImage(tempXlibSurface, gfxASurface::ImageFormatRGB24);
if (blackImage->CairoStatus() == CAIRO_STATUS_SUCCESS &&
whiteImage->CairoStatus() == CAIRO_STATUS_SUCCESS) {
gfxAlphaRecovery::Analysis analysis;
if (!gfxAlphaRecovery::RecoverAlpha(blackImage, whiteImage,
result ? &analysis : nullptr))
return;
ctx->SetSource(blackImage, offset);
/* if the caller wants to retrieve the rendered image, put it into
a 'similar' surface, and use that as the source for the drawing right
now. This means we always return a surface similar to the surface
used for 'cr', which is ideal if it's going to be cached and reused.
We do not return an image if the result has uniform color (including
alpha). */
if (result) {
if (analysis.uniformAlpha) {
result->mUniformAlpha = true;
result->mColor.a = analysis.alpha;
}
if (analysis.uniformColor) {
result->mUniformColor = true;
result->mColor.r = analysis.r;
result->mColor.g = analysis.g;
result->mColor.b = analysis.b;
} else {
result->mSurface = target->
CreateSimilarSurface(gfxASurface::CONTENT_COLOR_ALPHA,
gfxIntSize(size.width, size.height));
gfxContext copyCtx(result->mSurface);
copyCtx.SetSource(blackImage);
copyCtx.SetOperator(gfxContext::OPERATOR_SOURCE);
copyCtx.Paint();
ctx->SetSource(result->mSurface);
}
}
ctx->Paint();
}
}
NS_IMETHODIMP
nsSimplePageSequenceFrame::PrintNextPage()
{
// Print each specified page
// pageNum keeps track of the current page and what pages are printing
//
// printedPageNum keeps track of the current page number to be printed
// Note: When print al the pages or a page range the printed page shows the
// actual page number, when printing selection it prints the page number starting
// with the first page of the selection. For example if the user has a
// selection that starts on page 2 and ends on page 3, the page numbers when
// print are 1 and then two (which is different than printing a page range, where
// the page numbers would have been 2 and then 3)
if (mCurrentPageFrame == nsnull) {
return NS_ERROR_FAILURE;
}
PRBool printEvenPages, printOddPages;
mPageData->mPrintSettings->GetPrintOptions(nsIPrintSettings::kPrintEvenPages, &printEvenPages);
mPageData->mPrintSettings->GetPrintOptions(nsIPrintSettings::kPrintOddPages, &printOddPages);
// Begin printing of the document
nsDeviceContext *dc = PresContext()->DeviceContext();
nsresult rv = NS_OK;
// See whether we should print this page
mPrintThisPage = PR_TRUE;
// If printing a range of pages check whether the page number is in the
// range of pages to print
if (mDoingPageRange) {
if (mPageNum < mFromPageNum) {
mPrintThisPage = PR_FALSE;
} else if (mPageNum > mToPageNum) {
mPageNum++;
mCurrentPageFrame = nsnull;
return NS_OK;
}
}
// Check for printing of odd and even pages
if (mPageNum & 0x1) {
if (!printOddPages) {
mPrintThisPage = PR_FALSE; // don't print odd numbered page
}
} else {
if (!printEvenPages) {
mPrintThisPage = PR_FALSE; // don't print even numbered page
}
}
if (nsIPrintSettings::kRangeSelection == mPrintRangeType) {
mPrintThisPage = PR_TRUE;
}
if (mPrintThisPage) {
// XXX This is temporary fix for printing more than one page of a selection
// This does a poor man's "dump" pagination (see Bug 89353)
// It has laid out as one long page and now we are just moving or view up/down
// one page at a time and printing the contents of what is exposed by the rect.
// currently this does not work for IFrames
// I will soon improve this to work with IFrames
PRBool continuePrinting = PR_TRUE;
nscoord width, height;
width = PresContext()->GetPageSize().width;
height = PresContext()->GetPageSize().height;
height -= mMargin.top + mMargin.bottom;
width -= mMargin.left + mMargin.right;
nscoord selectionY = height;
nsIFrame* conFrame = mCurrentPageFrame->GetFirstChild(nsnull);
if (mSelectionHeight >= 0) {
conFrame->SetPosition(conFrame->GetPosition() + nsPoint(0, -mYSelOffset));
nsContainerFrame::PositionChildViews(conFrame);
}
// cast the frame to be a page frame
nsPageFrame * pf = static_cast<nsPageFrame*>(mCurrentPageFrame);
pf->SetPageNumInfo(mPageNum, mTotalPages);
pf->SetSharedPageData(mPageData);
PRInt32 printedPageNum = 1;
while (continuePrinting) {
if (PresContext()->IsRootPaginatedDocument()) {
PR_PL(("\n"));
PR_PL(("***************** BeginPage *****************\n"));
rv = dc->BeginPage();
NS_ENSURE_SUCCESS(rv, rv);
}
PR_PL(("SeqFr::PrintNextPage -> %p PageNo: %d", pf, mPageNum));
nsRefPtr<nsRenderingContext> renderingContext;
dc->CreateRenderingContext(*getter_AddRefs(renderingContext));
NS_ENSURE_TRUE(renderingContext, NS_ERROR_OUT_OF_MEMORY);
#if defined(XP_UNIX) && !defined(XP_MACOSX)
// On linux, need to rotate landscape-mode output on printed surfaces
PRInt32 orientation;
mPageData->mPrintSettings->GetOrientation(&orientation);
if (nsIPrintSettings::kLandscapeOrientation == orientation) {
// Shift up by one landscape-page-height (in points) before we rotate.
float offset = POINTS_PER_INCH_FLOAT *
(mCurrentPageFrame->GetSize().height / float(dc->AppUnitsPerCSSInch()));
renderingContext->ThebesContext()->Translate(gfxPoint(offset, 0));
renderingContext->ThebesContext()->Rotate(M_PI/2);
}
#endif // XP_UNIX && !XP_MACOSX
nsRect drawingRect(nsPoint(0, 0),
mCurrentPageFrame->GetSize());
nsRegion drawingRegion(drawingRect);
nsLayoutUtils::PaintFrame(renderingContext, mCurrentPageFrame,
drawingRegion, NS_RGBA(0,0,0,0),
nsLayoutUtils::PAINT_SYNC_DECODE_IMAGES);
if (mSelectionHeight >= 0 && selectionY < mSelectionHeight) {
selectionY += height;
printedPageNum++;
pf->SetPageNumInfo(printedPageNum, mTotalPages);
conFrame->SetPosition(conFrame->GetPosition() + nsPoint(0, -height));
nsContainerFrame::PositionChildViews(conFrame);
PR_PL(("***************** End Page (PrintNextPage) *****************\n"));
rv = dc->EndPage();
NS_ENSURE_SUCCESS(rv, rv);
} else {
continuePrinting = PR_FALSE;
}
}
}
return rv;
}