cWebshotsCollection.cpp

Go to the documentation of this file.

/*
    cWebshots - Webshots files handling classes
    Copyright (C) 2005  Hervé "Setaou" BRY <uwc at apinc dot org>

    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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/


#include "cWebshots.h"

#include <cstdio>
#include <sstream>

using namespace std;

namespace cWebshots
{

        
        //------------------------------------
        // Constructors / Destructors
        //------------------------------------

        cWebshotsCollection::cWebshotsCollection()
        {
                CreateDate = 0;
                EditDate = 0;
                In_Use = false;
        }

        cWebshotsCollection::cWebshotsCollection(const cWebshots::cWebshotsCollection &source)
        {
                *this = source;
        }

        //------------------------------------
        // File open /save
        //------------------------------------
        
        void cWebshotsCollection::LoadFromFile(string File)
        {
                ifstream in_file;

                // Clear the collection
                Clear();

                // Open the file for reading
                in_file.open(File.c_str(), ios_base::in | ios_base::binary);

                if (in_file.is_open())
                {
                        // Depending on the type of the file
                        switch (IdentifyFile(in_file))
                        {
                        case WBZ: // WBZ file
                                LoadWBZFile(in_file);
                                break;
                        case WBC: // WBC File
                                LoadWBCFile(in_file);
                                break;
                        case WB1: // encrypted WB1 file
                        case JPG: // JPG or plain WB1 file
                                AddPicture().LoadFromFile(File);
                                break;
                        case Unknown: // Unknown file type
                                {
                                        Exceptions::UnknownFormat Err("The file \"" + File + "\" has an unknown format.");
                                        throw Err;
                                }
                        }

                        // Close the file
                        in_file.close();
                }
                else
                {
                        Exceptions::FileSystemError Err("Unable to open the file \"" + File + "\" for reading.");
                        throw Err;
                }
        }

        void cWebshotsCollection::LoadWBCFile(ifstream &in_file)
        {
                long Count;
                int i;

                sWBC_Header Header;                                     // File header
                sWBC_Index* Index;                                      // File Index
                sWBC_Unit_Header Unit_Header;           // Unit header

                char* Buffer;

                cWebshotsPicture* Pic;

                // Read the header of the file
                in_file.seekg(0);
                in_file.read((char *)&Header, sizeof Header);

                // If the header is wrong
                if (Header.File_Marker != WBC_File_Marker)
                {
                        Exceptions::UnknownFormat Err("The file has an unknown format.");
                        throw Err;
                }

                Title = Header.File_Title;

                // Read the index
                in_file.seekg(2196);
                in_file.read((char *)&Count, sizeof Count);

                Index = new sWBC_Index[Count];
                in_file.read((char *)Index, Count * sizeof *Index);

                // for each unit in the file
                for (i = 0; i < Count; i++)
                {
                        // read the unit header
                        in_file.seekg(Index[i].Unit_Position);
                        in_file.read((char *)&Unit_Header, sizeof Unit_Header);
                        
                        // read the jpg file
                        Buffer = new char[Unit_Header.JPG_File_Size];
                        in_file.read(Buffer, Unit_Header.JPG_File_Size);

                        // load the picture and add it to the collection
                        try
                        {
                                Pic = new cWebshotsPicture;

                                Pic->LoadFromMemory(Buffer, Unit_Header.JPG_File_Size);
                                delete[] Buffer;

                                Pic->AdditionDate = Unit_Header.Addition_Timestamp;
                                Pic->Caption = Unit_Header.Description;
                                Pic->Category = Unit_Header.Category;
                                Pic->Credits = Unit_Header.Credits;
                                Pic->DailyDate = Unit_Header.Daily_Date;
                                if (strlen(Unit_Header.ID) > 1)
                                        Pic->ID = atol(&Unit_Header.ID[1]);
                                if (strlen(Unit_Header.ID) > 0)
                                        Pic->Source = Unit_Header.ID[0];
                                Pic->Original_Filename = Unit_Header.Original_Filename;
                                Pic->Album = Unit_Header.Album;
                                Pic->Title = Unit_Header.Title;

                                Pictures.push_back(Pic);
                        }
                        // if the picture has not been loaded correctly, skip it
                        catch (Exceptions::UnknownFormat)
                        {
                                delete Pic;
                        }
                }

                delete[] Index;
        }

        void cWebshotsCollection::LoadWBZFile(ifstream &in_file)
        {
                sWBZ_Header File_Header;
                sWBZ_Element_Header Element_Header;
                int i;
                char *ElementContent;
                string Metadata;

                // Read the header
                in_file.seekg(0);
                in_file.read((char *)&File_Header,sizeof File_Header);

                // Bad file format
                if (File_Header.File_Marker != WBZ_File_Marker)
                {
                        Exceptions::UnknownFormat Err("The file has an unknown format.");
                        throw Err;
                }

                // For each element
                for (i = 0; i < File_Header.Element_Count; i++)
                {
                        // Read the header
                        in_file.read((char *)&Element_Header,sizeof Element_Header);

                        // Corrupted header
                        if (Element_Header.Element_Marker != WBZ_Element_Marker)
                        {
                                stringstream Description;
                                Description << "Corrupted data : The header of the element n°" << (i + 1) << " is incorrect.";
                                Exceptions::CorruptedData Err(Description.str());
                                throw Err;
                        }

                        // Read the element
                        ElementContent = new char[Element_Header.File_Size];

                        try
                        {
                                in_file.read(ElementContent, Element_Header.File_Size);

                                // If the element is a picture
                                if ((strstr(Element_Header.File_Name,"wb1") != NULL) || (strstr(Element_Header.File_Name,"wbd") != NULL) || (strstr(Element_Header.File_Name,"jpg") != NULL))
                                {
                                        AddPicture().LoadFromMemory(ElementContent,Element_Header.File_Size);
                                }
                                // If the element is the metadata file
                                else if (strstr(Element_Header.File_Name,"wbx") != NULL)
                                {
                                        Metadata.assign(ElementContent);
                                }
                        }
                        // If an exception is thrown, delete the element content and re-throw the exception
                        catch (...)
                        {
                                delete[] ElementContent;
                                throw;
                        }

                        delete[] ElementContent;
                }

                // Once all elements are loaded, get the metadata for each picture in the collection
                for (i = 0; i < PictureCount(); i++)
                {
                        try
                        {
                                Pictures[i]->Source = GetINI(Metadata, IntToStr(i), "source");
                                Pictures[i]->Original_Filename = GetINI(Metadata, IntToStr(i), "filename");
                                Pictures[i]->ID = StrToLong(GetINI(Metadata, IntToStr(i), "id"));
                                Pictures[i]->Title = GetINI(Metadata, IntToStr(i), "title");
                                Pictures[i]->Credits = GetINI(Metadata, IntToStr(i), "credit");
                                Pictures[i]->DailyDate = StrToLong(GetINI(Metadata, IntToStr(i), "dailyDateYYYYMMDD"));
                                Pictures[i]->Category = GetINI(Metadata, IntToStr(i), "catTitle");
                                Pictures[i]->Album = GetINI(Metadata, IntToStr(i), "albumTitle");
                                Pictures[i]->AlbumID = GetINI(Metadata, IntToStr(i), "albumID");
                        }
                        // If there are missing metadata
                        catch (Exceptions::CorruptedData)
                        {
                                // Do nothing
                        }
                }
        }

        void cWebshotsCollection::LoadFromFolder(const string Path)
        {
                cWebshotsTXT album;
                cWebshotsPicture pic;
                int i;

                // Clear the collection
                Clear();

                // Load the photos.txt/album.txt files
                album.Load(Path);

                CreateDate = album.Album.create_date;
                EditDate = album.Album.edit_date;
                Description = album.Album.description;
                ID = album.Album.id;
                In_Use = album.Album.in_use;
                Title = album.Album.title;
                Topic = album.Album.topic_name;

                // For each picture in the album
                for (i = 0; i < album.PictureCount(); i++)
                {
                        try
                        {
                                pic.Clear();

                                // Load the picture
                                pic.LoadFromFile(Path + album.Picture(i).url_photo);

                                // Load the metadata
                                pic.ID = album.Picture(i).id;
                                pic.Original_Filename = album.Picture(i).url_photo;
                                pic.Title = album.Picture(i).title;
                                pic.Caption = album.Picture(i).caption;
                                pic.Credits = album.Picture(i).credit;
                                pic.Source = album.Picture(i).source;
                                pic.Album = Title;
                                pic.AlbumID = ID;
                                pic.Category = Topic;

                                // Add the picture to the collection
                                AddPicture(pic);
                        }
                        // If a picture does not load correctly 
                        catch (Exceptions::Exception)
                        {
                                // Do nothing
                        }
                }
        }


        void cWebshotsCollection::SaveToFile(string File, Webshots_Formats Format) const
        {
                // Open the file for writing
                ofstream out_file(File.c_str(), ios_base::out | ios_base::binary | ios::trunc);

                // If the file is open
                if (out_file.is_open())
                {
                        // Save the collection in the right format
                        if (Format == WBC)
                                SaveWBCFile(out_file);
                        else if (Format == WBZ)
                                SaveWBZFile(out_file);

                        out_file.close();
                }
                else
                {
                        Exceptions::FileSystemError Err("Unable to open the file \"" + File + "\" for writing.");
                        throw Err;
                }
        }

        void cWebshotsCollection::SaveWBCFile(ofstream &out_file) const
        {
                // File header
                sWBC_Header file_header;

                file_header.File_Marker = WBC_File_Marker;
                strcpy(file_header.File_Title,Title.c_str());
                file_header.Header_Size = 8608;
                file_header.unknown = 0;

                out_file.seekp(0);
                out_file.write((char *)&file_header, sizeof file_header);

                int i;

                // Units
                out_file.seekp(8608);

                sWBC_Unit_Header unit_header;

                for (i = 0; i < PictureCount(); i++)
                {
                        unit_header.Unit_Marker = WBC_Unit_Marker;
                        unit_header.Header_Size = sizeof unit_header;
                        unit_header.Unit_Size = unit_header.Header_Size + Pictures[i]->PictureSize() + Pictures[i]->ThumbnailSize();

                        strcpy(unit_header.Original_Filename, Pictures[i]->Original_Filename.c_str());
                        strcpy(unit_header.Title, Pictures[i]->Title.c_str());
                        strcpy(unit_header.Description, Pictures[i]->Caption.c_str());
                        strcpy(unit_header.Credits, Pictures[i]->Credits.c_str());
                        unit_header.Extension[0] = 0; // Empty string
                        unit_header.JPG_File_Size = Pictures[i]->PictureSize();
                        unit_header.BMP_Thumbnail_Size = Pictures[i]->ThumbnailSize();
                        unit_header.Unknown[0] = 0; // Empry string
                        unit_header.Daily_Date = Pictures[i]->DailyDate;
                        unit_header.Addition_Timestamp = Pictures[i]->AdditionDate;
                        unit_header.Fit_To_Screen = 0; // Default

                        strcpy(unit_header.ID,Pictures[i]->Source.c_str());
                        ltoa(Pictures[i]->ID, unit_header.ID + 1, 10);

                        strcpy(unit_header.Album,Pictures[i]->Album.c_str());
                        strcpy(unit_header.Category,Pictures[i]->Category.c_str());
                        unit_header.Unknown2[0] = 0;

                        out_file.write((char *)&unit_header, sizeof unit_header);

                        if (Pictures[i]->PictureSize() > 0)
                                out_file.write(Pictures[i]->PicturePtr(), Pictures[i]->PictureSize());
                        if (Pictures[i]->ThumbnailSize() > 0)
                                out_file.write(Pictures[i]->ThumbnailPtr(), Pictures[i]->ThumbnailSize());
                }

                // Index
                out_file.seekp(2196);

                sWBC_Index index;
                long offset;
                long count;

                count = PictureCount();

                out_file.write((char *)&count, sizeof count);

                offset = 8608;

                for (i = 0; i < PictureCount(); i++)
                {
                        index.Addition_TimeStamp = Pictures[i]->AdditionDate;
                        index.Unit_Position = offset;
                        index.Unit_Size = sizeof unit_header + Pictures[i]->PictureSize() + Pictures[i]->ThumbnailSize();
                        index.unknown = 0;
                        index.unknown2[0] = 0;

                        out_file.write((char *)&index, sizeof index);

                        offset += index.Unit_Size;
                }
        }


        void cWebshotsCollection::SaveWBZFile(ofstream &out_file) const
        {
                // File header
                sWBZ_Header header;

                header.Element_Count = PictureCount() + 1;
                header.File_Marker = WBZ_File_Marker;
                header.Header_Size = sizeof header;
                header.unknown1 = 0;
                header.Header_Version = 1;
                header.unknown3 = 0;
                header.unknown4[0] = 0; 

                out_file.write((char *)&header,sizeof header);

                // Pictures
                int i;

                for (i = 0; i < PictureCount(); i++)
                {
                        sWBZ_Element_Header pic_header;

                        pic_header.Element_Marker = WBZ_Element_Marker;
                        strcpy(pic_header.File_Name,Picture(i).Original_Filename.c_str());
                        pic_header.File_Size = Picture(i).PictureSize();
                        pic_header.File_Size2 = Picture(i).PictureSize();
                        pic_header.Header_Size = sizeof pic_header;
                        pic_header.Header_Version = 1;
                        pic_header.unknown2 = 0;
                        pic_header.unknown4[0] = 0;

                        out_file.write((char *)&pic_header,sizeof pic_header);
                        out_file.write(Picture(i).PicturePtr(),Picture(i).PictureSize());
                }

                // Last element : metadata
                stringstream meta_stream;
                string meta;

                meta_stream << "[Header]" << "\r\n";
                meta_stream << "Count=" << PictureCount() << "\r\n";

                // The following two lines are for compatibility with the old WBX format
                for (i = 0; i < PictureCount(); i++)
                        meta_stream << i << "=100" << "\r\n";

                for (i = 0; i < PictureCount(); i++)
                {
                        meta_stream << "[" << i << "]" << "\r\n";
                        meta_stream << "BOO_MakeWallpaper=1\r\n";
                        meta_stream << "FIL_ImageFileName=" << Picture(i).Original_Filename << "\r\n";
                        meta_stream << "STR_ImageTitle=" << Picture(i).Title << "\r\n";
                        meta_stream << "STR_ImageCredit=" << Picture(i).Credits << "\r\n";
                        meta_stream << "STR_ImagePID=" << Picture(i).Source << Picture(i).ID << "\r\n";
                        meta_stream << "STR_CollectionTitle=" << Picture(i).Category << " - " << Picture(i).Album << "\r\n";
                        meta_stream << "source=" << Picture(i).Source << "\r\n";
                        meta_stream << "filename=" << Picture(i).Original_Filename << "\r\n";
                        meta_stream << "id=" << Picture(i).ID << "\r\n";
                        meta_stream << "title=" << Picture(i).Title << "\r\n";
                        meta_stream << "credit=" << Picture(i).Credits << "\r\n";
                        meta_stream << "position=\r\n";
                        meta_stream << "catTitle=" << Picture(i).Category << "\r\n";
                        meta_stream << "albumID=" << Picture(i).AlbumID << "\r\n";
                        meta_stream << "albumTitle=" << Picture(i).Album << "\r\n";
                        meta_stream << "dailyDateYYYYMMDD=" << Picture(i).DailyDate << "\r\n";
                }

                meta = meta_stream.str();

                sWBZ_Element_Header meta_header;

                meta_header.Element_Marker = WBZ_Element_Marker;
                strcpy(meta_header.File_Name,"info.wbx");
                meta_header.File_Size = (long)meta.length();
                meta_header.File_Size2 = (long)meta.length();
                meta_header.Header_Size = sizeof meta_header;
                meta_header.Header_Version = 1;
                meta_header.unknown2 = 0;
                meta_header.unknown4[0] = 0;

                out_file.write((char *)&meta_header,sizeof meta_header);
                out_file.write(meta.c_str(),meta.length());
        }


        void cWebshotsCollection::SaveToFolder(const string Path) const
        {
                ofstream out_file;
                string filename;
                stringstream filename_stream;
                int i;

                // Create album.txt
                filename = Path + "album.txt";
                out_file.open(filename.c_str(),  ios_base::out | ios::trunc);

                if (out_file.is_open())
                {
                        out_file << "count||1" << endl
                                << "ID_0||" << ID << endl
                                << "TITLE_0||" << Title << endl
                                << "PHOTO_COUNT_0||" << PictureCount() << endl
                                << "IN_USE_0||" << (In_Use ? 1 : 0) << endl
                                << "DESCRIPTION_0||" << Description << endl
                                << "TOPIC_NAME_0||" << Topic << endl
                                << "CREATE_DATE_0||" << CreateDate << endl
                                << "EDIT_DATE_0||" << EditDate << endl;

                        out_file.close();
                }
                else
                {
                        Exceptions::FileSystemError Err("Unable to open the file \"" + filename + "\" for writing.");
                        throw Err;
                }

                // Create photos.txt & save each picture
                filename = Path + "photos.txt";
                out_file.open(filename.c_str(),  ios_base::out | ios::trunc);

                if (out_file.is_open())
                {
                        out_file << "count||" << PictureCount() << endl;

                        for (i = 0; i < PictureCount(); i++)
                        {
                                // Save the picture
                                filename_stream << Path << "ph" <<  Picture(i).ID << ".wb1"; 
                                Picture(i).SaveToFile(filename_stream.str());
                                filename_stream.str("");

                                out_file << "ID_" << i << "||" << Picture(i).ID << endl
                                        << "POSITION_" << i << "||" << Picture(0).ID + i << endl
                                        << "TITLE_" << i << "||" << Picture(i).Title << endl
                                        << "CAPTION_" << i << "||" << Picture(i).Caption << endl
                                        << "CREDIT_" << i << "||" << Picture(i).Credits << endl
                                        << "URL_PHOTO_" << i << "||" << "ph" <<  Picture(i).ID << ".wb1" << endl
                                        << "URL_THUMB_" << i << "||" << "ph" <<  Picture(i).ID << ".wb1" << endl // should be the url of the thumb, but it is not yet implemented  :)
                                        << "SOURCE_" << i << "||" << (Picture(i).Source.length() > 0 ? Picture(i).Source : "u") << endl;
                        }

                        out_file.close();
                }
                else
                {
                        Exceptions::FileSystemError Err("Unable to open the file \"" + filename + "\" for writing.");
                        throw Err;
                }
        }

        //------------------------------------
        // Access / add / remove / count pictures
        //------------------------------------

        cWebshotsPicture& cWebshotsCollection::Picture(int Index)
        {
                if ((Index < (int)Pictures.size()) && (Index >= 0))
                        return *Pictures[Index];
                else
                {
                        Exceptions::OutOfRange Err("Index out of range.");
                        throw Err;
                }
        }

        const cWebshotsPicture& cWebshotsCollection::Picture(int Index) const
        {
                if ((Index < (int)Pictures.size()) && (Index >= 0))
                        return *Pictures[Index];
                else
                {
                        Exceptions::OutOfRange Err("Index out of range.");
                        throw Err;
                }
        }

        void cWebshotsCollection::RemovePicture(int Index)
        {
                if ((Index < (int)Pictures.size()) && (Index >= 0))
                {
                        delete Pictures[Index];
                        Pictures.erase(Pictures.begin() + Index);
                }
                else
                {
                        Exceptions::OutOfRange Err("Index out of range.");
                        throw Err;
                }
        }

        cWebshotsPicture& cWebshotsCollection::AddPicture()
        {
                cWebshotsPicture* Pic = new cWebshotsPicture;
                Pictures.push_back(Pic);

                return *Pic;
        }

        cWebshotsPicture& cWebshotsCollection::AddPicture(const cWebshotsPicture& Picture)
        {
                return AddPicture() = Picture;
        }

        int cWebshotsCollection::PictureCount() const
        {
                return (int)Pictures.size();
        }

        void cWebshotsCollection::Clear()
        {
                unsigned long i;

                // Delete every picture
                for (i = 0; i < Pictures.size(); i++)
                        delete Pictures[i];

                // Clear the array
                Pictures.clear();

                // Clear the properties
                ID.clear();
                Title.clear();
                Description.clear();
                Topic.clear();
                In_Use = false;
                CreateDate = 0;
                EditDate = 0;
        }

        // -----------------------------------------
        // Operators
        // -----------------------------------------

        cWebshotsCollection& cWebshotsCollection::operator=(const cWebshotsCollection& source)
        {
                if (&source != this)
                {
                        int i;

                        // Clear the collection
                        Clear();

                        // Add the pictures of "source" to it
                        for (i = 0; i < source.PictureCount(); i++)
                                AddPicture(source.Picture(i));

                        // Copy the properties from "source"
                        ID = source.ID;
                        Title = source.Title;
                        Description = source.Description;
                        Topic =source.Topic;
                        In_Use = source.In_Use;
                        CreateDate = source.CreateDate;
                        EditDate = source.EditDate;
                }

                return *this;
        }

        cWebshotsCollection& cWebshotsCollection::operator+=(const cWebshotsCollection& source)
        {
                int i;

                for (i = 0; i < source.PictureCount(); i++)
                        AddPicture(source.Picture(i));

                return *this;
        }

        cWebshotsCollection& cWebshotsCollection::operator=(const cWebshotsPicture& source)
        {
                Clear();
                AddPicture(source);

                return *this;
        }

        cWebshotsCollection& cWebshotsCollection::operator+=(const cWebshotsPicture& source)
        {
                AddPicture(source);

                return *this;
        }

        cWebshotsPicture& cWebshotsCollection::operator[](const int Index)
        {
                if ((Index < (int)Pictures.size()) && (Index >= 0))
                        return *Pictures[Index];
                else
                {
                        Exceptions::OutOfRange Err("Index out of range.");
                        throw Err;
                }
        }

        const cWebshotsPicture& cWebshotsCollection::operator[](const int Index) const
        {
                if ((Index < (int)Pictures.size()) && (Index >= 0))
                        return *Pictures[Index];
                else
                {
                        Exceptions::OutOfRange Err("Index out of range.");
                        throw Err;
                }
        }


        cWebshotsCollection operator+(const cWebshotsCollection& col1, const cWebshotsCollection& col2)
        {
                cWebshotsCollection Collection;

                Collection = col1;
                Collection += col2;

                return Collection;
        }

        cWebshotsCollection operator+(const cWebshotsPicture& pic, const cWebshotsCollection& col)
        {
                cWebshotsCollection Collection;

                Collection = pic;
                Collection += col;

                return Collection;
        }

        cWebshotsCollection operator+(const cWebshotsCollection& col, const cWebshotsPicture& pic)
        {
                cWebshotsCollection Collection;

                Collection = col;
                Collection += pic;

                return Collection;
        }

        cWebshotsCollection operator+(const cWebshotsPicture& pic1, const cWebshotsPicture& pic2)
        {
                cWebshotsCollection Collection;

                Collection = pic1;
                Collection += pic2;

                return Collection;
        }

}

---