FloatRect VisualViewport::visibleRectInDocument() const
{
if (!mainFrame() || !mainFrame()->view())
return FloatRect();
FloatPoint viewLocation = FloatPoint(mainFrame()->view()->scrollableArea()->scrollPositionDouble());
return FloatRect(viewLocation, visibleSize());
}
void PhotoView::updatePanner( const QSizeF & vpSize )
{
QSizeF viewportSize = vpSize;
if ( ! viewportSize.isValid() )
viewportSize = size();
if ( viewportSize.width() < _panner->size().width() * 2 ||
viewportSize.height() < _panner->size().height() * 2 )
{
// If the panner would take up more than half the available space
// in any direction, don't show it.
_panner->hide();
}
else
{
Photo * photo = _photoDir->current();
if ( ! photo )
{
_panner->hide();
}
else
{
QSizeF origSize = photo->size();
QPointF canvasPos = _canvas->pos();
QSizeF canvasSize = _canvas->size();
qreal pannerX = 0.0;
qreal pannerY = -_panner->size().height();
if ( canvasSize.width() < viewportSize.width() )
pannerX = canvasPos.x();
if ( canvasSize.height() < viewportSize.height() )
pannerY += canvasPos.y() + canvasSize.height();
else
pannerY += viewportSize.height();
_panner->setPos( pannerX, pannerY );
QPointF visiblePos( -canvasPos.x(), -canvasPos.y() );
QSizeF visibleSize( qMin( viewportSize.width(),
canvasSize.width() ),
qMin( viewportSize.height(),
canvasSize.height() ) );
QRectF visibleRect( visiblePos / _zoomFactor,
visibleSize / _zoomFactor );
_panner->updatePanRect( visibleRect, origSize );
}
}
}
double VisualViewport::clientHeight() {
if (!mainFrame())
return 0;
updateStyleAndLayoutIgnorePendingStylesheets();
float height = adjustScrollForAbsoluteZoom(visibleSize().height(),
mainFrame()->pageZoomFactor());
return height - mainFrame()->view()->horizontalScrollbarHeight() / m_scale;
}
double VisualViewport::clientWidth() {
if (!mainFrame())
return 0;
updateStyleAndLayoutIgnorePendingStylesheets();
float width = adjustScrollForAbsoluteZoom(visibleSize().width(),
mainFrame()->pageZoomFactor());
return width - mainFrame()->view()->verticalScrollbarWidth() / m_scale;
}
void World::initializeWorldOnFirstFrame(const cv::Mat& reference, const bool restrictBallToScene){
// following is box2d world/ball initialization
if(restrictBallToScene)
{
// Create edges around the entire screen
b2BodyDef groundBodyDef;
groundBodyDef.position.Set(0,0);
cv::Size visibleSize(reference.cols, reference.rows);
this->m_groundBody = m_world->CreateBody(&groundBodyDef);
b2EdgeShape groundEdge;
b2FixtureDef boxShapeDef;
boxShapeDef.shape = &groundEdge;
// wall definitions - bottom
groundEdge.Set(b2Vec2(0,0), b2Vec2(visibleSize.width/PTM_RATIO, 0));
this->m_groundBody->CreateFixture(&boxShapeDef);
// left
groundEdge.Set(b2Vec2(0,0), b2Vec2(0, visibleSize.height/PTM_RATIO));
this->m_groundBody->CreateFixture(&boxShapeDef);
// top
groundEdge.Set(b2Vec2(0, visibleSize.height/PTM_RATIO),
b2Vec2(visibleSize.width/PTM_RATIO, visibleSize.height/PTM_RATIO));
this->m_groundBody->CreateFixture(&boxShapeDef);
// right
groundEdge.Set(b2Vec2(visibleSize.width/PTM_RATIO, visibleSize.height/PTM_RATIO),
b2Vec2(visibleSize.width/PTM_RATIO, 0));
this->m_groundBody->CreateFixture(&boxShapeDef);
}
// Create ball body and shape
b2BodyDef ballBodyDef;
ballBodyDef.type = b2_dynamicBody;
ballBodyDef.position.Set(30 / PTM_RATIO, 30 / PTM_RATIO);
m_ballBody = m_world->CreateBody(&ballBodyDef);
b2CircleShape circle;
circle.m_radius = this->m_ballRadius;
b2FixtureDef ballShapeDef;
ballShapeDef.shape = &circle;
ballShapeDef.density = 4.5f;
ballShapeDef.friction = 0.0f;
ballShapeDef.restitution = 1.0f;
m_ballFixture = m_ballBody->CreateFixture(&ballShapeDef);
m_ballBody->ApplyLinearImpulse(b2Vec2(30, 30), m_ballBody->GetPosition(), true);
}
int Scrollbar::thumbLength()
{
int trackLen = trackLength();
if (!totalSize())
return trackLen;
float proportion = static_cast<float>(visibleSize()) / totalSize();
int length = round(proportion * trackLen);
length = std::min(std::max(length, minimumThumbLength()), trackLen);
return length;
}
std::size_t Buffer::size() const
{
return visibleSize(impl->buffer.size());
}
FloatRect VisualViewport::visibleRect() const
{
return FloatRect(location(), visibleSize());
}
ScrollOffset ScrollableArea::maximumScrollOffset() const
{
return ScrollOffset(totalContentsSize() - visibleSize());
}
ScrollPosition ScrollableArea::maximumScrollPosition() const
{
return scrollPositionFromOffset(ScrollPosition(totalContentsSize() - visibleSize()));
}
bool QtPrinterTableView::print()
{
Q_D(QtPrinterTableView);
if (! d->printer->isValid()) {
qWarning() << "QtPrinterTableView::print: printer not valid, please setup the printer before calling print";
return false;
}
// next use a view just for the filling of the options...
QGraphicsScene scene;
QtGraphicsTableView view;
scene.addItem(&view);
view.setModel(d->model);
class QTableHeaderDataProvider2 : public QtGraphicsHeaderDataProvider
{
public:
QTableHeaderDataProvider2(QtTableModelInterface *model_) : model(model_) {}
QHash<int,QVariant> data(int logicalIndex, const QList<int> &roles) const
{
// ### call the model - temporary implementation
QHash<int,QVariant> hash;
for (int i = 0; i < roles.count(); ++i)
if (roles.at(i) == Qt::DisplayRole)
hash.insert(Qt::DisplayRole, logicalIndex + 1);
return hash;
}
QtTableModelInterface *model;
};
if (d->horizontalHeader) {
QtGraphicsHeader *header = new QtGraphicsHeader(Qt::Horizontal, &view);
header->setDataProvider(new QTableHeaderDataProvider2(d->model));
header->copySections(*d->horizontalHeader);
view.setHorizontalHeader(header);
}
if (d->verticalHeader) {
QtGraphicsHeader *header = new QtGraphicsHeader(Qt::Vertical, &view);
header->setDataProvider(new QTableHeaderDataProvider2(d->model));
header->copySections(*d->verticalHeader);
view.setVerticalHeader(header);
}
QPainter painter;
if (!painter.begin(d->printer)) {
qWarning() << "QtPrinterTableView::print: printer fails to begin(), sorry can't print";
return false;
}
// re-layout the header footer to the current page size.
if (d->header) {
d->header->documentLayout()->setPaintDevice(d->printer);
d->header->setPageSize(d->printer->pageRect().size());
}
if (d->footer) {
d->footer->documentLayout()->setPaintDevice(d->printer);
d->footer->setPageSize(d->printer->pageRect().size());
}
const qreal headerSize = d->printHeader(painter);
const qreal footerSize = d->printFooter(painter);
const bool vertical = d->orientation == Qt::Vertical;
const qreal scaleX = d->printer->logicalDpiX() / (qreal) qt_defaultDpiX();
const qreal scaleY = d->printer->logicalDpiY() / (qreal) qt_defaultDpiY();
painter.scale(scaleX, scaleY);
const QRect rect = d->printer->pageRect();
QSizeF visibleSize(rect.width() / scaleX, rect.height() / scaleY);
if (vertical)
visibleSize = QSizeF(visibleSize.width(), visibleSize.height() - headerSize - footerSize);
else // then rotate it.
visibleSize = QSizeF(visibleSize.height() - headerSize - footerSize, visibleSize.width());
view.setGeometry(0, 0, visibleSize.width(), visibleSize.height());
view.setHorizontalOffset(0);
int row = 0;
int column;
bool first = true;
qreal offsetInColumn = 0; // for those columns too wide and thus split over more than one page
while (row < d->model->rowCount()) {
column = 0;
view.setFirstRow(row);
qreal height = visibleSize.height();
while (true) {
const qreal rowHeight = view.rowHeight(row);
if (height - rowHeight < 0)
break;
if (row >= d->model->rowCount())
break;
++row;
height -= rowHeight;
}
while (column < d->model->columnCount()) {
if (!first) {
d->printer->newPage();
d->printHeader(painter);
d->printFooter(painter);
}
first = false;
view.setFirstColumn(column);
view.setHorizontalOffset(offsetInColumn);
qreal width = visibleSize.width();
while (true) {
const qreal columnWidth = view.columnWidth(column);
if (width == visibleSize.width() && columnWidth - offsetInColumn > visibleSize.width()) {
// the column doesn't fit on a page. Lets split it.
offsetInColumn += visibleSize.width();
width = 0;
break;
} else if (offsetInColumn > 0) { // we still have a part of a split column to print!
width -= columnWidth - offsetInColumn;
offsetInColumn = 0;
++column;
continue;
}
if (width - columnWidth + offsetInColumn < 0)
break;
if (column >= d->model->columnCount())
break;
++column;
width -= columnWidth;
}
view.doLayout();
painter.save(); // for each page
painter.translate(0, headerSize);
if (!vertical) {
painter.translate(0, visibleSize.width());
painter.rotate(-90);
}
#ifdef DEBUG_TABLES
painter.setPen(QPen(QColor(Qt::green)));
painter.drawRect(QRectF(0, 0, visibleSize.width() - width, visibleSize.height() - height));
#endif
painter.setClipRect(QRectF(0, 0, visibleSize.width() - width, visibleSize.height() - height));
// find and paint children which are the cells
QList<QGraphicsItem*> items = scene.items(view.rect());
QList<QGraphicsItem*>::Iterator iter = items.begin();
for (;iter != items.end(); ++iter) {
QGraphicsItem *parent = *iter;
while (parent != &view && parent != 0) // only draw children of our view
parent = parent->parentItem();
if (parent == 0)
continue;
if (!(*iter)->isVisible())
continue;
painter.save();
painter.translate((*iter)->mapToItem(&view, QPointF()));
#ifdef DEBUG_TABLES
QGraphicsWidget *w = dynamic_cast<QGraphicsWidget*>(*iter);
if (w) {
painter.save();
painter.setPen(QPen(QColor(Qt::red)));
painter.drawRect(QRectF(QPointF(), w->size()));
painter.restore();
}
#endif
(*iter)->paint(&painter, 0);
painter.restore();
}
painter.restore(); // for each page
}
}
return true;
}
FloatRect VisualViewport::visibleRect() const {
return FloatRect(FloatPoint(getScrollOffset()), visibleSize());
}
