krita/ui

kis_canvas_resource_provider.cpp

Go to the documentation of this file.
00001 /*
00002  *  Copyright (c) 2006 Boudewijn Rempt  <boud@valdyas.org>
00003  *
00004  *  This program is free software; you can redistribute it and/or modify
00005  *  it under the terms of the GNU General Public License as published by
00006  *  the Free Software Foundation; either version 2 of the License, or
00007  *  (at your option) any later version.
00008  *
00009  *  This program is distributed in the hope that it will be useful,
00010  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  *  GNU General Public License for more details.
00013  *
00014  *  You should have received a copy of the GNU General Public License
00015  *  along with this program; if not, write to the Free Software
00016  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
00017  */
00018 
00019 #include "kis_canvas_resource_provider.h"
00020 #include <QImage>
00021 #include <QPainter>
00022 
00023 #include <KoCanvasBase.h>
00024 #include <KoID.h>
00025 #include <KoColorSpaceRegistry.h>
00026 
00027 #include "colorprofiles/KoIccColorProfile.h"
00028 
00029 #include <KoAbstractGradient.h>
00030 #include <kis_pattern.h>
00031 #include <kis_paint_device.h>
00032 #include <filter/kis_filter_configuration.h>
00033 #include <kis_image.h>
00034 #include <kis_group_layer.h>
00035 #include <kis_paintop_preset.h>
00036 #include "kis_exposure_visitor.h"
00037 #include "kis_config.h"
00038 #include "kis_view2.h"
00039 #include "canvas/kis_canvas2.h"
00040 #include <kis_paintop_settings.h>
00041 
00042 KisCanvasResourceProvider::KisCanvasResourceProvider(KisView2 * view)
00043         : m_view(view)
00044 {
00045 }
00046 
00047 KisCanvasResourceProvider::~KisCanvasResourceProvider()
00048 {
00049 }
00050 
00051 void KisCanvasResourceProvider::setCanvasResourceProvider(KoCanvasResourceProvider * resourceProvider)
00052 {
00053     m_resourceProvider = resourceProvider;
00054 
00055     QVariant v;
00056     v.setValue(KoColor(Qt::black, m_view->image()->colorSpace()));
00057     m_resourceProvider->setResource(KoCanvasResource::ForegroundColor, v);
00058 
00059     v.setValue(KoColor(Qt::white, m_view->image()->colorSpace()));
00060     m_resourceProvider->setResource(KoCanvasResource::BackgroundColor, v);
00061 
00062     resetDisplayProfile();
00063 
00064     connect(m_resourceProvider, SIGNAL(resourceChanged(int, const QVariant &)),
00065             this, SLOT(slotResourceChanged(int, const QVariant&)));
00066 
00067 }
00068 
00069 
00070 KoCanvasBase * KisCanvasResourceProvider::canvas() const
00071 {
00072     return m_view->canvasBase();
00073 }
00074 
00075 KoColor KisCanvasResourceProvider::bgColor() const
00076 {
00077     return m_resourceProvider->resource(KoCanvasResource::BackgroundColor).value<KoColor>();
00078 }
00079 
00080 KoColor KisCanvasResourceProvider::fgColor() const
00081 {
00082     return m_resourceProvider->resource(KoCanvasResource::ForegroundColor).value<KoColor>();
00083 }
00084 
00085 float KisCanvasResourceProvider::HDRExposure() const
00086 {
00087     return static_cast<float>(m_resourceProvider->resource(HdrExposure).toDouble());
00088 }
00089 
00090 void KisCanvasResourceProvider::setHDRExposure(float exposure)
00091 {
00092     m_resourceProvider->setResource(HdrExposure, static_cast<double>(exposure));
00093     KisExposureVisitor eV(exposure);
00094     m_view->image()->projection()->colorSpace()->profile()->setProperty("exposure", exposure);
00095     m_view->image()->rootLayer()->accept(eV);
00096     m_view->canvasBase()->updateCanvas();
00097     m_view->canvasBase()->updateCanvasProjection(m_view->image()->bounds());
00098 }
00099 
00100 
00101 KisPattern * KisCanvasResourceProvider::currentPattern() const
00102 {
00103     return static_cast<KisPattern*>(m_resourceProvider->resource(CurrentPattern).value<void *>());
00104 }
00105 
00106 KisFilterConfiguration * KisCanvasResourceProvider::currentGeneratorConfiguration() const
00107 {
00108     return static_cast<KisFilterConfiguration*>(m_resourceProvider->
00109             resource(CurrentGeneratorConfiguration).value<void *>());
00110 }
00111 
00112 
00113 KoAbstractGradient* KisCanvasResourceProvider::currentGradient() const
00114 {
00115     return static_cast<KoAbstractGradient*>(m_resourceProvider->resource(CurrentGradient).value<void *>());
00116 }
00117 
00118 
00119 void KisCanvasResourceProvider::resetDisplayProfile()
00120 {
00121     // XXX: The X11 monitor profile overrides the settings
00122     m_displayProfile = KoIccColorProfile::getScreenProfile();
00123 
00124     if (m_displayProfile == 0) {
00125         KisConfig cfg;
00126         QString monitorProfileName = cfg.monitorProfile();
00127         m_displayProfile = KoColorSpaceRegistry::instance()->profileByName(monitorProfileName);
00128     }
00129     emit sigDisplayProfileChanged(m_displayProfile);
00130 }
00131 
00132 const KoColorProfile * KisCanvasResourceProvider::currentDisplayProfile() const
00133 {
00134     return m_displayProfile;
00135 
00136 }
00137 
00138 KisImageWSP KisCanvasResourceProvider::currentImage() const
00139 {
00140     return m_view->image();
00141 }
00142 
00143 KisNodeSP KisCanvasResourceProvider::currentNode() const
00144 {
00145     return m_view->activeNode();
00146 }
00147 
00148 KisPaintOpPresetSP KisCanvasResourceProvider::currentPreset() const
00149 {
00150     KisPaintOpPresetSP preset = m_resourceProvider->resource(CurrentPaintOpPreset).value<KisPaintOpPresetSP>();
00151     return preset;
00152 }
00153 
00154 
00155 void KisCanvasResourceProvider::slotPatternActivated(KoResource * res)
00156 {
00157     KisPattern * pattern = dynamic_cast<KisPattern*>(res);
00158     QVariant v = qVariantFromValue((void *) pattern);
00159     m_resourceProvider->setResource(CurrentPattern, v);
00160     emit sigPatternChanged(pattern);
00161 }
00162 
00163 void KisCanvasResourceProvider::slotGeneratorConfigurationActivated(KisFilterConfiguration * res)
00164 {
00165     KisFilterConfiguration * generatorConfiguration = dynamic_cast<KisFilterConfiguration*>(res);
00166     QVariant v = qVariantFromValue((void *) generatorConfiguration);
00167     m_resourceProvider->setResource(CurrentGeneratorConfiguration, v);
00168     emit sigGeneratorConfigurationChanged(generatorConfiguration);
00169 }
00170 
00171 void KisCanvasResourceProvider::slotGradientActivated(KoResource *res)
00172 {
00173 
00174     KoAbstractGradient * gradient = dynamic_cast<KoAbstractGradient*>(res);
00175     QVariant v = qVariantFromValue((void *) gradient);
00176     m_resourceProvider->setResource(CurrentGradient, v);
00177     emit sigGradientChanged(gradient);
00178 }
00179 
00180 void KisCanvasResourceProvider::slotPaintOpPresetActivated(const KisPaintOpPresetSP preset)
00181 {
00182 
00183     Q_ASSERT(preset->valid());
00184     Q_ASSERT(!preset->paintOp().id().isEmpty());
00185     Q_ASSERT(preset->settings());
00186     if (!preset) return;
00187 
00188     dbgUI << "slotPaintOpPresetActivated" << preset->paintOp();
00189 
00190     QVariant v;
00191     v.setValue(preset);
00192     m_resourceProvider->setResource(CurrentPaintOpPreset, v);
00193     emit sigPaintOpPresetChanged(preset);
00194 }
00195 
00196 void KisCanvasResourceProvider::setBGColor(const KoColor& c)
00197 {
00198 
00199     QVariant v;
00200     v.setValue(c);
00201     m_resourceProvider->setResource(KoCanvasResource::BackgroundColor, v);
00202     emit sigBGColorChanged(c);
00203 }
00204 
00205 void KisCanvasResourceProvider::setFGColor(const KoColor& c)
00206 {
00207     QVariant v;
00208     v.setValue(c);
00209     m_resourceProvider->setResource(KoCanvasResource::ForegroundColor, v);
00210     emit sigFGColorChanged(c);
00211 }
00212 
00213 void KisCanvasResourceProvider::slotSetFGColor(const KoColor& c)
00214 {
00215     setFGColor(c);
00216 }
00217 
00218 void KisCanvasResourceProvider::slotSetBGColor(const KoColor& c)
00219 {
00220     setBGColor(c);
00221 }
00222 
00223 void KisCanvasResourceProvider::slotNodeActivated(const KisNodeSP node)
00224 {
00225     QVariant v;
00226     v.setValue(node);
00227     m_resourceProvider->setResource(CurrentKritaNode, v);
00228     emit sigNodeChanged(currentNode());
00229 }
00230 
00231 
00232 void KisCanvasResourceProvider::slotImageSizeChanged()
00233 {
00234     if (KisImageWSP image = m_view->image()) {
00235         float fw = image->width() / image->xRes();
00236         float fh = image->height() / image->yRes();
00237 
00238         QSizeF postscriptSize(fw, fh);
00239         m_resourceProvider->setResource(KoCanvasResource::PageSize, postscriptSize);
00240     }
00241 }
00242 
00243 void KisCanvasResourceProvider::slotSetDisplayProfile(const KoColorProfile * profile)
00244 {
00245     m_displayProfile = const_cast<KoColorProfile*>(profile);
00246     emit sigDisplayProfileChanged(profile);
00247 }
00248 
00249 void KisCanvasResourceProvider::slotResourceChanged(int key, const QVariant & res)
00250 {
00251     switch (key) {
00252     case(KoCanvasResource::ForegroundColor):
00253         emit sigFGColorChanged(res.value<KoColor>());
00254         break;
00255     case(KoCanvasResource::BackgroundColor):
00256         emit sigBGColorChanged(res.value<KoColor>());
00257         break;
00258     case(CurrentPattern):
00259         emit sigPatternChanged(static_cast<KisPattern *>(res.value<void *>()));
00260         break;
00261     case(CurrentGeneratorConfiguration):
00262         emit sigGeneratorConfigurationChanged(static_cast<KisFilterConfiguration*>(res.value<void*>()));
00263     case(CurrentGradient):
00264         emit sigGradientChanged(static_cast<KoAbstractGradient *>(res.value<void *>()));
00265         break;
00266     case(CurrentPaintOpPreset):
00267         emit sigPaintOpPresetChanged(currentPreset());
00268         break;
00269     case(CurrentKritaNode) :
00270         emit sigNodeChanged(currentNode());
00271     default:
00272         ;
00273         // Do nothing
00274     };
00275 }
00276 
00277 #include "kis_canvas_resource_provider.moc"