1 files changed, 306 insertions, 0 deletions
diff --git a/chalk/core/kis_palette.cpp b/chalk/core/kis_palette.cpp
new file mode 100644
index 00000000..aa62b07a
--- /dev/null
+++ b/chalk/core/kis_palette.cpp
@@ -0,0 +1,306 @@
+/*
+ *  Copyright (c) 2005 Boudewijn Rempt <[email protected]>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#include <netinet/in.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <cfloat>
+
+#include <tqimage.h>
+#include <tqpoint.h>
+#include <tqvaluevector.h>
+#include <tqfile.h>
+#include <tqtextstream.h>
+
+#include <kdebug.h>
+#include <tdelocale.h>
+
+#include "kis_debug_areas.h"
+#include "kis_palette.h"
+#include "kis_iterators_pixel.h"
+
+
+namespace {
+    enum enumPaletteType {
+        FORMAT_UNKNOWN,
+        FORMAT_GPL, // Gimp palette
+        FORMAT_PAL, // RIFF palette
+        FORMAT_ACT // Photoshop binary color palette
+    };
+
+}
+
+
+KisPalette::KisPalette(const TQImage * img, TQ_INT32 nColors, const TQString & name)
+    : super(TQString("")),
+      m_name(name)
+{
+    Q_ASSERT(nColors > 0);
+    Q_ASSERT(!img->isNull());
+
+    // XXX: Implement
+
+    m_columns = 0; // Set the default value that the GIMP uses...
+}
+
+KisPalette::KisPalette(const KisPaintDeviceSP device, TQ_INT32 nColors, const TQString & name)
+    : super(TQString("")),
+      m_name(name)
+{
+    Q_ASSERT(nColors > 0);
+    Q_ASSERT(device != 0);
+
+
+    // XXX: Implement
+    m_columns = 0; // Set the default value that the GIMP uses...
+}
+
+
+KisPalette::KisPalette(const KisGradient * gradient, TQ_INT32 nColors, const TQString & name)
+    : super(TQString("")),
+      m_name(name)
+{
+    Q_ASSERT(nColors > 0);
+    Q_ASSERT(gradient != 0);
+
+    double dx, cur_x;
+    TQColor c;
+    TQ_INT32 i;
+    TQ_UINT8 opacity;
+    dx = 1.0 / (nColors - 1);
+
+    KisPaletteEntry e;
+    for (i = 0, cur_x = 0; i < nColors; i++, cur_x += dx) {
+        gradient->colorAt(cur_x, &e.color, &opacity);
+        e.name = "Untitled";
+        add(e);
+    }
+
+    m_columns = 0; // Set the default value that the GIMP uses...
+}
+
+KisPalette::KisPalette(const TQString& filename)
+    : super(filename)
+{
+    // Implemented in super class
+    m_columns = 0; // Set the default value that the GIMP uses...
+}
+
+KisPalette::KisPalette()
+    : super("")
+{
+    m_columns = 0; // Set the default value that the GIMP uses...
+}
+
+/// Create an copied palette
+KisPalette::KisPalette(const KisPalette& rhs)
+    : super("")
+{
+    setFilename(rhs.filename());
+    m_ownData = false;
+    m_img = rhs.m_img;
+    m_name = rhs.m_name;
+    m_comment = rhs.m_comment;
+    m_columns = rhs.m_columns;
+    m_colors = rhs.m_colors;
+    setValid(true);
+}
+
+KisPalette::~KisPalette()
+{
+}
+
+bool KisPalette::load()
+{
+    TQFile file(filename());
+    file.open(IO_ReadOnly);
+    m_data = file.readAll();
+    file.close();
+    return init();
+}
+
+
+bool KisPalette::save()
+{
+    TQFile file(filename());
+    if (!file.open(IO_WriteOnly | IO_Truncate)) {
+        return false;
+    }
+
+    TQTextStream stream(&file);
+    // Header: Magic\nName: <name>\nColumns: <no idea what this means, but default = 0>
+    // In any case, we don't use Columns...
+    stream << "GIMP Palette\nName: " << name() << "\nColumns: " << m_columns << "\n#\n";
+
+    for (uint i = 0; i < m_colors.size(); i++) {
+        const KisPaletteEntry& entry = m_colors.at(i);
+        TQColor c = entry.color;
+        stream << c.red() << " " << c.green() << " " << c.blue() << "\t";
+        if (entry.name.isEmpty())
+            stream << "Untitled\n";
+        else
+            stream << entry.name << "\n";
+    }
+
+    file.close();
+    return true;
+}
+
+TQImage KisPalette::img()
+{
+    return m_img;
+}
+
+TQ_INT32 KisPalette::nColors()
+{
+    return m_colors.count();
+}
+
+bool KisPalette::init()
+{
+    enumPaletteType format = FORMAT_UNKNOWN;
+
+    TQString s = TQString::fromUtf8(m_data.data(), m_data.count());
+
+    if (s.isEmpty() || s.isNull() || s.length() < 50) {
+        kdWarning(DBG_AREA_FILE) << "Illegal Gimp palette file: " << filename() << "\n";
+        return false;
+    }
+
+
+    if (s.startsWith("RIFF") || s.startsWith("PAL data"))
+    {
+       format = FORMAT_PAL;
+    }
+    else if (s.startsWith("GIMP Palette"))
+    {
+        // XXX: No checks for wrong input yet!
+        TQ_UINT32 index = 0;
+
+        TQStringList lines = TQStringList::split("\n", s);
+
+        if (lines.size() < 3) {
+            return false;
+        }
+
+        TQString entry, channel, columns;
+        TQStringList c;
+        TQ_INT32 r, g, b;
+        TQColor color;
+        KisPaletteEntry e;
+
+        format = FORMAT_GPL;
+
+        // Read name
+        if (!lines[1].startsWith("Name: ") || !lines[0].startsWith("GIMP") )
+        {
+            kdWarning(DBG_AREA_FILE) << "Illegal Gimp palette file: " << filename() << "\n";
+            return false;
+        }
+
+        setName(i18n(lines[1].mid(strlen("Name: ")).stripWhiteSpace().ascii()));
+
+        index = 2;
+
+        // Read columns
+        if (lines[index].startsWith("Columns: ")) {
+            columns = lines[index].mid(strlen("Columns: ")).stripWhiteSpace();;
+            m_columns = columns.toInt();
+            index = 3;
+        }
+
+        for (TQ_UINT32 i = index; i < lines.size(); i++) {
+            if (lines[i].startsWith("#")) {
+                m_comment += lines[i].mid(1).stripWhiteSpace() + " ";
+            }
+            else if (!lines[i].isEmpty())
+            {
+                TQStringList a = TQStringList::split(" ", lines[i].replace(TQChar('\t'), " "));
+
+                if (a.count() < 3)
+                {
+                    break;
+                }
+
+                r = a[0].toInt();
+                a.pop_front();
+                g = a[0].toInt();
+                a.pop_front();
+                b = a[0].toInt();
+                a.pop_front();
+
+                if (r < 0 || r > 255 ||
+                    g < 0 || g > 255 ||
+                    b < 0 || b > 255)
+                {
+                    break;
+                }
+
+                color = TQColor(r, g, b);
+                e.color = color;
+
+                TQString name = a.join(" ");
+                e.name = name.isEmpty() ? i18n("Untitled") : name;
+
+                add(e);
+            }
+        }
+        setValid(true);
+        return true;
+    }
+    else if (s.length() == 768) {
+        kdWarning(DBG_AREA_FILE) << "Photoshop format palette file. Not implemented yet\n";
+        format = FORMAT_ACT;
+    }
+    return false;
+}
+
+
+void KisPalette::add(const KisPaletteEntry & c)
+{
+    m_colors.push_back(c);
+}
+
+void KisPalette::remove(const KisPaletteEntry & c)
+{
+    TQValueVector<KisPaletteEntry>::iterator it = m_colors.begin();
+    TQValueVector<KisPaletteEntry>::iterator end = m_colors.end();
+
+    while (it != end) {
+        if ((*it) == c) {
+            m_colors.erase(it);
+            return;
+        }
+        ++it;
+    }
+}
+
+KisPaletteEntry KisPalette::getColor(TQ_UINT32 index)
+{
+    return m_colors[index];
+}
+
+#include "kis_palette.moc"