album.cpp

Go to the documentation of this file.

//==============================================
//  copyright            : (C) 2003 by Will Stokes
//==============================================
//  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.         
//
//  As a special exception, Will Stokes gives permission to 
//  link this program with Qt non-commercial edition, and 
//  distribute the resulting executable, without including the 
//  source code for the Qt non-commercial edition in the 
//  source distribution. 
//==============================================

//Systemwide includes
#include <qimage.h>
#include <qpixmap.h>
#include <qstring.h>
#include <time.h>
#include <qfile.h>
#include <qfileinfo.h>
#include <qtextstream.h>
#include <qdom.h>
#include <qdir.h>
#include <qapplication.h>
#include <qregexp.h>
#include <qdatetime.h>

//Projectwide includes
#include "album.h"
#include "subalbum.h"
#include "photo.h"
#include "imageTools.h"
#include "xmlTools.h"
#include "md5.h"
#include "../gui/subalbumPreviewWidget.h"
#include "../gui/statusWidget.h"
#include "../config.h"

//==============================================
Album::Album()
{
  //set strings to default values
  name = "";
  description ="";
  author = "";
    
  theme = "Classic";

  //by default no representative image
  smallRepresentativeImage = new QPixmap( QString(IMAGE_PATH)+"notSpecified.png" );
  largeRepresentativeImage = NULL;
  
  //no Subalbums by default
  firstSubalbum = NULL;
  lastSubalbum = NULL;

  //set the creation date to today
  updateCreationDate();
  
  //no subalbums
  numSubalbums = 0;
  numLoadedSubalbums = 0;
  
  //not previously saved by default
  savedToDisk = false;
  
  //no interesting modifications yet
  modified = false;
  
  //construct temp directory to save images to
  QDir rootDir( QDir::homeDirPath() );
  if(!rootDir.exists( ".albumShaper" ))
  {
    rootDir.mkdir( ".albumShaper" );
  }
  rootDir.cd( ".albumShaper" );
  if(!rootDir.exists( "tmp" ))
  {
    rootDir.mkdir( "tmp" );
  }
  saveLocation = QDir::homeDirPath() + "/.albumShaper/tmp";  
}
//==============================================
Album::~Album()    
{
  //delete representative image
  delete smallRepresentativeImage;
  delete largeRepresentativeImage;
  
  //delete subalbums  
  Subalbum* current = firstSubalbum;
  Subalbum* temp;
  while(current != NULL)
  {
    temp = current->getNext();
    delete current;
    current = temp;
  }
} 
//==============================================
void Album::setName(QString val)
{
  if(name != val)
  {
    name = val;
    modified = true;
  }
}
//==============================================
QString Album::getName()
{
  return QString(name);
}
//==============================================
void Album::setDescription(QString val)
{
  if(description != val)
  {
    description = val;
    modified = true;
  }
}
//==============================================
QString Album::getDescription()
{
  return QString(description);
}
//==============================================
void Album::setAuthor(QString val)
{
  if(author != val)
  {
    author = val;
    modified = true;
  }
}
//==============================================
QString Album::getAuthor()
{
  return QString(author);
}
//==============================================
void Album::setRepresentativeImages(QImage* rawImage)
{
  //---------------------------------------------------------    
  //delete representative images
  delete smallRepresentativeImage;
  delete largeRepresentativeImage;
  //---------------------------------------------------------    
  //compute representative image sizes
  int smallRepWidth = 0;
  int smallRepHeight = 0;
  int largeRepWidth = 0;
  int largeRepHeight = 0;
  resizeImage( rawImage->width(), rawImage->height(),
               107, 80,
               smallRepWidth, smallRepHeight);
  resizeImage( rawImage->width(), rawImage->height(),
               500, 320,
               largeRepWidth, largeRepHeight);
  //---------------------------------------------------------    
  //create various representative images
  //---------------------------------------------------------    
  //copy and scale small version
  QImage thumbnailSmall = rawImage->smoothScale( smallRepWidth, smallRepHeight );
  thumbnailSmall.setAlphaBuffer(true);
  smallRepresentativeImage = new QPixmap( smallRepWidth, smallRepHeight );
  smallRepresentativeImage->convertFromImage( thumbnailSmall );  

  //copy and scale large version
  QImage thumbnailLarge = rawImage->smoothScale( largeRepWidth, largeRepHeight );
  thumbnailLarge.setAlphaBuffer(true);
  largeRepresentativeImage = new QPixmap( largeRepWidth, largeRepHeight );
  largeRepresentativeImage->convertFromImage( thumbnailLarge );  

  //set modified
  modified = true;
}
//==============================================
QPixmap* Album::getRepresentativeImage(int size)
{
  if(size == SMALL)
    return smallRepresentativeImage;
  else if(size == LARGE)
    return largeRepresentativeImage;
  else
    return NULL;
}
//==============================================
Subalbum* Album::getFirstSubalbum()
{
  return firstSubalbum;
}
//==============================================
Subalbum* Album::getLastSubalbum()
{
  return lastSubalbum;
}
//==============================================
void Album::appendSubalbum(Subalbum* val)
{
  numSubalbums++;
  
  //first subalbum
  if(firstSubalbum == NULL)
  {
    firstSubalbum = val;
    lastSubalbum = val;
  }
  //append to end of list
  else
  {
    lastSubalbum->setNext( val );
    lastSubalbum = val;
  }

  //set modified
  modified = true;
}
//==============================================
void Album::removeSubalbum(Subalbum* val)
{
  //search through linked list and remove item
  Subalbum* prev = NULL;
  Subalbum* current = firstSubalbum;
  while(current != NULL)
  {
    //found it! remove it
    if(current == val)
    { 
      //update first pointer
      if(firstSubalbum == val)
        firstSubalbum = val->getNext();
      
      //update last pointer
      if(lastSubalbum == val) 
        lastSubalbum = prev;

      //update next pointer
      if(prev != NULL)
        prev->setNext( current->getNext() );
            
      //delete object
      delete val;
      val = NULL;
      numSubalbums--;
      return;
    }
    
    prev = current;
    current = current->getNext();
  }

  //set modified
  modified = true;
}
//==============================================
int Album::getModificationYear()
{
  return modificationYear;
}
//==============================================
int Album::getModificationMonth()
{
  return modificationMonth;
}
//==============================================
int Album::getModificationDay()
{
  return modificationDay;
}
//==============================================
void Album::updateCreationDate()
{
  //set creation date to today
  QDate date = QDate::currentDate();
  creationYear = date.year();
  creationMonth = date.month();
  creationDay = date.day();
}
//==============================================
void Album::updateModificationDate()
{
  //set last modification date to today
  QDate date = QDate::currentDate();
  modificationYear = date.year();
  modificationMonth = date.month();
  modificationDay = date.day();
}
//==============================================
int Album::importFromDisk(StatusWidget* status, QString fileName)
{
  //update file
  updateXML( QFileInfo(fileName).dirPath(TRUE) );
  
  //open file
  QFile albumFile( fileName );
  
  //unable ot open xml file? alert user
  if( !albumFile.open( IO_ReadOnly ) )
    return ALBUM_READ_ERROR;
    
  //parse dom
  QDomDocument albumDom;
  if( !albumDom.setContent( &albumFile ) )
    return ALBUM_XML_ERROR;

  //close file
  albumFile.close();

  //get main directory all other files and subdirectories are in  
  QString rootDir = QFileInfo(albumFile).dirPath(TRUE);
  saveLocation = rootDir + "/img";
  
  
  //if representative image exists load
  QImage repImage(rootDir + "/img/album.jpg");
  if(!repImage.isNull())
  {
    setRepresentativeImages(&repImage);  
  }  

  //count number of photos in album, needed for showing loading progress
  int numPhotos = 0;
  QDomElement root = albumDom.documentElement();
  QDomNode node = root.firstChild();
  while( !node.isNull() )
  {
    if( node.isElement() && node.nodeName() == "subalbum" )
    {
      QDomNode childNode = node.firstChild();
      while( !childNode.isNull() )
      {
        if( childNode.isElement() && childNode.nodeName() == "photo" )
          numPhotos++;
        childNode = childNode.nextSibling();      
      }
    }
    node = node.nextSibling();
  }
    
  //setup progress bar
  status->showProgressBar( "Loading:", numPhotos );
  qApp->processEvents();
  
  int subalbumNum = 0;
  
  //get root node and start parsing DOM
  root = albumDom.documentElement();
  node = root.firstChild();
  QDomText val;  
  while( !node.isNull() )
  {
    //------------------------------------------------------------
    //album name
    if( node.isElement() && node.nodeName() == "name" )
    { 
      val = node.firstChild().toText();
      if(!val.isNull())
        name = val.nodeValue();
    }
    //------------------------------------------------------------
    //album description
    else if( node.isElement() && node.nodeName() == "description" )
    { 
      val = node.firstChild().toText();
      if(!val.isNull())
        description = val.nodeValue();
    }
    //------------------------------------------------------------
    //album author
    else if( node.isElement() && node.nodeName() == "author" )
    { 
      val = node.firstChild().toText();
      if(!val.isNull())
        author = val.nodeValue();
    }
    //------------------------------------------------------------
    //album theme
    else if( node.isElement() && node.nodeName() == "theme" )
    { 
      val = node.firstChild().toText();
      if(!val.isNull())
        theme = val.nodeValue();
    }
    //------------------------------------------------------------
    //album creation date
    else if( node.isElement() && node.nodeName() == "created" )
    {     
      val = node.firstChild().toText();
          
      //split value based on spaces, should be 7 fields
      QStringList vals = QStringList::split( QRegExp(" "), val.nodeValue() );
      int i=0;
      int intVals[3];
      QStringList::Iterator it;
      for ( it = vals.begin(); it != vals.end(); ++it ) 
      {
        intVals[i] = QString(*it).toInt();
        i++;
        //only read first 3 entires, year/month/day, don't overwrite 
        //buffer on addition entries if xml messed up
        if(i > 2)
          break;
      }    
      creationYear = intVals[0];
      creationMonth = intVals[1];
      creationDay = intVals[2];
    }
    //------------------------------------------------------------
    //subalbum
    else if( node.isElement() && node.nodeName() == "subalbum" )
    {
      //increase counter    
      subalbumNum++;

      //create new subalbum
      Subalbum* salbum = new Subalbum(this, numSubalbums+1);
      
      //populate it
      salbum->importFromDisk( &node, subalbumNum, status, (rootDir + "/") );
      
      //append it to list of subalbums
      appendSubalbum(salbum);
    }
    //------------------------------------------------------------
    //advance to next node   
    node = node.nextSibling();
    //------------------------------------------------------------
  }

  //reset number of loaded subalbums  
  numLoadedSubalbums = numSubalbums;

  //hide progress bar
  status->setStatus( "Album loaded." );
  
  //save load directory name and loaded/saved bit
  saveLocation = rootDir;
  savedToDisk = true;
  
  return ALBUM_LOADED;
}
//==============================================
int Album::exportToDisk(StatusWidget* status, 
                                    bool smallSave,
                                    QString dirName,
                                    QString themeName)
{
  //check to see if save location has actually changed, if not don't force save images
  //this occurs when user blindly selects the same old spot, or is just changing the theme used by default
  bool forceSave = true;
  
  if(saveLocation == dirName)
   forceSave = false;
   
  saveLocation = dirName;
  theme = themeName;
  return exportToDisk(status, smallSave, forceSave);
}
//==============================================
int Album::exportToDisk(StatusWidget* status,
                                    bool smallSave,
                                    bool forceSave)
{
  //------------------------------------------
  //create subdirs
  QDir localDir(saveLocation);
  //img dirs
  localDir.mkdir("img");
  //subalbum dirs
  localDir.setPath(saveLocation + "/img");
  int i;
  for(i=1; i <= numSubalbums; i++)
  {
    QString dirName = QString("%1") .arg(i);
    localDir.mkdir(dirName);
  }
  //------------------------------------------    
  //checks worked, go ahead with export
  
  //count number of photos
  int totalPhotos=0;
  Subalbum* current = firstSubalbum;
  while(current != NULL)
  {
    totalPhotos+=current->getNumPhotos();
    current = current->getNext();  
  }  

  //setup progress bar
  status->showProgressBar( "Saving:", 3*totalPhotos );
  qApp->processEvents();

  //copy over theme resources
  exportThemeResources( theme );
    
  //export album cover image, subalbum thumbnails
  exportTopLevelImages();
  
  //export subalbum images (thumbnail, slideshow, and full versions of all images)
  exportSubalbumImages(status, smallSave, forceSave);
  
  //apply reordering to all images
  reorderSubalbumImages(status);
  
  //remove old images that nolonger belong
  removeStagnantImages();
  
  //remove previous html files
  localDir.setPath(saveLocation);
  QStringList list = localDir.entryList( QDir::Files );
  QStringList::Iterator file;
  for ( file = list.begin(); file != list.end(); ++file ) 
  {
    if((*file).endsWith(".html"))
    localDir.remove( saveLocation + "/" + *file );
  }
  
  //export xml structure of album
  if(!smallSave)
  {
    int result = exportToXML();
    if(result != ALBUM_EXPORTED)
      return result;
  }
  
  //export various html pages using selected theme
  transformXMLtoHTML( saveLocation, theme );
  
  //------------------------------------------
  //remove files from temp folder
  QDir tmpDir(QDir::homeDirPath() + "/.albumShaper/tmp" );
  QStringList strLst = tmpDir.entryList();
  QStringList::iterator it;
  for(it = strLst.begin(); it != strLst.end(); it++)
  {
      tmpDir.remove(*it);
  }
  //------------------------------------------
  savedToDisk = true;
  
  //just saved so no modifications since last save
  modified = false;
  
  //hide progress bar
  status->setStatus( "Album saved." );
  //------------------------------------------
  return ALBUM_EXPORTED;
}
//==============================================
int Album::exportToXML()
{
  //update modification date
  updateModificationDate();
  
  //create/open xml file
  QFile* xml = new QFile(saveLocation + "/Album.xml");
  if(xml->open(IO_WriteOnly))
  {
    QTextStream stream( xml );
   
    //write album information
    stream << "<?xml version=\"1.0\"?>\n";
    stream << "<album version=\"1.1\">\n";
    stream << "  <name>" << fixXMLString(name) << "</name>\n";
    stream << "  <description>" << fixXMLString(description) << "</description>\n";
    stream << "  <author>" << fixXMLString(author) << "</author>\n";  
    stream << "  <created>" << creationYear << " " << creationMonth << " " << creationDay << "</created>\n";
    stream << "  <modified>" << modificationYear << " " << modificationMonth << " " << modificationDay << "</modified>\n";
    stream << "  <theme>" << theme << "</theme>\n";
    stream << "  <thumbnailDimensions>" << THUMBNAIL_WIDTH << " " << THUMBNAIL_HEIGHT << "</thumbnailDimensions>\n";
    stream << "  <slideshowDimensions>" << SLIDESHOW_WIDTH << " " << SLIDESHOW_HEIGHT << "</slideshowDimensions>\n";
    
    //if album has a represenatative image save it's path
    if(getRepresentativeImage(LARGE) != NULL )
    {
      stream << "  <thumb path=\"img/album.jpg\"/>\n"; 
    }  
    
    //write subalbums
    Subalbum* current = firstSubalbum;
    while(current != NULL)
    {
      current->exportToXML(stream);
      current = current->getNext();
    }
  
    //end album
    stream << "</album>\n";    
    xml->close(); 
    
    return ALBUM_EXPORTED;
  }
  else
  {
    return ALBUM_ERROR_OPEN_FILE;
  }
}
//==============================================
void Album::exportTopLevelImages()
{
  //if image set export it
  if(getRepresentativeImage(LARGE) != NULL)
  {
    getRepresentativeImage(LARGE)->save(saveLocation + "/img/album.jpg", "JPEG", 100);
  }
  //else make sure any previously set images are removed
  else
  {
    QDir rootDir(saveLocation + "/img/");
    rootDir.remove("album.jpg");
  }
  
  //export subalbum thumbs
  int n=0;
  Subalbum* current = firstSubalbum;
  while(current != NULL)
  {
    n++;
    //if subalbum has representative image export it
    if(current->getRepresentativeImage(LARGE) != NULL )
    {
      QString fileName = QString(saveLocation + "/img/%1_thumb.jpg" ).arg(n);
      current->getRepresentativeImage(LARGE)->save(fileName, "JPEG", 100);
    }
    //otherwise make sure anyprevious set images are removed
    else
    {
      QDir rootDir(saveLocation + "/img/");
      rootDir.remove( QString("%1_thumb.jpg").arg(n) );
    }
    current = current->getNext();
  }  
}
//==============================================
void Album::exportSubalbumImages(StatusWidget* status, bool smallSave, bool forceSave)
{  
  //iterate over all subalbums
  int subalbumNumber=0;
  Subalbum* currentSubalbum = firstSubalbum;
  while(currentSubalbum != NULL)
  {
    subalbumNumber++;    
    
    //iterate over all photos in this subalbum
    int photoNumber=0;    
    Photo* currentPhoto = currentSubalbum->getFirst();
    while(currentPhoto != NULL)
    {
      photoNumber++;
      //---------------------------------------
      //if the current photo does not need to be saved then move on
      if( !forceSave && !currentPhoto->getNeedsSavingVal() )
      {
        currentPhoto = currentPhoto->getNext();
        status->incrementProgress();
        qApp->processEvents();
        continue;
      }
      //---------------------------------------
      //construct a QDir object for the tmp folder
      QDir rootDir;
      //---------------------------------------
      //get initial photo # and subalbum #, used for saving      
      int initPhotoNumber = currentPhoto->getInitialPhotoNumber();
      int initSubalbumNumber = currentPhoto->getInitialSubalbumNumber();
      //---------------------------------------
      //export thumbnail image
      QString fileName = QString(saveLocation + "/img/%1/%2_thumb.jpg" ).arg(initSubalbumNumber).arg(initPhotoNumber);
      currentPhoto->getImage(THUMBNAIL)->save(fileName, "JPEG", 100);

      //compute and store md5 for thumbnail     
      std::ifstream thumbnailFile(fileName.ascii());
      if(thumbnailFile.is_open())
      {
        currentPhoto->setThumbnailChecksum( getMD5(thumbnailFile) ); 
        thumbnailFile.close();
      }
      //---------------------------------------
      //export slideshow image
      QString oldName = currentPhoto->getSlideshowFilename();
      QString newName = QString(saveLocation + "/img/%1/%2_slideshow.jpg" ).arg(initSubalbumNumber).arg(initPhotoNumber);

      //if file has been modified move from current location to final location
      if( currentPhoto->getNeedsSavingVal() )
      {
        //attempt to rename file, if fails do explicit copy, then delete prev file
         if(!rootDir.rename( oldName, newName))
         {
           copyFile(oldName, newName);
           rootDir.remove(oldName);
         }
      }
      //If file has not been modified we must be doing a save-as and saving has been forced. In this case
      //COPY file from current location to final location, DON'T delete previous copy!!!
       else
       {
         copyFile(oldName, newName);
       }
             
      //compute and store md5 for slideshow image
      std::ifstream file(newName.ascii());
      if(file.is_open())
      {
        currentPhoto->setSlideshowChecksum( getMD5(file) ); 
        file.close();
      }
      //---------------------------------------
      //export full size image, skip is doing small save
      if(!smallSave) 
      {
        oldName = currentPhoto->getImageFilename();   
        newName = QString(saveLocation + "/img/%1/%2.jpg" ).arg(initSubalbumNumber).arg(initPhotoNumber);
      
        //if file has been modified move from current location to final location
        if( currentPhoto->getNeedsSavingVal() )
        {
          //attempt to rename file, if fails do explicit copy, then delete prev file
           if(!rootDir.rename( oldName, newName))
           {
             copyFile(oldName, newName);
             rootDir.remove(oldName);
           }
        }
        //If file has not been modified we must be doing a save-as and saving has been forced. In this case
        //COPY file from current location to final location, DON'T delete previous copy!!!
        else
        {
          copyFile(oldName, newName);
        }
            
        //compute and store md5 for image
        std::ifstream imageFile(newName.ascii());
        if(imageFile.is_open())
        {
          currentPhoto->setImageChecksum( getMD5(imageFile) ); 
          imageFile.close();
        }
      }
      //---------------------------------------
      //set new storage locations of files (skip if doing small save since large photo not exported)
      if(!smallSave)
      {
        currentPhoto->setImageFilename( QString(saveLocation + "/img/%1/%2.jpg").arg(initSubalbumNumber).arg(initPhotoNumber) );
        currentPhoto->setSlideshowFilename( QString(saveLocation + "/img/%1/%2_slideshow.jpg").arg(initSubalbumNumber).arg(initPhotoNumber) );
        currentPhoto->setThumbnailFilename( QString(saveLocation + "/img/%1/%2_thumb.jpg").arg(initSubalbumNumber).arg(initPhotoNumber) );
      }
      //---------------------------------------
      //set image as not needing saving (skip if doing small save since large photo not exported)
      if(!smallSave)
        currentPhoto->setNeedsSavingVal(false);
      //---------------------------------------
      //update progress bar
      status->incrementProgress();
      qApp->processEvents();
      //---------------------------------------   
      //move on to next photo in subalbum
      currentPhoto = currentPhoto->getNext();
      //---------------------------------------
    }
    //---------------------------------------
    //move on to next subalbum
    currentSubalbum = currentSubalbum->getNext();  
  }
}
//==============================================
void Album::reorderSubalbumImages(StatusWidget* status)
{
  //--------------------------------------------------------
  //--------------------------------------------------------
  //first pass over all photos, those whose initial and current numbers don't match up
  //rename slightly so we don't overwrte them the second time around
  //--------------------------------------------------------
  //--------------------------------------------------------
  //iterate over all subalbums
  int subalbumNumber=0;
  Subalbum* currentSubalbum = firstSubalbum;
  while(currentSubalbum != NULL)
  {
    subalbumNumber++;    
    
    //iterate over all photos in this subalbum
    int photoNumber=0;    
    Photo* currentPhoto = currentSubalbum->getFirst();
    while(currentPhoto != NULL)
    {
      photoNumber++;
      //---------------------------------------
      //get initial photo # and subalbum #, used for checks and moving
      int initPhotoNumber = currentPhoto->getInitialPhotoNumber();
      int initSubalbumNumber = currentPhoto->getInitialSubalbumNumber();
      //---------------------------------------
      //if the current photo has not moved then move on
      if( initPhotoNumber == photoNumber &&
          initSubalbumNumber == subalbumNumber)
      {
        currentPhoto = currentPhoto->getNext();
        status->incrementProgress();
        qApp->processEvents();
        continue;
      }
      //---------------------------------------
      //rename full image, slideshow image, and thumbnail image     
      QDir rootDir;
      QString oldName = QString(saveLocation + "/img/%1/%2.jpg" ).arg(initSubalbumNumber).arg(initPhotoNumber);
      QString newName = QString(saveLocation + "/img/%1/%2_moved.jpg" ).arg(initSubalbumNumber).arg(initPhotoNumber);     
      if(!rootDir.rename( oldName, newName))
      {
        copyFile(oldName, newName);      
        rootDir.remove( oldName );
      }
      //-----
      oldName = QString(saveLocation + "/img/%1/%2_slideshow.jpg" ).arg(initSubalbumNumber).arg(initPhotoNumber);
      newName = QString(saveLocation + "/img/%1/%2_slideshow_moved.jpg" ).arg(initSubalbumNumber).arg(initPhotoNumber);      
      if(!rootDir.rename( oldName, newName))
      {
        copyFile(oldName, newName);      
        rootDir.remove( oldName );
      }
      //-----
      oldName = QString(saveLocation + "/img/%1/%2_thumb.jpg" ).arg(initSubalbumNumber).arg(initPhotoNumber);
      newName = QString(saveLocation + "/img/%1/%2_thumb_moved.jpg" ).arg(initSubalbumNumber).arg(initPhotoNumber);      
      if(!rootDir.rename( oldName, newName))
      {
        copyFile(oldName, newName);      
        rootDir.remove( oldName );
      }
      //---------------------------------------
      //update progress bar
      status->incrementProgress();
      qApp->processEvents();
      //---------------------------------------   
      //move on to next photo in subalbum
      currentPhoto = currentPhoto->getNext();
      //---------------------------------------
    }
    //---------------------------------------
    //move on to next subalbum
    currentSubalbum = currentSubalbum->getNext();  
  }

  //--------------------------------------------------------
  //--------------------------------------------------------
  //second pass over all photos, those whose initial and current numbers don't match up
  //rename to their final names and reset initial photo and subalbum numbers
  //--------------------------------------------------------
  //--------------------------------------------------------
  //iterate over all subalbums
  subalbumNumber=0;
  currentSubalbum = firstSubalbum;
  while(currentSubalbum != NULL)
  {
    subalbumNumber++;    
    
    //iterate over all photos in this subalbum
    int photoNumber=0;    
    Photo* currentPhoto = currentSubalbum->getFirst();
    while(currentPhoto != NULL)
    {
      photoNumber++;
      //---------------------------------------
      //get initial photo # and subalbum #, used for checks and moving
      int initPhotoNumber = currentPhoto->getInitialPhotoNumber();
      int initSubalbumNumber = currentPhoto->getInitialSubalbumNumber();
      //---------------------------------------
      //if the current photo has not moved then move on
      if( initPhotoNumber == photoNumber &&
          initSubalbumNumber == subalbumNumber)
      {
        currentPhoto = currentPhoto->getNext();
        status->incrementProgress();
        qApp->processEvents();
        continue;
      }
      //---------------------------------------
      //rename full image, slideshow image, and thumbnail image to their final names
      QDir rootDir;
      QString oldName = QString(saveLocation + "/img/%1/%2_moved.jpg" ).arg(initSubalbumNumber).arg(initPhotoNumber);
      QString newName = QString(saveLocation + "/img/%1/%2.jpg" ).arg(subalbumNumber).arg(photoNumber);     
      if(!rootDir.rename( oldName, newName))
      {
        copyFile(oldName, newName);      
        rootDir.remove( oldName );
      }
      //-----
      oldName = QString(saveLocation + "/img/%1/%2_slideshow_moved.jpg" ).arg(initSubalbumNumber).arg(initPhotoNumber);
      newName = QString(saveLocation + "/img/%1/%2_slideshow.jpg" ).arg(subalbumNumber).arg(photoNumber);      
      if(!rootDir.rename( oldName, newName))
      {
        copyFile(oldName, newName);      
        rootDir.remove( oldName );
      }
      //-----
      oldName = QString(saveLocation + "/img/%1/%2_thumb_moved.jpg" ).arg(initSubalbumNumber).arg(initPhotoNumber);
      newName = QString(saveLocation + "/img/%1/%2_thumb.jpg" ).arg(subalbumNumber).arg(photoNumber);      
      if(!rootDir.rename( oldName, newName))
      {
        copyFile(oldName, newName);      
        rootDir.remove( oldName );
      }
      //---------------------------------------
      //reset initial photo and subalbum numbers, and filenames
      currentPhoto->setInitialPhotoNumber(photoNumber);
      currentPhoto->setInitialSubalbumNumber(subalbumNumber);      
      currentPhoto->setImageFilename( QString(saveLocation + "/img/%1/%2.jpg").arg(subalbumNumber).arg(photoNumber) );
      currentPhoto->setSlideshowFilename( QString(saveLocation + "/img/%1/%2_slideshow.jpg").arg(subalbumNumber).arg(photoNumber) );
      currentPhoto->setThumbnailFilename( QString(saveLocation + "/img/%1/%2_thumb.jpg").arg(subalbumNumber).arg(photoNumber) );
      //---------------------------------------
      //update progress bar
      status->incrementProgress();
      qApp->processEvents();
      //---------------------------------------   
      //move on to next photo in subalbum
      currentPhoto = currentPhoto->getNext();
      //---------------------------------------
    }
    //---------------------------------------
    //move on to next subalbum
    currentSubalbum = currentSubalbum->getNext();  
  }
}
//==============================================
void Album::removeStagnantImages()
{
  QDir rootDir(saveLocation + "/img/");
  //---------------------------------
  //remove stagnant photos in existing subalbums
  int subalbumNumber=0;
  Subalbum* currentSubalbum = firstSubalbum;
  while(currentSubalbum != NULL)
  {
    subalbumNumber++;    

    int i;
    for(i=currentSubalbum->getNumPhotos() + 1;
        i <= currentSubalbum->getNumLoadedPhotos();
        i++)
    {
      QString thumbString = QString(saveLocation + "/img/%1/%2_thumb.jpg" ).arg(subalbumNumber).arg(i);
      QString slideshowString = QString(saveLocation + "/img/%1/%2_slideshow.jpg" ).arg(subalbumNumber).arg(i);
      QString imageString = QString(saveLocation + "/img/%1/%2.jpg" ).arg(subalbumNumber).arg(i);
      rootDir.remove(thumbString);
      rootDir.remove(slideshowString);
      rootDir.remove(imageString);
    }
    
    //reset number of loaded photos since old photos removed now
    currentSubalbum->resetNumLoadedPhotos();
    
    //move on to next subalbum
    currentSubalbum = currentSubalbum->getNext();  
  }
  //---------------------------------
  //remove stagnant subalbums and all their contents
  int i;
  for(i=numSubalbums+1; i<=numLoadedSubalbums; i++)
  {
    //get filelist for directory
    QDir imageDir(  QString(saveLocation + "/img/%1/").arg(i) );
    QStringList list = imageDir.entryList( QDir::Files );
    
    //remove each file in directory
    QStringList::Iterator file;
    for ( file = list.begin(); file != list.end(); ++file ) 
    {
      rootDir.remove( QString(saveLocation + "/img/%1/" + *file).arg(i) );
    }
    
    //remove directory
    rootDir.rmdir( QString("%1").arg(i) );
    
    //remove thumbnail image
    rootDir.remove( QString(saveLocation + "/img/%1_thumb.jpg").arg(i) );
    
    //remove slideshow and thumbnail html pages
    rootDir.remove( QString(saveLocation + "/subalbum_%1_thumbs.html").arg(i) );    
    rootDir.remove( QString(saveLocation + "/subalbum_%1_slideshow.html").arg(i) );        
  }
  
  //reset number of loaded subalbums since stagnant directories removed now
  numLoadedSubalbums = numSubalbums;
  //---------------------------------
}  
//==============================================
void Album::exportThemeResources( QString theme )
{
  //create resources directory if it doesn't exist
  QDir localDir(saveLocation);
  localDir.mkdir("resources");
  localDir.setPath(saveLocation + "/resources");
    
  //remove all files in this directory from previous saves with other themes
  QStringList list = localDir.entryList( QDir::Files );
  QStringList::Iterator file;
  for ( file = list.begin(); file != list.end(); ++file ) 
  {
    localDir.remove( saveLocation + "/resources/" + *file );
  }
    
  //copy resource files over from theme's resources directory
  localDir.setPath(THEMES_PATH + theme + "/resources");
  list = localDir.entryList( QDir::Files );
  for ( file = list.begin(); file != list.end(); ++file ) 
  {
    copyFile( THEMES_PATH + theme + "/resources/" + *file,
                  saveLocation + "/resources/" + *file);
  } 
}
//==============================================
bool Album::prevSave()
{
  return savedToDisk;
}
//==============================================
bool Album::albumModified()
{
  return modified;
}
//==============================================
void Album::syncSubalbumList(SubalbumPreviewWidget* item)
{
  //base case, no items
  if(item == NULL)
  {
    firstSubalbum = NULL;
    lastSubalbum = NULL;
    return;
  }
  
  //set first and last pointers
  firstSubalbum = item->getSubalbum();
  firstSubalbum->setNext(NULL);
  lastSubalbum = firstSubalbum;
    
  //set all next pointers
  while(item->nextItem() != NULL)
  {
    item->getSubalbum()->setNext( ((SubalbumPreviewWidget*)item->nextItem())->getSubalbum() );
    item = (SubalbumPreviewWidget*)item->nextItem();
    lastSubalbum = item->getSubalbum();
    lastSubalbum->setNext(NULL);
  }
}
//==============================================
QString Album::getSaveLocation()
{
  return saveLocation;
}
//==============================================
int Album::getNumSubalbums()
{
  return numSubalbums;
}
//==============================================
QString Album::getTheme()
{
  return QString(theme);
}
//==============================================
void Album::setModified(bool val)
{
  modified = val;
}
//==============================================

---