void KisInfinityManager::drawDecoration(QPainter& gc, const QRectF& updateArea, const KisCoordinatesConverter *converter, KisCanvas2 *canvas) { Q_UNUSED(updateArea); Q_UNUSED(converter); Q_UNUSED(canvas); if (!m_filteringEnabled) return; gc.save(); gc.setTransform(QTransform(), false); KisConfig cfg; QColor color = cfg.canvasBorderColor(); gc.fillPath(m_decorationPath, color.darker(115)); QPainterPath p; p.moveTo(5, 2); p.lineTo(-3, 8); p.lineTo(-5, 5); p.lineTo( 2, 0); p.lineTo(-5,-5); p.lineTo(-3,-8); p.lineTo( 5,-2); p.arcTo(QRectF(3, -2, 4, 4), 90, -180); foreach (const QTransform &t, m_handleTransform) { gc.fillPath(t.map(p), color); }
void KisOpenGLCanvas2::paintGL() { if (!OPENGL_SUCCESS) { KisConfig cfg; cfg.writeEntry("canvasState", "OPENGL_PAINT_STARTED"); } KisOpenglCanvasDebugger::instance()->nofityPaintRequested(); renderCanvasGL(); if (d->glSyncObject) { Sync::deleteSync(d->glSyncObject); } d->glSyncObject = Sync::getSync(); QPainter gc(this); renderDecorations(&gc); gc.end(); if (!OPENGL_SUCCESS) { KisConfig cfg; cfg.writeEntry("canvasState", "OPENGL_SUCCESS"); OPENGL_SUCCESS = true; } }
KisInputManager::Private::Private(KisInputManager *qq) : q(qq) , canvas(0) , toolProxy(0) , forwardAllEventsToTool(false) , disableTouchOnCanvas(false) , touchHasBlockedPressEvents(false) , lastTouchEvent(0) , defaultInputAction(0) , eventsReceiver(0) , moveEventCompressor(10 /* ms */, KisSignalCompressor::FIRST_ACTIVE) , testingAcceptCompressedTabletEvents(false) , testingCompressBrushEvents(false) , focusOnEnter(true) , containsPointer(true) { KisConfig cfg; disableTouchOnCanvas = cfg.disableTouchOnCanvas(); moveEventCompressor.setDelay(cfg.tabletEventsDelay()); testingAcceptCompressedTabletEvents = cfg.testingAcceptCompressedTabletEvents(); testingCompressBrushEvents = cfg.testingCompressBrushEvents(); setupActions(); canvasSwitcher = new CanvasSwitcher(this, q); qApp->installEventFilter(globalEventEater); }
void KisToolFreehandHelper::stabilizerStart(KisPaintInformation firstPaintInfo) { // FIXME: Ugly hack, this is no a "distance" in any way int sampleSize = qRound(m_d->effectiveSmoothnessDistance()); sampleSize = qMax(3, sampleSize); // Fill the deque with the current value repeated until filling the sample m_d->stabilizerDeque.clear(); for (int i = sampleSize; i > 0; i--) { m_d->stabilizerDeque.enqueue(firstPaintInfo); } // Poll and draw regularly KisConfig cfg; int stabilizerSampleSize = cfg.stabilizerSampleSize(); m_d->stabilizerPollTimer.setInterval(stabilizerSampleSize); m_d->stabilizerPollTimer.start(); int delayedPaintInterval = cfg.stabilizerDelayedPaintInterval(); if (delayedPaintInterval < stabilizerSampleSize) { m_d->stabilizerDelayedPaintHelper.start(delayedPaintInterval, firstPaintInfo); } m_d->stabilizedSampler.clear(); m_d->stabilizedSampler.addEvent(firstPaintInfo); }
bool KisOpenGLImageTextures::imageCanUseHDRExposureProgram(KisImageSP image) { #ifdef HAVE_GLEW if (!image->colorSpace()->hasHighDynamicRange()) { return false; } KisConfig cfg; if (!cfg.useOpenGLShaders()) { return false; } if (HDRExposureProgram == 0) { return false; } if (!HDRExposureProgram->isValid()) { return false; } if (!haveHDRTextureFormat(image->colorSpace())) { return false; } return true; #else Q_UNUSED(image); return false; #endif }
void KisCoordinatesConverter::getQPainterCheckersInfo(QTransform *transform, QPointF *brushOrigin, QPolygonF *polygon) const { /** * Qt has different rounding for QPainter::drawRect/drawImage. * The image is rounded mathematically, while rect in aligned * to the next integer. That causes transparent line appear on * the canvas. * * See: https://bugreports.qt.nokia.com/browse/QTBUG-22827 */ QRectF imageRect = imageRectInViewportPixels(); imageRect.adjust(0,0,-0.5,-0.5); KisConfig cfg; if (cfg.scrollCheckers()) { *transform = viewportToWidgetTransform(); *polygon = imageRect; *brushOrigin = imageToViewport(QPointF(0,0)); } else { *transform = QTransform(); *polygon = viewportToWidgetTransform().map(imageRect); *brushOrigin = QPoint(0,0); } }
void KisPaintingInformationBuilder::updateSettings() { KisConfig cfg; KisCubicCurve curve; curve.fromString(cfg.pressureTabletCurve()); m_pressureSamples = curve.floatTransfer(LEVEL_OF_PRESSURE_RESOLUTION + 1); }
bool PaletteDockerDock::eventFilter(QObject* object, QEvent* event) { if (object == m_wdgPaletteDock->paletteView->viewport() && event->type() == QEvent::Wheel) { QWheelEvent* qwheel = dynamic_cast<QWheelEvent* >(event); if (qwheel->modifiers() & Qt::ControlModifier) { int numDegrees = qwheel->delta() / 8; int numSteps = numDegrees / 7; int curSize = m_wdgPaletteDock->paletteView->horizontalHeader()->sectionSize(0); int setSize = numSteps + curSize; if ( setSize >= 12 ) { m_wdgPaletteDock->paletteView->horizontalHeader()->setDefaultSectionSize(setSize); m_wdgPaletteDock->paletteView->verticalHeader()->setDefaultSectionSize(setSize); KisConfig cfg; cfg.setPaletteDockerPaletteViewSectionSize(setSize); } return true; } else { return false; } } else { return QWidget::eventFilter(object, event); } }
void KisColorSelector::loadSettings() { KisConfig cfg; setColorSpace(KisColor::Type(cfg.readEntry<qint32>("ArtColorSel.ColorSpace" , KisColor::HSY))); setNumLightPieces(cfg.readEntry("ArtColorSel.LightPieces", 19)); m_selectedColor.setH(cfg.readEntry<float>("ArtColorSel.SelColorH", 0.0f)); m_selectedColor.setS(cfg.readEntry<float>("ArtColorSel.SelColorS", 0.0f)); m_selectedColor.setX(cfg.readEntry<float>("ArtColorSel.SelColorX", 0.0f)); m_selectedColor.setA(1.0f); setInverseSaturation(cfg.readEntry<bool>("ArtColorSel.InversedSaturation", false)); setLight(cfg.readEntry<float>("ArtColorSel.Light", 0.5f), cfg.readEntry<bool>("ArtColorSel.RelativeLight", false)); recalculateRings( cfg.readEntry("ArtColorSel.NumRings" , 11), cfg.readEntry("ArtColorSel.RingPieces", 12) ); QList<float> angles = cfg.readList<float>("ArtColorSel.RingAngles"); for (int i = 0; i < m_colorRings.size(); ++i) { if (i < angles.size() && i < m_colorRings.size()) { m_colorRings[i].angle = angles[i]; } } selectColor(m_selectedColor); update(); }
void KisGridConfig::saveStaticData() const { KisConfig cfg; cfg.setGridMainStyle(m_lineTypeMain); cfg.setGridSubdivisionStyle(m_lineTypeSubdivision); cfg.setGridMainColor(m_colorMain); cfg.setGridSubdivisionColor(m_colorSubdivision); }
KisFilterPreviewWidget::KisFilterPreviewWidget(QWidget* parent): QWidget(parent) { KisConfig cfg; // for preview make it smaller than on canvas qint32 checkSize = qMax(1,cfg.checkSize() / 2); QImage checkImage = KisCanvasWidgetBase::createCheckersImage(checkSize); m_checkBrush = QBrush(checkImage); m_pixmap = QPixmap::fromImage(checkImage); }
PaletteDockerDock::~PaletteDockerDock() { KoResourceServer<KoColorSet>* rServer = KoResourceServerProvider::instance()->paletteServer(); rServer->removeObserver(this); if (m_currentColorSet) { KisConfig cfg; cfg.setDefaultPalette(m_currentColorSet->name()); } }
KisTextureTile::~KisTextureTile() { #ifdef USE_PIXEL_BUFFERS KisConfig cfg; if (cfg.useOpenGLTextureBuffer()) { delete m_glBuffer; } #endif glDeleteTextures(1, &m_textureId); }
void KisGridConfig::loadStaticData() { KisConfig cfg; m_lineTypeMain = LineTypeInternal(cfg.getGridMainStyle()); m_lineTypeSubdivision = LineTypeInternal(cfg.getGridSubdivisionStyle()); m_colorMain = cfg.getGridMainColor(); m_colorSubdivision = cfg.getGridSubdivisionColor(); }
void KisOpenGLCanvas2::initializeGL() { KisOpenGL::initializeContext(context()); initializeOpenGLFunctions(); KisConfig cfg; d->openGLImageTextures->setProofingConfig(canvas()->proofingConfiguration()); d->openGLImageTextures->initGL(context()->functions()); d->openGLImageTextures->generateCheckerTexture(createCheckersImage(cfg.checkSize())); initializeShaders(); // If we support OpenGL 3.2, then prepare our VAOs and VBOs for drawing if (KisOpenGL::hasOpenGL3()) { d->quadVAO.create(); d->quadVAO.bind(); glEnableVertexAttribArray(PROGRAM_VERTEX_ATTRIBUTE); glEnableVertexAttribArray(PROGRAM_TEXCOORD_ATTRIBUTE); // Create the vertex buffer object, it has 6 vertices with 3 components d->quadBuffers[0].create(); d->quadBuffers[0].setUsagePattern(QOpenGLBuffer::StaticDraw); d->quadBuffers[0].bind(); d->quadBuffers[0].allocate(d->vertices, 6 * 3 * sizeof(float)); glVertexAttribPointer(PROGRAM_VERTEX_ATTRIBUTE, 3, GL_FLOAT, GL_FALSE, 0, 0); // Create the texture buffer object, it has 6 texture coordinates with 2 components d->quadBuffers[1].create(); d->quadBuffers[1].setUsagePattern(QOpenGLBuffer::StaticDraw); d->quadBuffers[1].bind(); d->quadBuffers[1].allocate(d->texCoords, 6 * 2 * sizeof(float)); glVertexAttribPointer(PROGRAM_TEXCOORD_ATTRIBUTE, 2, GL_FLOAT, GL_FALSE, 0, 0); // Create the outline buffer, this buffer will store the outlines of // tools and will frequently change data d->outlineVAO.create(); d->outlineVAO.bind(); glEnableVertexAttribArray(PROGRAM_VERTEX_ATTRIBUTE); // The outline buffer has a StreamDraw usage pattern, because it changes constantly d->lineBuffer.create(); d->lineBuffer.setUsagePattern(QOpenGLBuffer::StreamDraw); d->lineBuffer.bind(); glVertexAttribPointer(PROGRAM_VERTEX_ATTRIBUTE, 3, GL_FLOAT, GL_FALSE, 0, 0); } ptr_glLogicOp = (kis_glLogicOp)(context()->getProcAddress("glLogicOp")); Sync::init(context()); d->canvasInitialized = true; }
void KisCanvasResourceProvider::resetDisplayProfile() { // XXX: The X11 monitor profile overrides the settings m_displayProfile = KisCanvasResourceProvider::getScreenProfile(); if (m_displayProfile == 0) { KisConfig cfg; QString monitorProfileName = cfg.monitorProfile(); m_displayProfile = KoColorSpaceRegistry::instance()->profileByName(monitorProfileName); } emit sigDisplayProfileChanged(m_displayProfile); }
void KisNodeModel::updateSettings() { KisConfig cfg; bool oldShowRootLayer = m_d->showRootLayer; bool oldShowGlobalSelection = m_d->showGlobalSelection; m_d->showRootLayer = cfg.showRootLayer(); m_d->showGlobalSelection = cfg.showGlobalSelection(); if (m_d->showRootLayer != oldShowRootLayer || m_d->showGlobalSelection != oldShowGlobalSelection) { resetIndexConverter(); reset(); } }
WdgImagesplit::WdgImagesplit(QWidget* parent) : QWidget(parent) { setupUi(this); KisConfig cfg; intHorizontalSplitLines->setValue(cfg.horizontalSplitLines()); intVerticalSplitLines->setValue(cfg.verticalSplitLines()); chkAutoSave->setChecked(true); }
KisInputManager::Private::Private(KisInputManager *qq) : q(qq) , moveEventCompressor(10 /* ms */, KisSignalCompressor::FIRST_ACTIVE) , canvasSwitcher(this, qq) { KisConfig cfg; disableTouchOnCanvas = cfg.disableTouchOnCanvas(); moveEventCompressor.setDelay(cfg.tabletEventsDelay()); testingAcceptCompressedTabletEvents = cfg.testingAcceptCompressedTabletEvents(); testingCompressBrushEvents = cfg.testingCompressBrushEvents(); setupActions(); }
KisFavoriteResourceManager::KisFavoriteResourceManager(KisPaintopBox *paintopBox) : m_paintopBox(paintopBox) , m_colorList(0) , m_blockUpdates(false) , m_initialized(false) { KisConfig cfg; m_maxPresets = cfg.favoritePresets(); m_colorList = new ColorDataList(); connect(KisConfigNotifier::instance(), SIGNAL(configChanged()), SLOT(configChanged())); KisPaintOpPresetResourceServer * rServer = KisResourceServerProvider::instance()->paintOpPresetServer(false); rServer->addObserver(this); }
void KisOpenGLImageTextures::createHDRExposureProgramIfCan() { KisConfig cfg; if (!cfg.useOpenGLShaders()) return; #ifdef HAVE_GLEW if (HDRExposureProgram == 0 && KisOpenGL::hasShadingLanguage()) { dbgUI << "Creating shared HDR exposure program"; HDRExposureProgram = new KisOpenGLHDRExposureProgram(); Q_CHECK_PTR(HDRExposureProgram); } #endif }
int KisOpenGL::initializeContext(QOpenGLContext* s) { #ifdef HAVE_OPENGL KisConfig cfg; dbgUI << "OpenGL: Opening new context"; // Double check we were given the version we requested QSurfaceFormat format = s->format(); glVersion = 100 * format.majorVersion() + format.minorVersion(); if (!SharedSurface) { SharedSurface = new QOffscreenSurface(); SharedSurface->setFormat(format); SharedSurface->create(); } if (!SharedContext) { SharedContext = new QOpenGLContext; SharedContext->setFormat(format); SharedContext->setShareContext(s); SharedContext->create(); SharedContext->makeCurrent(SharedSurface); } QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions(); QFile log(QDesktopServices::storageLocation(QDesktopServices::TempLocation) + "/krita-opengl.txt"); log.open(QFile::WriteOnly); QString vendor((const char*)f->glGetString(GL_VENDOR)); log.write(vendor.toLatin1()); log.write(", "); QString renderer((const char*)f->glGetString(GL_RENDERER)); log.write(renderer.toLatin1()); log.write(", "); QString version((const char*)f->glGetString(GL_VERSION)); log.write(version.toLatin1()); // Check if we have a bugged driver that needs fence workaround bool isOnX11 = false; #ifdef HAVE_X11 isOnX11 = true; #endif if ((isOnX11 && renderer.startsWith("AMD")) || cfg.forceOpenGLFenceWorkaround()) { NeedsFenceWorkaround = true; } #else Q_UNUSED(s); NeedsFenceWorkaround = false; #endif return glVersion; }
KisTextureTile::KisTextureTile(QRect imageRect, const KisGLTexturesInfo *texturesInfo, const QByteArray &fillData, FilterMode filter) : m_textureId(0) #ifdef USE_PIXEL_BUFFERS , m_glBuffer(0) #endif , m_tileRectInImagePixels(imageRect) , m_filter(filter) , m_texturesInfo(texturesInfo) , m_needsMipmapRegeneration(false) { const GLvoid *fd = fillData.constData(); m_textureRectInImagePixels = stretchRect(m_tileRectInImagePixels, texturesInfo->border); m_tileRectInTexturePixels = relativeRect(m_textureRectInImagePixels, m_tileRectInImagePixels, m_texturesInfo); glGenTextures(1, &m_textureId); glBindTexture(GL_TEXTURE_2D, m_textureId); setTextureParameters(); #ifdef USE_PIXEL_BUFFERS createTextureBuffer(fillData); // we set fill data to 0 so the next glTexImage2D call uses our buffer fd = 0; #endif glTexImage2D(GL_TEXTURE_2D, 0, m_texturesInfo->internalFormat, m_texturesInfo->width, m_texturesInfo->height, 0, m_texturesInfo->format, m_texturesInfo->type, fd); #ifdef USE_PIXEL_BUFFERS KisConfig cfg; if (cfg.useOpenGLTextureBuffer()) { m_glBuffer->release(); } #endif setNeedsMipmapRegeneration(); }
/** * Displays a message box telling the user that * shader compilation failed and turns off OpenGL. */ void KisOpenGLCanvas2::reportFailedShaderCompilation(const QString &context) { KisConfig cfg; if (cfg.useVerboseOpenGLDebugOutput()) { dbgUI << "GL-log:" << context; } qDebug() << "Shader Compilation Failure: " << context; QMessageBox::critical(this, i18nc("@title:window", "Krita"), QString(i18n("Krita could not initialize the OpenGL canvas:\n\n%1\n\n Krita will disable OpenGL and close now.")).arg(context), QMessageBox::Close); cfg.setUseOpenGL(false); cfg.setCanvasState("OPENGL_FAILED"); }
void KisCanvas2::createCanvas() { KisConfig cfg; slotSetDisplayProfile( KoColorSpaceRegistry::instance()->profileByName(cfg.monitorProfile()) ); if (cfg.useOpenGL()) { #ifdef HAVE_OPENGL createOpenGLCanvas(); #else warnKrita << "OpenGL requested while its not available, starting qpainter canvas"; createQPainterCanvas(); #endif } else { createQPainterCanvas(); } }
void HistoryDock::setCanvas(KoCanvasBase *canvas) { setEnabled(canvas != 0); KisCanvas2* myCanvas = dynamic_cast<KisCanvas2*>( canvas ); if (myCanvas) { KUndo2Stack* undoStack = canvas->shapeController()->resourceManager()->undoStack(); m_undoView->setStack(undoStack); KisConfig cfg; m_undoView->stack()->setUseCumulativeUndoRedo(cfg.useCumulativeUndoRedo()); m_undoView->stack()->setTimeT1(cfg.stackT1()); m_undoView->stack()->setTimeT2(cfg.stackT2()); m_undoView->stack()->setStrokesN(cfg.stackN()); } m_undoView->setCanvas( myCanvas ); }
void ImageBuilder::createImageFromClipboardDelayed() { DocumentManager::instance()->disconnect(this, SLOT(createImageFromClipboardDelayed())); KisConfig cfg; cfg.setPasteBehaviour(PASTE_ASSUME_MONITOR); QSize sz = KisClipboard::instance()->clipSize(); KisPaintDeviceSP clipDevice = KisClipboard::instance()->clip(QRect(0, 0, sz.width(), sz.height()), false); KisImageWSP image = DocumentManager::instance()->document()->image(); if (image && image->root() && image->root()->firstChild()) { KisLayer * layer = dynamic_cast<KisLayer*>(image->root()->firstChild().data()); Q_ASSERT(layer); layer->setOpacity(OPACITY_OPAQUE_U8); QRect r = clipDevice->exactBounds(); KisPainter::copyAreaOptimized(QPoint(), clipDevice, layer->paintDevice(), r); layer->setDirty(QRect(0, 0, sz.width(), sz.height())); } }
MainWindow::MainWindow(QStringList fileNames, QWidget* parent, Qt::WindowFlags flags ) : QMainWindow( parent, flags ), d( new Private(this) ) { qApp->setActiveWindow( this ); setWindowTitle(i18n("Krita Sketch")); setWindowIcon(KIcon("kritasketch")); // Load filters and other plugins in the gui thread Q_UNUSED(KisFilterRegistry::instance()); Q_UNUSED(KisPaintOpRegistry::instance()); KisConfig cfg; cfg.setCursorStyle(CURSOR_STYLE_NO_CURSOR); cfg.setUseOpenGL(true); foreach(QString fileName, fileNames) { DocumentManager::instance()->recentFileManager()->addRecent(fileName); }
QPointF KisCoordinatesConverter::centeringCorrection() const { KisConfig cfg; QSize documentSize = imageRectInWidgetPixels().toAlignedRect().size(); QPointF dPoint(documentSize.width(), documentSize.height()); QPointF wPoint(m_d->canvasWidgetSize.width(), m_d->canvasWidgetSize.height()); QPointF minOffset = -cfg.vastScrolling() * wPoint; QPointF maxOffset = dPoint - wPoint + cfg.vastScrolling() * wPoint; QPointF range = maxOffset - minOffset; range.rx() = qMin(range.x(), (qreal)0.0); range.ry() = qMin(range.y(), (qreal)0.0); range /= 2; return -range; }
void KisCoordinatesConverter::getOpenGLCheckersInfo(const QRectF &viewportRect, QTransform *textureTransform, QTransform *modelTransform, QRectF *textureRect, QRectF *modelRect) const { KisConfig cfg; if(cfg.scrollCheckers()) { *textureTransform = QTransform(); *textureRect = QRectF(0, 0, viewportRect.width(),viewportRect.height()); } else { *textureTransform = viewportToWidgetTransform(); *textureRect = viewportRect; } *modelTransform = viewportToWidgetTransform(); *modelRect = viewportRect; }