int RichTextRenderer::fitToSize(const QSize& size, int minimumFontSize, int maximumFontSize) { int width = size.width(); int height = size.height(); const QString sizeKey = QString("%1:%2:%3:%4").arg(html()).arg(width).arg(height).arg(minimumFontSize); // for centering qreal boxHeight = -1; double ptSize = -1; if(static_autoTextSizeCache.contains(sizeKey)) { ptSize = *(static_autoTextSizeCache[sizeKey]); //qDebug()<<"RichTextRenderer::fitToSize(): size search: CACHE HIT: loaded size:"<<ptSize; // We go thru the much-more-verbose method of creating // the document and setting the html, width, merge cursor, // etc, just so we can get the document height after // setting the font size inorder to use it to center the textbox. // If we didnt nead the height, we could just use autoText->setFontSize() QTextDocument doc; doc.setTextWidth(width); if (Qt::mightBeRichText(html())) doc.setHtml(html()); else doc.setPlainText(html()); QTextCursor cursor(&doc); cursor.select(QTextCursor::Document); QTextCharFormat format; format.setFontPointSize(ptSize); cursor.mergeCharFormat(format); boxHeight = doc.documentLayout()->documentSize().height(); setHtml(doc.toHtml()); } else { double ptSize = minimumFontSize > 0 ? minimumFontSize : findFontSize(); double sizeInc = 1; // how big of a jump to add to the ptSize each iteration int count = 0; // current loop iteration int maxCount = 100; // max iterations of the search loop bool done = false; double lastGoodSize = ptSize; QString lastGoodHtml = html(); QTextDocument doc; qreal heightTmp; doc.setTextWidth(width); if (Qt::mightBeRichText(html())) doc.setHtml(html()); else doc.setPlainText(html()); QTextCursor cursor(&doc); cursor.select(QTextCursor::Document); QTextCharFormat format; while(!done && count++ < maxCount) { format.setFontPointSize(ptSize); cursor.mergeCharFormat(format); heightTmp = doc.documentLayout()->documentSize().height(); if(heightTmp < height && ptSize < maximumFontSize) { lastGoodSize = ptSize; //lastGoodHtml = html(); boxHeight = heightTmp; sizeInc *= 1.1; // qDebug()<<"size search: "<<ptSize<<"pt was good, trying higher, inc:"<<sizeInc<<"pt"; ptSize += sizeInc; } else { // qDebug()<<"fitToSize: size search: last good ptsize:"<<lastGoodSize<<", stopping search"; done = true; } } if(boxHeight < 0 && minimumFontSize <= 0) // didnt find a size { ptSize = 100; count = 0; done = false; sizeInc = 1; //qDebug()<<"RichTextRenderer::fitToSize(): size search: going UP failed, now I'll try to go DOWN"; while(!done && count++ < maxCount) { format.setFontPointSize(ptSize); cursor.mergeCharFormat(format); heightTmp = doc.documentLayout()->documentSize().height(); if(heightTmp < height) { lastGoodSize = ptSize; //lastGoodHtml = html(); boxHeight = heightTmp; sizeInc *= 1.1; //qDebug()<<"size search: "<<ptSize<<"pt was good, trying higher, inc:"<<sizeInc<<"pt"; ptSize -= sizeInc; } else { //qDebug()<<"SongSlideGroup::textToSlides(): size search: last good ptsize:"<<lastGoodSize<<", stopping search"; done = true; } } } format.setFontPointSize(lastGoodSize); cursor.mergeCharFormat(format); setHtml(doc.toHtml()); //qDebug()<<"RichTextRenderer::fitToSize(): size search: caching ptsize:"<<lastGoodSize<<", count: "<<count<<"( minimum size was:"<<minimumFontSize<<")"; boxHeight = heightTmp; //static_autoTextSizeCache[sizeKey] = lastGoodSize; // We are using a QCache instead of a plain QMap, so that requires a pointer value // Using QCache because the key for the cache could potentially become quite large if there are large amounts of HTML // and I dont want to just keep accumlating html in the cache infinitely static_autoTextSizeCache.insert(sizeKey, new double(lastGoodSize),1); } return (int)boxHeight; }
void tst_QLayout::smartMaxSize() { QVector<int> expectedWidths; QFile f(QLatin1String(SRCDIR "/baseline/smartmaxsize")); QCOMPARE(f.open(QIODevice::ReadOnly | QIODevice::Text), true); QTextStream stream(&f); while(!stream.atEnd()) { QString line = stream.readLine(200); expectedWidths.append(line.section(QLatin1Char(' '), 6, -1, QString::SectionSkipEmpty).toInt()); } f.close(); int sizeCombinations[] = { 0, 10, 20, QWIDGETSIZE_MAX}; QSizePolicy::Policy policies[] = { QSizePolicy::Fixed, QSizePolicy::Minimum, QSizePolicy::Maximum, QSizePolicy::Preferred, QSizePolicy::Expanding, QSizePolicy::MinimumExpanding, QSizePolicy::Ignored }; Qt::Alignment alignments[] = { 0, Qt::AlignLeft, Qt::AlignRight, Qt::AlignHCenter }; int expectedIndex = 0; int regressionCount = 0; for (int p = 0; p < sizeof(policies)/sizeof(QSizePolicy::Policy); ++p) { QSizePolicy sizePolicy; sizePolicy.setHorizontalPolicy(policies[p]); for (int min = 0; min < sizeof(sizeCombinations)/sizeof(int); ++min) { int minSize = sizeCombinations[min]; for (int max = 0; max < sizeof(sizeCombinations)/sizeof(int); ++max) { int maxSize = sizeCombinations[max]; for (int sh = 0; sh < sizeof(sizeCombinations)/sizeof(int); ++sh) { int sizeHint = sizeCombinations[sh]; for (int a = 0; a < sizeof(alignments)/sizeof(int); ++a) { Qt::Alignment align = alignments[a]; QSize sz = qSmartMaxSize(QSize(sizeHint, 1), QSize(minSize, 1), QSize(maxSize, 1), sizePolicy, align); int width = sz.width(); #if 0 qDebug() << expectedIndex << sizePolicy.horizontalPolicy() << align << minSize << sizeHint << maxSize << width; #else int expectedWidth = expectedWidths[expectedIndex]; if (width != expectedWidth) { qDebug() << "error at index" << expectedIndex << ":" << sizePolicy.horizontalPolicy() << align << minSize << sizeHint << maxSize << width; ++regressionCount; } #endif ++expectedIndex; } } } } } QCOMPARE(regressionCount, 0); }
bool operator<(const QSize &firstSize, const QSize &secondSize) { return (firstSize.height() + (QUACKLE_MAXIMUM_BOARD_SIZE + 1) * firstSize.width()) < (secondSize.height() + (QUACKLE_MAXIMUM_BOARD_SIZE + 1) * secondSize.width()); }
static QBitmap qwtBorderMask( const QWidget *canvas, const QSize &size ) { const QRect r( 0, 0, size.width(), size.height() ); QPainterPath borderPath; ( void )QMetaObject::invokeMethod( const_cast< QWidget *>( canvas ), "borderPath", Qt::DirectConnection, Q_RETURN_ARG( QPainterPath, borderPath ), Q_ARG( QRect, r ) ); if ( borderPath.isEmpty() ) { if ( canvas->contentsRect() == canvas->rect() ) return QBitmap(); QBitmap mask( size ); mask.fill( Qt::color0 ); QPainter painter( &mask ); painter.fillRect( canvas->contentsRect(), Qt::color1 ); return mask; } QImage image( size, QImage::Format_ARGB32_Premultiplied ); image.fill( Qt::color0 ); QPainter painter( &image ); painter.setClipPath( borderPath ); painter.fillRect( r, Qt::color1 ); // now erase the frame painter.setCompositionMode( QPainter::CompositionMode_DestinationOut ); if ( canvas->testAttribute(Qt::WA_StyledBackground ) ) { QStyleOptionFrame opt; opt.initFrom(canvas); opt.rect = r; canvas->style()->drawPrimitive( QStyle::PE_Frame, &opt, &painter, canvas ); } else { const QVariant borderRadius = canvas->property( "borderRadius" ); const QVariant frameWidth = canvas->property( "frameWidth" ); if ( borderRadius.type() == QVariant::Double && frameWidth.type() == QVariant::Int ) { const double br = borderRadius.toDouble(); const int fw = frameWidth.toInt(); if ( br > 0.0 && fw > 0 ) { painter.setPen( QPen( Qt::color1, fw ) ); painter.setBrush( Qt::NoBrush ); painter.setRenderHint( QPainter::Antialiasing, true ); painter.drawPath( borderPath ); } } } painter.end(); const QImage mask = image.createMaskFromColor( QColor( Qt::color1 ).rgb(), Qt::MaskOutColor ); return QBitmap::fromImage( mask ); }
void GBAKeyEditor::setLocation(QWidget* widget, qreal x, qreal y) { QSize s = size(); QSize hint = widget->sizeHint(); widget->setGeometry(s.width() * x - hint.width() / 2.0, s.height() * y - hint.height() / 2.0, hint.width(), hint.height()); }
QString generate_key(qint64 key, const QSize & size) { return QString("%1-%2-%3").arg(key).arg(size.width()).arg(size.height()); }
void PixmapLabel::setPixmap(QPixmap const& p) { m_pixmap = p; if (m_mode == Mode::FixedSize) { QSize size = m_pixmap.size() * m_scalingFactor; this->resize(size); QLabel::setPixmap(m_pixmap.scaled(size, Qt::KeepAspectRatio, Qt::SmoothTransformation)); LOGGER_DEBUG("Setting pixmap in FixedSize mode with Size {} x {} (Pixmap size = {} x {}, Scaling Factor = {})", size.width(), size.height(), m_pixmap.width(), m_pixmap.height(), m_scalingFactor); } else if (m_mode == Mode::HeightForWidth) { QSize size = this->size(); QLabel::setPixmap(m_pixmap.scaled(size, Qt::KeepAspectRatio, Qt::SmoothTransformation)); LOGGER_DEBUG("Setting pixmap in HeightForWidth mode with Size {} x {} (Pixmap size = {} x {})", size.width(), size.height(), m_pixmap.width(), m_pixmap.height()); } else if (m_mode == Mode::TouchFromInside) { QSize size = this->size(); QLabel::setPixmap(m_pixmap.scaled(size, Qt::KeepAspectRatio, Qt::SmoothTransformation)); LOGGER_DEBUG("Setting pixmap in TouchFromInside mode with Size {} x {} (Pixmap size = {} x {})", size.width(), size.height(), m_pixmap.width(), m_pixmap.height()); } }
void OpenGL2Common::paintGL() { if (videoFrameArr.isEmpty() && !hasImage) return; const QSize winSize = widget()->size(); bool resetDone = false; if (!videoFrameArr.isEmpty()) { const VideoFrame *videoFrame = VideoFrame::fromData(videoFrameArr); if (doReset) { /* Prepare textures */ glBindTexture(GL_TEXTURE_2D, 2); glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, videoFrame->linesize[0], outH, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL); glBindTexture(GL_TEXTURE_2D, 3); glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, videoFrame->linesize[1], outH >> 1, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL); glBindTexture(GL_TEXTURE_2D, 4); glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, videoFrame->linesize[2], outH >> 1, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL); /* Prepare texture coordinates */ texCoordYCbCr[2] = texCoordYCbCr[6] = (videoFrame->linesize[0] == outW) ? 1.0f : (outW / (videoFrame->linesize[0] + 1.0f)); resetDone = true; } glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, 2); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, videoFrame->linesize[0], outH, GL_LUMINANCE, GL_UNSIGNED_BYTE, videoFrame->data[0]); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, 3); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, videoFrame->linesize[1], outH >> 1, GL_LUMINANCE, GL_UNSIGNED_BYTE, videoFrame->data[1]); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, 4); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, videoFrame->linesize[2], outH >> 1, GL_LUMINANCE, GL_UNSIGNED_BYTE, videoFrame->data[2]); VideoFrame::unref(videoFrameArr); hasImage = true; } shaderProgramYCbCr->setAttributeArray(positionYCbCrLoc, verticesYCbCr[flip], 2); shaderProgramYCbCr->setAttributeArray(texCoordYCbCrLoc, texCoordYCbCr, 2); shaderProgramYCbCr->enableAttributeArray(positionYCbCrLoc); shaderProgramYCbCr->enableAttributeArray(texCoordYCbCrLoc); shaderProgramYCbCr->bind(); if (doReset) { shaderProgramYCbCr->setUniformValue("scale", W / (float)winSize.width(), H / (float)winSize.height()); shaderProgramYCbCr->setUniformValue("videoEq", Brightness, Contrast, Saturation, Hue); doReset = !resetDone; } glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); shaderProgramYCbCr->release(); shaderProgramYCbCr->disableAttributeArray(texCoordYCbCrLoc); shaderProgramYCbCr->disableAttributeArray(positionYCbCrLoc); glActiveTexture(GL_TEXTURE3); /* OSD */ osdMutex.lock(); if (!osdList.isEmpty()) { glBindTexture(GL_TEXTURE_2D, 1); QRect bounds; const qreal scaleW = (qreal)W / outW, scaleH = (qreal)H / outH; bool mustRepaint = Functions::mustRepaintOSD(osdList, osdChecksums, &scaleW, &scaleH, &bounds); if (!mustRepaint) mustRepaint = osdImg.size() != bounds.size(); if (mustRepaint) { if (osdImg.size() != bounds.size()) osdImg = QImage(bounds.size(), QImage::Format_ARGB32); osdImg.fill(0); QPainter p(&osdImg); p.translate(-bounds.topLeft()); Functions::paintOSD(false, osdList, scaleW, scaleH, p, &osdChecksums); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bounds.width(), bounds.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, osdImg.bits()); } const float left = (bounds.left() + X) * 2.0f / winSize.width(); const float right = (bounds.right() + X + 1) * 2.0f / winSize.width(); const float top = (bounds.top() + Y) * 2.0f / winSize.height(); const float bottom = (bounds.bottom() + Y + 1) * 2.0f / winSize.height(); const float verticesOSD[8] = { left - 1.0f, -bottom + 1.0f, right - 1.0f, -bottom + 1.0f, left - 1.0f, -top + 1.0f, right - 1.0f, -top + 1.0f, }; shaderProgramOSD->setAttributeArray(positionOSDLoc, verticesOSD, 2); shaderProgramOSD->setAttributeArray(texCoordOSDLoc, texCoordOSD, 2); shaderProgramOSD->enableAttributeArray(positionOSDLoc); shaderProgramOSD->enableAttributeArray(texCoordOSDLoc); glEnable(GL_BLEND); shaderProgramOSD->bind(); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); shaderProgramOSD->release(); glDisable(GL_BLEND); shaderProgramOSD->disableAttributeArray(texCoordOSDLoc); shaderProgramOSD->disableAttributeArray(positionOSDLoc); } osdMutex.unlock(); glBindTexture(GL_TEXTURE_2D, 0); }
// Code should take into account the aspect ratios of both the video as // well as the actual screen to allow proper letterboxing to take place. void VideoOutWindow::ApplyLetterboxing(void) { float disp_aspect = fix_aspect(GetDisplayAspect()); float aspect_diff = disp_aspect - overriden_video_aspect; bool aspects_match = abs(aspect_diff / disp_aspect) <= 0.02f; bool nomatch_with_fill = !aspects_match && ((kAdjustFill_HorizontalStretch == adjustfill) || (kAdjustFill_VerticalStretch == adjustfill)); bool nomatch_without_fill = (!aspects_match) && !nomatch_with_fill; // Adjust for video/display aspect ratio mismatch if (nomatch_with_fill && (disp_aspect > overriden_video_aspect)) { float pixNeeded = ((disp_aspect / overriden_video_aspect) * (float) display_video_rect.height()) + 0.5f; display_video_rect.moveTop( display_video_rect.top() + (display_video_rect.height() - (int) pixNeeded) / 2); display_video_rect.setHeight((int) pixNeeded); } else if (nomatch_with_fill) { float pixNeeded = ((overriden_video_aspect / disp_aspect) * (float) display_video_rect.width()) + 0.5f; display_video_rect.moveLeft( display_video_rect.left() + (display_video_rect.width() - (int) pixNeeded) / 2); display_video_rect.setWidth((int) pixNeeded); } else if (nomatch_without_fill && (disp_aspect > overriden_video_aspect)) { float pixNeeded = ((overriden_video_aspect / disp_aspect) * (float) display_video_rect.width()) + 0.5f; display_video_rect.moveLeft( display_video_rect.left() + (display_video_rect.width() - (int) pixNeeded) / 2); display_video_rect.setWidth((int) pixNeeded); } else if (nomatch_without_fill) { float pixNeeded = ((disp_aspect / overriden_video_aspect) * (float) display_video_rect.height()) + 0.5f; display_video_rect.moveTop( display_video_rect.top() + (display_video_rect.height() - (int) pixNeeded) / 2); display_video_rect.setHeight((int) pixNeeded); } // Process letterbox zoom modes if (adjustfill == kAdjustFill_Full) { // Zoom mode -- Expand by 4/3 and overscan. // 1/6 of original is 1/8 of new display_video_rect = QRect( display_video_rect.left() - (display_video_rect.width() / 6), display_video_rect.top() - (display_video_rect.height() / 6), display_video_rect.width() * 4 / 3, display_video_rect.height() * 4 / 3); } else if (adjustfill == kAdjustFill_Half) { // Zoom mode -- Expand by 7/6 and overscan. // Intended for eliminating the top bars on 14:9 material. // Also good compromise for 4:3 material on 16:9 screen. // Expanding by 7/6, so remove 1/6 of original from overscan; // take half from each side, so remove 1/12. display_video_rect = QRect( display_video_rect.left() - (display_video_rect.width() / 12), display_video_rect.top() - (display_video_rect.height() / 12), display_video_rect.width() * 7 / 6, display_video_rect.height() * 7 / 6); } else if (adjustfill == kAdjustFill_HorizontalStretch) { // Horizontal Stretch mode -- 1/6 of original is 1/8 of new // Intended to be used to eliminate side bars on 4:3 material // encoded to 16:9. display_video_rect.moveLeft( display_video_rect.left() - (display_video_rect.width() / 6)); display_video_rect.setWidth(display_video_rect.width() * 4 / 3); } else if (adjustfill == kAdjustFill_VerticalStretch) { // Vertical Stretch mode -- 1/6 of original is 1/8 of new // Intended to be used to eliminate top/bottom bars on 16:9 // material encoded to 4:3. display_video_rect.moveTop( display_video_rect.top() - (display_video_rect.height() / 6)); display_video_rect.setHeight(display_video_rect.height() * 4 / 3); } else if (adjustfill == kAdjustFill_VerticalFill && display_video_rect.height() > 0) { // Video fills screen vertically. May be cropped left and right float factor = (float)display_visible_rect.height() / (float)display_video_rect.height(); QSize newsize = QSize((int) (display_video_rect.width() * factor), (int) (display_video_rect.height() * factor)); QSize temp = (display_video_rect.size() - newsize) / 2; QPoint newloc = display_video_rect.topLeft() + QPoint(temp.width(), temp.height()); display_video_rect = QRect(newloc, newsize); } else if (adjustfill == kAdjustFill_HorizontalFill && display_video_rect.width() > 0) { // Video fills screen horizontally. May be cropped top and bottom float factor = (float)display_visible_rect.width() / (float)display_video_rect.width(); QSize newsize = QSize((int) (display_video_rect.width() * factor), (int) (display_video_rect.height() * factor)); QSize temp = (display_video_rect.size() - newsize) / 2; QPoint newloc = display_video_rect.topLeft() + QPoint(temp.width(), temp.height()); display_video_rect = QRect(newloc, newsize); } }
QSize DpiScaler::scaled( const QPaintDevice* pd, const QSize& size ) { return scaled( pd, size.width(), size.height() ); }
bool QGLPixelBufferPrivate::init(const QSize &size, const QGLFormat &f, QGLWidget *shareWidget) { QGLWidget dmy; dmy.makeCurrent(); // needed for wglGetProcAddress() to succeed PFNWGLCREATEPBUFFERARBPROC wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC) wglGetProcAddress("wglCreatePbufferARB"); PFNWGLGETPBUFFERDCARBPROC wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC) wglGetProcAddress("wglGetPbufferDCARB"); PFNWGLQUERYPBUFFERARBPROC wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC) wglGetProcAddress("wglQueryPbufferARB"); PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC) wglGetProcAddress("wglChoosePixelFormatARB"); if (!wglCreatePbufferARB) // assumes that if one can be resolved, all of them can return false; dc = GetDC(dmy.winId()); Q_ASSERT(dc); PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC) wglGetProcAddress("wglGetExtensionsStringARB"); if (wglGetExtensionsStringARB) { QString extensions(QLatin1String(wglGetExtensionsStringARB(dc))); has_render_texture = extensions.contains(QLatin1String("WGL_ARB_render_texture")); } int attribs[40]; qt_format_to_attrib_list(has_render_texture, f, attribs); // Find pbuffer capable pixel format. unsigned int num_formats = 0; int pixel_format; wglChoosePixelFormatARB(dc, attribs, 0, 1, &pixel_format, &num_formats); // some GL implementations don't support pbuffers with accum // buffers, so try that before we give up if (num_formats == 0 && f.accum()) { QGLFormat tmp = f; tmp.setAccum(false); qt_format_to_attrib_list(has_render_texture, tmp, attribs); wglChoosePixelFormatARB(dc, attribs, 0, 1, &pixel_format, &num_formats); } if (num_formats == 0) { qWarning("QGLPixelBuffer: Unable to find a pixel format with pbuffer - giving up."); ReleaseDC(dmy.winId(), dc); return false; } format = pfiToQGLFormat(dc, pixel_format); // NB! The below ONLY works if the width/height are powers of 2. // Set some pBuffer attributes so that we can use this pBuffer as // a 2D RGBA texture target. int pb_attribs[] = {WGL_TEXTURE_FORMAT_ARB, WGL_TEXTURE_RGBA_ARB, WGL_TEXTURE_TARGET_ARB, WGL_TEXTURE_2D_ARB, 0}; pbuf = wglCreatePbufferARB(dc, pixel_format, size.width(), size.height(), has_render_texture ? pb_attribs : 0); if(!pbuf) { // try again without the render_texture extension pbuf = wglCreatePbufferARB(dc, pixel_format, size.width(), size.height(), 0); has_render_texture = false; if (!pbuf) { qWarning("QGLPixelBuffer: Unable to create pbuffer [w=%d, h=%d] - giving up.", size.width(), size.height()); ReleaseDC(dmy.winId(), dc); return false; } } ReleaseDC(dmy.winId(), dc); dc = wglGetPbufferDCARB(pbuf); ctx = wglCreateContext(dc); if (!dc || !ctx) { qWarning("QGLPixelBuffer: Unable to create pbuffer context - giving up."); return false; } HGLRC share_ctx = shareWidget ? shareWidget->d_func()->glcx->d_func()->rc : 0; if (share_ctx && !wglShareLists(share_ctx, ctx)) qWarning("QGLPixelBuffer: Unable to share display lists - with share widget."); int width, height; wglQueryPbufferARB(pbuf, WGL_PBUFFER_WIDTH_ARB, &width); wglQueryPbufferARB(pbuf, WGL_PBUFFER_HEIGHT_ARB, &height); return true; }
QSize DpiScaler::scaled( const QSize& size ) const { return scaled( size.width(), size.height() ); }
KSSH::KSSH(QWidget *parent) : QDialog(parent) { setupUi(this); QLayout *lay; lay = layout(); if (lay) lay->setSizeConstraint(QLayout::SetFixedSize); opt = false; mopt = false; editorF->hide(); QSize s = size(); QPoint p(s.width(), s.height()); QPoint po = pos(); QDesktopWidget *d = QApplication::desktop(); int w = d->width(); // returns desktop width int h = d->height (); // returns desktop height int x = 0, y = 0; if ((p + po).x()>w) po.setX(x = w-p.x()); if ((p + po).y()>h) po.setY(y = h-p.y()); if (x<0) po.setX(0); if (y<0) po.setY(0); move(po); optionsGB->hide(); moreF->hide(); adjustSize(); compUser = new KCompletion(); userCB->setCompletionObject(compUser); compHost = new KCompletion(); hostCB->setCompletionObject(compHost); hostCB->setFocus(); connect(hostCB, SIGNAL(editTextChanged(const QString&)), this, SLOT(userFor(const QString&))); connect(compHost, SIGNAL(match(const QString&)), this, SLOT(userFor(const QString&))); userCB->insertItem(1, ""); hostCB->insertItem(2, ""); loadHosts(); loadOptions("DefaultConfig"); connect(aboutPB, SIGNAL(clicked()), this, SLOT(about())); connect(optionsPB, SIGNAL(clicked()), this, SLOT(options())); connect(morePB, SIGNAL(clicked()), this, SLOT(moreOptions())); connect(hostTB, SIGNAL(clicked()), this, SLOT(hostEditor())); connect(userTB, SIGNAL(clicked()), this, SLOT(userEditor())); connect(cancelPB, SIGNAL(clicked()), this, SLOT(cancelEditor())); connect(okPB, SIGNAL(clicked()), this, SLOT(okEditor())); connect(connectPB, SIGNAL(clicked()), this, SLOT(ssh())); connect(savePB, SIGNAL(clicked()), this, SLOT(saveAsDefault())); connect(quitPB, SIGNAL(clicked()), this, SLOT(exitHandler())); KConfigGroup general_group = KGlobal::config()->group("General"); int fi = hostCB->findText(general_group.readEntry("LastHost")); if (fi) hostCB->setCurrentIndex(fi); int def = KGlobalSettings::completionMode(); int mode = general_group.readEntry("HostCompletionMode", def); hostCB->setCompletionMode((KGlobalSettings::Completion) mode); mode = general_group.readEntry("UserCompletionMode", def); userCB->setCompletionMode((KGlobalSettings::Completion)mode); setWindowIcon(KIcon("kssh.png")); }
static QSize maxSize(const QSize &a, const QSize &b) { return QSize(qMax(a.width(), b.width()), qMax(a.height(), b.height())); }
void QTermWidget::setSize(const QSize &size) { if (!m_impl->m_terminalDisplay) return; m_impl->m_terminalDisplay->setSize(size.width(), size.height()); }
/// Correct for underalignment static QSize fix_alignment(QSize raw) { return QSize((raw.width() + 15) & (~0xf), (raw.height() + 15) & (~0xf)); }
void PictureShape::paint(QPainter &painter, const KoViewConverter &converter, KoShapePaintingContext &paintContext) { Q_UNUSED(paintContext); QRectF viewRect = converter.documentToView(QRectF(QPointF(0,0), size())); if (imageData() == 0) { painter.fillRect(viewRect, QColor(Qt::gray)); return; } painter.save(); applyConversion(painter, converter); paintBorder(painter, converter); painter.restore(); QSize pixmapSize = calcOptimalPixmapSize(viewRect.size(), imageData()->image().size()); // Normalize the clipping rect if it isn't already done. m_clippingRect.normalize(imageData()->imageSize()); // Handle style:mirror, i.e. mirroring horizontally and/or vertically. // // NOTE: At this time we don't handle HorizontalOnEven // and HorizontalOnOdd, which have to know which // page they are on. In those cases we treat it as // no horizontal mirroring at all. bool doFlip = false; QSizeF shapeSize = size(); QSizeF viewSize = converter.documentToView(shapeSize); qreal midpointX = 0.0; qreal midpointY = 0.0; qreal scaleX = 1.0; qreal scaleY = 1.0; if (m_mirrorMode & MirrorHorizontal) { midpointX = viewSize.width() / qreal(2.0); scaleX = -1.0; doFlip = true; } if (m_mirrorMode & MirrorVertical) { midpointY = viewSize.height() / qreal(2.0); scaleY = -1.0; doFlip = true; } if (doFlip) { QTransform outputTransform = painter.transform(); QTransform worldTransform = QTransform(); //kDebug(31000) << "Flipping" << midpointX << midpointY << scaleX << scaleY; worldTransform.translate(midpointX, midpointY); worldTransform.scale(scaleX, scaleY); worldTransform.translate(-midpointX, -midpointY); //kDebug(31000) << "After flipping for window" << worldTransform; QTransform newTransform = worldTransform * outputTransform; painter.setWorldTransform(newTransform); } // Paint the image as prepared in waitUntilReady() if (!m_printQualityImage.isNull() && pixmapSize != m_printQualityRequestedSize) { QSizeF imageSize = m_printQualityImage.size(); QRectF cropRect( imageSize.width() * m_clippingRect.left, imageSize.height() * m_clippingRect.top, imageSize.width() * m_clippingRect.width(), imageSize.height() * m_clippingRect.height() ); painter.drawImage(viewRect, m_printQualityImage, cropRect); m_printQualityImage = QImage(); // free memory } else { QPixmap pixmap; QString key(generate_key(imageData()->key(), pixmapSize)); // If the required pixmap is not in the cache // launch a task in a background thread that scales // the source image to the required size if (!QPixmapCache::find(key, &pixmap)) { QThreadPool::globalInstance()->start(new _Private::PixmapScaler(this, pixmapSize)); painter.fillRect(viewRect, QColor(Qt::gray)); // just paint a gray rect as long as we don't have the required pixmap } else { QRectF cropRect( pixmapSize.width() * m_clippingRect.left, pixmapSize.height() * m_clippingRect.top, pixmapSize.width() * m_clippingRect.width(), pixmapSize.height() * m_clippingRect.height() ); painter.drawPixmap(viewRect, pixmap, cropRect); } } }
ScaleDlg::ScaleDlg( const QSize & origsize, QVBox * parent, const char * name ) : QObject( parent, name ) , m_origsize( origsize ) , m_newsizeunit( 0 ) , m_newsizeunit2( 0 ) , m_resolutionunit( 0 ) , m_newwidth( origsize.width() ) , m_newheight( origsize.height() ) , m_resx( 72 ) , m_resy( 72 ) { QGroupBox * pixelgroup = new QGroupBox( i18n( "Pixel Dimensions" ), parent ); QGroupBox * printgroup = new QGroupBox( i18n( "Print Size && Display Units" ), parent ); QGridLayout * pixelgroupgrid = new QGridLayout( pixelgroup, 1, 1, KDialog::marginHint(), KDialog::spacingHint() ); QGridLayout * printgroupgrid = new QGridLayout( printgroup, 1, 1, KDialog::marginHint(), KDialog::spacingHint() ); QLabel * label; pixelgroupgrid->addRowSpacing( 0, KDialog::spacingHint() ); label = new QLabel( i18n( "Original width:" ), pixelgroup ); label->setAlignment( int( QLabel::AlignVCenter | QLabel::AlignRight ) ); pixelgroupgrid->addWidget( label, 1, 0 ); label = new QLabel( i18n( "Height:" ), pixelgroup ); label->setAlignment( int( QLabel::AlignVCenter | QLabel::AlignRight ) ); pixelgroupgrid->addWidget( label, 2, 0 ); pixelgroupgrid->addRowSpacing( 3, KDialog::spacingHint() ); label = new QLabel( i18n( "New width:" ), pixelgroup ); label->setAlignment( int( QLabel::AlignVCenter | QLabel::AlignRight ) ); pixelgroupgrid->addWidget( label, 4, 0 ); label = new QLabel( i18n( "Height:" ), pixelgroup ); label->setAlignment( int( QLabel::AlignVCenter | QLabel::AlignRight ) ); pixelgroupgrid->addWidget( label, 5, 0 ); pixelgroupgrid->addRowSpacing( 6, KDialog::spacingHint() ); label = new QLabel( i18n( "Ratio X:" ), pixelgroup ); label->setAlignment( int( QLabel::AlignVCenter | QLabel::AlignRight ) ); pixelgroupgrid->addWidget( label, 7, 0 ); label = new QLabel( i18n( "Y:" ), pixelgroup ); label->setAlignment( int( QLabel::AlignVCenter | QLabel::AlignRight ) ); pixelgroupgrid->addWidget( label, 8, 0 ); printgroupgrid->addRowSpacing( 0, KDialog::spacingHint() ); label = new QLabel( i18n( "New width:" ), printgroup ); label->setAlignment( int( QLabel::AlignVCenter | QLabel::AlignRight ) ); printgroupgrid->addWidget( label, 1, 0 ); label = new QLabel( i18n( "Height:" ), printgroup ); label->setAlignment( int( QLabel::AlignVCenter | QLabel::AlignRight ) ); printgroupgrid->addWidget( label, 2, 0 ); printgroupgrid->addRowSpacing( 3, KDialog::spacingHint() ); label = new QLabel( i18n( "Resolution X:" ), printgroup ); label->setAlignment( int( QLabel::AlignVCenter | QLabel::AlignRight ) ); printgroupgrid->addWidget( label, 4, 0 ); label = new QLabel( i18n( "Y:" ), printgroup ); label->setAlignment( int( QLabel::AlignVCenter | QLabel::AlignRight ) ); printgroupgrid->addWidget( label, 5, 0 ); m_pOldWidth = new QLabel( QString::number( origsize.width() ), pixelgroup ); m_pOldWidth->setAlignment( int( QLabel::AlignVCenter | QLabel::AlignRight ) ); pixelgroupgrid->addWidget( m_pOldWidth, 1, 1 ); m_pOldHeight = new QLabel( QString::number( origsize.height() ), pixelgroup ); m_pOldHeight->setAlignment( int( QLabel::AlignVCenter | QLabel::AlignRight ) ); pixelgroupgrid->addWidget( m_pOldHeight, 2, 1 ); m_pNewWidth = new KFloatSpinBox( 1.0, 100000.0, 10.0, 0, pixelgroup ); pixelgroupgrid->addWidget( m_pNewWidth, 4, 1 ); m_pNewHeight = new KFloatSpinBox( 1.0, 100000.0, 10.0, 0, pixelgroup ); pixelgroupgrid->addWidget( m_pNewHeight, 5, 1 ); m_pNewSizeUnit = new KComboBox( pixelgroup ); m_pNewSizeUnit->insertItem( i18n( "px" ) ); m_pNewSizeUnit->insertItem( i18n( "%" ) ); pixelgroupgrid->addMultiCellWidget( m_pNewSizeUnit, 4, 5, 2, 2, Qt::AlignVCenter ); m_pRatioX = new KFloatSpinBox( 0.0001, 10000.0, 0.1, 4, pixelgroup ); pixelgroupgrid->addWidget( m_pRatioX, 7, 1 ); m_pRatioY = new KFloatSpinBox( 0.0001, 10000.0, 0.1, 4, pixelgroup ); pixelgroupgrid->addWidget( m_pRatioY, 8, 1 ); m_pLinkRatio = new QCheckBox( i18n( "Link" ), pixelgroup ); pixelgroupgrid->addMultiCellWidget( m_pLinkRatio, 7, 8, 2, 2, Qt::AlignVCenter ); m_pNewWidth2 = new KFloatSpinBox( 0.0001, 10000.0, 0.1, 4, printgroup ); printgroupgrid->addWidget( m_pNewWidth2, 1, 1 ); m_pNewHeight2 = new KFloatSpinBox( 0.0001, 10000.0, 0.1, 4, printgroup ); printgroupgrid->addWidget( m_pNewHeight2, 2, 1 ); m_pNewSizeUnit2 = new KComboBox( printgroup ); m_pNewSizeUnit2->insertItem( i18n( "in" ) ); m_pNewSizeUnit2->insertItem( i18n( "mm" ) ); printgroupgrid->addMultiCellWidget( m_pNewSizeUnit2, 1, 2, 2, 2, Qt::AlignVCenter ); m_pResolutionX = new KFloatSpinBox( 0.0001, 6000.0, 1.0, 4, printgroup ); printgroupgrid->addWidget( m_pResolutionX, 4, 1 ); m_pResolutionY = new KFloatSpinBox( 0.0001, 6000.0, 1.0, 4, printgroup ); printgroupgrid->addWidget( m_pResolutionY, 5, 1 ); m_pLinkResolution = new QCheckBox( i18n( "Link" ), printgroup ); printgroupgrid->addMultiCellWidget( m_pLinkResolution, 4, 5, 2, 2, Qt::AlignVCenter ); m_pResolutionUnit = new KComboBox( printgroup ); m_pResolutionUnit->insertItem( i18n( "pixels/in" ) ); m_pResolutionUnit->insertItem( i18n( "pixels/mm" ) ); printgroupgrid->addMultiCellWidget( m_pResolutionUnit, 6, 6, 1, 2, Qt::AlignLeft ); m_pNewWidth->setValue( m_origsize.width() ); m_pNewHeight->setValue( m_origsize.height() ); m_newsizeunit = 0; m_newsizeunit2 = 0; m_resolutionunit = 0; connect( m_pNewWidth, SIGNAL( valueChanged( float ) ), SLOT( slotNewWidth( float ) ) ); connect( m_pNewHeight, SIGNAL( valueChanged( float ) ), SLOT( slotNewHeight( float ) ) ); connect( m_pNewWidth2, SIGNAL( valueChanged( float ) ), SLOT( slotNewWidth2( float ) ) ); connect( m_pNewHeight2, SIGNAL( valueChanged( float ) ), SLOT( slotNewHeight2( float ) ) ); connect( m_pResolutionX, SIGNAL( valueChanged( float ) ), SLOT( slotResolutionX( float ) ) ); connect( m_pResolutionY, SIGNAL( valueChanged( float ) ), SLOT( slotResolutionY( float ) ) ); connect( m_pNewSizeUnit, SIGNAL( activated( int ) ), SLOT( slotChangeNewSizeUnit( int ) ) ); connect( m_pNewSizeUnit2, SIGNAL( activated( int ) ), SLOT( slotChangeNewSizeUnit2( int ) ) ); connect( m_pResolutionUnit, SIGNAL( activated( int ) ), SLOT( slotChangeResolutionUnit( int ) ) ); }
QPointF QtGradientWidgetPrivate::toViewport(const QPointF &point) const { QSize size = q_ptr->size(); return QPointF(point.x() * size.width(), point.y() * size.height()); }
void kMyMoneyCalendar::resizeEvent(QResizeEvent*) { QWidget *buttons[] = { styleControl, d->userButton1, d->userButton2, yearBackward, monthBackward, selectMonth, selectYear, monthForward, yearForward, d->closeButton }; const int NoOfButtons = sizeof(buttons) / sizeof(buttons[0]); QSize sizes[NoOfButtons]; int buttonHeight = 0; int count; int w; int x = 0; // ----- calculate button row height: for (count = 0; count < NoOfButtons; ++count) { if (buttons[count]) { // closeButton may be 0 sizes[count] = buttons[count]->sizeHint(); buttonHeight = qMax(buttonHeight, sizes[count].height()); } else sizes[count] = QSize(0, 0); // closeButton } // ----- calculate size of the month button: for (count = 0; count < NoOfButtons; ++count) { if (buttons[count] == selectMonth) { QStyleOptionToolButton opt; opt.initFrom(selectMonth); QSize metricBound = style()->sizeFromContents(QStyle::CT_ToolButton, &opt, maxMonthRect); sizes[count].setWidth(qMax(metricBound.width(), maxMonthRect.width() + 2*QApplication::style()->pixelMetric(QStyle::PM_ButtonMargin))); } } // ----- place the buttons: // Put the style button and user buttons to the left and the rest to the right x = 0; int noUserButtons = 2; buttons[0]->setGeometry(x, 0, sizes[0].width(), buttonHeight); x += sizes[0].width(); for (count = 1; count <= noUserButtons; ++count) { if (buttons[count]) { buttons[count]->setGeometry(x, 0, sizes[count].width(), buttonHeight); x += sizes[count].width(); } } x = width(); for (count = (1 + noUserButtons); count < NoOfButtons; ++count) { w = sizes[count].width(); x -= w; } for (count = (1 + noUserButtons); count < NoOfButtons; ++count) { w = sizes[count].width(); if (buttons[count]) buttons[count]->setGeometry(x, 0, w, buttonHeight); x += w; } // ----- place the line edit for direct input: sizes[0] = line->sizeHint(); int week_width = d->selectWeek->fontMetrics().width(i18n("Week XX")) + ((d->closeButton != 0) ? 50 : 20); line->setGeometry(0, height() - sizes[0].height(), width() - week_width, sizes[0].height()); d->selectWeek->setGeometry(width() - week_width, height() - sizes[0].height(), week_width, sizes[0].height()); // ----- adjust the table: table->setGeometry(0, buttonHeight, width(), height() - buttonHeight - sizes[0].height()); table->setFocus(); }
void PixmapLabel::resizeEvent(QResizeEvent* event) { QSize targetSize = sizeHint(); LOGGER_DEBUG("Resize event occured, resizing to {} x {} with container size {} x {}.", targetSize.width(), targetSize.height(), this->width(), this->height()); QLabel::setPixmap(m_pixmap.scaled(targetSize, Qt::KeepAspectRatio, Qt::SmoothTransformation)); }
/* * Create the object list dialog */ void imodvObjectListDialog(ImodvApp *a, int state) { int m; if (!state){ if (Oolist_dialog) Oolist_dialog->close(); return; } if (Oolist_dialog){ Oolist_dialog->raise(); return; } grouping = false; // Get number of buttons, number of columns and number per column // Make maximum number of buttons needed for all loaded models for (m = 0; m < a->numMods; m++) if (numOolistButtons < a->mod[m]->objsize) numOolistButtons = a->mod[m]->objsize; if (numOolistButtons > MAX_OOLIST_BUTTONS) numOolistButtons = MAX_OOLIST_BUTTONS; OolistButtons = (QCheckBox **)malloc(numOolistButtons * sizeof(QCheckBox *)); groupButtons = (QCheckBox **)malloc(numOolistButtons * sizeof(QCheckBox *)); if (!OolistButtons || !groupButtons) { if (OolistButtons) free(OolistButtons); if (groupButtons) free(groupButtons); numOolistButtons = 0; wprint("\aMemory error getting array for checkboxes\n"); return; } Oolist_dialog = new ImodvOlist(imodvDialogManager.parent(IMODV_DIALOG)); imodvOlistUpdateOnOffs(a); // Get sizes to adjust window size with QSize svSize = Oolist_dialog->mScroll->sizeHint(); QSize frameSize = Oolist_dialog->mFrame->sizeHint(); imod_info_input(); Oolist_dialog->adjustSize(); // 4 pixels added was enough to prevent scroll bars // If width is constrained, allow more height for horizontal scroll bar int newWidth = Oolist_dialog->width() + frameSize.width() - svSize.width() + 8; int newHeight = Oolist_dialog->height() + frameSize.height() - svSize.height() + 8; if (newWidth > MAX_OOLIST_WIDTH) { newWidth = MAX_OOLIST_WIDTH; newHeight += 20; } if (newHeight > QApplication::desktop()->height() - 100) newHeight = QApplication::desktop()->height() - 100; Oolist_dialog->resize(newWidth, newHeight); setModvDialogTitle(Oolist_dialog, "3dmodv Object List: "); imodvDialogManager.add((QWidget *)Oolist_dialog, IMODV_DIALOG); // After getting size with group buttons present, maybe hide them Oolist_dialog->updateGroups(a); adjustGeometryAndShow((QWidget *)Oolist_dialog, IMODV_DIALOG); Oolist_dialog->adjustFrameSize(); }
void qAnimationDlg::render(bool asSeparateFrames) { if (!m_view3d) { assert(false); return; } QString outputFilename = outputFileLineEdit->text(); //save to persistent settings { QSettings settings; settings.beginGroup("qAnimation"); settings.setValue("filename", outputFilename); settings.endGroup(); } setEnabled(false); //count the total number of frames int frameCount = countFrames(0); int fps = fpsSpinBox->value(); int superRes = superResolutionSpinBox->value(); //show progress dialog QProgressDialog progressDialog(QString("Frames: %1").arg(frameCount), "Cancel", 0, frameCount, this); progressDialog.setWindowTitle("Render"); progressDialog.show(); QApplication::processEvents(); #ifdef QFFMPEG_SUPPORT QScopedPointer<QVideoEncoder> encoder(0); QSize originalViewSize; if (!asSeparateFrames) { //get original viewport size originalViewSize = m_view3d->qtSize(); //hack: as the encoder requires that the video dimensions are multiples of 8, we resize the window a little bit... { //find the nearest multiples of 8 QSize customSize = originalViewSize; if (originalViewSize.width() % 8 || originalViewSize.height() % 8) { if (originalViewSize.width() % 8) customSize.setWidth((originalViewSize.width() / 8 + 1) * 8); if (originalViewSize.height() % 8) customSize.setHeight((originalViewSize.height() / 8 + 1) * 8); m_view3d->resize(customSize); QApplication::processEvents(); } } int bitrate = bitrateSpinBox->value() * 1024; int gop = fps; encoder.reset(new QVideoEncoder(outputFilename, m_view3d->glWidth(), m_view3d->glHeight(), bitrate, gop, static_cast<unsigned>(fpsSpinBox->value()))); QString errorString; if (!encoder->open(&errorString)) { QMessageBox::critical(this, "Error", QString("Failed to open file for output: %1").arg(errorString)); setEnabled(true); return; } } #else if (!asSeparateFrames) { QMessageBox::critical(this, "Error", QString("Animation mode is not supported (no FFMPEG support)")); return; } #endif bool lodWasEnabled = m_view3d->isLODEnabled(); m_view3d->setLODEnabled(false); QDir outputDir( QFileInfo(outputFilename).absolutePath() ); int frameIndex = 0; bool success = true; size_t vp1 = 0, vp2 = 0; while (getNextSegment(vp1, vp2)) { Step& step1 = m_videoSteps[vp1]; Step& step2 = m_videoSteps[vp2]; ViewInterpolate interpolator(step1.viewport, step2.viewport); int frameCount = static_cast<int>( fps * step1.duration_sec ); interpolator.setMaxStep(frameCount); cc2DViewportObject current_params; while ( interpolator.nextView( current_params ) ) { applyViewport ( ¤t_params ); //render to image QImage image = m_view3d->renderToImage(superRes, false, false, true ); if (image.isNull()) { QMessageBox::critical(this, "Error", "Failed to grab the screen!"); success = false; break; } if (superRes > 1) { image = image.scaled(image.width()/superRes, image.height()/superRes, Qt::IgnoreAspectRatio, Qt::SmoothTransformation); } if (asSeparateFrames) { QString filename = QString("frame_%1.png").arg(frameIndex, 6, 10, QChar('0')); QString fullPath = outputDir.filePath(filename); if (!image.save(fullPath)) { QMessageBox::critical(this, "Error", QString("Failed to save frame #%1").arg(frameIndex + 1)); success = false; break; } } else { #ifdef QFFMPEG_SUPPORT QString errorString; if (!encoder->encodeImage(image, frameIndex, &errorString)) { QMessageBox::critical(this, "Error", QString("Failed to encode frame #%1: %2").arg(frameIndex + 1).arg(errorString)); success = false; break; } #endif } ++frameIndex; progressDialog.setValue(frameIndex); QApplication::processEvents(); if (progressDialog.wasCanceled()) { QMessageBox::warning(this, "Warning", QString("Process has been cancelled")); success = false; break; } } if (!success) { break; } if (vp2 == 0) { //stop loop here! break; } vp1 = vp2; } m_view3d->setLODEnabled(lodWasEnabled); #ifdef QFFMPEG_SUPPORT if (encoder) { encoder->close(); //hack: restore original size m_view3d->resize(originalViewSize); QApplication::processEvents(); } #endif progressDialog.hide(); QApplication::processEvents(); if (success) { QMessageBox::information(this, "Job done", "The animation has been saved successfully"); } setEnabled(true); }
/*! Loads a thumbnail representation of \a content. The thumbnail will be scaled to \a size according to the given aspect ratio mode. */ QImage QContentStore::thumbnail(const QContent &content, const QSize &size, Qt::AspectRatioMode mode) { QImage thumbnail; QString thumbPath = thumbnailPath(content.fileName()); QFileInfo thumbInfo(thumbPath); if (thumbInfo.exists()) { if (thumbInfo.lastModified() > content.lastUpdated()) thumbnail = readThumbnail(thumbPath, size, mode); } else { thumbnail = QContentFactory::thumbnail(content, size, mode); } if (thumbnail.isNull()) { if (QIODevice *device = content.open()) { QImageReader reader(device); if (reader.canRead()) { QSize scaledSize = reader.size(); reader.setQuality(25); if (scaledSize.width() > 128 || scaledSize.height() > 128) { scaledSize.scale(QSize(128, 128), Qt::KeepAspectRatio); reader.setQuality( 49 ); // Otherwise Qt smooth scales reader.setScaledSize(scaledSize); reader.read(&thumbnail); if (!thumbnail.isNull()) { QImageWriter writer(thumbPath, QByteArray::fromRawData("PNG", 3)); writer.setQuality(25); writer.write(thumbnail); if (size.isValid()) thumbnail = thumbnail.scaled(size, mode); } } else { if (size.isValid()) { scaledSize.scale(size, mode); reader.setQuality( 49 ); // Otherwise Qt smooth scales reader.setScaledSize(scaledSize); } reader.read(&thumbnail); } } delete device; } } if (thumbnail.isNull() && content.type().startsWith(m_audioPrefix)) { QDir dir = QFileInfo(content.fileName()).absoluteDir(); foreach (const QString &fileName, m_folderThumbnails) { if (dir.exists(fileName)) { thumbnail = readThumbnail(dir.absoluteFilePath(fileName), size, mode); break; } } }
/** * @brief Save new window size */ void Settings::setWindowSize(const QSize &_size) { m_options[UM::CONF::window_width] = _size.width(); m_options[UM::CONF::window_height] = _size.height(); }
QSize ItemDelegate::sizeHint( const QStyleOptionViewItem & option, const QModelIndex & index ) const { // 18 is a bit arbitrary, it gives (most?) editors a usable size QSize s = QStyledItemDelegate::sizeHint( option, index ); return QSize( s.width(), qMax( s.height(), 18 ) ); }
bool DomConvenience::variantToElement(const QVariant& v, QDomElement& e) { bool ok = true; clearAttributes(e); switch (v.type()) { case QVariant::String: e.setTagName("string"); e.setAttribute("value", v.toString().utf8()); break; case QVariant::CString: e.setTagName("string"); e.setAttribute("value", v.toCString()); break; case QVariant::Int: e.setTagName("int"); e.setAttribute("value", v.toInt()); break; case QVariant::UInt: e.setTagName("uint"); e.setAttribute("value", v.toUInt()); break; case QVariant::Double: e.setTagName("double"); e.setAttribute("value", v.toDouble()); break; case QVariant::Bool: e.setTagName("bool"); e.setAttribute("value", boolString(v.toBool())); break; case QVariant::Color: { e.setTagName("color"); QColor color = v.toColor(); e.setAttribute("red", color.red()); e.setAttribute("green", color.green()); e.setAttribute("blue", color.blue()); } break; case QVariant::Point: { e.setTagName("point"); QPoint point = v.toPoint(); e.setAttribute("x", point.x()); e.setAttribute("y", point.y()); } break; case QVariant::Rect: { e.setTagName("rect"); QRect rect = v.toRect(); e.setAttribute("x", rect.x()); e.setAttribute("y", rect.y()); e.setAttribute("width", rect.width()); e.setAttribute("height", rect.height()); } break; case QVariant::Size: { e.setTagName("size"); QSize qsize = v.toSize(); e.setAttribute("width", qsize.width()); e.setAttribute("height", qsize.height()); } break; case QVariant::Font: { e.setTagName("font"); QFont f(v.toFont()); e.setAttribute("family", f.family()); e.setAttribute("pointsize", f.pointSize()); e.setAttribute("bold", boolString(f.bold())); e.setAttribute("italic", boolString(f.italic())); e.setAttribute("underline", boolString(f.underline())); e.setAttribute("strikeout", boolString(f.strikeOut())); } break; case QVariant::SizePolicy: { e.setTagName("sizepolicy"); QSizePolicy sp(v.toSizePolicy()); e.setAttribute("hsizetype", sp.horData()); e.setAttribute("vsizetype", sp.verData()); #if (QT_VERSION >= 300) e.setAttribute("horstretch", sp.horStretch()); e.setAttribute("verstretch", sp.verStretch()); #endif } break; case QVariant::Cursor: e.setTagName("cursor"); e.setAttribute("shape", v.toCursor().shape()); break; case QVariant::StringList: { e.setTagName("stringlist"); uint j; QDomNode n; QDomNodeList stringNodeList = e.elementsByTagName("string"); QDomElement stringElem; QStringList stringList = v.toStringList(); QStringList::Iterator it = stringList.begin(); for (j = 0; ((j < stringNodeList.length()) && (it != stringList.end())); j++) { // get the current string element stringElem = stringNodeList.item(j).toElement(); // set it to the current string variantToElement(QVariant(*it), stringElem); // iterate to the next string ++it; } // more nodes in previous stringlist then current, remove excess nodes if (stringNodeList.count() > stringList.count()) { while (j < stringNodeList.count()) e.removeChild(stringNodeList.item(j).toElement()); } else if (j <stringList.count()) { while (it != stringList.end()) { // create a new element stringElem = m_doc.createElement("string"); // set it to the currentstring variantToElement(QVariant(*it), stringElem); // append it to the current element e.appendChild(stringElem); // iterate to the next string ++it; } } } break; #if QT_VERSION >= 300 case QVariant::KeySequence: e.setTagName("key"); e.setAttribute("sequence", (QString)v.toKeySequence()); break; #endif #if 0 case QVariant::List: case QVaraint::Map: #endif default: qWarning("Don't know how to persist variant of type: %s (%d)!", v.typeName(), v.type()); ok = false; break; } return ok; }
void FF10Node::process( qint64 pTimeStamp ) { fugio::Performance Perf( mNode, __FUNCTION__, pTimeStamp ); FF_Main_FuncPtr MainFunc = mLibrary->func(); if( !MainFunc ) { return; } fugio::Image DstImg = mValOutput->variant().value<fugio::Image>(); if( DstImg.format() == fugio::ImageFormat::UNKNOWN ) { /* if( mLibrary->flags().testFlag( FreeframeLibrary::CAP_32BIT ) ) { DstImg.setFormat( fugio::ImageFormat::RGBA8 ); // mBitDepth = FF_CAP_32BITVIDEO; } else */if( mLibrary->flags().testFlag( FreeframeLibrary::CAP_24BIT ) ) { #if defined( Q_OS_WIN ) DstImg.setFormat( fugio::ImageFormat::BGR8 ); #else DstImg.setFormat( fugio::ImageFormat::RGB8 ); #endif mBitDepth = FF_CAP_24BITVIDEO; } else if( mLibrary->flags().testFlag( FreeframeLibrary::CAP_16BIT ) ) { DstImg.setFormat( fugio::ImageFormat::RGB_565 ); mBitDepth = FF_CAP_16BITVIDEO; } } if( DstImg.format() == fugio::ImageFormat::UNKNOWN ) { return; } //------------------------------------------------------------------------- // Calculate the input size QSize SrcSze; for( int i = 0 ; i < mInputs.size() ; i++ ) { fugio::Image SrcImg = variant<fugio::Image>( mInputs.at( i ) ); if( !SrcImg.isValid() ) { continue; } if( SrcImg.width() > SrcSze.width() ) { SrcSze.setWidth( SrcImg.width() ); } if( SrcImg.height() > SrcSze.height() ) { SrcSze.setHeight( SrcImg.height() ); } if( SrcImg.format() != DstImg.format() ) { continue; } } if( !SrcSze.isValid() ) { return; } //------------------------------------------------------------------------- // Initialise the instance FFMixed PMU; if( DstImg.size() != SrcSze ) { if( mInstanceId ) { PMU.UIntValue = 0; PMU = MainFunc( FF_DEINSTANTIATE, PMU, mInstanceId ); mInstanceId = 0; } DstImg.setSize( SrcSze ); if( mBitDepth == FF_CAP_16BITVIDEO ) { DstImg.setLineSize( 0, 2 * SrcSze.width() ); } else if( mBitDepth == FF_CAP_24BITVIDEO ) { DstImg.setLineSize( 0, 3 * SrcSze.width() ); } else if( mBitDepth == FF_CAP_32BITVIDEO ) { DstImg.setLineSize( 0, 4 * SrcSze.width() ); } mDstBuf.resize( 1024 + DstImg.bufferSize( 0 ) + 1024 ); DstImg.setBuffer( 0, &mDstBuf[ 1024 ] ); VideoInfoStruct VIS; VIS.BitDepth = mBitDepth; VIS.FrameWidth = SrcSze.width(); VIS.FrameHeight = SrcSze.height(); VIS.Orientation = FF_ORIENTATION_TL; PMU.PointerValue = &VIS; PMU = MainFunc( FF_INSTANTIATE, PMU, 0 ); if( PMU.UIntValue == FF_FAIL ) { return; } mInstanceId = PMU.PointerValue; } if( !mInstanceId ) { return; } //------------------------------------------------------------------------- // Prepare the source frames QVector<void *> SrcPtr; for( int i = 0 ; i < mInputs.size() ; i++ ) { fugio::Image SrcImg = variant<fugio::Image>( mInputs.at( i ) ); if( !SrcImg.isValid() ) { continue; } if( SrcImg.size() != SrcSze || SrcImg.lineSize( 0 ) != DstImg.lineSize( 0 ) ) { continue; } SrcPtr << SrcImg.buffer( 0 ); } //------------------------------------------------------------------------- // Update the parameters SetParameterStructTag PrmSet; for( int i = 0 ; i < mParams.size() ; i++ ) { QSharedPointer<fugio::PinInterface> PrmPin = mParams.at( i ); FreeframeLibrary::ParamEntry PrmEnt = mLibrary->params().at( i ); QVariant PrmVal = variant( PrmPin ); PrmSet.ParameterNumber = i; if( PrmEnt.mType == FF_TYPE_STANDARD ) { PrmSet.NewParameterValue.FloatValue = qBound( 0.0f, PrmVal.value<float>(), 1.0f ); PMU.PointerValue = &PrmSet; MainFunc( FF_SETPARAMETER, PMU, mInstanceId ); } else if( PrmEnt.mType == FF_TYPE_BOOLEAN ) { PrmSet.NewParameterValue.UIntValue = PrmVal.value<bool>() ? FF_TRUE : FF_FALSE; PMU.PointerValue = &PrmSet; MainFunc( FF_SETPARAMETER, PMU, mInstanceId ); } PMU.UIntValue = i; PMU = MainFunc( FF_GETPARAMETERDISPLAY, PMU, mInstanceId ); if( PMU.UIntValue != FF_FAIL ) { PrmPin->setDisplayLabel( QString::fromLatin1( QByteArray( (const char *)PMU.PointerValue, 16 ) ) ); } } //------------------------------------------------------------------------- // Call the plugin if( SrcPtr.size() >= mLibrary->minInputFrames() ) { if( mLibrary->hasProcessFrameCopy() ) { ProcessFrameCopyStruct PFC; PFC.numInputFrames = SrcPtr.size(); PFC.pOutputFrame = DstImg.buffer( 0 ); PFC.ppInputFrames = SrcPtr.data(); PMU.PointerValue = &PFC; PMU = MainFunc( FF_PROCESSFRAMECOPY, PMU, mInstanceId ); } else { if( !SrcPtr.isEmpty() ) { memcpy( DstImg.buffer( 0 ), SrcPtr.first(), DstImg.bufferSize( 0 ) ); } PMU.PointerValue = DstImg.buffer( 0 ); PMU = MainFunc( FF_PROCESSFRAME, PMU, mInstanceId ); } } //------------------------------------------------------------------------- // Update the pin if we succeed if( PMU.UIntValue == FF_SUCCESS ) { pinUpdated( mPinOutput ); } }
QPoint GraphicalBoardFrame::coordinatesOfTile(const QSize &loc) { QPoint point(loc.width(), loc.height()); return (point * m_sideLength) + m_tilesOffset; }
void VisualizerWidget::resizeEvent(QResizeEvent* event) { QSize s = event->size(); m_renderer.resize(s.width(),s.height()); }