file_request.h

Go to the documentation of this file.

#ifndef FILE_REQUEST_H
#define FILE_REQUEST_H

#include <lwpp/utility.h>
#include <lwpp/storeable.h>
#include <lwpp/message.h>
#include <deque>

#ifndef LWFTYPE_INSTALL
#define LWFTYPE_INSTALL         "Install" // installation directory, not defined by LW
#endif

namespace lwpp
{
#ifdef LWPP_PLATFORM_WIN
  const char fSep = '\\'; 
#elif defined(LWPP_PLATFORM_OSX_CFM)
  const char fSep = ':';
  //extern const char *fSeps = ":";
#elif defined(LWPP_PLATFORM_OSX_UB)
  const char fSep = '/';
#else
#error no valid Platform
#endif
  extern const char *fSeps;
class DirInfo : protected GlobalBase<LWDirInfoFunc>
  {
  private:
    const char *dirType;
    std::string return_dir;
  public:
    DirInfo (const char *dirtype = 0) :  dirType(dirtype)
    {
      if ((dirtype == 0) || (*dirtype == 0)) dirType = LWFTYPE_CONTENT;
    }

    const char *GetDirectory(const char* locType = 0);

    const std::string GetDirectoryStr(const char* locType = 0)
    {
      return std::string(GetDirectory(locType));
    }

    const char *stripPath(const char *fileName);
  };

  // Directory scanning
  class Directory
  {
    DIR *directory;
    struct dirent *entry;
    public:
      Directory(const std::string name);
      ~Directory();
      bool exists();
      const char *getEntry(void);
  };

  bool isDirectory(const std::string name);

  void makeAllDirectories(const char *path);

  class FileType  : protected GlobalBase<LWFileTypeFunc>
  {
  public:
    FileType (void){;}
    const char *GetType(const char *filetype) const
    {
      return globPtr(filetype);
    }
  };

  std::string getTempPath();

  class BaseFileRequest
  {
  public:
    virtual bool Post(void) = 0;
    virtual const char *getFullName(void) = 0;
  };

  class OSFileRequest : public BaseFileRequest
  {
    struct Data;
    Data *m_data;
  public:
    OSFileRequest (const int reqType = FREQ_LOAD, char *title = "",
                   const char *fileType = "", const char *ext = "", const char *baseName = "",
                  const char *path = "",  const char *_baseDirType = 0, int bufLen = 1024);

    virtual ~OSFileRequest();

    virtual bool Post(void);

    virtual const char *getFullName(void);
  private:
    int type;
#ifdef LWPP_PLATFORM_WIN
#elif defined(LWPP_PLATFORM_OSX_CFM)
    NavDialogCreationOptions dialogOptions;
    NavDialogRef dialog;
    OSStatus status;
    NavReplyRecord replyRecord;
    std::string temp_path;
#elif defined(LWPP_PLATFORM_OSX_UB)
#else
 #error No OS specifice file requester!
#endif
  };


  class FileRequest2 : public BaseFileRequest, protected GlobalBase<LWFileActivateFunc>, protected DirInfo
  {
    private:
      LWFileReqLocal frloc;
    public:
      FileRequest2 (const int reqType = FREQ_LOAD, const char *title = "",
                    const char *fileType = "", const char *baseName = "",
                    const char *path = "",  const char *_baseDirType = 0,
                    int (*pickName) (void) = 0, int bufLen = 1024)
      : DirInfo(_baseDirType)
      {
        frloc.reqType = reqType;
        frloc.bufLen = bufLen;
        frloc.result = 0;
        frloc.title = title;
        frloc.fileType = fileType;
        frloc.path = new char[bufLen];
        frloc.baseName = new char[bufLen];
        frloc.fullName = new char[bufLen];
        strcpy (frloc.path, path);
        strcpy (frloc.baseName, baseName);
        frloc.pickName = pickName;
      }
      ~FileRequest2 (void)
      {
        delete[] frloc.path;
        delete[] frloc.baseName;
        delete[] frloc.fullName;
      }

      bool Post(void)
      {
        return ((GlobalBase<LWFileActivateFunc>::globPtr( LWFILEREQ_VERSION, &frloc ) == AFUNC_OK) && (frloc.result == 1));
      }
      const char *getFullName()
      {
        return DirInfo::stripPath(frloc.fullName);
      }
      const char *getFullPath() const
      {
        return frloc.fullName;
      }
      const char *getPath() const
      {
        return frloc.path;
      }
      LWFileReqLocal *getFileReqLocal()
      {
        return &frloc;
      }
      void setBaseName(const std::string name)
      {
        strcpy (frloc.baseName, name.c_str());
      }
  };

  // remove trailing file separator
  void trimTrail(std::string &path);


  class FileName : public Storeable
  {
    private:
      const char *baseDir; 
      std::string fileName; 
      std::string relativePath; 
      std::string fullName; 
      std::string relName;
      bool valid; 
      bool useBase; 

      void buildFullName();
      void splitFileName();
      bool setRelativeName(const char *relName);
      void setExtension(const char *ext);
      static std::string extractExtension(const char *source);
    public:

      FileName (const char *_baseDir = LWFTYPE_CONTENT, bool base = false) : baseDir(_baseDir), valid(false), useBase(base)
      {
        ;
      }
      FileName (const std::string name, bool base = false) : baseDir(LWFTYPE_CONTENT), valid(false), useBase(base)
      {
        setFullName(name);
      }
      std::string getRelativeName();
      const char *getRelativeNameC();
      //std::string getRelativeName(const char *_baseDir);
      std::string getFileName(void);
      std::string getPath(void);
      std::string getFullPath(void);
      //void makePath(void);

      const char *getFullName()
      {
        if (!valid) buildFullName();
#ifdef _DEBUG
        lwpp::dostream dout;
        dout << "FileName::getFullName() -  " << fullName << std::endl;
#endif
        return fullName.c_str();
      }
      std::string getAbsoluteName()
      {
        if (!valid) buildFullName();
        if (!useBase)
        {
          DirInfo di(baseDir);
          return std::string(di.GetDirectory()) + fullName;
        }
        return fullName;
      }
      FileName &operator=(const char *name)
      {
        setFullName(name);
        return *this;
      }
      FileName &operator=(const std::string name)
      {
        setFullName(name);
        return *this;
      }
      void setFullName(const std::string name)
      {
        fullName = name;
        splitFileName();
      }
      void setFileName(const std::string name)
      {
        fileName = name;
        valid = false;
      }
      void setFileExtension(const char *extension = "")
      {
        setExtension(extension);
      }
      std::string getFileExtension()
      {
        return std::string(extractExtension(fileName.c_str()));
      }
      // remove trailing numbers
      void stripNumberTrail(void);
      void setExtractedExtension(const char *source)
      {
        std::string ext(extractImageExtension(source));
        setExtension(ext.c_str());
      }
      static std::string extractImageExtension(const char *source);

      //static bool Exists(const char *name);
      static bool Exists(const std::string &name); //{return Exists(name.c_str());}
      bool Exists() {return Exists(getFullName());}

      LWError Load(const LoadState &ls );
      LWError Save(const SaveState &ss );
  };

  std::string stripExtension(const char *source);

  std::string trim(const std::string& s, const char *ws=" \t\r");

  std::string makeRelativeName(const std::string basePath, const std::string absFileName);
  
  std::string makeAbsoluteName(const std::string basePath, const std::string relFileName);

  typedef std::deque<std::string> pathList;
  std::string makeRelativeName(pathList basePath, const std::string absFileName);
  pathList splitPath(std::string sourcePath);
  pathList splitFullPath(std::string sourcePath, std::string &fileName, std::string &ext);
  std::string makeFullFileName(const pathList &path, const std::string &file, const std::string &ext);
  std::string makeFullPath(const pathList &path);

  std::string makeAbsoluteName(pathList basePath, const std::string relFileName);
  std::string makeAbsoluteName(const std::string basePath, const std::string relFileName);

  class Stat
  {
    struct statData;
    statData *d;
  public:
    Stat(const std::string fName);
    ~Stat();
    bool isDirectory() const;
    bool exists() const;
    time_t getCreateTimeStamp() const;
    time_t getModifyTimeStamp() const;
    size_t getFileSize() const;
  };
} // end namespace lwpp

#endif // FILE_REQUEST_H