void FlickCharm::deactivateFrom(QWidget *widget)
{
QAbstractScrollArea *scrollArea = qobject_cast<QAbstractScrollArea*>(widget);
if (scrollArea) {
QWidget *viewport = scrollArea->viewport();
viewport->removeEventFilter(this);
scrollArea->removeEventFilter(this);
delete d->flickData[viewport];
d->flickData.remove(viewport);
return;
}
QWebView *webView = qobject_cast<QWebView*>(widget);
if (webView) {
webView->removeEventFilter(this);
delete d->flickData[webView];
d->flickData.remove(webView);
return;
}
}
bool eventFilter(QObject *o, QEvent *e) {
switch (e->type()) {
case QEvent::MouseMove: {
if (notRelevant(e))
return false;
if (m_panning) {
const QPoint pos = static_cast<QMouseEvent*>(e)->pos();
bool noClick = !m_click;
if (noClick) {
const int dx = pos.x() - m_lastPos.x();
const int dy = pos.y() - m_lastPos.y();
if (QAbstractScrollArea *area = qobject_cast<QAbstractScrollArea*>(o->parent())) {
// dolphin stacks a graphicsview into a view inside a view ...
QAbstractScrollArea *runner = area;
while ((runner = qobject_cast<QAbstractScrollArea*>(runner->parent())))
area = runner;
if (dx && area->horizontalScrollBar())
area->horizontalScrollBar()->setValue(area->horizontalScrollBar()->value() - dx);
if (dy && area->verticalScrollBar()) {
area->verticalScrollBar()->setValue(area->verticalScrollBar()->value() - dy);
}
} else { // mostly QWebView
int factor[2] = {1, 1};
if (o->inherits("QWebView")) {
foreach (const QObject *o2, o->children()) {
if (o2->inherits("QWebPage")) {
foreach (const QObject *o3, o2->children()) {
if (o3->inherits("QWebFrame")) {
const QSize sz = o3->property("contentsSize").toSize();
if (sz.isValid()) {
const QSize wsz = static_cast<QWidget*>(o)->size();
factor[0] = qMin(6, qRound(float(sz.width()) / wsz.width()));
factor[1] = qMin(6, qRound(float(sz.height()) / wsz.height()));
}
break;
}
}
break;
}
}
}
if (dy) {
QWheelEvent wev(pos, dy*factor[1], Qt::NoButton, Qt::NoModifier, Qt::Vertical);
QApplication::sendEvent(o, &wev);
}
if (dx) {
QWheelEvent weh(pos, dx*factor[0], Qt::NoButton, Qt::NoModifier, Qt::Horizontal);
QApplication::sendEvent(o, &weh); // "oi wehh"
}
}
}
m_lastPos = pos;
// qDebug() << "mouse move" << m_click << QPoint(m_startPoint - m_lastPos) << QApplication::startDragDistance();
m_click = m_click && qAbs(QPoint(m_startPoint - m_lastPos).manhattanLength()) < QApplication::startDragDistance();
// qDebug() << "->" << m_click;
return true; // noClick;
}
return false;
}
static void createPlatformGraphicsContext3DFromWidget(QWidget* widget, PlatformGraphicsContext3D* context,
PlatformGraphicsSurface3D* surface)
{
*context = 0;
*surface = 0;
QAbstractScrollArea* scrollArea = qobject_cast<QAbstractScrollArea*>(widget);
if (!scrollArea)
return;
QGLWidget* glViewport = qobject_cast<QGLWidget*>(scrollArea->viewport());
if (!glViewport)
return;
QGLWidget* glWidget = new QGLWidget(0, glViewport);
if (glWidget->isValid()) {
// Geometry can be set to zero because m_glWidget is used only for its QGLContext.
glWidget->setGeometry(0, 0, 0, 0);
#if HAVE(QT5)
*surface = glWidget->windowHandle();
*context = glWidget->context()->contextHandle();
#else
*surface = glWidget;
*context = const_cast<QGLContext*>(glWidget->context());
#endif
} else {
delete glWidget;
glWidget = 0;
}
}
void KoCursorPrivate::setAutoHideCursor( QWidget *w, bool enable, bool customEventFilter )
{
if ( !w || !enabled )
return;
QWidget* viewport = 0;
QAbstractScrollArea * sv = qobject_cast<QAbstractScrollArea *>( w );
if ( sv )
viewport = sv->viewport();
if ( enable )
{
if ( m_eventFilters.contains( w ) )
return;
KoCursorPrivateAutoHideEventFilter* filter = new KoCursorPrivateAutoHideEventFilter( w );
m_eventFilters.insert( w, filter );
if (viewport) {
m_eventFilters.insert( viewport, filter );
connect(viewport, SIGNAL(destroyed(QObject*)), this, SLOT(slotViewportDestroyed(QObject*)));
}
if ( !customEventFilter ) {
w->installEventFilter( filter ); // for key events
if (viewport)
viewport->installEventFilter( filter ); // for mouse events
}
connect( w, SIGNAL(destroyed(QObject*)),
this, SLOT(slotWidgetDestroyed(QObject*)) );
}
else
{
void
TreeCanvas::scroll(int i) {
QAbstractScrollArea* sa =
static_cast<QAbstractScrollArea*>(parentWidget()->parentWidget());
double p = static_cast<double>(i)/100.0;
double xdiff = static_cast<double>(targetX-sourceX)*p;
double ydiff = static_cast<double>(targetY-sourceY)*p;
sa->horizontalScrollBar()->setValue(sourceX+static_cast<int>(xdiff));
sa->verticalScrollBar()->setValue(sourceY+static_cast<int>(ydiff));
}
// The widget which gets mouse events, and that shows the cursor
// (that is the viewport, for a QAbstractScrollArea)
QWidget* KoCursorPrivateAutoHideEventFilter::mouseWidget() const
{
QWidget* w = m_widget;
// Is w a QAbstractScrollArea ? Call setCursor on the viewport in that case.
QAbstractScrollArea * sv = qobject_cast<QAbstractScrollArea *>( w );
if ( sv )
w = sv->viewport();
return w;
}
void QDesignerFormBuilder::applyProperties(QObject *o, const QList<DomProperty*> &properties)
{
typedef QList<DomProperty*> DomPropertyList;
if (properties.empty())
return;
const QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(core()->extensionManager(), o);
const QDesignerDynamicPropertySheetExtension *dynamicSheet = qt_extension<QDesignerDynamicPropertySheetExtension*>(core()->extensionManager(), o);
const bool changingMetaObject = WidgetFactory::classNameOf(core(), o) == QStringLiteral("QAxWidget");
const QDesignerMetaObjectInterface *meta = core()->introspection()->metaObject(o);
const bool dynamicPropertiesAllowed = dynamicSheet && dynamicSheet->dynamicPropertiesAllowed();
QDesignerPropertySheet *designerPropertySheet = qobject_cast<QDesignerPropertySheet *>(
core()->extensionManager()->extension(o, Q_TYPEID(QDesignerPropertySheetExtension)));
if (designerPropertySheet) {
if (designerPropertySheet->pixmapCache())
designerPropertySheet->setPixmapCache(m_pixmapCache);
if (designerPropertySheet->iconCache())
designerPropertySheet->setIconCache(m_iconCache);
}
const DomPropertyList::const_iterator cend = properties.constEnd();
for (DomPropertyList::const_iterator it = properties.constBegin(); it != cend; ++it) {
DomProperty *p = *it;
QVariant v;
if (!readDomEnumerationValue(p, sheet, v))
v = toVariant(o->metaObject(), p);
if (v.isNull())
continue;
const QString attributeName = p->attributeName();
if (d->applyPropertyInternally(o, attributeName, v))
continue;
// refuse fake properties like current tab name (weak test)
if (!dynamicPropertiesAllowed) {
if (changingMetaObject) // Changes after setting control of QAxWidget
meta = core()->introspection()->metaObject(o);
if (meta->indexOfProperty(attributeName) == -1)
continue;
}
QObject *obj = o;
QAbstractScrollArea *scroll = qobject_cast<QAbstractScrollArea *>(o);
if (scroll && attributeName == QStringLiteral("cursor") && scroll->viewport())
obj = scroll->viewport();
// a real property
obj->setProperty(attributeName.toUtf8(), v);
}
}
void MetaInfoDialog::artworkContextMenuRequested(const QPoint &pos)
{
QAbstractScrollArea *scrollArea = dynamic_cast<QAbstractScrollArea*>(QObject::sender());
QWidget *sender = scrollArea ? scrollArea->viewport() : dynamic_cast<QWidget*>(QObject::sender());
if(sender)
{
if(pos.x() <= sender->width() && pos.y() <= sender->height() && pos.x() >= 0 && pos.y() >= 0)
{
m_contextMenuArtwork->popup(sender->mapToGlobal(pos));
}
}
}
void
TreeCanvas::layoutDone(int w, int h, int scale0) {
targetW = w; targetH = h; targetScale = scale0;
QSize viewport_size = size();
QAbstractScrollArea* sa =
static_cast<QAbstractScrollArea*>(parentWidget()->parentWidget());
sa->horizontalScrollBar()->setRange(0,w-viewport_size.width());
sa->verticalScrollBar()->setRange(0,h-viewport_size.height());
if (layoutDoneTimerId == 0)
layoutDoneTimerId = startTimer(15);
}
VisualNode*
TreeCanvas::eventNode(QEvent* event) {
int x = 0;
int y = 0;
switch (event->type()) {
case QEvent::ToolTip:
{
QHelpEvent* he = static_cast<QHelpEvent*>(event);
x = he->x();
y = he->y();
break;
}
case QEvent::MouseButtonDblClick:
case QEvent::MouseButtonPress:
case QEvent::MouseButtonRelease:
case QEvent::MouseMove:
{
QMouseEvent* me = static_cast<QMouseEvent*>(event);
x = me->x();
y = me->y();
break;
}
case QEvent::ContextMenu:
{
QContextMenuEvent* ce = static_cast<QContextMenuEvent*>(event);
x = ce->x();
y = ce->y();
break;
}
default:
return NULL;
}
QAbstractScrollArea* sa =
static_cast<QAbstractScrollArea*>(parentWidget()->parentWidget());
int xoff = sa->horizontalScrollBar()->value()/scale;
int yoff = sa->verticalScrollBar()->value()/scale;
BoundingBox bb = root->getBoundingBox();
int w =
static_cast<int>((bb.right-bb.left+Layout::extent)*scale);
if (w < sa->viewport()->width())
xoff -= (sa->viewport()->width()-w)/2;
VisualNode* n;
n = root->findNode(*na,
static_cast<int>(x/scale-xtrans+xoff),
static_cast<int>((y-30)/scale+yoff));
return n;
}
MouseMachine::MouseMachine(QWidget* parent, MouseMachine::Options options)
: QObject(parent)
, theParent(parent)
, m_options(options)
, machine(0)
, trPressed2Idle(0)
, trPressed2Man(0)
, trManScrolling(0)
, trIdle2Pressed(0)
, trMan2Auto(0)
, trMan2Idle(0)
, trAuto2Idle(0)
, trAuto2Man(0)
, trDoubleclick(0)
{
#ifdef Q_OS_SYMBIAN
iTouchFeedback = MTouchFeedback::Instance();
#endif
speedTimer.setInterval(SPEED_INTERVAL);
connect(&speedTimer, SIGNAL(timeout()), SLOT(slotCalculateSpeed()));
dblclickTimer.setInterval(DBLCLICK_INTERVAL);
dblclickTimer.setSingleShot(true);
connect(&dblclickTimer, SIGNAL(timeout()), SLOT(slotSingleTap()));
scrollTimeline.setCurveShape(QTimeLine::EaseOutCurve);
scrollTimeline.setEasingCurve(QEasingCurve::OutQuad);
connect(&scrollTimeline, SIGNAL(valueChanged(qreal)), SLOT(slotAutoscroll(qreal)));
connect(&scrollTimeline, SIGNAL(finished()), SLOT(slotAutoscrollFinished()));
tapHoldTimer.setInterval(TAPHOLD_TIMEOUT);
tapHoldTimer.setSingleShot(true);
theTarget = theParent;
QAbstractScrollArea *scrollArea = qobject_cast<QAbstractScrollArea*>(theParent);
if (scrollArea) {
scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
theTarget = scrollArea->viewport();
theTarget->installEventFilter(this);
}
theParent->installEventFilter(this);
buildMachine();
machine->start();
}
void
TreeCanvas::update(void) {
QMutexLocker locker(&mutex);
layoutMutex.lock();
if (root != NULL) {
root->layout(*na);
BoundingBox bb = root->getBoundingBox();
int w = static_cast<int>((bb.right-bb.left+Layout::extent)*scale);
int h =
static_cast<int>(2*Layout::extent+
root->getShape()->depth()*Layout::dist_y*scale);
xtrans = -bb.left+(Layout::extent / 2);
QSize viewport_size = size();
QAbstractScrollArea* sa =
static_cast<QAbstractScrollArea*>(parentWidget()->parentWidget());
sa->horizontalScrollBar()->setRange(0,w-viewport_size.width());
sa->verticalScrollBar()->setRange(0,h-viewport_size.height());
sa->horizontalScrollBar()->setPageStep(viewport_size.width());
sa->verticalScrollBar()->setPageStep(viewport_size.height());
sa->horizontalScrollBar()->setSingleStep(Layout::extent);
sa->verticalScrollBar()->setSingleStep(Layout::extent);
}
if (autoZoom)
zoomToFit();
layoutMutex.unlock();
QWidget::update();
}
void FancyStyle::polish(QWidget *widget) {
QPlastiqueStyle::polish(widget);
{
QAbstractScrollArea *sa = qobject_cast<QAbstractScrollArea*>(widget);
if (sa) {
if (sa->frameShape() == QFrame::StyledPanel) {
sa->setFrameShadow(QFrame::Plain);
}
}
}
#ifdef Q_WS_MAC
{
QLabel *l = qobject_cast<QLabel*>(widget);
if (l) {
l->setFont(QApplication::font());
}
}
#endif
}
bool TextView::eventFilter(QObject *obj, QEvent *event)
{
#ifdef SCINTILLA
QAbstractScrollArea * sa = scintEditor;
#else
QAbstractScrollArea * sa = plainTextEdit;
#endif
if (obj == sa) {
sa->setAttribute(Qt::WA_NoMousePropagation, false);
if (event->type() == QEvent::KeyPress) {
QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
switch (keyEvent->key())
{
case Qt::Key_Z:
if (keyEvent->modifiers().testFlag(Qt::ShiftModifier) && keyEvent->modifiers().testFlag(Qt::ControlModifier)) {
byteSource->historyForward();
keyEvent->accept();
return true;
}
else if (keyEvent->modifiers().testFlag(Qt::ControlModifier)) {
byteSource->historyBackward();
keyEvent->accept();
return true;
}
break;
default:
return false;
}
} else if (event->type() == QEvent::Wheel) {
if (sa->verticalScrollBar()->isVisible()) {
sa->setAttribute(Qt::WA_NoMousePropagation);
}
return false;
}
}
return QWidget::eventFilter(obj, event);
}
void FlickCharm::activateOn(QWidget *widget)
{
QAbstractScrollArea *scrollArea = qobject_cast<QAbstractScrollArea*>(widget);
if (scrollArea) {
scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
QWidget *viewport = scrollArea->viewport();
viewport->installEventFilter(this);
scrollArea->installEventFilter(this);
d->flickData.remove(viewport);
d->flickData[viewport] = new FlickData;
d->flickData[viewport]->widget = widget;
d->flickData[viewport]->state = FlickData::Steady;
return;
}
QWebView *webView = qobject_cast<QWebView*>(widget);
if (webView) {
QWebFrame *frame = webView->page()->mainFrame();
frame->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff);
frame->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff);
webView->installEventFilter(this);
d->flickData.remove(webView);
d->flickData[webView] = new FlickData;
d->flickData[webView]->widget = webView;
d->flickData[webView]->state = FlickData::Steady;
return;
}
qWarning() << "FlickCharm only works on QAbstractScrollArea (and derived classes)";
qWarning() << "or QWebView (and derived classes)";
}
void
TreeCanvas::paintEvent(QPaintEvent* event) {
QMutexLocker locker(&layoutMutex);
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing);
QAbstractScrollArea* sa =
static_cast<QAbstractScrollArea*>(parentWidget()->parentWidget());
int xoff = sa->horizontalScrollBar()->value()/scale;
int yoff = sa->verticalScrollBar()->value()/scale;
BoundingBox bb = root->getBoundingBox();
int w =
static_cast<int>((bb.right-bb.left+Layout::extent)*scale);
if (w < sa->viewport()->width())
xoff -= (sa->viewport()->width()-w)/2;
QRect origClip = event->rect();
painter.translate(0, 30);
painter.scale(scale,scale);
painter.translate(xtrans-xoff, -yoff);
QRect clip(static_cast<int>(origClip.x()/scale-xtrans+xoff),
static_cast<int>(origClip.y()/scale+yoff),
static_cast<int>(origClip.width()/scale),
static_cast<int>(origClip.height()/scale));
DrawingCursor dc(root, *na, curBest, painter, clip, showCopies);
PreorderNodeVisitor<DrawingCursor>(dc).run();
// int nodesLayouted = 1;
// clock_t t0 = clock();
// while (v.next()) { nodesLayouted++; }
// double t = (static_cast<double>(clock()-t0) / CLOCKS_PER_SEC) * 1000.0;
// double nps = static_cast<double>(nodesLayouted) /
// (static_cast<double>(clock()-t0) / CLOCKS_PER_SEC);
// std::cout << "Drawing done. " << nodesLayouted << " nodes in "
// << t << " ms. " << nps << " nodes/s." << std::endl;
}
void
TreeCanvas::centerCurrentNode(void) {
QMutexLocker locker(&mutex);
int x=0;
int y=0;
VisualNode* c = currentNode;
while (c != NULL) {
x += c->getOffset();
y += Layout::dist_y;
c = c->getParent(*na);
}
x = static_cast<int>((xtrans+x)*scale); y = static_cast<int>(y*scale);
QAbstractScrollArea* sa =
static_cast<QAbstractScrollArea*>(parentWidget()->parentWidget());
x -= sa->viewport()->width() / 2;
y -= sa->viewport()->height() / 2;
sourceX = sa->horizontalScrollBar()->value();
targetX = std::max(sa->horizontalScrollBar()->minimum(), x);
targetX = std::min(sa->horizontalScrollBar()->maximum(),
targetX);
sourceY = sa->verticalScrollBar()->value();
targetY = std::max(sa->verticalScrollBar()->minimum(), y);
targetY = std::min(sa->verticalScrollBar()->maximum(),
targetY);
if (!smoothScrollAndZoom) {
sa->horizontalScrollBar()->setValue(targetX);
sa->verticalScrollBar()->setValue(targetY);
} else {
scrollTimeLine.stop();
scrollTimeLine.setFrameRange(0,100);
scrollTimeLine.setDuration(std::max(200,
std::min(1000,
std::min(std::abs(sourceX-targetX),
std::abs(sourceY-targetY)))));
scrollTimeLine.start();
}
}
void
TreeCanvas::resizeEvent(QResizeEvent* e) {
QAbstractScrollArea* sa =
static_cast<QAbstractScrollArea*>(parentWidget()->parentWidget());
int w = sa->horizontalScrollBar()->maximum()+e->oldSize().width();
int h = sa->verticalScrollBar()->maximum()+e->oldSize().height();
sa->horizontalScrollBar()->setRange(0,w-e->size().width());
sa->verticalScrollBar()->setRange(0,h-e->size().height());
sa->horizontalScrollBar()->setPageStep(e->size().width());
sa->verticalScrollBar()->setPageStep(e->size().height());
}
/* Returns a new scrollbar for the given orientation, or set the scrollbar
* passed as parameter */
wxScrollBar *wxWindowQt::QtSetScrollBar( int orientation, wxScrollBar *scrollBar )
{
QAbstractScrollArea *scrollArea = QtGetScrollBarsContainer();
wxCHECK_MSG( scrollArea, NULL, "Window without scrolling area" );
// Create a new scrollbar if needed
if ( !scrollBar )
{
scrollBar = new wxScrollBar( const_cast< wxWindowQt* >( this ), wxID_ANY,
wxDefaultPosition, wxDefaultSize,
orientation == wxHORIZONTAL ? wxSB_HORIZONTAL : wxSB_VERTICAL);
// Connect scrollbar events to this window
scrollBar->Bind( wxEVT_SCROLL_LINEUP, &wxWindowQt::QtOnScrollBarEvent, this );
scrollBar->Bind( wxEVT_SCROLL_LINEDOWN, &wxWindowQt::QtOnScrollBarEvent, this );
scrollBar->Bind( wxEVT_SCROLL_PAGEUP, &wxWindowQt::QtOnScrollBarEvent, this );
scrollBar->Bind( wxEVT_SCROLL_PAGEDOWN, &wxWindowQt::QtOnScrollBarEvent, this );
scrollBar->Bind( wxEVT_SCROLL_TOP, &wxWindowQt::QtOnScrollBarEvent, this );
scrollBar->Bind( wxEVT_SCROLL_BOTTOM, &wxWindowQt::QtOnScrollBarEvent, this );
scrollBar->Bind( wxEVT_SCROLL_THUMBTRACK, &wxWindowQt::QtOnScrollBarEvent, this );
scrollBar->Bind( wxEVT_SCROLL_THUMBRELEASE, &wxWindowQt::QtOnScrollBarEvent, this );
}
// Let Qt handle layout
if ( orientation == wxHORIZONTAL )
{
scrollArea->setHorizontalScrollBar( scrollBar->GetHandle() );
m_horzScrollBar = scrollBar;
}
else
{
scrollArea->setVerticalScrollBar( scrollBar->GetHandle() );
m_vertScrollBar = scrollBar;
}
return scrollBar;
}
// scroll by dx, dy
// return true if the widget was scrolled
bool scrollWidget(const int dx, const int dy)
{
QAbstractScrollArea *scrollArea = qobject_cast<QAbstractScrollArea*>(widget);
if (scrollArea) {
const int x = scrollArea->horizontalScrollBar()->value();
const int y = scrollArea->verticalScrollBar()->value();
scrollArea->horizontalScrollBar()->setValue(x - dx);
scrollArea->verticalScrollBar()->setValue(y - dy);
return (scrollArea->horizontalScrollBar()->value() != x
|| scrollArea->verticalScrollBar()->value() != y);
}
QWebView *webView = qobject_cast<QWebView*>(widget);
if (webView) {
QWebFrame *frame = webView->page()->mainFrame();
const QPoint position = frame->scrollPosition();
frame->setScrollPosition(position - QPoint(dx, dy));
return frame->scrollPosition() != position;
}
return false;
}
/*!
\fn void CSizeGrip::mousePressEvent(QMouseEvent * event)
Receives the mouse press events for the widget, and primes the
resize operation. The mouse press event is passed in the \a event
parameter.
*/
void CSizeGrip::mousePressEvent(QMouseEvent * e)
{
ungrabGesture(Qt::TapAndHoldGesture);
if (e->button() != Qt::LeftButton) {
QWidget::mousePressEvent(e);
return;
}
QWidget *tlw = qt_sizegrip_topLevelWidget();
p = e->globalPos();
gotMousePress = true;
r = tlw->geometry();
#ifdef Q_WS_X11
#if QT_VERSION >= 0x050000
// Use a native X11 sizegrip for "real" top-level windows if supported.
if (tlw->isWindow() && X11->isSupportedByWM(ATOM(_NET_WM_MOVERESIZE))
&& !(tlw->windowFlags() & Qt::X11BypassWindowManagerHint)
&& !tlw->testAttribute(Qt::WA_DontShowOnScreen) && !qt_widget_private(tlw)->hasHeightForWidth()) {
XEvent xev;
xev.xclient.type = ClientMessage;
xev.xclient.message_type = ATOM(_NET_WM_MOVERESIZE);
xev.xclient.display = X11->display;
xev.xclient.window = tlw->winId();
xev.xclient.format = 32;
xev.xclient.data.l[0] = e->globalPos().x();
xev.xclient.data.l[1] = e->globalPos().y();
if (atBottom())
xev.xclient.data.l[2] = atLeft() ? 6 : 4; // bottomleft/bottomright
else
xev.xclient.data.l[2] = atLeft() ? 0 : 2; // topleft/topright
xev.xclient.data.l[3] = Button1;
xev.xclient.data.l[4] = 0;
XUngrabPointer(X11->display, X11->time);
XSendEvent(X11->display, QX11Info::appRootWindow(x11Info().screen()), False,
SubstructureRedirectMask | SubstructureNotifyMask, &xev);
return;
}
#endif
#endif // Q_WS_X11
#ifdef Q_WS_WIN
#if QT_VERSION >= 0x050000
if (tlw->isWindow() && !tlw->testAttribute(Qt::WA_DontShowOnScreen) && !qt_widget_private(tlw)->hasHeightForWidth()) {
uint orientation = 0;
if (atBottom())
orientation = atLeft() ? SZ_SIZEBOTTOMLEFT : SZ_SIZEBOTTOMRIGHT;
else
orientation = atLeft() ? SZ_SIZETOPLEFT : SZ_SIZETOPRIGHT;
ReleaseCapture();
PostMessage(tlw->winId(), WM_SYSCOMMAND, orientation, 0);
return;
}
#endif
#endif // Q_WS_WIN
// Find available desktop/workspace geometry.
QRect availableGeometry;
bool hasVerticalSizeConstraint = true;
bool hasHorizontalSizeConstraint = true;
if (tlw->isWindow())
availableGeometry = QApplication::desktop()->availableGeometry(tlw);
else {
const QWidget *tlwParent = tlw->parentWidget();
// Check if tlw is inside QAbstractScrollArea/QScrollArea.
// If that's the case tlw->parentWidget() will return the viewport
// and tlw->parentWidget()->parentWidget() will return the scroll area.
#ifndef QT_NO_SCROLLAREA
QAbstractScrollArea *scrollArea = qobject_cast<QAbstractScrollArea *>(tlwParent->parentWidget());
if (scrollArea) {
hasHorizontalSizeConstraint = scrollArea->horizontalScrollBarPolicy() == Qt::ScrollBarAlwaysOff;
hasVerticalSizeConstraint = scrollArea->verticalScrollBarPolicy() == Qt::ScrollBarAlwaysOff;
}
#endif // QT_NO_SCROLLAREA
availableGeometry = tlwParent->contentsRect();
}
// Find frame geometries, title bar height, and decoration sizes.
const QRect frameGeometry = tlw->frameGeometry();
const int titleBarHeight = qMax(tlw->geometry().y() - frameGeometry.y(), 0);
const int bottomDecoration = qMax(frameGeometry.height() - tlw->height() - titleBarHeight, 0);
const int leftRightDecoration = qMax((frameGeometry.width() - tlw->width()) / 2, 0);
// Determine dyMax depending on whether the sizegrip is at the bottom
// of the widget or not.
if (atBottom()) {
if (hasVerticalSizeConstraint)
dyMax = availableGeometry.bottom() - r.bottom() - bottomDecoration;
else
dyMax = INT_MAX;
} else {
if (hasVerticalSizeConstraint)
dyMax = availableGeometry.y() - r.y() + titleBarHeight;
else
dyMax = -INT_MAX;
}
// In RTL mode, the size grip is to the left; find dxMax from the desktop/workspace
// geometry, the size grip geometry and the width of the decoration.
if (atLeft()) {
if (hasHorizontalSizeConstraint)
dxMax = availableGeometry.x() - r.x() + leftRightDecoration;
else
dxMax = -INT_MAX;
} else {
if (hasHorizontalSizeConstraint)
dxMax = availableGeometry.right() - r.right() - leftRightDecoration;
else
dxMax = INT_MAX;
}
}
void
TreeCanvas::scaleTree(int scale0, int zoomx, int zoomy) {
QMutexLocker locker(&layoutMutex);
QSize viewport_size = size();
QAbstractScrollArea* sa =
static_cast<QAbstractScrollArea*>(parentWidget()->parentWidget());
if (zoomx==-1)
zoomx = viewport_size.width()/2;
if (zoomy==-1)
zoomy = viewport_size.height()/2;
int xoff = (sa->horizontalScrollBar()->value()+zoomx)/scale;
int yoff = (sa->verticalScrollBar()->value()+zoomy)/scale;
BoundingBox bb;
scale0 = std::min(std::max(scale0, LayoutConfig::minScale),
LayoutConfig::maxScale);
scale = (static_cast<double>(scale0)) / 100.0;
bb = root->getBoundingBox();
int w =
static_cast<int>((bb.right-bb.left+Layout::extent)*scale);
int h =
static_cast<int>(2*Layout::extent+
root->getShape()->depth()*Layout::dist_y*scale);
sa->horizontalScrollBar()->setRange(0,w-viewport_size.width());
sa->verticalScrollBar()->setRange(0,h-viewport_size.height());
sa->horizontalScrollBar()->setPageStep(viewport_size.width());
sa->verticalScrollBar()->setPageStep(viewport_size.height());
sa->horizontalScrollBar()->setSingleStep(Layout::extent);
sa->verticalScrollBar()->setSingleStep(Layout::extent);
xoff *= scale;
yoff *= scale;
sa->horizontalScrollBar()->setValue(xoff-zoomx);
sa->verticalScrollBar()->setValue(yoff-zoomy);
emit scaleChanged(scale0);
QWidget::update();
}
void FindBar::find(FindBar::FindDirection dir)
{
Q_ASSERT(m_associatedWebView);
if (isHidden()) {
QPoint previous_position = m_associatedWebView->page()->currentFrame()->scrollPosition();
m_associatedWebView->page()->focusNextPrevChild(true);
m_associatedWebView->page()->currentFrame()->setScrollPosition(previous_position);
return;
}
QWebPage::FindFlags options = QWebPage::FindWrapsAroundDocument;
if (dir == Backward)
options |= QWebPage::FindBackward;
if (matchCase())
options |= QWebPage::FindCaseSensitively;
// HACK Because we're using the QWebView inside a QScrollArea container, the attempts
// to scroll the QWebView itself have no direct effect.
// Therefore we temporarily shrink the page viewport to the message viewport (ie. the size it
// can cover at max), then perform the search, store the scrollPosition, restore the page viewport
// and finally scroll the messageview to the gathered scrollPosition, mapped to the message (ie.
// usually offset by the mail header)
auto emb = qobject_cast<EmbeddedWebView *>(m_associatedWebView);
QAbstractScrollArea *container = emb ? static_cast<QAbstractScrollArea*>(emb->scrollParent()) : nullptr;
const QSize oldVpS = m_associatedWebView->page()->viewportSize();
const bool useResizeTrick = container ? !!container->verticalScrollBar() : false;
// first shrink the page viewport
if (useResizeTrick) {
m_associatedWebView->setUpdatesEnabled(false); // don't let the user see the flicker we might produce
QSize newVpS = oldVpS.boundedTo(container->size());
m_associatedWebView->page()->setViewportSize(newVpS);
}
// now perform the search (pot. in the shrinked viewport)
bool found = m_associatedWebView->page()->findText(_lastStringSearched, options);
notifyMatch(found);
// scroll and reset the page viewport if necessary
if (useResizeTrick) {
Q_ASSERT(container->verticalScrollBar());
// the page has now a usable scroll position ...
int scrollPosition = m_associatedWebView->page()->currentFrame()->scrollPosition().y();
// ... which needs to be extended by the pages offset (usually the header widget)
// NOTICE: QWidget::mapTo() fails as the viewport child position can be negative, so we run ourself
QWidget *runner = m_associatedWebView;
while (runner->parentWidget() != container->viewport()) {
scrollPosition += runner->y();
runner = runner->parentWidget();
}
// reset viewport to original size ...
m_associatedWebView->page()->setViewportSize(oldVpS);
// ... let the user see the change ...
m_associatedWebView->setUpdatesEnabled(true);
// ... and finally scroll to the desired position
if (found)
container->verticalScrollBar()->setValue(scrollPosition);
}
if (!found) {
QPoint previous_position = m_associatedWebView->page()->currentFrame()->scrollPosition();
m_associatedWebView->page()->focusNextPrevChild(true);
m_associatedWebView->page()->currentFrame()->setScrollPosition(previous_position);
}
}
void ScrollAreaLayout::setGeometry ( const QRect & r ) {
QAbstractScrollArea* theChild = dynamic_cast<QAbstractScrollArea*>(theItem->widget());
//qDebug() << "--------------------------------------";
// qDebug() << " Layout geometry:" << r;
//qDebug() << " Scroll bar width: " << theChild->verticalScrollBar()->width();
// get the widget which is scrolled by the scrollarea
//QWidget* wdg = theChild->widget();
// qDebug() << "Widget sizeHint():" << wdg->objectName() << " - "<< wdg->sizeHint();
//qDebug() << "Widget size():" << wdg->objectName() << " - "<< wdg->size();
// int fh = theChild->fontMetrics().height();
//qDebug() << "Scroll area max size:" << QSize(36 * fh, 24 * fh);
int wid = theChild->sizeHint().width(); // frame width is considered!
int h = theChild->sizeHint().height(); // frame height is considered!
int xpos = 0;
int ypos = 0;
if (r.width() < wid && r.height() < h) {
// both scrollbars required
wid = r.width();
h = r.height();
} else if (r.width() < wid) {
// only horizontal scroll bar required
h += theChild->horizontalScrollBar()->sizeHint().height();
wid = r.width();
// the new y position is based on the extended height (including scroll bars)
// this leads to a lesser smoothly transition from no scroll bars to scroll bars,
// but avoids an asymmetry once the scroll bars are shown.
ypos = (r.height() - h) / 2;
if (r.height() < h) { // again both required
xpos = 0;
ypos = 0;
h = r.height();
}
} else if (r.height() < h) {
// only vertical scroll bar required
wid += theChild->verticalScrollBar()->sizeHint().width();
h = r.height();
// the new x position is based on the extended width (including scroll bars)
// this leads to a lesser smoothly transition from no scroll bars to scroll bars,
// but avoids an asymmetry once the scroll bars are shown.
xpos = (r.width() - wid) / 2;
if (r.width() < wid) { // again both required
xpos = 0;
ypos = 0;
wid = r.width();
}
} else {
xpos = (r.width() - wid) / 2;
ypos = (r.height() - h) / 2;
}
int frameWidth = 0; // !!!!
QRect newRect = QRect(xpos, ypos, wid + frameWidth, h + frameWidth);
//qDebug() << " Child geometry:" << newRect;
theChild->setGeometry(newRect);
}
void tst_QAbstractScrollArea::scrollBarWidgets()
{
QWidget *w1 = new QWidget(0);
QWidget *w2 = new QWidget(0);
QWidget *w3 = new QWidget(0);
Qt::Alignment all = Qt::AlignLeft | Qt::AlignRight | Qt::AlignTop | Qt::AlignBottom;
QWidgetList w1List = QWidgetList() << w1;
QWidgetList w2List = QWidgetList() << w2;
QWidgetList w3List = QWidgetList() << w3;
QWidgetList w1w2List = w1List + w2List;
QWidgetList allList = w1List + w2List + w3List;
QAbstractScrollArea area;
area.show();
QCOMPARE(area.scrollBarWidgets(all), QWidgetList());
area.addScrollBarWidget(w1, Qt::AlignLeft);
QCOMPARE(area.scrollBarWidgets(all), w1List);
QCOMPARE(area.scrollBarWidgets(Qt::AlignLeft), w1List);
QCOMPARE(area.scrollBarWidgets(Qt::AlignRight), QWidgetList());
QCOMPARE(area.scrollBarWidgets(Qt::AlignTop), QWidgetList());
QCOMPARE(area.scrollBarWidgets(Qt::AlignBottom), QWidgetList());
area.addScrollBarWidget(w2, Qt::AlignBottom);
QCOMPARE(area.scrollBarWidgets(all), w1w2List);
QCOMPARE(area.scrollBarWidgets(Qt::AlignLeft), w1List);
QCOMPARE(area.scrollBarWidgets(Qt::AlignRight), QWidgetList());
QCOMPARE(area.scrollBarWidgets(Qt::AlignTop), QWidgetList());
QCOMPARE(area.scrollBarWidgets(Qt::AlignBottom), w2List);
// duplicate add
area.addScrollBarWidget(w2, Qt::AlignBottom);
QCOMPARE(area.scrollBarWidgets(all), w1w2List);
QCOMPARE(area.scrollBarWidgets(Qt::AlignLeft), w1List);
QCOMPARE(area.scrollBarWidgets(Qt::AlignRight), QWidgetList());
QCOMPARE(area.scrollBarWidgets(Qt::AlignTop), QWidgetList());
QCOMPARE(area.scrollBarWidgets(Qt::AlignBottom), w2List);
//reparent
w2->setParent(w1);
QCOMPARE(area.scrollBarWidgets(all), w1List);
QCOMPARE(area.scrollBarWidgets(Qt::AlignLeft), w1List);
QCOMPARE(area.scrollBarWidgets(Qt::AlignRight), QWidgetList());
QCOMPARE(area.scrollBarWidgets(Qt::AlignTop), QWidgetList());
QCOMPARE(area.scrollBarWidgets(Qt::AlignBottom), QWidgetList());
// add after reparent
area.addScrollBarWidget(w2, Qt::AlignBottom);
QCOMPARE(area.scrollBarWidgets(all), w1w2List);
QCOMPARE(area.scrollBarWidgets(Qt::AlignLeft), w1List);
QCOMPARE(area.scrollBarWidgets(Qt::AlignRight), QWidgetList());
QCOMPARE(area.scrollBarWidgets(Qt::AlignTop), QWidgetList());
QCOMPARE(area.scrollBarWidgets(Qt::AlignBottom), w2List);
// two widgets at Bottom.
area.addScrollBarWidget(w3, Qt::AlignBottom);
QCOMPARE(area.scrollBarWidgets(all).toSet(), allList.toSet());
QCOMPARE(area.scrollBarWidgets(Qt::AlignLeft), w1List);
QCOMPARE(area.scrollBarWidgets(Qt::AlignRight), QWidgetList());
QCOMPARE(area.scrollBarWidgets(Qt::AlignTop), QWidgetList());
QCOMPARE(area.scrollBarWidgets(Qt::AlignBottom).toSet(), (w2List + w3List).toSet());
//delete
delete w1;
delete w2;
delete w3;
QCOMPARE(area.scrollBarWidgets(all), QWidgetList());
QCOMPARE(area.scrollBarWidgets(Qt::AlignLeft), QWidgetList());
QCOMPARE(area.scrollBarWidgets(Qt::AlignRight), QWidgetList());
QCOMPARE(area.scrollBarWidgets(Qt::AlignTop), QWidgetList());
QCOMPARE(area.scrollBarWidgets(Qt::AlignBottom), QWidgetList());
}
void tst_QAbstractScrollArea::setScrollBars2()
{
QAbstractScrollArea scrollArea;
scrollArea.resize(300, 300);
QScrollBar *hbar = new QScrollBar;
scrollArea.setHorizontalScrollBar(hbar);
qApp->processEvents();
QCOMPARE(scrollArea.horizontalScrollBar(), hbar);
QScrollBar *vbar = new QScrollBar;
scrollArea.setVerticalScrollBar(vbar);
qApp->processEvents();
QCOMPARE(scrollArea.verticalScrollBar(), vbar);
scrollArea.horizontalScrollBar()->setRange(0, 100);
scrollArea.verticalScrollBar()->setRange(0, 100);
scrollArea.show();
// Make sure scroll bars are not explicitly hidden by QAbstractScrollArea itself.
QVERIFY(hbar->isVisible());
QVERIFY(vbar->isVisible());
// Hide the OLD scroll bar and ensure that the NEW one is hidden.
hbar->hide();
scrollArea.setHorizontalScrollBar(new QScrollBar);
qApp->processEvents();
QVERIFY(!scrollArea.horizontalScrollBar()->isVisible());
vbar->hide();
scrollArea.setVerticalScrollBar(new QScrollBar);
qApp->processEvents();
QVERIFY(!scrollArea.verticalScrollBar()->isVisible());
scrollArea.verticalScrollBar()->show();
scrollArea.horizontalScrollBar()->show();
// Hide the NEW scroll bar and ensure that it's visible
// (because the OLD one is visible).
hbar = new QScrollBar;
hbar->hide();
scrollArea.setHorizontalScrollBar(hbar);
qApp->processEvents();
QVERIFY(hbar->isVisible());
vbar = new QScrollBar;
vbar->hide();
scrollArea.setVerticalScrollBar(vbar);
qApp->processEvents();
QVERIFY(vbar->isVisible());
vbar->setRange(0, 0);
qApp->processEvents();
QVERIFY(!vbar->isVisible());
hbar->setRange(0, 0);
qApp->processEvents();
QVERIFY(!hbar->isVisible());
}