void PluginView::paint(GraphicsContext* context, const IntRect& dirtyRect)
{
if (!m_plugin || !m_isInitialized)
return;
if (context->paintingDisabled()) {
if (context->updatingControlTints())
m_plugin->updateControlTints(context);
return;
}
// FIXME: We should try to intersect the dirty rect with the plug-in's clip rect here.
IntRect paintRect = IntRect(IntPoint(), frameRect().size());
if (paintRect.isEmpty())
return;
if (m_snapshot) {
m_snapshot->paint(*context, contentsScaleFactor(), frameRect().location(), m_snapshot->bounds());
return;
}
GraphicsContextStateSaver stateSaver(*context);
// Translate the coordinate system so that the origin is in the top-left corner of the plug-in.
context->translate(frameRect().location().x(), frameRect().location().y());
m_plugin->paint(context, paintRect);
}
/*!
Draw the border of the canvas
\param painter Painter
*/
void QwtPlotGLCanvas::drawBorder( QPainter *painter )
{
const int fw = frameWidth();
if ( fw <= 0 )
return;
if ( frameShadow() == QwtPlotGLCanvas::Plain )
{
qDrawPlainRect( painter, frameRect(),
palette().shadow().color(), lineWidth() );
}
else
{
if ( frameShape() == QwtPlotGLCanvas::Box )
{
qDrawShadeRect( painter, frameRect(), palette(),
frameShadow() == Sunken, lineWidth(), midLineWidth() );
}
else
{
qDrawShadePanel( painter, frameRect(), palette(),
frameShadow() == Sunken, lineWidth() );
}
}
}
/*
* this function switches to a stack ;)
*/
void OWidgetStack::switchStack() {
if (m_stack ) {
m_stack->setGeometry( frameRect() );
return;
}
m_mode = SmallScreen;
m_stack = new QWidgetStack(this);
m_stack->setGeometry( frameRect() );
m_stack->show();
connect(m_stack, SIGNAL(aboutToShow(QWidget*) ),
this, SIGNAL(aboutToShow(QWidget*) ) );
connect(m_stack, SIGNAL(aboutToShow(int) ),
this, SIGNAL(aboutToShow(int) ) );
/* now reparent the widgets... luckily QWidgetSatck does most of the work */
if (m_list.isEmpty() )
return;
QMap<int, QWidget*>::Iterator it = m_list.begin();
for ( ; it != m_list.end(); ++it )
m_stack->addWidget( it.data(), it.key() );
if ( m_mWidget )
m_stack->raiseWidget( m_mWidget );
}
void PluginView::updatePluginWidget()
{
if (!parent())
return;
ASSERT(parent()->isFrameView());
FrameView* frameView = toFrameView(parent());
IntRect oldWindowRect = m_windowRect;
IntRect oldClipRect = m_clipRect;
m_windowRect = IntRect(frameView->contentsToWindow(frameRect().location()), frameRect().size());
m_clipRect = windowClipRect();
m_clipRect.move(-m_windowRect.x(), -m_windowRect.y());
if (m_windowRect == oldWindowRect && m_clipRect == oldClipRect)
return;
if (m_status != PluginStatusLoadedSuccessfully)
return;
if (!m_isWindowed && !m_windowRect.isEmpty()) {
Display* display = getPluginDisplay(nullptr);
if (m_drawable)
XFreePixmap(display, m_drawable);
m_drawable = XCreatePixmap(display, getRootWindow(m_parentFrame.get()),
m_windowRect.width(), m_windowRect.height(),
((NPSetWindowCallbackStruct*)m_npWindow.ws_info)->depth);
XSync(display, false); // make sure that the server knows about the Drawable
}
setNPWindowIfNeeded();
}
/*
* we will switch to top level mode
* reparent the list of widgets and then delete the stack
*/
void OWidgetStack::switchTop() {
m_mode = BigScreen;
/* this works because it is guaranteed that switchStack was called at least once*/
if (!m_stack && m_mWidget) {
m_mWidget->setGeometry( frameRect() );
return;
}else if (!m_stack)
return;
if (!m_list.isEmpty() ) {
QMap<int, QWidget*>::Iterator it = m_list.begin();
for ( ; it != m_list.end(); ++it ) {
/* better than reparenting twice */
if ( it.data() == m_mWidget ) {
m_mWidget->reparent(this, 0, frameRect().topLeft() );
m_mWidget->setGeometry( frameRect() );
m_mWidget->show();
}else
/* ### FIXME we need to place the widget better */
it.data()->reparent(0, WType_TopLevel, QPoint(10, 10) );
}
}
delete m_stack;
m_stack = 0;
}
/*!
Draw the border of the plot canvas
\param painter Painter
\sa setBorderRadius()
*/
void QwtPlotCanvas::drawBorder( QPainter *painter )
{
if ( d_data->borderRadius > 0 )
{
if ( frameWidth() > 0 )
{
QwtPainter::drawRoundedFrame( painter, QRectF( frameRect() ),
d_data->borderRadius, d_data->borderRadius,
palette(), frameWidth(), frameStyle() );
}
}
else
{
#if QT_VERSION >= 0x040500
#if QT_VERSION < 0x050000
QStyleOptionFrameV3 opt;
#else
QStyleOptionFrame opt;
#endif
opt.init(this);
int frameShape = frameStyle() & QFrame::Shape_Mask;
int frameShadow = frameStyle() & QFrame::Shadow_Mask;
opt.frameShape = QFrame::Shape( int( opt.frameShape ) | frameShape );
#if 0
opt.rect = frameRect();
#endif
switch (frameShape)
{
case QFrame::Box:
case QFrame::HLine:
case QFrame::VLine:
case QFrame::StyledPanel:
case QFrame::Panel:
{
opt.lineWidth = lineWidth();
opt.midLineWidth = midLineWidth();
break;
}
default:
{
opt.lineWidth = frameWidth();
break;
}
}
if ( frameShadow == Sunken )
opt.state |= QStyle::State_Sunken;
else if ( frameShadow == Raised )
opt.state |= QStyle::State_Raised;
style()->drawControl(QStyle::CE_ShapedFrame, &opt, painter, this);
#else
drawFrame( painter );
#endif
}
}
/*
RectanglesDrawEventHandler : Handles the draw events for the "Rectangles" window.
Parameter DescriptionsinHandler : A reference to the current handler call chain. This is passed to your handler so that you can call CallNextEventHandler if you need to.
inEvent : The event that triggered this call.
inUserData : The application-specific data you passed in to InstallEventHandler.
*/
OSStatus RectanglesDrawEventHandler (EventHandlerCallRef inHandler, EventRef inEvent, void* inUserData) {
OSStatus status = eventNotHandledErr;
CGContextRef context;
CGRect r;
//CallNextEventHandler in order to make sure the default handling of the inEvent
// (drawing the white background) happens
status = CallNextEventHandler( inHandler, inEvent );
require_noerr(status, CantCallNextEventHandler);
// Get the CGContextRef
status = GetEventParameter (inEvent,
kEventParamCGContextRef,
typeCGContextRef,
NULL,
sizeof (CGContextRef),
NULL,
&context);
require_noerr(status, CantGetEventParameter);
/* Set the stroke color to black. */
CGContextSetRGBStrokeColor(context, 0, 0, 0, 1);
r.size.height = 210;
r.origin.x = 20;
r.origin.y = 20;
r.size.width = 210;
frameRect(context, r);
r.size.height = 145;
r.origin.x = 75;
r.origin.y = 55;
r.size.width = 100;
frameRect(context, r);
/* Set the fill color to green. */
CGContextSetRGBFillColor(context, 0, 1, 0, 1);
r.size.height = 210;
r.origin.x = 270;
r.origin.y = 20;
r.size.width = 210;
paintRect(context, r);
/* Set the fill color to yellow. */
CGContextSetRGBFillColor(context, 1, 1, 0, 1);
r.size.height = 145;
r.origin.x = 325;
r.origin.y = 55;
r.size.width = 100;
paintRect(context, r);
CantCallNextEventHandler:
CantGetEventParameter:
return status;
}
/**
* @internal_resons
*/
void OWidgetStack::resizeEvent( QResizeEvent* ev ) {
QFrame::resizeEvent( ev );
if (m_mode == SmallScreen )
m_stack->setGeometry( frameRect() );
else
if (m_mWidget )
m_mWidget->setGeometry( frameRect() );
}
std::unique_ptr<FloatingObject> FloatingObject::copyToNewContainer(
LayoutSize offset,
bool shouldPaint,
bool isDescendant) const {
return WTF::wrapUnique(new FloatingObject(
layoutObject(), getType(),
LayoutRect(frameRect().location() - offset, frameRect().size()),
shouldPaint, isDescendant, isLowestNonOverhangingFloatInChild()));
}
void QGroupBox::paintEvent( QPaintEvent *event )
{
QPainter paint( this );
if ( lenvisible && !isCheckable() ) { // draw title
QFontMetrics fm = paint.fontMetrics();
int h = fm.height();
int tw = fm.width( str, lenvisible ) + fm.width(QChar(' '));
int x;
int marg = bFlat ? 0 : 8;
if ( align & AlignHCenter ) // center alignment
x = frameRect().width()/2 - tw/2;
else if ( align & AlignRight ) // right alignment
x = frameRect().width() - tw - marg;
else if ( align & AlignLeft ) // left alignment
x = marg;
else { // auto align
if( QApplication::reverseLayout() )
x = frameRect().width() - tw - marg;
else
x = marg;
}
QRect r( x, 0, tw, h );
int va = style().styleHint(QStyle::SH_GroupBox_TextLabelVerticalAlignment, this);
if(va & AlignTop)
r.moveBy(0, fm.descent());
QColor pen( (QRgb) style().styleHint(QStyle::SH_GroupBox_TextLabelColor, this ) );
if (!style().styleHint(QStyle::SH_UnderlineAccelerator, this))
va |= NoAccel;
style().drawItem( &paint, r, ShowPrefix | AlignHCenter | va, colorGroup(),
isEnabled(), 0, str, -1, ownPalette() ? 0 : &pen );
paint.setClipRegion( event->region().subtract( r ) ); // clip everything but title
#ifndef QT_NO_CHECKBOX
} else if ( d->checkbox ) {
QRect cbClip = d->checkbox->geometry();
QFontMetrics fm = paint.fontMetrics();
cbClip.setX( cbClip.x() - fm.width(QChar(' ')) );
cbClip.setWidth( cbClip.width() + fm.width(QChar(' ')) );
paint.setClipRegion( event->region().subtract( cbClip ) );
#endif
}
if ( bFlat ) {
QRect fr = frameRect();
QPoint p1( fr.x(), fr.y() + 1 );
QPoint p2( fr.x() + fr.width(), p1.y() );
// ### This should probably be a style primitive.
qDrawShadeLine( &paint, p1, p2, colorGroup(), TRUE,
lineWidth(), midLineWidth() );
} else {
drawFrame(&paint);
}
drawContents( &paint ); // draw the contents
}
//! @todo add more frame types
void ClassName::drawFrame(QPainter *p)
{
if (frameShape() == QFrame::Box) {
if (frameShadow() == Plain)
qDrawPlainRect(p, frameRect(), d->frameColor, lineWidth());
else
qDrawShadeRect(p, frameRect(), palette(), frameShadow() == QFrame::Sunken,
lineWidth(), midLineWidth());
} else {
SuperClassName::drawFrame(p);
}
}
/*
* The following is assumed:
* (hadj && vadj) || (!hadj && !vadj)
*/
void ScrollView::setGtkAdjustments(GtkAdjustment* hadj, GtkAdjustment* vadj, bool resetValues)
{
ASSERT(!hadj == !vadj);
m_horizontalAdjustment = hadj;
m_verticalAdjustment = vadj;
// Reset the adjustments to a sane default
if (m_horizontalAdjustment) {
ScrollbarGtk* hScrollbar = reinterpret_cast<ScrollbarGtk*>(horizontalScrollbar());
if (hScrollbar)
hScrollbar->attachAdjustment(m_horizontalAdjustment);
ScrollbarGtk* vScrollbar = reinterpret_cast<ScrollbarGtk*>(verticalScrollbar());
if (vScrollbar)
vScrollbar->attachAdjustment(m_verticalAdjustment);
// We used to reset everything to 0 here, but when page cache
// is enabled we reuse FrameViews that are cached. Since their
// size is not going to change when being restored, (which is
// what would cause the upper limit in the adjusments to be
// set in the normal case), we make sure they are up-to-date
// here. This is needed for the parent scrolling widget to be
// able to report correct values.
m_horizontalAdjustment->lower = 0;
m_horizontalAdjustment->upper = resetValues ? 0 : frameRect().width();
m_horizontalAdjustment->value = resetValues ? 0 : scrollOffset().width();
gtk_adjustment_changed(m_horizontalAdjustment);
gtk_adjustment_value_changed(m_horizontalAdjustment);
m_verticalAdjustment->lower = 0;
m_verticalAdjustment->upper = resetValues ? 0 : frameRect().height();
m_verticalAdjustment->value = resetValues ? 0 : scrollOffset().height();
gtk_adjustment_changed(m_verticalAdjustment);
gtk_adjustment_value_changed(m_verticalAdjustment);
} else {
ScrollbarGtk* hScrollbar = reinterpret_cast<ScrollbarGtk*>(horizontalScrollbar());
if (hScrollbar)
hScrollbar->detachAdjustment();
ScrollbarGtk* vScrollbar = reinterpret_cast<ScrollbarGtk*>(verticalScrollbar());
if (vScrollbar)
vScrollbar->detachAdjustment();
}
/* reconsider having a scrollbar */
setHasVerticalScrollbar(false);
setHasHorizontalScrollbar(false);
}
void DProgressFrame::slideUsbSeclect() {
if (m_Active) {
return;
}
else {
m_Active=true;
}
this->layout()->setEnabled(false);
m_TopShadow->show();
m_ProcessLabel->setPixmap(QPixmap(""));
emit changedUsbSeclet();
int offsetx=frameRect().width(); //inherited from mother
int offsety=frameRect().height();//inherited from mother
m_SecondWidget->setGeometry(0, 0, offsetx, offsety);
offsetx=0;
//offsety=offsety;
//re-position the next widget outside/aside of the display area
QPoint pnext=m_SecondWidget->pos();
QPoint pnow=m_FirstWidget->pos();
m_FirstWidget->move(pnow.x(), pnow.y()- offsety + 64+ 36);
m_SecondWidget->move(pnext.x(), pnext.y() + 64+ 36);
//make it visible/show
m_SecondWidget->show();
m_SecondWidget->raise();
m_TopShadow->raise();
//animate both, the now and next widget to the side, using movie framework
QPropertyAnimation *animnow = new QPropertyAnimation(m_FirstWidget, "pos");
animnow->setDuration(m_Speed);
animnow->setEasingCurve(QEasingCurve::OutBack);
animnow->setStartValue(QPoint(pnow.x(), pnow.y()));
animnow->setEndValue(QPoint(offsetx+pnow.x(), -offsety+pnow.y() + 64 + 36));
QPropertyAnimation *animnext = new QPropertyAnimation(m_SecondWidget, "pos");
animnext->setDuration(m_Speed);
animnext->setEasingCurve(QEasingCurve::OutBack);
animnext->setStartValue(QPoint(pnext.x(), offsety+pnext.y()));
animnext->setEndValue(QPoint(pnext.x(), pnext.y() + 64+ 36));
m_AnimGroup = new QParallelAnimationGroup;
m_AnimGroup->addAnimation(animnow);
m_AnimGroup->addAnimation(animnext);
connect(m_AnimGroup, SIGNAL(finished()),this,SLOT(slideUsbDone()));
m_Active=true;
m_AnimGroup->start();
}
void StatsWidgetElement::paintEvent(QPaintEvent * /*ev*/)
{
QPen pen;
pen.setColor(QColor(0, 0, 0, 255));
QRect rect;
rect.setTopLeft(QPoint(BORDER_X, BORDER_Y));
rect.setWidth(frameRect().width() - BORDER_WIDTH);
rect.setHeight(frameRect().height() - BORDER_WIDTH);
QPainter p(this);
p.setPen(pen);
p.setRenderHint(QPainter::Antialiasing);
p.drawRoundRect(rect, 1000 / rect.width(), 1000 / rect.height());
}
QRect QFrame::contentsRect() const
{
QRect r = frameRect();
int w = frameWidth(); // total width
r.setRect( r.x()+w, r.y()+w, r.width()-w*2, r.height()-w*2 );
return r;
}
/*Init appearance models for new main tracks and cancel appearance models non-main tracks*/
void TrackAssociation::InitAppearanceModelForMainTracks()
{
cv::Rect frameRect(0,0,image_width,image_height);
for(std::vector<ObjSubTrack*>::iterator iter = this->subTrackVector.begin(); iter != this->subTrackVector.end(); ++iter)
{
ObjSubTrack *sub_track = *iter;
const DetectionModel &model = sub_track->detectionSubTrack.back();
assert(sub_track->isValid);
if(sub_track->main_in_track && sub_track->matched_len>=1)
{
if(!sub_track->appModel.valid)
{
//train app model
sub_track->appModel.SuperviseTraining(this->frame_pool.back(), model.ConvertToRect());
}
}else
{
if(sub_track->appModel.valid)
{
//cancel app model for non major tracks
sub_track->appModel.Clear();
}
}
}
}
nsresult
nsContentEventHandler::OnQueryEditorRect(nsQueryContentEvent* aEvent)
{
nsresult rv = Init(aEvent);
if (NS_FAILED(rv))
return rv;
nsIFrame* frame = mRootContent->GetPrimaryFrame();
NS_ENSURE_TRUE(frame, NS_ERROR_FAILURE);
// get rect for first frame
nsRect resultRect(nsPoint(0, 0), frame->GetRect().Size());
rv = ConvertToRootViewRelativeOffset(frame, resultRect);
NS_ENSURE_SUCCESS(rv, rv);
// account for any additional frames
while ((frame = frame->GetNextContinuation()) != nsnull) {
nsRect frameRect(nsPoint(0, 0), frame->GetRect().Size());
rv = ConvertToRootViewRelativeOffset(frame, frameRect);
NS_ENSURE_SUCCESS(rv, rv);
resultRect.UnionRect(resultRect, frameRect);
}
aEvent->mReply.mRect =
resultRect.ToOutsidePixels(mPresContext->AppUnitsPerDevPixel());
aEvent->mSucceeded = PR_TRUE;
return NS_OK;
}
/*!
\internal
Mostly for the sake of Q3Frame
*/
void QFrame::drawFrame(QPainter *p)
{
Q_D(QFrame);
QStyleOptionFrameV3 opt;
opt.init(this);
int frameShape = d->frameStyle & QFrame::Shape_Mask;
int frameShadow = d->frameStyle & QFrame::Shadow_Mask;
opt.frameShape = Shape(int(opt.frameShape) | frameShape);
opt.rect = frameRect();
switch (frameShape) {
case QFrame::Box:
case QFrame::HLine:
case QFrame::VLine:
case QFrame::StyledPanel:
case QFrame::Panel:
opt.lineWidth = d->lineWidth;
opt.midLineWidth = d->midLineWidth;
break;
default:
// most frame styles do not handle customized line and midline widths
// (see updateFrameWidth()).
opt.lineWidth = d->frameWidth;
break;
}
if (frameShadow == Sunken)
opt.state |= QStyle::State_Sunken;
else if (frameShadow == Raised)
opt.state |= QStyle::State_Raised;
style()->drawControl(QStyle::CE_ShapedFrame, &opt, p, this);
}
void RosegardenScrollView::updateBottomWidgetGeometry()
{
RG_DEBUG << "RosegardenScrollView::updateBottomWidgetGeometry" << endl;
if (!m_bottomWidget)
return ;
int bottomWidgetHeight = m_bottomWidget->sizeHint().height();
setContentsMargins(0, 0, 0, bottomWidgetHeight);
QRect r = frameRect();
int hScrollBarHeight = 0;
if (horizontalScrollBar()->isVisible())
hScrollBarHeight = horizontalScrollBar()->height() + 2; // + 2 offset needed to preserve border shadow
int vScrollBarWidth = 0;
if (verticalScrollBar()->isVisible())
vScrollBarWidth = verticalScrollBar()->width();
m_bottomWidget->setGeometry(r.x(),
r.y() + r.height() - bottomWidgetHeight - hScrollBarHeight,
r.width() - vScrollBarWidth,
bottomWidgetHeight);
if (bottomWidgetHeight != m_currentBottomWidgetHeight) {
emit bottomWidgetHeightChanged(bottomWidgetHeight);
m_currentBottomWidgetHeight = bottomWidgetHeight;
}
}
QRect SparqlTextEdit::lineNumbersRect() const
{
QRect frame = frameRect();
frame.adjust(frameWidth(), frameWidth(), -frameWidth(), -frameWidth());
frame.setWidth(qMin(frame.width(), leftMargin));
return frame;
}
void WebPluginContainerImpl::paint(GraphicsContext* gc, const IntRect& damageRect)
{
if (gc->paintingDisabled())
return;
if (!parent())
return;
// Don't paint anything if the plugin doesn't intersect the damage rect.
if (!frameRect().intersects(damageRect))
return;
gc->save();
ASSERT(parent()->isFrameView());
ScrollView* view = parent();
// The plugin is positioned in window coordinates, so it needs to be painted
// in window coordinates.
IntPoint origin = view->windowToContents(IntPoint(0, 0));
gc->translate(static_cast<float>(origin.x()), static_cast<float>(origin.y()));
#if WEBKIT_USING_SKIA
WebCanvas* canvas = gc->platformContext()->canvas();
#elif WEBKIT_USING_CG
WebCanvas* canvas = gc->platformContext();
#endif
IntRect windowRect =
IntRect(view->contentsToWindow(damageRect.location()), damageRect.size());
m_webPlugin->paint(canvas, windowRect);
gc->restore();
}
void StyledLabel::updateToolTip()
{
if (frameRect().width() - 2*frameWidth() < _layout.minimumWidth())
setToolTip(QString("<qt>%1</qt>").arg(Qt::escape(_layout.text()))); // only rich text gets wordwrapped!
else
setToolTip(QString());
}
void CGUITabControl::selectTab(core::position2d<s32> p)
{
IGUISkin* skin = Environment->getSkin();
IGUIFont* font = skin->getFont();
core::rect<s32> frameRect(AbsoluteRect);
s32 tabheight = skin->getSize(gui::EGDS_BUTTON_HEIGHT);
frameRect.UpperLeftCorner.Y += 2;
frameRect.LowerRightCorner.Y = frameRect.UpperLeftCorner.Y + tabheight;
s32 pos = frameRect.UpperLeftCorner.X + 2;
for (u32 i=0; i<Tabs.size(); ++i)
{
// get Text
const wchar_t* text = 0;
if (Tabs[i])
text = Tabs[i]->getText();
// get text length
s32 len = 20;
if (font)
len += font->getDimension(text).Width;
frameRect.UpperLeftCorner.X = pos;
frameRect.LowerRightCorner.X = frameRect.UpperLeftCorner.X + len;
pos += len;
if (frameRect.isPointInside(p))
{
setActiveTab(i);
return;
}
}
}
void UBDocumentThumbnailWidget::dragMoveEvent(QDragMoveEvent *event)
{
QRect boundingFrame = frameRect();
//setting up automatic scrolling
const int SCROLL_DISTANCE = 16;
int bottomDist = boundingFrame.bottom() - event->pos().y(), topDist = boundingFrame.top() - event->pos().y();
if(qAbs(bottomDist) <= SCROLL_DISTANCE)
{
mScrollMagnitude = (SCROLL_DISTANCE - bottomDist)*4;
if(verticalScrollBar()->isVisible() && !mScrollTimer->isActive()) mScrollTimer->start(100);
}
else if(qAbs(topDist) <= SCROLL_DISTANCE)
{
mScrollMagnitude = (- SCROLL_DISTANCE - topDist)*4;
if(verticalScrollBar()->isVisible() && !mScrollTimer->isActive()) mScrollTimer->start(100);
}
else
{
mScrollMagnitude = 0;
mScrollTimer->stop();
}
QList<UBSceneThumbnailPixmap*> pixmapItems;
foreach (QGraphicsItem *item, scene()->items(mapToScene(boundingFrame)))
{
UBSceneThumbnailPixmap* sceneItem = dynamic_cast<UBSceneThumbnailPixmap*>(item);
if (sceneItem)
pixmapItems.append(sceneItem);
}
void ScopeViewBase::paintEvent( QPaintEvent * event )
{
QRect r = event->rect();
if (b_needRedraw)
{
//CALLGRIND_TOGGLE_COLLECT();
updateOutputHeight();
QPainter p;
m_pixmap->fill( paletteBackgroundColor() );
p.begin(m_pixmap);
p.setClipRegion(event->region());
//let the subclass draw the background (grids, etc.)
drawBackground(p);
// drawProbeMap(p, Oscilloscope::self()->m_logicProbeDataMap);
// drawProbeMap(p, Oscilloscope::self()->m_floatingProbeDataMap);
p.setPen(Qt::black);
p.drawRect( frameRect() );
b_needRedraw = false;
//CALLGRIND_TOGGLE_COLLECT();
}
bitBlt( this, r.x(), r.y(), m_pixmap, r.x(), r.y(), r.width(), r.height() );
}
void WEBPImageDecoder::initializeNewFrame(size_t index) {
if (!(m_formatFlags & ANIMATION_FLAG)) {
ASSERT(!index);
return;
}
WebPIterator animatedFrame;
WebPDemuxGetFrame(m_demux, index + 1, &animatedFrame);
ASSERT(animatedFrame.complete == 1);
ImageFrame* buffer = &m_frameBufferCache[index];
IntRect frameRect(animatedFrame.x_offset, animatedFrame.y_offset,
animatedFrame.width, animatedFrame.height);
buffer->setOriginalFrameRect(
intersection(frameRect, IntRect(IntPoint(), size())));
buffer->setDuration(animatedFrame.duration);
buffer->setDisposalMethod(animatedFrame.dispose_method ==
WEBP_MUX_DISPOSE_BACKGROUND
? ImageFrame::DisposeOverwriteBgcolor
: ImageFrame::DisposeKeep);
buffer->setAlphaBlendSource(animatedFrame.blend_method == WEBP_MUX_BLEND
? ImageFrame::BlendAtopPreviousFrame
: ImageFrame::BlendAtopBgcolor);
buffer->setRequiredPreviousFrameIndex(
findRequiredPreviousFrame(index, !animatedFrame.has_alpha));
WebPDemuxReleaseIterator(&animatedFrame);
}
/*!
\since 5.5
Initializes \a option with the values from this QFrame. This method is
useful for subclasses when they need a QStyleOptionFrame but don't want to
fill in all the information themselves.
\sa QStyleOption::initFrom()
*/
void QFrame::initStyleOption(QStyleOptionFrame *option) const
{
if (!option)
return;
Q_D(const QFrame);
option->initFrom(this);
int frameShape = d->frameStyle & QFrame::Shape_Mask;
int frameShadow = d->frameStyle & QFrame::Shadow_Mask;
option->frameShape = Shape(int(option->frameShape) | frameShape);
option->rect = frameRect();
switch (frameShape) {
case QFrame::Box:
case QFrame::HLine:
case QFrame::VLine:
case QFrame::StyledPanel:
case QFrame::Panel:
option->lineWidth = d->lineWidth;
option->midLineWidth = d->midLineWidth;
break;
default:
// most frame styles do not handle customized line and midline widths
// (see updateFrameWidth()).
option->lineWidth = d->frameWidth;
break;
}
if (frameShadow == Sunken)
option->state |= QStyle::State_Sunken;
else if (frameShadow == Raised)
option->state |= QStyle::State_Raised;
}
/*!
Virtual function that draws the mask of the frame's frame.
If you reimplemented drawFrame(QPainter*) and your widget should
support transparency you probably have to re-implement this function as well.
\sa drawFrame(), updateMask(), QWidget::setAutoMask(), QPainter::setClipRect()
*/
void QFrame::drawFrameMask( QPainter* p )
{
QPoint p1, p2;
QRect r = frameRect();
int type = fstyle & MShape;
int style = fstyle & MShadow;
#ifdef QT_NO_DRAWUTIL
p->setPen( color1 );
p->drawRect( r ); //### a bit too simple
#else
QColorGroup g(color1, color1, color1, color1, color1, color1, color1, color1, color0);
switch ( type ) {
case Box:
if ( style == Plain )
qDrawPlainRect( p, r, g.foreground(), lwidth );
else
qDrawShadeRect( p, r, g, style == Sunken, lwidth,
midLineWidth() );
break;
case Panel:
if ( style == Plain )
qDrawPlainRect( p, r, g.foreground(), lwidth );
else
qDrawShadePanel( p, r, g, style == Sunken, lwidth );
break;
case WinPanel:
if ( style == Plain )
qDrawPlainRect( p, r, g.foreground(), wpwidth );
else
qDrawWinPanel( p, r, g, style == Sunken );
break;
case HLine:
case VLine:
if ( type == HLine ) {
p1 = QPoint( r.x(), r.height()/2 );
p2 = QPoint( r.x()+r.width(), p1.y() );
}
else {
p1 = QPoint( r.x()+r.width()/2, 0 );
p2 = QPoint( p1.x(), r.height() );
}
if ( style == Plain ) {
QPen oldPen = p->pen();
p->setPen( QPen(g.foreground(),lwidth) );
p->drawLine( p1, p2 );
p->setPen( oldPen );
}
else
qDrawShadeLine( p, p1, p2, g, style == Sunken,
lwidth, midLineWidth() );
break;
}
#endif // QT_NO_DRAWUTIL
}
void Scrollbar::paint(GraphicsContext* context, const IntRect& damageRect)
{
if (!frameRect().intersects(damageRect))
return;
if (!theme()->paint(this, context, damageRect))
Widget::paint(context, damageRect);
}
void Scrollbar::paint(GraphicsContext* context, const CullRect& cullRect) const
{
if (!cullRect.intersectsCullRect(frameRect()))
return;
if (!theme()->paint(this, context, cullRect))
Widget::paint(context, cullRect);
}