krita

kis_color.cc

00001 /*
00002  *  Copyright (c) 2005 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 #include <qcolor.h>
00019  
00020 #include "kdebug.h"
00021 #include "kis_debug_areas.h"
00022 #include "kis_color.h"
00023 #include "kis_profile.h"
00024 #include "kis_colorspace.h"
00025 #include "kis_colorspace_factory_registry.h"
00026 
00027 KisColor::KisColor()
00028 {
00029     m_data = 0;
00030     m_colorSpace = 0;
00031 }
00032 
00033 KisColor::~KisColor()
00034 {
00035     delete [] m_data;
00036 }
00037 
00038 KisColor::KisColor(const QColor & color, KisColorSpace * colorSpace)
00039     : m_colorSpace(colorSpace)
00040 {
00041     Q_ASSERT(color.isValid());
00042     Q_ASSERT(colorSpace);
00043     
00044     m_data = new Q_UINT8[colorSpace->pixelSize()];
00045     memset(m_data, 0, m_colorSpace->pixelSize());
00046 
00047     m_colorSpace->fromQColor(color, OPACITY_OPAQUE, m_data);
00048 }
00049 
00050 
00051 KisColor::KisColor(const QColor & color, Q_UINT8 alpha, KisColorSpace * colorSpace)
00052     : m_colorSpace(colorSpace)
00053 {
00054     Q_ASSERT(color.isValid());
00055     Q_ASSERT(colorSpace);
00056     m_data = new Q_UINT8[colorSpace->pixelSize()];
00057     memset(m_data, 0, m_colorSpace->pixelSize());
00058 
00059     m_colorSpace->fromQColor(color, alpha, m_data);
00060 }
00061 
00062 KisColor::KisColor(const Q_UINT8 * data, KisColorSpace * colorSpace)
00063     : m_colorSpace(colorSpace)
00064 {
00065 
00066     m_data = new Q_UINT8[colorSpace->pixelSize()];
00067     memset(m_data, 0, m_colorSpace->pixelSize());
00068     memmove(m_data, data, colorSpace->pixelSize());
00069 }
00070 
00071 
00072 KisColor::KisColor(const KisColor &src, KisColorSpace * colorSpace)
00073     : m_colorSpace(colorSpace)
00074 {
00075     m_data = new Q_UINT8[colorSpace->pixelSize()];
00076     memset(m_data, 0, m_colorSpace->pixelSize());
00077 
00078     src.colorSpace()->convertPixelsTo(src.data(), m_data, colorSpace, 1);
00079 }
00080 
00081 KisColor::KisColor(const KisColor & rhs)
00082 {
00083     if (this == &rhs) return;
00084 
00085     m_colorSpace = rhs.colorSpace();
00086     m_data = new Q_UINT8[m_colorSpace->pixelSize()];
00087     memset(m_data, 0, m_colorSpace->pixelSize());
00088     memcpy(m_data, rhs.data(), m_colorSpace->pixelSize());
00089 }
00090 
00091 KisColor & KisColor::operator=(const KisColor & rhs)
00092 {
00093     delete [] m_data;
00094     m_data = 0;
00095     m_colorSpace = rhs.colorSpace();
00096 
00097     if (rhs.m_colorSpace && rhs.m_data) {
00098         m_data = new Q_UINT8[m_colorSpace->pixelSize()];
00099         memcpy(m_data, rhs.m_data, m_colorSpace->pixelSize());
00100     }
00101     return * this;
00102 }
00103 
00104 void KisColor::convertTo(KisColorSpace * cs)
00105 {
00106     //kdDebug(DBG_AREA_CMS) << "Our colormodel: " << m_colorSpace->id().name()
00107     //      << ", new colormodel: " << cs->id().name() << "\n";
00108 
00109     if (m_colorSpace == cs)
00110         return;
00111 
00112     Q_UINT8 * m_data2 = new Q_UINT8[cs->pixelSize()];
00113     memset(m_data2, 0, cs->pixelSize());
00114 
00115     m_colorSpace->convertPixelsTo(m_data, m_data2, cs, 1);
00116 
00117     delete [] m_data;
00118     m_data = m_data2;
00119     m_colorSpace = cs;
00120 }
00121 
00122 
00123 void KisColor::setColor(Q_UINT8 * data, KisColorSpace * colorSpace)
00124 {
00125     delete [] m_data;
00126     m_data = new Q_UINT8[colorSpace->pixelSize()];
00127     memcpy(m_data, data, colorSpace->pixelSize());
00128     m_colorSpace = colorSpace;
00129 }
00130 
00131 // To save the user the trouble of doing color->colorSpace()->toQColor(color->data(), &c, &a, profile
00132 void KisColor::toQColor(QColor *c) const
00133 {
00134     if (m_colorSpace && m_data) {
00135         // XXX (bsar): There must be a better way, but I'm getting hopelessly confused about constness by now
00136         KisColorSpace * cs(const_cast<KisColorSpace*>(m_colorSpace));
00137 
00138         cs->toQColor(m_data, c);
00139     }
00140 }
00141 
00142 void KisColor::toQColor(QColor *c, Q_UINT8 *opacity) const
00143 {
00144     if (m_colorSpace && m_data) {
00145         // XXX (bsar): There must be a better way, but I'm getting hopelessly confused about constness by now
00146         KisColorSpace * cs(const_cast<KisColorSpace*>(m_colorSpace));
00147         cs->toQColor(m_data, c, opacity);
00148     }
00149 }
00150 
00151 QColor KisColor::toQColor() const
00152 {
00153     QColor c;
00154     toQColor(&c);
00155     return c;
00156 }
00157 
00158 void KisColor::dump() const
00159 {
00160 
00161     //kdDebug(DBG_AREA_CMS) << "KisColor (" << this << "), " << m_colorSpace->id().name() << "\n";
00162     QValueVector<KisChannelInfo *> channels = m_colorSpace->channels();
00163 
00164     QValueVector<KisChannelInfo *>::const_iterator begin = channels.begin();
00165     QValueVector<KisChannelInfo *>::const_iterator end = channels.end();
00166 
00167     for (QValueVector<KisChannelInfo *>::const_iterator it = begin; it != end; ++it)
00168     {
00169         KisChannelInfo * ch = (*it);
00170         // XXX: setNum always takes a byte.
00171         if (ch->size() == sizeof(Q_UINT8)) {
00172             // Byte
00173             //kdDebug(DBG_AREA_CMS) << "Channel (byte): " << ch->name() << ": " << QString().setNum(m_data[ch->pos()]) << "\n";
00174         }
00175         else if (ch->size() == sizeof(Q_UINT16)) {
00176             // Short (may also by an nvidia half)
00177             //kdDebug(DBG_AREA_CMS) << "Channel (short): " << ch->name() << ": " << QString().setNum(*((const Q_UINT16 *)(m_data+ch->pos())))  << "\n";
00178         }
00179         else if (ch->size() == sizeof(Q_UINT32)) {
00180             // Integer (may also be float... Find out how to distinguish these!)
00181             //kdDebug(DBG_AREA_CMS) << "Channel (int): " << ch->name() << ": " << QString().setNum(*((const Q_UINT32 *)(m_data+ch->pos())))  << "\n";
00182         }
00183     }
00184 
00185 }
KDE Home | KDE Accessibility Home | Description of Access Keys