DB/ImageInfo.cpp

   1 /* Copyright (C) 2003-2006 Jesper K. Pedersen <blackie@kde.org>
   2
   3    This program is free software; you can redistribute it and/or
   4    modify it under the terms of the GNU General Public
   5    License as published by the Free Software Foundation; either
   6    version 2 of the License, or (at your option) any later version.
   7
   8    This program is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11    General Public License for more details.
  12
  13    You should have received a copy of the GNU General Public License
  14    along with this program; see the file COPYING.  If not, write to
  15    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  16    Boston, MA 02110-1301, USA.
  17 */
  18
  19 #include "ImageInfo.h"
  20 #include <qfileinfo.h>
  21 #include "Settings/SettingsData.h"
  22 #include "Utilities/Util.h"
  23 #include "DB/ImageDB.h"
  24 #include "DB/CategoryCollection.h"
  25 #include "FileInfo.h"
  26 #include <qstringlist.h>
  27 #include "DB/MemberMap.h"
  28 #include <config-kpa-exiv2.h>
  29 #include "Exif/Database.h"
  30 #include <kdebug.h>
  31 #include <Utilities/Set.h>
  32
  33 using namespace DB;
  34
  35 ImageInfo::ImageInfo() :_null( true ), _rating(-1), _stackId(0), _stackOrder(0),
  36     _geoPosition(),
  37     _locked( false ), _dirty( false ), _delaySaving( false )
  38 {
  39 }
  40
  41 ImageInfo::ImageInfo( const QString& relativeFileName, MediaType type, bool readExifInfo )
  42     :  _imageOnDisk( YesOnDisk ), _null( false ), _size( -1, -1 ), _type( type ),
  43     _rating(-1), _stackId(0), _stackOrder(0),
  44     _geoPosition(),
  45     _locked(false), _delaySaving( true )
  46 {
  47     QString fullPath = Settings::SettingsData::instance()->imageDirectory()+ relativeFileName;
  48     QFileInfo fi( fullPath );
  49     _label = fi.completeBaseName();
  50     _angle = 0;
  51
  52     setFileName(relativeFileName);
  53
  54     // Read EXIF information
  55     if ( readExifInfo )
  56         readExif(fullPath, EXIFMODE_INIT);
  57
  58     _dirty = false;
  59     _delaySaving = false;
  60 }
  61
  62 /** Change delaying of saving changes.
  63  *
  64  * Will save changes when set to false.
  65  *
  66  * Use this method to set multiple attributes with only one
  67  * database operation.
  68  *
  69  * Example:
  70  * \code
  71  * info.delaySavingChanges(true);
  72  * info.setLabel("Hello");
  73  * info.setDescription("Hello world");
  74  * info.delaySavingChanges(false);
  75  * \endcode
  76  *
  77  * \see saveChanges()
  78  */
  79 void ImageInfo::delaySavingChanges(bool b)
  80 {
  81     _delaySaving = b;
  82     if (!b)
  83         saveChanges();
  84 }
  85
  86 void ImageInfo::setLabel( const QString& desc )
  87 {
  88     if (desc != _label)
  89         _dirty = true;
  90     _label = desc;
  91     saveChangesIfNotDelayed();
  92 }
  93
  94 QString ImageInfo::label() const
  95 {
  96     return _label;
  97 }
  98
  99 void ImageInfo::setDescription( const QString& desc )
 100 {
 101     if (desc != _description)
 102         _dirty = true;
 103     _description = desc;
 104     saveChangesIfNotDelayed();
 105 }
 106
 107 QString ImageInfo::description() const
 108 {
 109     return _description;
 110 }
 111
 112
 113 void ImageInfo::setCategoryInfo( const QString& key, const StringSet& value )
 114 {
 115     // Don't check if really changed, because it's too slow.
 116     _dirty = true;
 117     _categoryInfomation[key] = value;
 118     saveChangesIfNotDelayed();
 119 }
 120
 121 bool ImageInfo::hasCategoryInfo( const QString& key, const QString& value ) const
 122 {
 123     return _categoryInfomation[key].contains(value);
 124 }
 125
 126 bool DB::ImageInfo::hasCategoryInfo( const QString& key, const StringSet& values ) const
 127 {
 128     return Utilities::overlap( _categoryInfomation[key], values );
 129 }
 130
 131
 132
 133 StringSet ImageInfo::itemsOfCategory( const QString& key ) const
 134 {
 135     return _categoryInfomation[key];
 136 }
 137
 138 void ImageInfo::renameItem( const QString& key, const QString& oldValue, const QString& newValue )
 139 {
 140     StringSet& set = _categoryInfomation[key];
 141     StringSet::iterator it = set.find( oldValue );
 142     if ( it != set.end() ) {
 143         _dirty = true;
 144         set.erase( it );
 145         set.insert( newValue );
 146         saveChangesIfNotDelayed();
 147     }
 148 }
 149
 150 QString ImageInfo::fileName( PathType type ) const
 151 {
 152     switch (type) {
 153     case DB::RelativeToImageRoot: return _relativeFileName;
 154     case DB::AbsolutePath:        return _absoluteFileName;
 155     default:
 156         kFatal("Invalid parameter to ImageInfo::fileName()");
 157         return QString();
 158     }
 159 }
 160
 161 void ImageInfo::setFileName( const QString& relativeFileName )
 162 {
 163     if (relativeFileName != _relativeFileName)
 164         _dirty = true;
 165     _relativeFileName = relativeFileName;
 166     setAbsoluteFileName();
 167     _imageOnDisk = Unchecked;
 168     DB::CategoryPtr folderCategory = DB::ImageDB::instance()->categoryCollection()->
 169         categoryForName(QString::fromLatin1("Folder"));
 170     if (folderCategory) {
 171         DB::MemberMap& map = DB::ImageDB::instance()->memberMap();
 172         createFolderCategoryItem( folderCategory, map );
 173         //ImageDB::instance()->setMemberMap( map );
 174     }
 175     saveChangesIfNotDelayed();
 176 }
 177
 178
 179 void ImageInfo::rotate( int degrees )
 180 {
 181     if (degrees != 0)
 182         _dirty = true;
 183     _angle += degrees + 360;
 184     _angle = _angle % 360;
 185     saveChangesIfNotDelayed();
 186 }
 187
 188 int ImageInfo::angle() const
 189 {
 190     return _angle;
 191 }
 192
 193 void ImageInfo::setAngle( int angle )
 194 {
 195     if (angle != _angle)
 196         _dirty = true;
 197     _angle = angle;
 198     saveChangesIfNotDelayed();
 199 }
 200
 201 short ImageInfo::rating() const
 202 {
 203     return _rating;
 204 }
 205
 206 void ImageInfo::setRating( short rating )
 207 {
 208     Q_ASSERT( (rating >= 0 && rating <= 10) || rating == -1 );
 209
 210     if ( rating > 10 )
 211         rating = 10;
 212     if ( rating < -1 )
 213         rating = -1;
 214     if ( _rating != rating )
 215         _dirty = true;
 216
 217     _rating = rating;
 218     saveChangesIfNotDelayed();
 219 }
 220
 221 DB::StackID ImageInfo::stackId() const
 222 {
 223     return _stackId;
 224 }
 225
 226 void ImageInfo::setStackId( const DB::StackID stackId )
 227 {
 228     if ( stackId != _stackId )
 229         _dirty = true;
 230     _stackId = stackId;
 231     saveChangesIfNotDelayed();
 232 }
 233
 234 unsigned int ImageInfo::stackOrder() const
 235 {
 236     return _stackOrder;
 237 }
 238
 239 void ImageInfo::setStackOrder( const unsigned int stackOrder )
 240 {
 241     if ( stackOrder != _stackOrder )
 242         _dirty = true;
 243     _stackOrder = stackOrder;
 244     saveChangesIfNotDelayed();
 245 }
 246
 247 const GpsCoordinates& ImageInfo::geoPosition() const
 248 {
 249     return _geoPosition;
 250 }
 251
 252 void ImageInfo::setGeoPosition( const GpsCoordinates& geoPosition )
 253 {
 254     if ( geoPosition != _geoPosition )
 255         _dirty = true;
 256     _geoPosition = geoPosition;
 257     saveChangesIfNotDelayed();
 258 }
 259
 260 void ImageInfo::setDate( const ImageDate& date )
 261 {
 262     if (date != _date)
 263         _dirty = true;
 264     _date = date;
 265     saveChangesIfNotDelayed();
 266 }
 267
 268 ImageDate& ImageInfo::date()
 269 {
 270     return _date;
 271 }
 272
 273 ImageDate ImageInfo::date() const
 274 {
 275     return _date;
 276 }
 277
 278 bool ImageInfo::operator!=( const ImageInfo& other ) const
 279 {
 280     return !(*this == other);
 281 }
 282
 283 bool ImageInfo::operator==( const ImageInfo& other ) const
 284 {
 285     bool changed =
 286         ( _relativeFileName != other._relativeFileName ||
 287           _label != other._label ||
 288           ( !_description.isEmpty() && !other._description.isEmpty() && _description != other._description ) || // one might be isNull.
 289           _date != other._date ||
 290           _angle != other._angle ||
 291           _geoPosition != other._geoPosition ||
 292           _rating != other._rating ||
 293           ( _stackId != other._stackId ||
 294             ! ( ( _stackId == 0 ) ? true :
 295             ( _stackOrder == other._stackOrder ) ) )
 296            );
 297     if ( !changed ) {
 298         QStringList keys = DB::ImageDB::instance()->categoryCollection()->categoryNames();
 299         for( QStringList::ConstIterator it = keys.constBegin(); it != keys.constEnd(); ++it )
 300             changed |= _categoryInfomation[*it] != other._categoryInfomation[*it];
 301     }
 302     return !changed;
 303 }
 304
 305 void ImageInfo::renameCategory( const QString& oldName, const QString& newName )
 306 {
 307     _dirty = true;
 308     _categoryInfomation[newName] = _categoryInfomation[oldName];
 309     _categoryInfomation.remove(oldName);
 310     saveChangesIfNotDelayed();
 311 }
 312
 313 void ImageInfo::setLocked( bool locked )
 314 {
 315     _locked = locked;
 316 }
 317
 318 bool ImageInfo::isLocked() const
 319 {
 320     return _locked;
 321 }
 322
 323 void ImageInfo::readExif(const QString& fullPath, DB::ExifMode mode)
 324 {
 325     DB::FileInfo exifInfo = DB::FileInfo::read( fullPath, mode );
 326
 327     bool oldDelaySaving = _delaySaving;
 328     delaySavingChanges(true);
 329
 330     // Date
 331     if ( updateDateInformation(mode) ) {
 332         setDate( exifInfo.dateTime() );
 333     }
 334
 335     // Orientation
 336     if ( (mode & EXIFMODE_ORIENTATION) && Settings::SettingsData::instance()->useEXIFRotate() ) {
 337         setAngle( exifInfo.angle() );
 338     }
 339
 340     // Description
 341     if ( (mode & EXIFMODE_DESCRIPTION) && Settings::SettingsData::instance()->useEXIFComments() ) {
 342         setDescription( exifInfo.description() );
 343     }
 344
 345     delaySavingChanges(false);
 346     _delaySaving = oldDelaySaving;
 347
 348     // Database update
 349     if ( mode & EXIFMODE_DATABASE_UPDATE ) {
 350 #ifdef HAVE_EXIV2
 351         Exif::Database::instance()->remove( fullPath );
 352         Exif::Database::instance()->add( fullPath );
 353 #endif
 354     }
 355 }
 356
 357
 358 QStringList ImageInfo::availableCategories() const
 359 {
 360     return _categoryInfomation.keys();
 361 }
 362
 363 QSize ImageInfo::size() const
 364 {
 365     return _size;
 366 }
 367
 368 void ImageInfo::setSize( const QSize& size )
 369 {
 370     if (size != _size)
 371         _dirty = true;
 372     _size = size;
 373     saveChangesIfNotDelayed();
 374 }
 375
 376 bool ImageInfo::imageOnDisk( const QString& fileName )
 377 {
 378     QFileInfo fi( fileName );
 379     return fi.exists();
 380 }
 381
 382 ImageInfo::ImageInfo( const QString& fileName,
 383                       const QString& label,
 384                       const QString& description,
 385                       const ImageDate& date,
 386                       int angle,
 387                       const MD5& md5sum,
 388                       const QSize& size,
 389                       MediaType type,
 390                       short rating,
 391                       unsigned int stackId,
 392                       unsigned int stackOrder,
 393                       const GpsCoordinates& geoPosition )
 394 {
 395     _delaySaving = true;
 396     _relativeFileName = fileName;
 397     setAbsoluteFileName();
 398     _label =label;
 399     _description =description;
 400     _date = date;
 401     _angle =angle;
 402     _md5sum =md5sum;
 403     _size = size;
 404     _imageOnDisk = Unchecked;
 405     _locked = false;
 406     _null = false;
 407     _type = type;
 408     _dirty = true;
 409     delaySavingChanges(false);
 410
 411     if ( rating > 10 )
 412         rating = 10;
 413     if ( rating < -1 )
 414         rating = -1;
 415     _rating = rating;
 416     _geoPosition = geoPosition;
 417     _stackId = stackId;
 418     _stackOrder = stackOrder;
 419 }
 420
 421 // TODO: we should get rid of this operator. It seems only be necessary
 422 // because of the 'delaySavings' field that gets a special value.
 423 // ImageInfo should just be a dumb data object holder and not incorporate
 424 // storing strategies.
 425 ImageInfo& ImageInfo::operator=( const ImageInfo& other )
 426 {
 427     _relativeFileName = other._relativeFileName;
 428     setAbsoluteFileName();
 429     _label = other._label;
 430     _description = other._description;
 431     _date = other._date;
 432     _categoryInfomation = other._categoryInfomation;
 433     _angle = other._angle;
 434     _imageOnDisk = other._imageOnDisk;
 435     _md5sum = other._md5sum;
 436     _null = other._null;
 437     _size = other._size;
 438     _dirty = other._dirty;
 439     _rating = other._rating;
 440     _stackId = other._stackId;
 441     _stackOrder = other._stackOrder;
 442     _geoPosition = other._geoPosition;
 443
 444     delaySavingChanges(false);
 445
 446     return *this;
 447 }
 448
 449 MediaType DB::ImageInfo::mediaType() const
 450 {
 451     return _type;
 452 }
 453
 454 /**
 455  * During profiling I found that it took almost 5% of the time during
 456  * categorizing when browsing, simply to calculate the absolute filename, therefore it is
 457  * now an instance variable rather than calculated dynamically in
 458  * fileName().
 459  */
 460 void DB::ImageInfo::setAbsoluteFileName()
 461 {
 462     _absoluteFileName = Settings::SettingsData::instance()->imageDirectory() + _relativeFileName;
 463 }
 464
 465 void DB::ImageInfo::createFolderCategoryItem( DB::CategoryPtr folderCategory, DB::MemberMap& memberMap )
 466 {
 467     QString folderName = Utilities::relativeFolderName( _relativeFileName );
 468     if ( folderName.isEmpty() )
 469         return;
 470
 471     QStringList directories = folderName.split(QString::fromLatin1( "/" ) );
 472
 473     QString curPath;
 474     for( QStringList::ConstIterator directoryIt = directories.constBegin(); directoryIt != directories.constEnd(); ++directoryIt ) {
 475         if ( curPath.isEmpty() )
 476             curPath = *directoryIt;
 477         else {
 478             QString oldPath = curPath;
 479             curPath = curPath + QString::fromLatin1( "/" ) + *directoryIt;
 480             memberMap.addMemberToGroup( folderCategory->name(), oldPath, curPath );
 481         }
 482     }
 483
 484     _categoryInfomation.insert( folderCategory->name() , StringSet() << folderName );
 485     folderCategory->addItem( folderName );
 486 }
 487
 488 void DB::ImageInfo::copyExtraData( const DB::ImageInfo& from)
 489 {
 490     _categoryInfomation = from._categoryInfomation;
 491     _description = from._description;
 492     // Hmm...  what should the date be?  orig or modified?
 493     // _date = from._date;
 494     _angle = from._angle;
 495     _rating = from._rating;
 496     _geoPosition = from._geoPosition;
 497 }
 498
 499 void DB::ImageInfo::removeExtraData ()
 500 {
 501     _categoryInfomation.clear();
 502     _description.clear();
 503     _rating = -1;
 504     _geoPosition = GpsCoordinates();
 505 }
 506
 507 void DB::ImageInfo::addCategoryInfo( const QString& category, const StringSet& values )
 508 {
 509     for ( StringSet::const_iterator valueIt = values.constBegin(); valueIt != values.constEnd(); ++valueIt ) {
 510         if (! _categoryInfomation[category].contains( *valueIt ) ) {
 511             _dirty = true;
 512             _categoryInfomation[category].insert( *valueIt );
 513         }
 514     }
 515     saveChangesIfNotDelayed();
 516 }
 517
 518 void DB::ImageInfo::clearAllCategoryInfo()
 519 {
 520     _categoryInfomation.clear();
 521 }
 522
 523 void DB::ImageInfo::removeCategoryInfo( const QString& category, const StringSet& values )
 524 {
 525     for ( StringSet::const_iterator valueIt = values.constBegin(); valueIt != values.constEnd(); ++valueIt ) {
 526         if ( _categoryInfomation[category].contains( *valueIt ) ) {
 527             _dirty = true;
 528             _categoryInfomation[category].remove(*valueIt);
 529         }
 530     }
 531     saveChangesIfNotDelayed();
 532 }
 533
 534 void DB::ImageInfo::addCategoryInfo( const QString& category, const QString& value )
 535 {
 536     if (! _categoryInfomation[category].contains( value ) ) {
 537         _dirty = true;
 538         _categoryInfomation[category].insert( value );
 539     }
 540     saveChangesIfNotDelayed();
 541 }
 542
 543 void DB::ImageInfo::removeCategoryInfo( const QString& category, const QString& value )
 544 {
 545     if ( _categoryInfomation[category].contains( value ) ) {
 546         _dirty = true;
 547         _categoryInfomation[category].remove( value );
 548     }
 549     saveChangesIfNotDelayed();
 550 }
 551
 552 bool DB::ImageInfo::updateDateInformation( int mode ) const
 553 {
 554     if ((mode & EXIFMODE_DATE) == 0)
 555         return false;
 556
 557     if ( (mode & EXIFMODE_FORCE) != 0 )
 558         return true;
 559
 560 #ifdef HAVE_EXIV2
 561     return true;
 562 #endif
 563
 564     return Settings::SettingsData::instance()->trustTimeStamps();
 565 }
 566