package.h

// Name:        package.h
// Purpose:     wxPackage, wxPackageArray
// Author:      Julian Smart, Francesco Montorsi, Daniel J. Lauk
// Modified by:
// Created:     2004-11-07
// RCS-ID:      $Id: package.h,v 1.13 2007/02/01 20:28:14 frm Exp $
// Copyright:   (c) Julian Smart, Francesco Montorsi, Daniel J. Lauk
// Licence:     wxWidgets licence

#ifndef _PACKAGE_H_
#define _PACKAGE_H_

// Includes
#include "wxp/packageinfo.h"
#include "wx/md5.h"

class wxArchiveInputStream;

extern wxPackage wxEmptyPackage;
extern wxPackageArray wxEmptyPackageArray;


// ----------------------------------------------------------------------------
// wxPackageStatus
// ----------------------------------------------------------------------------

enum wxPackageStatus
{
    wxPS_INVALID = -1,

    wxPS_REMOTE,

    wxPS_DOWNLOADED,

    wxPS_DECOMPRESSED,

    wxPS_BUILT,

    wxPS_INSTALLED,

    // the number of possible package states
    wxPS_MAX
};

wxDEFINE_STRING2ENUM(PackageStatus)



// ----------------------------------------------------------------------------
// wxProgressHandler
// ----------------------------------------------------------------------------

// A small interface class which acts as a callback:
// the OnUpdate() method is called when some progress is being done.
class wxProgressHandler
{
public:
    wxProgressHandler(wxObject *owner = NULL) { m_owner=owner; }
    virtual ~wxProgressHandler() {}

    // NOTE: the "progress" value is a value always comprised between
    //       zero and the maximum 1000.
    //       It's not the progress "delta" but the value of the progress
    //       (i.e. don't sum it with previous progress values).
    virtual bool OnUpdate(unsigned long progress, const wxString &text) = 0;

    wxObject *GetOwner() const
        { return m_owner; }

protected:
    wxObject *m_owner;
};



// ----------------------------------------------------------------------------
// wxPackage
// ----------------------------------------------------------------------------

class wxPackage : public wxPackageInfo
{
    // required to get access to DoGetRecursiveDependency
    friend class wxPackageDependency;

    DECLARE_DYNAMIC_CLASS(wxPackage)

public:
    /* 30/12/2006 WARNING: don't know if the following wxPS_REMOVE => wxPS_INVALID
                           change won't break wxPM !! */

    wxPackage() : m_status(wxPS_INVALID) {}
    wxPackage(const wxPackageInfo &info, wxPackageStatus stat = wxPS_INVALID) 
        : m_status(stat)
        { *this = info; }
    virtual ~wxPackage() {}


    wxPackage& operator= (const wxPackageInfo& info)
        { *((wxPackageInfo*)this) = info; return *this; }

public:     // static

    static wxArrayString s_arrLocalRepo;

    static wxArrayString s_arrRemoteRepo;

    // load/save

    static bool LoadGlobals(wxConfigBase *, const wxString &path);

    static void SaveGlobals(wxConfigBase *, const wxString &path);

public:     // getters

    wxPackageStatus GetStatus() const
        { return m_status; }
    wxString GetStatusStr() const
        { return wxPackageStatus2String(m_status); }

    wxString GetDownloadPath() const
        { return m_strDownloadPath; }
    wxString GetDecompressionPath() const
        { return m_strDecompressionPath; }
    wxString GetInstallationPath() const
        { return m_strInstallationPath; }

    wxCompilerSettings &GetCompilerSettings()
        { return m_compiler; }
    wxCompilerSettings GetCompilerSettings() const
        { return m_compiler; }

public:     // WXP getters

    wxString GetRelativeWXPPath() const
        { return m_strWXPPath; }
    wxString GetAbsWXPPath() const
        { return m_strDecompressionPath + wxFileName::GetPathSeparator() +  m_strWXPPath; }

    wxString GetWXPFileName() const
        { return wxFileName(m_strWXPPath).GetFullName(); }
/*
    wxString GetWXZFileName() const
    {
        if (m_status >= wxPS_DECOMPRESSED)
            // FIZME: this is very arbitrary: also the .tar.gz and .zip extensions could be used
            return wxFileName(m_strWXPPath).GetName() + wxT(".wxz");
        return wxFileSystem::URLToFileName(GetDownloadHref().Item(0)).GetFullName();
    }
*/
    wxULongLong GetDecompressedSize() const;

public:     // setters

    void SetCompilerSettings(const wxCompilerSettings &sett)
        { m_compiler=sett; }

    void SetDecompressionPath(const wxString &path)
        { m_strDecompressionPath=path; }

public:     // miscellaneous

    bool IsOk() const;

    wxWidgetsBuildArray GetSupportedWxBuilds(bool docompilercheck = true) const;

    bool GetRecursiveDependencies(
                    wxPackageDependencyArray *ret,
                    const wxPackageArray &arr,
                    wxPackageDependencyType type,
                    wxPackageDependencyArray *notfound = NULL) const;

    wxArrayString GetIncludedFiles(wxULongLong *totalsize = NULL) const;

    bool LoadCompressedPackage(const wxString &wxzpath);

    bool Decompress(const wxString &path, wxProgressHandler *handler = NULL);

    bool Compress(const wxString &wxz = wxEmptyString, wxProgressHandler *handler = NULL);

    bool UploadWithFTP(const wxString &user = wxEmptyString, 
                       const wxString &password = wxEmptyString, 
                       const wxString &server = wxEmptyString, 
                       const wxString &path = wxEmptyString);

public:     // status

    void SetRemoteStatus(const wxString &downloadpath = wxEmptyString);

    void SetDownloadedStatus(const wxString &downloadpath);

    void SetDecompressedStatus(const wxString &decompressionpath);

    void SetBuiltStatus();

    void SetInstalledStatus(const wxString &installpath);

    void SetRelativeWXPPath(const wxString &path)
        { m_strWXPPath=path; }

    void UpdatePackageInfo();

public:     // load & save

    bool LoadStatusInfo(wxConfigBase *cfg, const wxString &path);
    bool SaveStatusInfo(wxConfigBase *cfg, const wxString &path) const;

    bool UpdateCompressedSize()
    {
        wxASSERT(m_status >= wxPS_DOWNLOADED);

        if (m_strDownloadPath.IsEmpty())
        {
            // this happens when e.g. the package has the wxPS_DECOMPRESSED
            // status but it's a new package and thus the compressed package
            // does not exist (yet)!
            return false;
        }

        m_nCompressedSize = wxFileName(m_strDownloadPath).GetSize();
        if (m_nCompressedSize == wxInvalidSize)
            return false;
        return true;
    }

    bool UpdateMD5()
    {
        wxASSERT(m_status >= wxPS_DOWNLOADED);

        if (m_strDownloadPath.IsEmpty())
        {
            // this happens when e.g. the package has the wxPS_DECOMPRESSED
            // status but it's a new package and thus the compressed package
            // does not exist (yet)!
            return false;
        }

        m_strMD5 = wxMD5::GetFileMD5(m_strDownloadPath);
        return !m_strMD5.IsEmpty();
    }

protected:         // wxPackageInfo overloads

    virtual wxPackageCommand GetCmd(const wxPackageCommand &cmd, 
                                    wxPackageBuildSystemStage stage,
                                    long flags,
                                    const wxPackageCondition &cond) const;

protected:      // internal utilities

    bool DoGetRecursiveDependencies(
                    wxPackageDependencyArray *ret,
                    const wxPackageArray &arr,
                    wxPackageDependencyType type,
                    wxPackageDependencyArray *notfound,
                    wxPackageIdArray *alreadyprocessed) const;

    wxArchiveInputStream *GetInputStream(const wxString &wxzpath) const;

    virtual void DoUpdateSubstitutionHashMap(wxPackageSubstituteInfoContext ctx);


protected:          // miscellaneous

    wxPackageStatus m_status;

    wxCompilerSettings m_compiler;

protected:          // paths

    wxString m_strDownloadPath;

    wxString m_strDecompressionPath;

    wxString m_strWXPPath;

    wxString m_strInstallationPath;
};

// the array
WX_DECLARE_OBJARRAY(wxPackage, wxPackageArrayHelper);

// a light array of wxPackages
WX_DEFINE_ARRAY(const wxPackage *, wxPackagePtrArray);





// ----------------------------------------------------------------------------
// wxPackageArray
// ----------------------------------------------------------------------------

class wxPackageArray : public wxPackageArrayHelper
{
public:
    wxPackageArray() {}

public:     // miscellaneous

    // define & implement IsOk(), IndexByName(), ItemByName(), Contains()
    // and ContainsItemNamed() functions
    WX_DECLARE_STD_OBJARRAY_HELPERS(wxPackage, wxEmptyPackage);

    int IndexById(const wxPackageId &id) const
    {
        for (size_t i=0; i<GetCount(); i++)
            if ((const wxPackageId &)Item(i) == id)
                return i;
        return wxNOT_FOUND;
    }

    wxPackage &ItemById(const wxPackageId &id)
    {
        int n = IndexById(id);
        if (n != wxNOT_FOUND)
            return wxPackageArrayHelper::Item(n);
        return wxEmptyPackage;
    }

public:         // misc

    // Removes duplicate packages and returns the number of removed packages.
    size_t RemoveDuplicates();

    bool UpdatePackage(const wxPackage &pkg);

    bool GetRecursiveDependencies(
                    wxPackageDependencyArray *ret,
                    const wxPackageArray &arr,
                    wxPackageDependencyType type,
                    wxPackageDependencyArray *notfound = NULL) const;

    wxPackageArray GetPackagesWhichBelongTo(wxPackageCategory cat) const;

    void InvalidateCachedSubstHashMap(wxPackageSubstituteInfoContext ctx = wxPSIC_INVALID);

public:         // load functions

    bool LoadCompressedPackagesFrom(const wxString &path);

    bool LoadCompressedPackagesFromLocalRepo();

public:     // status load & save

    bool LoadPackagesStatusInfo(wxConfigBase *, const wxString &);

    bool SavePackagesStatusInfo(wxConfigBase *, const wxString &) const;
};

#endif      // _PACKAGE_H_

---