void ImageViewer::updateShift()
{
QRectF widgetRect(rect()); //! + SIZE_SHIFT ???
QRectF pixRect(topLeft + shift, image.size()*scale);
if(pixRect.width() <= widgetRect.width()
&& pixRect.height() <= widgetRect.height()){
shift = Config::OriginPoint;
setCursor(QCursor(Qt::ArrowCursor));
}else{
if(pixRect.width() <= widgetRect.width())
shift.setX(0);
else if(pixRect.left() > 0 && pixRect.right() > widgetRect.width())
shift.setX(shift.x() + (0 - pixRect.left()));
else if(pixRect.left() < 0 && pixRect.right() < widgetRect.width())
shift.setX(shift.x() + (widgetRect.width() - pixRect.right()));
if(pixRect.height() <= widgetRect.height())
shift.setY(0);
else if(pixRect.top() > 0 && pixRect.bottom() > widgetRect.height())
shift.setY(shift.y() + (0 - pixRect.top()));
else if(pixRect.top() < 0 && pixRect.bottom() < widgetRect.height())
shift.setY(shift.y() + (widgetRect.height() - pixRect.bottom()));
if(cursor().shape() != Qt::ClosedHandCursor)//in mouse move event
setCursor(QCursor(Qt::OpenHandCursor));
}
update();
}
void
ClientLayerManager::MakeSnapshotIfRequired()
{
if (!mShadowTarget) {
return;
}
if (mWidget) {
if (CompositorChild* remoteRenderer = GetRemoteRenderer()) {
nsIntRect bounds;
mWidget->GetBounds(bounds);
IntSize widgetSize = bounds.Size().ToIntSize();
SurfaceDescriptor inSnapshot, snapshot;
if (mForwarder->AllocSurfaceDescriptor(widgetSize,
gfxContentType::COLOR_ALPHA,
&inSnapshot) &&
// The compositor will usually reuse |snapshot| and return
// it through |outSnapshot|, but if it doesn't, it's
// responsible for freeing |snapshot|.
remoteRenderer->SendMakeSnapshot(inSnapshot, &snapshot)) {
RefPtr<DataSourceSurface> surf = GetSurfaceForDescriptor(snapshot);
DrawTarget* dt = mShadowTarget->GetDrawTarget();
Rect widgetRect(Point(0, 0), Size(widgetSize.width, widgetSize.height));
dt->DrawSurface(surf, widgetRect, widgetRect,
DrawSurfaceOptions(),
DrawOptions(1.0f, CompositionOp::OP_OVER));
}
if (IsSurfaceDescriptorValid(snapshot)) {
mForwarder->DestroySharedSurface(&snapshot);
}
}
}
mShadowTarget = nullptr;
}
void ImageViewer::updateShift()
{
QRectF widgetRect(rect()); //! + SIZE_SHIFT ???
QRectF pixRect(topLeft + shift, image.size()*scale);
if(pixRect.width() <= widgetRect.width()
&& pixRect.height() <= widgetRect.height()){
shift = QPointF(0, 0);
}else{
if(pixRect.width() <= widgetRect.width())
shift.setX(0);
else if(pixRect.left() > 0 && pixRect.right() > widgetRect.width())
shift.setX(shift.x() + (0 - pixRect.left()));
else if(pixRect.left() < 0 && pixRect.right() < widgetRect.width())
shift.setX(shift.x() + (widgetRect.width() - pixRect.right()));
if(pixRect.height() <= widgetRect.height())
shift.setY(0);
else if(pixRect.top() > 0 && pixRect.bottom() > widgetRect.height())
shift.setY(shift.y() + (0 - pixRect.top()));
else if(pixRect.top() < 0 && pixRect.bottom() < widgetRect.height())
shift.setY(shift.y() + (widgetRect.height() - pixRect.bottom()));
}
update();
}
bool PropertyRowNumberField::getHoverInfo(PropertyHoverInfo* hit, const Point& cursorPos, const PropertyTree* tree) const
{
if (pressed_ && !userReadOnly())
hit->cursor = property_tree::CURSOR_BLANK;
else if (widgetRect(tree).contains(cursorPos) && !userReadOnly())
hit->cursor = property_tree::CURSOR_SLIDE;
hit->toolTip = tooltip_;
return true;
}
void AppUtil::ensureWidgetIsVisible(QWidget* widget)
{
if (widget == NULL)
return;
QWidget* parent = widget->parentWidget();
if (widget->windowFlags() & Qt::Window)
{
// The widget is a top-level window (a dialog, for instance)
// @todo Use the screen where the main application currently is?
QDesktopWidget dw;
QWidget* screen(dw.screen());
if (screen != NULL)
{
// Move the widget to the center of the default screen
const QRect screenRect(screen->rect());
if (screenRect.contains(widget->pos()) == false)
{
QRect widgetRect(widget->rect());
widgetRect.moveCenter(screenRect.center());
widget->setGeometry(widgetRect);
}
}
else
{
// Last resort: move to top left and hope the widget is visible
widget->move(0, 0);
}
}
else if (parent != NULL)
{
// The widget's placement is bounded by a parent
const QRect parentRect(parent->rect());
if (parentRect.contains(widget->pos()) == false)
{
// Move the widget to the center of the parent if wouldn't
// otherwise be visible
QRect widgetRect(widget->rect());
widgetRect.moveCenter(parentRect.center());
widget->setGeometry(widgetRect);
}
}
}
bool PropertyRowNumberField::onMouseDown(PropertyTree* tree, Point point, bool& changed)
{
changed = false;
if (widgetRect(tree).contains(point) && !userReadOnly()) {
startIncrement();
pressed_ = true;
return true;
}
return false;
}
void BuddyEditor::setBackground(QWidget *background)
{
clear();
ConnectionEdit::setBackground(background);
const LabelList label_list = background->findChildren<QLabel*>();
foreach (QLabel *label, label_list) {
const QString buddy_name = buddy(label, m_formWindow->core());
if (buddy_name.isEmpty())
continue;
QWidget *target = background->findChild<QWidget*>(buddy_name);
if (target == 0)
continue;
Connection *con = new Connection(this);
con->setEndPoint(EndPoint::Source, label, widgetRect(label).center());
con->setEndPoint(EndPoint::Target, target, widgetRect(target).center());
addConnection(con);
}
}
int PropertyRowField::hitButton(const PropertyTree* tree, const Point& point) const
{
int buttonCount = this->buttonCount();
Rect buttonsRect = widgetRect(tree);
buttonsRect.x = buttonsRect.x + buttonsRect.w - buttonCount * BUTTON_SIZE;
if (buttonsRect.contains(point)) {
int buttonIndex = (point.x() - buttonsRect.x) / BUTTON_SIZE;
if (buttonIndex >= 0 && buttonIndex < buttonCount)
return buttonIndex;
}
return -1;
}
void PageView::calculateCurrentPageNumber(int x, int y)
{
// Safety check
if (widgetList == 0)
return;
QRect viewportRect(x, y, visibleWidth(), visibleHeight());
//kdDebug() << "viewportRect(" << viewportRect.x() << ", " << viewportRect.y() << ", "
// << viewportRect.width() << ", " << viewportRect.height() << ")" << endl;
int maxVisiblePixels = 0;
DocumentWidget* _currentWidget = 0;
for (Q_UINT16 i = 0; i < widgetList->size(); i++)
{
DocumentWidget* documentWidget = widgetList->at(i);
// Safety check
if (documentWidget == 0)
continue;
// Check if the Widget is visible
int cx = childX(documentWidget);
int cy = childY(documentWidget);
QRect widgetRect(cx, cy, documentWidget->width(), documentWidget->height());
bool isVisible = widgetRect.intersects(viewportRect);
if (!isVisible)
continue;
// Calculate the number of visible pixels of the widget
QRect visibleRect = widgetRect.intersect(viewportRect);
int visiblePixels = visibleRect.width() * visibleRect.height();
//kdDebug() << visiblePixels << " pixels are visible of page " << documentWidget->getPageNumber() << endl;
// If a bigger part of this widget as of the previous widgets is visible make it the current widget.
if (maxVisiblePixels < visiblePixels)
{
maxVisiblePixels = visiblePixels;
_currentWidget = documentWidget;
}
}
// No page is visible
if (_currentWidget == 0)
return;
// Return the number of the current page
emit currentPageChanged(_currentWidget->getPageNumber());
}
void PropertyRowNumberField::onMouseDrag(const PropertyDragEvent& e)
{
if (!dragStarted_) {
e.tree->model()->rowAboutToBeChanged(this);
dragStarted_ = true;
}
Point screenSize = e.tree->ui()->screenSize();
float relativeDelta = float(e.totalDelta.x()) / screenSize.x();
int fieldRectWidth = widgetRect(e.tree).width();
if (fieldRectWidth < 16)
fieldRectWidth = int(e.tree->treeSize().x() * e.tree->valueColumnWidth());
float valueFieldFraction = fieldRectWidth < FLT_EPSILON ? 0 : float(e.totalDelta.x()) / fieldRectWidth;
incrementLog(relativeDelta, valueFieldFraction);
setMultiValue(false);
}
void ThumbnailList::updateWidgets()
{
// find all widgets that intersects the viewport and update them
QRect viewportRect( contentsX(), contentsY(), visibleWidth(), visibleHeight() );
QValueList<ThumbnailWidget *>::iterator vIt = m_visibleThumbnails.begin(), vEnd = m_visibleThumbnails.end();
for ( ; vIt != vEnd; ++vIt )
{
ThumbnailWidget * t = *vIt;
QRect widgetRect( childX( t ), childY( t ), t->width(), t->height() );
// update only the exposed area of the widget (saves pixels..)
QRect relativeRect = viewportRect.intersect( widgetRect );
if ( !relativeRect.isValid() )
continue;
relativeRect.moveBy( -widgetRect.left(), -widgetRect.top() );
t->update( relativeRect );
}
}
bool PropertyRowField::onActivate(const PropertyActivationEvent& e)
{
int buttonCount = this->buttonCount();
Rect buttonsRect = widgetRect(e.tree);
buttonsRect.x = buttonsRect.x + buttonsRect.w - buttonCount * BUTTON_SIZE;
if (e.reason == e.REASON_PRESS) {
int buttonIndex = hitButton(e.tree, e.clickPoint);
if (buttonIndex != -1)
if (onActivateButton(buttonIndex, e))
return true;
}
if (e.reason == e.REASON_DOUBLECLICK && buttonsRect.contains(e.clickPoint))
return false;
return PropertyRow::onActivate(e);
}
void Widget::processEvent(simplgui::Event event)
{
sf::Transform globalTr = getGlobalTransform();
sf::FloatRect widgetRect(sf::Vector2f(0.f, 0.f), getEffectiveSize());
widgetRect = globalTr.transformRect(widgetRect);
if(event.type == simplgui::Event::MouseButtonPressed)
{
if(widgetRect.contains(event.mouseButton.x, event.mouseButton.y))
{
setFocused(true);
m_click = true;
}
else //TODO: Allow widgets to go outside their effective size rectangle (like combobox with their unfoldable list)
{
setFocused(false);
}
}
else if(event.type == simplgui::Event::MouseButtonReleased)
{
m_click = false;
}
else if(event.type == simplgui::Event::MouseMoved)
{
if(widgetRect.contains(event.mouseMove.x, event.mouseMove.y))
{
}
else //TODO: Allow widgets to go outside their effective size rectangle (like combobox with their unfoldable list)
{
m_click = false;
}
}
doProcessEvent(event);
}
void
BPose::Draw(BRect rect, const BRect& updateRect, BPoseView* poseView,
BView* drawView, bool fullDraw, BPoint offset, bool selected)
{
// If the background wasn't cleared and Draw() is not called after
// having edited a name or similar (with fullDraw)
if (!fBackgroundClean && !fullDraw) {
fBackgroundClean = true;
poseView->Invalidate(rect);
return;
} else
fBackgroundClean = false;
bool directDraw = (drawView == poseView);
bool windowActive = poseView->Window()->IsActive();
bool showSelectionWhenInactive = poseView->fShowSelectionWhenInactive;
bool isDrawingSelectionRect = poseView->fIsDrawingSelectionRect;
ModelNodeLazyOpener modelOpener(fModel);
if (poseView->ViewMode() == kListMode) {
uint32 size = poseView->IconSizeInt();
BRect iconRect(rect);
iconRect.left += kListOffset;
iconRect.right = iconRect.left + size;
iconRect.top = iconRect.bottom - size;
if (updateRect.Intersects(iconRect)) {
iconRect.OffsetBy(offset);
DrawIcon(iconRect.LeftTop(), drawView, poseView->IconSize(),
directDraw, !windowActive && !showSelectionWhenInactive);
}
// draw text
int32 columnsToDraw = 1;
if (fullDraw)
columnsToDraw = poseView->CountColumns();
for (int32 index = 0; index < columnsToDraw; index++) {
BColumn* column = poseView->ColumnAt(index);
if (column == NULL)
break;
// if widget doesn't exist, create it
BTextWidget* widget = WidgetFor(column, poseView, modelOpener);
if (widget && widget->IsVisible()) {
BRect widgetRect(widget->ColumnRect(rect.LeftTop(), column,
poseView));
if (updateRect.Intersects(widgetRect)) {
BRect widgetTextRect(widget->CalcRect(rect.LeftTop(),
column, poseView));
bool selectDuringDraw = directDraw && selected
&& windowActive;
if (index == 0 && selectDuringDraw) {
//draw with dark background to select text
drawView->PushState();
drawView->SetLowColor(0, 0, 0);
}
if (index == 0) {
widget->Draw(widgetRect, widgetTextRect,
column->Width(), poseView, drawView, selected,
fClipboardMode, offset, directDraw);
} else {
widget->Draw(widgetTextRect, widgetTextRect,
column->Width(), poseView, drawView, false,
fClipboardMode, offset, directDraw);
}
if (index == 0 && selectDuringDraw)
drawView->PopState();
else if (index == 0 && selected) {
if (windowActive || isDrawingSelectionRect) {
widgetTextRect.OffsetBy(offset);
drawView->InvertRect(widgetTextRect);
} else if (!windowActive
&& showSelectionWhenInactive) {
widgetTextRect.OffsetBy(offset);
drawView->PushState();
drawView->SetDrawingMode(B_OP_BLEND);
drawView->SetHighColor(128, 128, 128, 255);
drawView->FillRect(widgetTextRect);
drawView->PopState();
}
}
}
}
}
} else {
// draw in icon mode
BPoint location(Location(poseView));
BPoint iconOrigin(location);
iconOrigin += offset;
DrawIcon(iconOrigin, drawView, poseView->IconSize(), directDraw,
!windowActive && !showSelectionWhenInactive);
BColumn* column = poseView->FirstColumn();
if (column == NULL)
return;
BTextWidget* widget = WidgetFor(column, poseView, modelOpener);
if (widget == NULL || !widget->IsVisible())
return;
rect = widget->CalcRect(location, 0, poseView);
bool selectDuringDraw = directDraw && selected
&& (poseView->IsDesktopWindow() || windowActive);
if (selectDuringDraw) {
// draw with dark background to select text
drawView->PushState();
drawView->SetLowColor(0, 0, 0);
}
widget->Draw(rect, rect, rect.Width(), poseView, drawView,
selected, fClipboardMode, offset, directDraw);
if (selectDuringDraw)
drawView->PopState();
else if (selected && directDraw) {
if (windowActive || isDrawingSelectionRect) {
rect.OffsetBy(offset);
drawView->InvertRect(rect);
} else if (!windowActive && showSelectionWhenInactive) {
drawView->PushState();
drawView->SetDrawingMode(B_OP_BLEND);
drawView->SetHighColor(128, 128, 128, 255);
drawView->FillRect(rect);
drawView->PopState();
}
}
}
}
void PropertyRowBool::redraw(IDrawContext& context)
{
context.drawCheck(widgetRect(context.tree), userReadOnly(), multiValue() ? CHECK_IN_BETWEEN : (value_ ? CHECK_SET : CHECK_NOT_SET));
}
void BuddyEditor::updateBackground()
{
if (m_updating || background() == 0)
return;
ConnectionEdit::updateBackground();
m_updating = true;
QList<Connection *> newList;
const LabelList label_list = background()->findChildren<QLabel*>();
foreach (QLabel *label, label_list) {
const QString buddy_name = buddy(label, m_formWindow->core());
if (buddy_name.isEmpty())
continue;
const QList<QWidget *> targets = background()->findChildren<QWidget*>(buddy_name);
if (targets.isEmpty())
continue;
QWidget *target = 0;
QListIterator<QWidget *> it(targets);
while (it.hasNext()) {
QWidget *widget = it.next();
if (widget && !widget->isHidden()) {
target = widget;
break;
}
}
if (target == 0)
continue;
Connection *con = new Connection(this);
con->setEndPoint(EndPoint::Source, label, widgetRect(label).center());
con->setEndPoint(EndPoint::Target, target, widgetRect(target).center());
newList.append(con);
}
QList<Connection *> toRemove;
const int c = connectionCount();
for (int i = 0; i < c; i++) {
Connection *con = connection(i);
QObject *source = con->object(EndPoint::Source);
QObject *target = con->object(EndPoint::Target);
bool found = false;
QListIterator<Connection *> it(newList);
while (it.hasNext()) {
Connection *newConn = it.next();
if (newConn->object(EndPoint::Source) == source && newConn->object(EndPoint::Target) == target) {
found = true;
break;
}
}
if (found == false)
toRemove.append(con);
}
if (!toRemove.isEmpty()) {
DeleteConnectionsCommand command(this, toRemove);
command.redo();
foreach (Connection *con, toRemove)
delete takeConnection(con);
}
QListIterator<Connection *> it(newList);
while (it.hasNext()) {
Connection *newConn = it.next();
bool found = false;
const int c = connectionCount();
for (int i = 0; i < c; i++) {
Connection *con = connection(i);
if (con->object(EndPoint::Source) == newConn->object(EndPoint::Source) &&
con->object(EndPoint::Target) == newConn->object(EndPoint::Target)) {
found = true;
break;
}
}
if (found == false) {
AddConnectionCommand command(this, newConn);
command.redo();
} else {
delete newConn;
}
}
m_updating = false;
}
Rect PropertyRowField::fieldRect(const PropertyTree* tree) const
{
Rect fieldRect = widgetRect(tree);
fieldRect.w -= buttonCount() * BUTTON_SIZE;
return fieldRect;
}
void calculateGeometry()
{
// Convert to global points
QObject* parent__ = parent();
if ( parent__ == NULL )
return;
QWidget* parent_ = static_cast< QWidget* >( parent__ );
QRect parentRect = parent_ -> geometry();
parentRect.moveTopLeft( parent_ -> mapToGlobal(QPoint(0,0)) );
QRect widgetRect( parentRect );
QLayout* layout_ = layout();
if ( layout_ != NULL )
{
QApplication::instance() -> sendPostedEvents();
layout_ -> activate();
layout_ -> update();
}
QRect normalGeometry_ = normalGeometry();
// Use normal geometry if there is any
if ( normalGeometry_.width() != 0 && normalGeometry_.height() != 0 )
{
widgetRect.setWidth( normalGeometry_.width() );
widgetRect.setHeight( normalGeometry_.height() );
}
if ( layout_ != 0 )
{
QSize sizeHint = layout_ -> sizeHint();
if ( widgetRect.height() < sizeHint.height() )
widgetRect.setHeight( sizeHint.height() );
if ( widgetRect.width() < sizeHint.width() )
widgetRect.setWidth( sizeHint.width() );
widgetRect.setSize( sizeHint );
}
QPoint bindTo;
switch(parentCornerToAnchor_)
{
default:
case Qt::TopLeftCorner:
bindTo = parentRect.topLeft(); break;
case Qt::TopRightCorner:
bindTo = parentRect.topRight(); break;
case Qt::BottomLeftCorner:
bindTo = parentRect.bottomLeft(); break;
case Qt::BottomRightCorner:
bindTo = parentRect.bottomRight(); break;
}
switch(widgetCornerToAnchor_)
{
default:
case Qt::TopLeftCorner:
widgetRect.moveTopLeft( bindTo ); break;
case Qt::TopRightCorner:
widgetRect.moveTopRight( bindTo ); break;
case Qt::BottomLeftCorner:
widgetRect.moveBottomLeft( bindTo ); break;
case Qt::BottomRightCorner:
widgetRect.moveBottomRight( bindTo ); break;
}
QDesktopWidget desktopWidget;
// If user only has one screen, ensure the popup doesn't go off screen
// If multiple screens, this could be annoying as the popup can be viewed on a 2nd screen
if ( desktopWidget.screenCount() == 1)
widgetRect = desktopWidget.screenGeometry( parent_ ).intersected( widgetRect );
setGeometry( widgetRect );
}
bool DocumentWidget::isVisible()
{
QRect visibleRect(scrollView->contentsX(), scrollView->contentsY(), scrollView->visibleWidth(), scrollView->visibleHeight());
QRect widgetRect(scrollView->childX(this), scrollView->childY(this), width(), height());
return widgetRect.intersects(visibleRect);
}
void KisOpenGLCanvas2::drawImage()
{
if (!d->displayShader) {
return;
}
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
KisCoordinatesConverter *converter = coordinatesConverter();
d->displayShader->bind();
QMatrix4x4 projectionMatrix;
projectionMatrix.setToIdentity();
projectionMatrix.ortho(0, width(), height(), 0, NEAR_VAL, FAR_VAL);
// Set view/projection matrices
QMatrix4x4 modelMatrix(coordinatesConverter()->imageToWidgetTransform());
modelMatrix.optimize();
modelMatrix = projectionMatrix * modelMatrix;
d->displayShader->setUniformValue(d->displayShader->location(Uniform::ModelViewProjection), modelMatrix);
QMatrix4x4 textureMatrix;
textureMatrix.setToIdentity();
d->displayShader->setUniformValue(d->displayShader->location(Uniform::TextureMatrix), textureMatrix);
QRectF widgetRect(0,0, width(), height());
QRectF widgetRectInImagePixels = converter->documentToImage(converter->widgetToDocument(widgetRect));
qreal scaleX, scaleY;
converter->imageScale(&scaleX, &scaleY);
d->displayShader->setUniformValue(d->displayShader->location(Uniform::ViewportScale), (GLfloat) scaleX);
d->displayShader->setUniformValue(d->displayShader->location(Uniform::TexelSize), (GLfloat) d->openGLImageTextures->texelSize());
QRect ir = d->openGLImageTextures->storedImageBounds();
QRect wr = widgetRectInImagePixels.toAlignedRect();
if (!d->wrapAroundMode) {
// if we don't want to paint wrapping images, just limit the
// processing area, and the code will handle all the rest
wr &= ir;
}
int firstColumn = d->xToColWithWrapCompensation(wr.left(), ir);
int lastColumn = d->xToColWithWrapCompensation(wr.right(), ir);
int firstRow = d->yToRowWithWrapCompensation(wr.top(), ir);
int lastRow = d->yToRowWithWrapCompensation(wr.bottom(), ir);
int minColumn = d->openGLImageTextures->xToCol(ir.left());
int maxColumn = d->openGLImageTextures->xToCol(ir.right());
int minRow = d->openGLImageTextures->yToRow(ir.top());
int maxRow = d->openGLImageTextures->yToRow(ir.bottom());
int imageColumns = maxColumn - minColumn + 1;
int imageRows = maxRow - minRow + 1;
for (int col = firstColumn; col <= lastColumn; col++) {
for (int row = firstRow; row <= lastRow; row++) {
int effectiveCol = col;
int effectiveRow = row;
QPointF tileWrappingTranslation;
if (effectiveCol > maxColumn || effectiveCol < minColumn) {
int translationStep = floor(qreal(col) / imageColumns);
int originCol = translationStep * imageColumns;
effectiveCol = col - originCol;
tileWrappingTranslation.rx() = translationStep * ir.width();
}
if (effectiveRow > maxRow || effectiveRow < minRow) {
int translationStep = floor(qreal(row) / imageRows);
int originRow = translationStep * imageRows;
effectiveRow = row - originRow;
tileWrappingTranslation.ry() = translationStep * ir.height();
}
KisTextureTile *tile =
d->openGLImageTextures->getTextureTileCR(effectiveCol, effectiveRow);
if (!tile) {
warnUI << "OpenGL: Trying to paint texture tile but it has not been created yet.";
continue;
}
/*
* We create a float rect here to workaround Qt's
* "history reasons" in calculation of right()
* and bottom() coordinates of integer rects.
*/
QRectF textureRect(tile->tileRectInTexturePixels());
QRectF modelRect(tile->tileRectInImagePixels().translated(tileWrappingTranslation.x(), tileWrappingTranslation.y()));
//Setup the geometry for rendering
if (KisOpenGL::hasOpenGL3()) {
rectToVertices(d->vertices, modelRect);
d->quadBuffers[0].bind();
d->quadBuffers[0].write(0, d->vertices, 3 * 6 * sizeof(float));
rectToTexCoords(d->texCoords, textureRect);
d->quadBuffers[1].bind();
d->quadBuffers[1].write(0, d->texCoords, 2 * 6 * sizeof(float));
}
else {
rectToVertices(d->vertices, modelRect);
d->displayShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE);
d->displayShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, d->vertices);
rectToTexCoords(d->texCoords, textureRect);
d->displayShader->enableAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE);
d->displayShader->setAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE, d->texCoords);
}
if (d->displayFilter) {
glActiveTexture(GL_TEXTURE0 + 1);
glBindTexture(GL_TEXTURE_3D, d->displayFilter->lutTexture());
d->displayShader->setUniformValue(d->displayShader->location(Uniform::Texture1), 1);
}
int currentLodPlane = tile->currentLodPlane();
if (d->displayShader->location(Uniform::FixedLodLevel) >= 0) {
d->displayShader->setUniformValue(d->displayShader->location(Uniform::FixedLodLevel),
(GLfloat) currentLodPlane);
}
glActiveTexture(GL_TEXTURE0);
tile->bindToActiveTexture();
if (currentLodPlane > 0) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
} else if (SCALE_MORE_OR_EQUAL_TO(scaleX, scaleY, 2.0)) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
} else {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
switch(d->filterMode) {
case KisOpenGL::NearestFilterMode:
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
break;
case KisOpenGL::BilinearFilterMode:
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
break;
case KisOpenGL::TrilinearFilterMode:
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
break;
case KisOpenGL::HighQualityFiltering:
if (SCALE_LESS_THAN(scaleX, scaleY, 0.5)) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
} else {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
break;
}
}
glDrawArrays(GL_TRIANGLES, 0, 6);
}
}
glBindTexture(GL_TEXTURE_2D, 0);
d->displayShader->release();
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
