You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
562 lines
14 KiB
562 lines
14 KiB
|
|
/*
|
|
Copyright (c) 2003,2004,2005 Clarence Dang <dang@kde.org>
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#define DEBUG_KP_DOCUMENT_SAVE_OPTIONS 0
|
|
|
|
|
|
#include <kpdocumentsaveoptions.h>
|
|
|
|
#include <tqpixmap.h>
|
|
#include <tqstring.h>
|
|
|
|
#include <kconfig.h>
|
|
#include <kdebug.h>
|
|
#include <kglobal.h>
|
|
|
|
#include <kpdefs.h>
|
|
|
|
|
|
struct kpDocumentSaveOptionsPrivate
|
|
{
|
|
TQString m_mimeType;
|
|
int m_colorDepth;
|
|
bool m_dither;
|
|
int m_quality;
|
|
};
|
|
|
|
|
|
kpDocumentSaveOptions::kpDocumentSaveOptions ()
|
|
: d (new kpDocumentSaveOptionsPrivate ())
|
|
{
|
|
d->m_mimeType = invalidMimeType ();
|
|
d->m_colorDepth = invalidColorDepth ();
|
|
d->m_dither = initialDither ();
|
|
d->m_quality = invalidQuality ();
|
|
}
|
|
|
|
kpDocumentSaveOptions::kpDocumentSaveOptions (const kpDocumentSaveOptions &rhs)
|
|
: d (new kpDocumentSaveOptionsPrivate ())
|
|
{
|
|
d->m_mimeType = rhs.mimeType ();
|
|
d->m_colorDepth = rhs.colorDepth ();
|
|
d->m_dither = rhs.dither ();
|
|
d->m_quality = rhs.quality ();
|
|
}
|
|
|
|
kpDocumentSaveOptions::kpDocumentSaveOptions (TQString mimeType, int colorDepth, bool dither, int quality)
|
|
: d (new kpDocumentSaveOptionsPrivate ())
|
|
{
|
|
d->m_mimeType = mimeType;
|
|
d->m_colorDepth = colorDepth;
|
|
d->m_dither = dither;
|
|
d->m_quality = quality;
|
|
}
|
|
|
|
kpDocumentSaveOptions::~kpDocumentSaveOptions ()
|
|
{
|
|
delete d;
|
|
}
|
|
|
|
|
|
// public
|
|
bool kpDocumentSaveOptions::operator== (const kpDocumentSaveOptions &rhs) const
|
|
{
|
|
return (mimeType () == rhs.mimeType () &&
|
|
colorDepth () == rhs.colorDepth () &&
|
|
dither () == rhs.dither () &&
|
|
quality () == rhs.quality ());
|
|
}
|
|
|
|
// public
|
|
bool kpDocumentSaveOptions::operator!= (const kpDocumentSaveOptions &rhs) const
|
|
{
|
|
return !(*this == rhs);
|
|
}
|
|
|
|
|
|
// public
|
|
kpDocumentSaveOptions &kpDocumentSaveOptions::operator= (const kpDocumentSaveOptions &rhs)
|
|
{
|
|
setMimeType (rhs.mimeType ());
|
|
setColorDepth (rhs.colorDepth ());
|
|
setDither (rhs.dither ());
|
|
setQuality (rhs.quality ());
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
// public
|
|
void kpDocumentSaveOptions::printDebug (const TQString &prefix) const
|
|
{
|
|
const TQString usedPrefix = !prefix.isEmpty () ?
|
|
prefix + TQString::fromLatin1 (": ") :
|
|
TQString();
|
|
|
|
kdDebug () << usedPrefix
|
|
<< "mimeType=" << mimeType ()
|
|
<< " colorDepth=" << colorDepth ()
|
|
<< " dither=" << dither ()
|
|
<< " quality=" << quality ()
|
|
<< endl;
|
|
}
|
|
|
|
|
|
// public
|
|
TQString kpDocumentSaveOptions::mimeType () const
|
|
{
|
|
return d->m_mimeType;
|
|
}
|
|
|
|
// public
|
|
void kpDocumentSaveOptions::setMimeType (const TQString &mimeType)
|
|
{
|
|
d->m_mimeType = mimeType;
|
|
}
|
|
|
|
|
|
// public static
|
|
TQString kpDocumentSaveOptions::invalidMimeType ()
|
|
{
|
|
return TQString();
|
|
}
|
|
|
|
// public static
|
|
bool kpDocumentSaveOptions::mimeTypeIsInvalid (const TQString &mimeType)
|
|
{
|
|
return (mimeType == invalidMimeType ());
|
|
}
|
|
|
|
// public
|
|
bool kpDocumentSaveOptions::mimeTypeIsInvalid () const
|
|
{
|
|
return mimeTypeIsInvalid (mimeType ());
|
|
}
|
|
|
|
|
|
// public
|
|
int kpDocumentSaveOptions::colorDepth () const
|
|
{
|
|
return d->m_colorDepth;
|
|
}
|
|
|
|
// public
|
|
void kpDocumentSaveOptions::setColorDepth (int depth)
|
|
{
|
|
d->m_colorDepth = depth;
|
|
}
|
|
|
|
|
|
// public static
|
|
int kpDocumentSaveOptions::invalidColorDepth ()
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
// public static
|
|
bool kpDocumentSaveOptions::colorDepthIsInvalid (int colorDepth)
|
|
{
|
|
return (colorDepth != 1 && colorDepth != 8 && colorDepth != 32);
|
|
}
|
|
|
|
// public
|
|
bool kpDocumentSaveOptions::colorDepthIsInvalid () const
|
|
{
|
|
return colorDepthIsInvalid (colorDepth ());
|
|
}
|
|
|
|
|
|
// public
|
|
bool kpDocumentSaveOptions::dither () const
|
|
{
|
|
return d->m_dither;
|
|
}
|
|
|
|
// public
|
|
void kpDocumentSaveOptions::setDither (bool dither)
|
|
{
|
|
d->m_dither = dither;
|
|
}
|
|
|
|
|
|
// public static
|
|
int kpDocumentSaveOptions::initialDither ()
|
|
{
|
|
return false; // to avoid accidental double dithering
|
|
}
|
|
|
|
|
|
// public
|
|
int kpDocumentSaveOptions::quality () const
|
|
{
|
|
return d->m_quality;
|
|
}
|
|
|
|
// public
|
|
void kpDocumentSaveOptions::setQuality (int quality)
|
|
{
|
|
d->m_quality = quality;
|
|
}
|
|
|
|
|
|
// public static
|
|
int kpDocumentSaveOptions::invalidQuality ()
|
|
{
|
|
return -2;
|
|
}
|
|
|
|
// public static
|
|
bool kpDocumentSaveOptions::qualityIsInvalid (int quality)
|
|
{
|
|
return (quality < -1 || quality > 100);
|
|
}
|
|
|
|
// public
|
|
bool kpDocumentSaveOptions::qualityIsInvalid () const
|
|
{
|
|
return qualityIsInvalid (quality ());
|
|
}
|
|
|
|
|
|
// public static
|
|
TQString kpDocumentSaveOptions::defaultMimeType (KConfigBase *config)
|
|
{
|
|
return config->readEntry (kpSettingForcedMimeType,
|
|
TQString::fromLatin1 ("image/png"));
|
|
}
|
|
|
|
// public static
|
|
void kpDocumentSaveOptions::saveDefaultMimeType (KConfigBase *config,
|
|
const TQString &mimeType)
|
|
{
|
|
config->writeEntry (kpSettingForcedMimeType, mimeType);
|
|
}
|
|
|
|
|
|
// public static
|
|
int kpDocumentSaveOptions::defaultColorDepth (KConfigBase *config)
|
|
{
|
|
int colorDepth =
|
|
config->readNumEntry (kpSettingForcedColorDepth, -1);
|
|
|
|
if (colorDepthIsInvalid (colorDepth))
|
|
{
|
|
// (not screen depth, in case of transparency)
|
|
colorDepth = 32;
|
|
}
|
|
|
|
return colorDepth;
|
|
}
|
|
|
|
// public static
|
|
void kpDocumentSaveOptions::saveDefaultColorDepth (KConfigBase *config, int colorDepth)
|
|
{
|
|
config->writeEntry (kpSettingForcedColorDepth, colorDepth);
|
|
}
|
|
|
|
|
|
// public static
|
|
int kpDocumentSaveOptions::defaultDither (KConfigBase *config)
|
|
{
|
|
return config->readBoolEntry (kpSettingForcedDither, initialDither ());
|
|
}
|
|
|
|
// public static
|
|
void kpDocumentSaveOptions::saveDefaultDither (KConfigBase *config, bool dither)
|
|
{
|
|
config->writeEntry (kpSettingForcedDither, dither);
|
|
}
|
|
|
|
|
|
// public static
|
|
int kpDocumentSaveOptions::defaultQuality (KConfigBase *config)
|
|
{
|
|
int val = config->readNumEntry (kpSettingForcedQuality, -1);
|
|
if (qualityIsInvalid (val))
|
|
val = -1;
|
|
|
|
return val;
|
|
}
|
|
|
|
// public static
|
|
void kpDocumentSaveOptions::saveDefaultQuality (KConfigBase *config, int quality)
|
|
{
|
|
config->writeEntry (kpSettingForcedQuality, quality);
|
|
}
|
|
|
|
|
|
// public static
|
|
kpDocumentSaveOptions kpDocumentSaveOptions::defaultDocumentSaveOptions (KConfigBase *config)
|
|
{
|
|
kpDocumentSaveOptions saveOptions;
|
|
saveOptions.setMimeType (defaultMimeType (config));
|
|
saveOptions.setColorDepth (defaultColorDepth (config));
|
|
saveOptions.setDither (defaultDither (config));
|
|
saveOptions.setQuality (defaultQuality (config));
|
|
|
|
#if DEBUG_KP_DOCUMENT_SAVE_OPTIONS
|
|
saveOptions.printDebug ("kpDocumentSaveOptions::defaultDocumentSaveOptions()");
|
|
#endif
|
|
|
|
return saveOptions;
|
|
}
|
|
|
|
// public static
|
|
bool kpDocumentSaveOptions::saveDefaultDifferences (KConfigBase *config,
|
|
const kpDocumentSaveOptions &oldDocInfo,
|
|
const kpDocumentSaveOptions &newDocInfo)
|
|
{
|
|
bool savedSomething = false;
|
|
|
|
#if DEBUG_KP_DOCUMENT_SAVE_OPTIONS
|
|
kdDebug () << "kpDocumentSaveOptions::saveDefaultDifferences()" << endl;
|
|
oldDocInfo.printDebug ("\told");
|
|
newDocInfo.printDebug ("\tnew");
|
|
#endif
|
|
|
|
if (newDocInfo.mimeType () != oldDocInfo.mimeType ())
|
|
{
|
|
saveDefaultMimeType (config, newDocInfo.mimeType ());
|
|
savedSomething = true;
|
|
}
|
|
|
|
if (newDocInfo.colorDepth () != oldDocInfo.colorDepth ())
|
|
{
|
|
saveDefaultColorDepth (config, newDocInfo.colorDepth ());
|
|
savedSomething = true;
|
|
}
|
|
|
|
if (newDocInfo.dither () != oldDocInfo.dither ())
|
|
{
|
|
saveDefaultDither (config, newDocInfo.dither ());
|
|
savedSomething = true;
|
|
}
|
|
|
|
if (newDocInfo.quality () != oldDocInfo.quality ())
|
|
{
|
|
saveDefaultQuality (config, newDocInfo.quality ());
|
|
savedSomething = true;
|
|
}
|
|
|
|
return savedSomething;
|
|
}
|
|
|
|
|
|
static TQStringList mimeTypesSupportingProperty (const TQString &property,
|
|
const TQStringList &defaultMimeTypesWithPropertyList)
|
|
{
|
|
TQStringList mimeTypeList;
|
|
|
|
KConfigGroupSaver cfgGroupSaver (KGlobal::config (),
|
|
kpSettingsGroupMimeTypeProperties);
|
|
KConfigBase *cfg = cfgGroupSaver.config ();
|
|
|
|
if (cfg->hasKey (property))
|
|
{
|
|
mimeTypeList = cfg->readListEntry (property);
|
|
}
|
|
else
|
|
{
|
|
mimeTypeList = defaultMimeTypesWithPropertyList;
|
|
|
|
cfg->writeEntry (property, mimeTypeList);
|
|
cfg->sync ();
|
|
}
|
|
|
|
return mimeTypeList;
|
|
}
|
|
|
|
static bool mimeTypeSupportsProperty (const TQString &mimeType,
|
|
const TQString &property, const TQStringList &defaultMimeTypesWithPropertyList)
|
|
{
|
|
const TQStringList mimeTypeList = mimeTypesSupportingProperty (
|
|
property, defaultMimeTypesWithPropertyList);
|
|
|
|
return mimeTypeList.contains (mimeType);
|
|
}
|
|
|
|
|
|
// SYNC: update mime info
|
|
//
|
|
// Only care about writable mimetypes.
|
|
//
|
|
// Run "branches/kolourpaint/control/scripts/gen_mimetype_line.sh Write" in
|
|
// the version of kdelibs/kimgio/ (e.g. KDE 3.5) KolourPaint is shipped with,
|
|
// to check for any new mimetypes to add info for. In the methods below,
|
|
// you can specify this info (maximum color depth, whether it's lossy etc.).
|
|
//
|
|
// Update the below list also and bump up "kpSettingsGroupMimeTypeProperties"
|
|
// in kpdefs.h.
|
|
//
|
|
// Currently, Depth and Quality settings are mutually exclusive with
|
|
// Depth overriding Quality. I've currently favoured Quality with the
|
|
// below mimetypes (i.e. all lossy mimetypes are only given Quality settings,
|
|
// no Depth settings).
|
|
//
|
|
// Mimetypes done:
|
|
// image/jp2 [UNTESTED]
|
|
// image/jpeg
|
|
// image/png
|
|
// image/x-bmp
|
|
// image/x-eps
|
|
// image/x-pcx
|
|
// image/x-portable-bitmap
|
|
// image/x-portable-greymap
|
|
// image/x-portable-pixmap
|
|
// image/x-rgb
|
|
// image/x-targa
|
|
// image/x-xbm
|
|
// image/x-xpm
|
|
//
|
|
// To test whether depth is configurable, write an image in the new
|
|
// mimetype with all depths and read each one back. See what
|
|
// kpDocument thinks the depth is when it gets TQImage to read it.
|
|
|
|
|
|
// public static
|
|
int kpDocumentSaveOptions::mimeTypeMaximumColorDepth (const TQString &mimeType)
|
|
{
|
|
TQStringList defaultList;
|
|
|
|
// SYNC: update mime info here
|
|
|
|
// Greyscale actually (unenforced since depth not set to configurable)
|
|
defaultList << TQString::fromLatin1 ("image/x-eps:32");
|
|
|
|
defaultList << TQString::fromLatin1 ("image/x-portable-bitmap:1");
|
|
|
|
// Greyscale actually (unenforced since depth not set to configurable)
|
|
defaultList << TQString::fromLatin1 ("image/x-portable-greymap:8");
|
|
|
|
defaultList << TQString::fromLatin1 ("image/x-xbm:1");
|
|
|
|
const TQStringList mimeTypeList = mimeTypesSupportingProperty (
|
|
kpSettingMimeTypeMaximumColorDepth, defaultList);
|
|
|
|
const TQString mimeTypeColon = mimeType + TQString::fromLatin1 (":");
|
|
for (TQStringList::const_iterator it = mimeTypeList.begin ();
|
|
it != mimeTypeList.end ();
|
|
it++)
|
|
{
|
|
if ((*it).startsWith (mimeTypeColon))
|
|
{
|
|
int number = (*it).mid (mimeTypeColon.length ()).toInt ();
|
|
if (!colorDepthIsInvalid (number))
|
|
{
|
|
return number;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 32;
|
|
}
|
|
|
|
// public
|
|
int kpDocumentSaveOptions::mimeTypeMaximumColorDepth () const
|
|
{
|
|
return mimeTypeMaximumColorDepth (mimeType ());
|
|
}
|
|
|
|
|
|
// public static
|
|
bool kpDocumentSaveOptions::mimeTypeHasConfigurableColorDepth (const TQString &mimeType)
|
|
{
|
|
TQStringList defaultMimeTypes;
|
|
|
|
// SYNC: update mime info here
|
|
defaultMimeTypes << TQString::fromLatin1 ("image/png");
|
|
defaultMimeTypes << TQString::fromLatin1 ("image/x-bmp");
|
|
defaultMimeTypes << TQString::fromLatin1 ("image/x-pcx");
|
|
|
|
// TODO: Only 1, 24 not 8; TQt only sees 32 but "file" cmd realises
|
|
// it's either 1 or 24.
|
|
defaultMimeTypes << TQString::fromLatin1 ("image/x-rgb");
|
|
|
|
// TODO: Only 8 and 24 - no 1.
|
|
defaultMimeTypes << TQString::fromLatin1 ("image/x-xpm");
|
|
|
|
return mimeTypeSupportsProperty (mimeType,
|
|
kpSettingMimeTypeHasConfigurableColorDepth,
|
|
defaultMimeTypes);
|
|
}
|
|
|
|
// public
|
|
bool kpDocumentSaveOptions::mimeTypeHasConfigurableColorDepth () const
|
|
{
|
|
return mimeTypeHasConfigurableColorDepth (mimeType ());
|
|
}
|
|
|
|
|
|
// public static
|
|
bool kpDocumentSaveOptions::mimeTypeHasConfigurableQuality (const TQString &mimeType)
|
|
{
|
|
TQStringList defaultMimeTypes;
|
|
|
|
// SYNC: update mime info here
|
|
defaultMimeTypes << TQString::fromLatin1 ("image/jp2");
|
|
defaultMimeTypes << TQString::fromLatin1 ("image/jpeg");
|
|
|
|
return mimeTypeSupportsProperty (mimeType,
|
|
kpSettingMimeTypeHasConfigurableQuality,
|
|
defaultMimeTypes);
|
|
}
|
|
|
|
// public
|
|
bool kpDocumentSaveOptions::mimeTypeHasConfigurableQuality () const
|
|
{
|
|
return mimeTypeHasConfigurableQuality (mimeType ());
|
|
}
|
|
|
|
|
|
// public
|
|
int kpDocumentSaveOptions::isLossyForSaving (const TQPixmap &pixmap) const
|
|
{
|
|
int ret = 0;
|
|
|
|
if (mimeTypeMaximumColorDepth () < pixmap.depth ())
|
|
{
|
|
ret |= MimeTypeMaximumColorDepthLow;
|
|
}
|
|
|
|
if (mimeTypeHasConfigurableColorDepth () &&
|
|
!colorDepthIsInvalid () /*TODO: prevent*/ &&
|
|
(colorDepth () < pixmap.depth () ||
|
|
colorDepth () < 32 && pixmap.mask ()))
|
|
{
|
|
ret |= ColorDepthLow;
|
|
}
|
|
|
|
if (mimeTypeHasConfigurableQuality () &&
|
|
!qualityIsInvalid ())
|
|
{
|
|
ret |= Quality;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|