addon.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2010-2015 Lucas Baudin, Joerg Henrichs
//
//  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 3
//  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 HEADER_ADDON_HPP
#define HEADER_ADDON_HPP
 
#include "utils/time.hpp"
 
#include <assert.h>
#include <string>
#include "irrString.h"
 
class XMLNode;
using namespace irr;
 
class Addon
{
public:
    enum AddonStatus {AS_APPROVED = 0x0001,
                      AS_ALPHA    = 0x0002,
                      AS_BETA     = 0x0004,
                      AS_RC       = 0x0008,
                      AS_INVISIBLE= 0x0010,
                      //AS_HQ       = 0x0020,   currently not supported
                      AS_DFSG     = 0x0040,
                      AS_FEATURED = 0x0080,
                      AS_LATEST   = 0X0100,
                      AS_BAD_DIM  = 0x0200
    };
 
    enum SortOrder { SO_DEFAULT,   // featured first, then alphabetically
                     SO_NAME,      // Sorted alphabetically by name
                     SO_DATE       // Sorted by date, newest first
    };
 
    // ------------------------------------------------------------------------
    static bool isAddon(const std::string &directory);
    // ------------------------------------------------------------------------
    static std::string createAddonId(const std::string &id)
    {
        return "addon_"+id;
    }   // createAddonId
    // ------------------------------------------------------------------------
 
private:
    core::stringw m_name;
    std::string m_id;
    std::string m_dir_name;
 
    core::stringw m_designer;
    int         m_revision;
    int         m_installed_revision;
    int         m_icon_revision;
    int         m_status;
    bool        m_still_exists;
    StkTime::TimeType m_date;
    core::stringw m_description;
    std::string m_icon_url;
    std::string m_icon_basename;
    bool        m_icon_ready;
    std::string m_zip_file;
    bool        m_installed;
    int         m_size;
    mutable float       m_rating;
    std::string m_min_include_ver;
    std::string m_max_include_ver;
    std::string m_type;
 
    static SortOrder m_sort_order;
 
public:
         Addon(const XMLNode &xml);
 
    void deleteInvalidIconFile();
    // ------------------------------------------------------------------------
    static void setSortOrder(SortOrder so) { m_sort_order = so; }
    // ------------------------------------------------------------------------
    void writeXML(std::ofstream *out_stram);
    // ------------------------------------------------------------------------
    void copyInstallData(const Addon &addon);
    // ------------------------------------------------------------------------
    const core::stringw& getName() const { return m_name; }
    // ------------------------------------------------------------------------
    const std::string& getMinIncludeVer() const {return m_min_include_ver; }
    // ------------------------------------------------------------------------
    const std::string& getMaxIncludeVer() const {return m_max_include_ver; }
    // ------------------------------------------------------------------------
    const float getRating() const {return m_rating; }
    // ------------------------------------------------------------------------
    void setRating(const float rating) const {m_rating = rating; }
    // ------------------------------------------------------------------------
    const std::string& getType() const { return m_type; }
    // ------------------------------------------------------------------------
    const std::string& getZipFileName() const { return m_zip_file; }
    // ------------------------------------------------------------------------
    const std::string& getIconURL() const { return m_icon_url; }
    // ------------------------------------------------------------------------
    const std::string& getIconBasename() const { return m_icon_basename; }
    // ------------------------------------------------------------------------
    const core::stringw& getDescription() const { return m_description; }
    // ------------------------------------------------------------------------
    StkTime::TimeType getDate() const { return m_date; }
    // ------------------------------------------------------------------------
    std::string getDateAsString() const;
    // ------------------------------------------------------------------------
    bool  isInstalled() const { return m_installed; }
    // ------------------------------------------------------------------------
    int   getInstalledRevision() const { return m_installed_revision; }
    // ------------------------------------------------------------------------
    int   getRevision() const { return m_revision; }
    // ------------------------------------------------------------------------
    const std::string& getId() const { return m_id; }
    // ------------------------------------------------------------------------
    const core::stringw& getDesigner() const { return m_designer; }
    // ------------------------------------------------------------------------
    bool getStillExists() const { return m_still_exists; }
    // ------------------------------------------------------------------------
    void setStillExists() { m_still_exists = true; }
    // ------------------------------------------------------------------------
    bool needsUpdate() const
    {
        return m_installed && getInstalledRevision() < getRevision();
    }   // needsUpdate
    // ------------------------------------------------------------------------
    bool iconNeedsUpdate() const
    {
        return m_revision > m_icon_revision;
    }   // iconNeedsUpdate
    // ------------------------------------------------------------------------
    void setInstalled(bool state)
    {
        m_installed         = state;
        if(state)
            m_installed_revision = m_revision;
    }   // setInstalled
    // ------------------------------------------------------------------------
    bool iconReady() const { return m_icon_ready; }
    // ------------------------------------------------------------------------
    void setIconReady()
    {
        m_icon_revision = m_revision;
        m_icon_ready=true;
    }   // setIconReady
    // ------------------------------------------------------------------------
    int getSize() const { return m_size; }
    // ------------------------------------------------------------------------
    std::string getTypeDirectory() const
    {
        if(m_type=="kart")
            return "karts/";
        else if(m_type=="track")
            return "tracks/";
        else if(m_type=="arena")  // arenas are installed as tracks
            return "tracks/";
        // It must be one of the two
        assert(false);
        return "";  // Ignore compiler warning
    }   // getTypeDirectory
 
    // ------------------------------------------------------------------------
    bool testIncluded(const std::string &min_ver, const std::string &max_ver);
    // ------------------------------------------------------------------------
    bool testStatus(AddonStatus n) const {return (m_status & n) !=0; }
    // ------------------------------------------------------------------------
    std::string getDataDir() const;
    // ------------------------------------------------------------------------
    bool filterByWords(const core::stringw words) const;
    // ------------------------------------------------------------------------
    
    bool operator<(const Addon &a) const
    {
        switch(m_sort_order)
        {
            case SO_DEFAULT:
                if(testStatus(AS_FEATURED) &&
                    !a.testStatus(AS_FEATURED))  return true;
                if(!testStatus(AS_FEATURED) &&
                    a.testStatus(AS_FEATURED))  return false;
            // Otherwise fall through to name comparison!
            case SO_NAME:
                // m_id is the lower case name
                return m_id < a.m_id;
                break;
            case SO_DATE:
                return m_date < a.m_date;
                break;
        }   // switch
        // Fix compiler warning.
        return true;
    }   // operator<
    // ------------------------------------------------------------------------
    const std::string& getDirName() const { return m_dir_name; }
};   // Addon
 
 
#endif