cWebshots.h

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
*/


#ifndef __CWEBSHOTS_H
#define __CWEBSHOTS_H


#include <vector>
#include <string>
#include <fstream>

namespace cWebshots
{

        using namespace std;

        //----------------------------------------------------------
        // Constants
        //----------------------------------------------------------

        // File type marker
        const unsigned long WBC_File_Marker    = 0x95FA16AB;    
        const unsigned long WBC_Unit_Marker    = 0xF071CDE2;    
        const unsigned long WBZ_File_Marker    = 0x6791AB43;    
        const unsigned long WBZ_Element_Marker = 0x1082CDE1;    
        const unsigned long JFIF_File_Marker   = 0xE0FFD8FF;    
        const unsigned long EXIF_File_Marker   = 0xE1FFD8FF;    
        const unsigned long WB1_File_Marker    = 0x42425757;    
        const unsigned long TXT_File_Marker    = 0x6E756F63;    

        enum Webshots_Formats
        {
                WB1,            
                WBC,            
                WBZ,            
                JPG,            
                Folder,         
                Unknown         
        };

        // ----------------------------------------------------------
        //  Class cWebshotsPicture          
        //  ~~~~~~~~~~~~~~~~~~~~~~
        //  Members are defined in cWebshotsPicture.cpp
        // ----------------------------------------------------------

        class cWebshotsPicture
        {
        private:
                char *JPGFile;                          
                long JPGFile_Size;                      
                char *BMPThumbnail;                     
                long BMPThumbnail_Size;         

                void LoadWB1(ifstream &in_file);

                void LoadMetaDataTXT(string file);

        public:
                ~cWebshotsPicture(void);
                cWebshotsPicture(void);
                cWebshotsPicture(const cWebshotsPicture& source);

                cWebshotsPicture& operator=(const cWebshotsPicture& source);

                void Clear();

                void LoadFromFile(string File);
                void LoadFromMemory(const char *data, long size);
                void SaveToFile(string file, Webshots_Formats format = JPG) const;

                char *PicturePtr() const;
                long PictureSize() const;
                char *ThumbnailPtr() const;
                long ThumbnailSize() const;

                long ID;                                        
                string Original_Filename;       
                string Title;                           
                string Caption;                         
                string Credits;                         

                string Category;                        
                string Album;                           
                string AlbumID;                         

                string Source;                          
                long DailyDate;                         
                long AdditionDate;                      
        };


        // ----------------------------------------------------------
        //  Class cWebshotsTXT
        //  ~~~~~~~~~~~~~~~~~~~~~~
        //  Members are defined in cWebshotsTXT.cpp
        // ----------------------------------------------------------

        struct sPhotosTXT
        {
                long id;                                        
                string position;                        
                string title;                           
                string caption;                         
                string credit;                          
                string url_photo;                       
                string url_thumb;                       
                string source;                          
        };

        struct sAlbumTXT
        {
                string id;                                      
                string title;                           
                int photo_count;                        
                bool in_use;                            
                string description;                     
                string topic_name;                      
                long create_date;                       
                long edit_date;                         
        };

        class cWebshotsTXT
        {
        private:
                sPhotosTXT *Pictures;           
                int Count;                                      

        public:
                cWebshotsTXT(void);
                cWebshotsTXT(string directory);
                ~cWebshotsTXT(void);

                void Load(string directory);

                sPhotosTXT& Picture(int index);
                int PictureCount();

                int IndexFromFileName(string filename, bool case_sensitive = false);

                sAlbumTXT Album;                        

                static const int IndexNotFound = -1;    
        };


        // ----------------------------------------------------------
        //  Class cWesbshotsCollection
        //  ~~~~~~~~~~~~~~~~~~~~~~
        //  Members are defined in cWebshotsCollection.cpp
        // ----------------------------------------------------------

        class cWebshotsCollection
        {
        private:
                vector<cWebshotsPicture*> Pictures;             

                void LoadWBCFile(ifstream &in_file);
                void LoadWBZFile(ifstream &in_file);

                void SaveWBCFile(ofstream &out_file) const;
                void SaveWBZFile(ofstream &out_file) const;

        public:
                cWebshotsCollection(const cWebshotsCollection& source);
                cWebshotsCollection();

                cWebshotsCollection& operator=(const cWebshotsCollection& source);
                cWebshotsCollection& operator+=(const cWebshotsCollection& source);
                cWebshotsCollection& operator=(const cWebshotsPicture& source);
                cWebshotsCollection& operator+=(const cWebshotsPicture& source);

                cWebshotsPicture& operator[](const int Index);
                const cWebshotsPicture& operator[](const int Index) const;

                friend cWebshotsCollection operator+(const cWebshotsCollection& col1, const cWebshotsCollection& col2);
                friend cWebshotsCollection operator+(const cWebshotsPicture& pic, const cWebshotsCollection& col);
                friend cWebshotsCollection operator+(const cWebshotsCollection& col, const cWebshotsPicture& pic);
                friend cWebshotsCollection operator+(const cWebshotsPicture& pic1, const cWebshotsPicture& pic2);

                string Title;                   
                string Description;             
                string Topic;                   
                string ID;                              
                bool In_Use;                    
                long CreateDate;                
                long EditDate;                  

                void LoadFromFile(const string File);
                void LoadFromFolder(const string Path);

                void SaveToFile(const string File, Webshots_Formats Format) const;
                void SaveToFolder(const string Path) const;

                cWebshotsPicture& Picture(int Index);
                const cWebshotsPicture& Picture(int Index) const;

                cWebshotsPicture& AddPicture();
                cWebshotsPicture& AddPicture(const cWebshotsPicture& Picture);

                void RemovePicture(const int Index);
                void Clear();

                int PictureCount() const;
        };

        //----------------------------------------------------------
        // Structures
        //----------------------------------------------------------

        struct sWBC_Header
        {
                long File_Marker;                       
                long Header_Size;                       
                long unknown;                           
                char File_Title[256];           
        };

        struct sWBC_Index
        {
                long Unit_Position;                     
                long Unit_Size;                         
                long unknown;                           
                long Addition_TimeStamp;        
                char unknown2[24];                      
        };

        struct sWBC_Unit_Header
        {
                long Unit_Marker;                       
                long Header_Size;                       
                long Unit_Size;                         
                char Original_Filename[256];    
                char Title[128];                        
                char Description[256];          
                char Credits[256];                      
                char Extension[8];                      
                long JPG_File_Size;                     
                long BMP_Thumbnail_Size;        
                char Unknown[140];                      
                long Daily_Date;                        
                long Addition_Timestamp;        
                long Fit_To_Screen;                     
                char ID[128];                           
                char Album[96];                         
                char Category[256];                     
                char Unknown2[532];                     
        };

        struct sWBZ_Header
        {
                long File_Marker;                       
                long Header_Size;                       
                long unknown1;                          
                long Header_Version;            
                long unknown3;                          
                long Element_Count;                     
                char unknown4[128];                     
        };

        struct sWBZ_Element_Header
        {
                long Element_Marker;            
                long Header_Size;                       
                long Header_Version;            
                char File_Name[256];            
                long File_Size;                         
                long unknown2;                          
                long File_Size2;                        
                char unknown4[256];                     
        };

        //----------------------------------------------------------
        // Exceptions
        //----------------------------------------------------------
        
        namespace Exceptions
        {
                class Exception
                {
                private:
                        string strDescription;

                public:
                        Exception()
                        {
                                strDescription = "Unknown error !";
                        };

                        Exception(string _Description)
                        {
                                strDescription = _Description;
                        };

                        string Description()
                        {
                                return strDescription;
                        };
                };

                class FileSystemError : public Exception
                {
                public:
                        FileSystemError(string _Description) : Exception(_Description) {};
                };

                class DataError : public Exception
                {
                public:
                        DataError(string _Description) : Exception(_Description) {};
                };

                class UnknownFormat : public DataError
                {
                public:
                        UnknownFormat(string _Description) : DataError(_Description) {};
                };

                class CorruptedData : public DataError
                {
                public:
                        CorruptedData(string _Description) : DataError(_Description) {};
                };

                class OutOfRange : public Exception
                {
                public:
                        OutOfRange(string _Description) : Exception(_Description) {};
                };
        }

        //----------------------------------------------------------
        // Misc
        //----------------------------------------------------------

        string GetFileName(string path);
        string GetDirectory(string path);

        Webshots_Formats IdentifyFile(string File);
        Webshots_Formats IdentifyFile(ifstream &in_file);

        void Tokenize(const string& str, vector<string>& tokens, const string& delimiters);
        string GetINI(const string &Data, const string &Section, const string &Field);
        string IntToStr(const int &i);
        long StrToLong(const string &s);
}


#endif

---