lhazregs.h

[詳解]

/*************************************************************************/
#pragma once
 
#include "altstr.hpp"
#include <windows.h>
#include "mybuf.h"
#include "myregistory.h"
#include "defpasswords.h"
#include "lhazarc.h"
#include "lhazshellex.h"
 
#define GS(type, v) ¥
public: ¥
    type    Get##v(void) const { return v; } ¥
    void    Set##v(type b) { v = b; } ¥
private: ¥
    type    v;
 
using std::vector;
 
class DEFPASSWORDS;
class DESTDIRS;
class LHAZEXTHIST;
class LHAZHIST;
 
/*************************************************************************/
class LHAZREGS : public MYREGISTORY {
 
public:
    enum COMPNAME  { COMP_DEF, COMP_SET };
    enum COMPQUICK { COMP_QUICK = 1, COMP_POPUP, COMP_NAME };
    enum EXETYPE   { EXETYPE_OPEN, EXETYPE_EXPLORE, EXETYPE_APP };
    enum EXTQUICK  { EXT_POPUP = 1, EXT_HERE, EXT_DIR, EXT_VIEW };
    enum KOBETU    { K_FOLDER, K_FILE };
    enum VIEWTOTAL { VT_GIGA, VT_MEGA, VT_KILO, VT_BYTE };
    enum { LHAZMAXVIEWER = 5 };
    //
    struct XYS {
        XYS(void);
        int x;
        int y;
    };
    //
    static const TCHAR      LHAZGDCREDENTIALSREG[];
    //
    LHAZREGS(const WSTR& name);
    ‾LHAZREGS(void);
    //
    void                    DeleteDropBoxToken(void);
    void                    DeleteGDEmail(void);
    void                    DeleteGDPassword(void);
    bool                    GetKobetuComp(void) const   { return KobetuComp;    }
    void                    SetKobetuComp(bool b, bool w = false);
    bool                    GetNoComp(void) const       { return NoComp;        }
    void                    SetNoComp(bool b, bool w = false);
    bool                    IsEncZip(void) const {
        return (CompType == ARCHIVE::ENCZIP);
    }
    bool                    IsCab(void) const {
        return (CompType == ARCHIVE::CAB || CompType == ARCHIVE::SFXCAB);
    }
    WSTR                    GetDownloadsDir(void) const;
    const WSTR&             GetViewers(int idx) const { return Viewers[idx]; }
    void                    SetViewers(int idx, const WSTR& v) { Viewers[idx] = v; }
    vector<WSTR>&           GetArcNames(void) { return ArcNames; }
    const TCHAR*            GetArcNameDef(void) const { return ArcNameDef; }
    vector<WSTR>&           GetCompExclude(void) { return CompExclude; }
    vector<WSTR>&           GetFilters(void) { return Filters; }
    vector<WSTR>&           GetGrepStrings(void) { return GrepStrings; }
    vector<WSTR>&           GetListFiles(void) { return ListFiles; }
    DEFPASSWORDS*           GetDefPasswords(void) const { return DefPasswords; }
    void                    SetDefPasswords(DEFPASSWORDS* d) { DefPasswords = d; }
    int                     GetPassCnt(void) const { return DefPasswords->Size(); }
    const TCHAR*            GetPasswords(int i) const { return DefPasswords->Get(i); }
    void                    SaveReg(bool popchange);
    vector<ARCHIVE::TYPE>&  GetCompPopups(void) { return CompPopups; }
    void                    SetShellView(bool);
    bool                    SetShellViewSub(const TCHAR* p, const TCHAR* sw);
    void                    ClearAll(void);
    LHAZSHELLEX&            GetShellEx(void) { return ShellEx; }
    DESTDIRS*               GetDestDirs(void) const { return DestDirs; }
    void                    SetDestDirs(DESTDIRS* d) { DestDirs = d; }
    LHAZEXTHIST*            GetExtHist(void) const { return ExtHist; }
    void                    SetExtHist(LHAZEXTHIST* h) { ExtHist = h; }
    void                    Save(void);
    // Bool values
    GS(bool,                m_close_after_extract);
    GS(bool,                m_close_after_compress);
    GS(bool,                m_popsave);
    GS(bool,                m_tzst_enabled);
    GS(bool,                m_usedropbox);
    GS(bool,                m_usegoogledrive);
    GS(bool,                m_useonedrive);
    GS(bool,                CompPopupKobetu);
    GS(bool,                CompPopupStore);
    GS(bool,                ConComp);
    GS(bool,                ConView);
    GS(bool,                DefPassDspCmp);
    GS(bool,                DefPassDspExt);
    GS(bool,                DelDigit);
    GS(bool,                DelDigitPop);
    GS(bool,                HasTreeView);
    GS(bool,                KanrenL);
    GS(bool,                KanrenZ);
    GS(bool,                KanrenC);
    GS(bool,                KanrenT);
    GS(bool,                KanrenA);
    GS(bool,                KanrenG);
    GS(bool,                KanrenB);
    GS(bool,                Kanren2);
    GS(bool,                KanrenR);
    GS(bool,                Kanren7);
    GS(bool,                KanrenTXZ);
    GS(bool,                KanrenXZ);
    GS(bool,                ListCsv);
    GS(bool,                ListOpen);
    GS(bool,                MakeDir);
    GS(bool,                MultiPrg);
    GS(bool,                NoMakeDir);
    GS(bool,                NoPopSave);
    GS(bool,                OpenCompDir);
    GS(bool,                OpenDir);
    GS(bool,                Passtry);
    GS(bool,                PassTwice);
    GS(bool,                RecExtHist);
    GS(bool,                RecHis);
    GS(bool,                SaveExtDlgPos);
    // Int values
    GS(int,                 ArcNameSel);
    GS(int,                 Bz2Size);
    GS(int,                 CabMethod);
    GS(COMPNAME,            CompName);
    GS(COMPQUICK,           CompQuick);
    GS(ARCHIVE::TYPE,       CompType);
    GS(int,                 DefPassCmp);
    GS(int,                 DefPassExt);
    GS(unsigned int,        DivSize);
    GS(int,                 EncryptMethod);
    GS(EXETYPE,             ExeType);
    GS(EXTQUICK,            ExtQuick);
    GS(int,                 Filter);
    GS(int,                 GzipLevel);
    GS(int,                 Iconic);
    GS(KOBETU,              KobetuMethod);
    GS(int,                 ListFormat);
    GS(int,                 ListViewer);
    GS(RECT,                LVRect);
    GS(int,                 LzhHeader);
    GS(int,                 LzhMethod);
    GS(int,                 OpenType);
    GS(int,                 PassEnterDef);
    GS(int,                 PrgStyle);
    GS(int,                 SfxUseDlg);
    GS(int,                 SzipLevel);
    GS(int,                 SzipMethod);
    GS(int,                 ViewByte);
    GS(VIEWTOTAL,           ViewTotal);
    GS(int,                 XZLevel);
    GS(int,                 ZipLevel);
    GS(int,                 ZstdLevel);
    // String values
    GS(WSTR,                CompDir);
    GS(WSTR,                ExecApp);
    GS(WSTR,                GDDownloadDir);
    GS(WSTR,                m_gd_email);
    GS(WSTR,                m_gd_password);
    GS(WSTR,                GrepViewer);
    GS(WSTR,                ListCountFile);
    GS(WSTR,                OpenFolder);
    GS(WSTR,                TempDir);
    GS(WSTR,                CurrentGoogleMail);
    GS(WSTR,                CurrentGoogleUser);
    GS(WSTR,                PresetPassword);
    // Structure values
    GS(RECT,                GrepRect);
    GS(XYS,                 XY);
 
private:
    static const TCHAR      ArcNameDef[];
    static const TCHAR      LHAZREG[];
    //
    bool                    KobetuComp;
    bool                    NoComp;
    WSTR                    Viewers[LHAZMAXVIEWER];
    vector<WSTR>            ArcNames;
    vector<WSTR>            CompExclude;
    DEFPASSWORDS*           DefPasswords;
    DESTDIRS*               DestDirs;
    LHAZEXTHIST*            ExtHist;
    vector<WSTR>            Filters;
    vector<WSTR>            GrepStrings;
    vector<WSTR>            ListFiles;
    vector<ARCHIVE::TYPE>   CompPopups;
    LHAZSHELLEX             ShellEx;
    //
    void                    CheckListFiles(void);
    void                    DeleteReg(const WSTR& d);
    bool                    GetAssoc(const TCHAR* ext, const TCHAR* aso, const TCHAR* viw, const TCHAR* old);
    void                    ReadCompPopups(void);
    void                    ResetReg(ARCHIVE::TYPE);
    void                    ResetRegSub(LPTSTR oldclass, LPCTSTR ext);
 
};
 
#undef GS
 
extern  LHAZREGS*   LhazRegs;