/*
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 <tdeconfig.h>
# include <kdebug.h>
# include <tdeglobal.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 ( TDEConfigBase * config )
{
return config - > readEntry ( kpSettingForcedMimeType ,
TQString : : fromLatin1 ( " image/png " ) ) ;
}
// public static
void kpDocumentSaveOptions : : saveDefaultMimeType ( TDEConfigBase * config ,
const TQString & mimeType )
{
config - > writeEntry ( kpSettingForcedMimeType , mimeType ) ;
}
// public static
int kpDocumentSaveOptions : : defaultColorDepth ( TDEConfigBase * 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 ( TDEConfigBase * config , int colorDepth )
{
config - > writeEntry ( kpSettingForcedColorDepth , colorDepth ) ;
}
// public static
int kpDocumentSaveOptions : : defaultDither ( TDEConfigBase * config )
{
return config - > readBoolEntry ( kpSettingForcedDither , initialDither ( ) ) ;
}
// public static
void kpDocumentSaveOptions : : saveDefaultDither ( TDEConfigBase * config , bool dither )
{
config - > writeEntry ( kpSettingForcedDither , dither ) ;
}
// public static
int kpDocumentSaveOptions : : defaultQuality ( TDEConfigBase * config )
{
int val = config - > readNumEntry ( kpSettingForcedQuality , - 1 ) ;
if ( qualityIsInvalid ( val ) )
val = - 1 ;
return val ;
}
// public static
void kpDocumentSaveOptions : : saveDefaultQuality ( TDEConfigBase * config , int quality )
{
config - > writeEntry ( kpSettingForcedQuality , quality ) ;
}
// public static
kpDocumentSaveOptions kpDocumentSaveOptions : : defaultDocumentSaveOptions ( TDEConfigBase * 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 ( TDEConfigBase * config ,
const kpDocumentSaveOptions & oldDocInfo ,
const kpDocumentSaveOptions & newDocInfo )
{
bool savedSomething = false ;
# if DEBUG_KP_DOCUMENT_SAVE_OPTIONS
kdDebug ( ) < < " kpDocumentSaveOptions::saveDefaultDifferences() " < < endl ;
oldDocInfo . printDebug ( " \t old " ) ;
newDocInfo . printDebug ( " \t new " ) ;
# 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 ;
TDEConfigGroupSaver cfgGroupSaver ( TDEGlobal : : config ( ) ,
kpSettingsGroupMimeTypeProperties ) ;
TDEConfigBase * 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 tdelibs/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 ;
}