source: dev/trunk/ab5.0/abdev/abdev/include/ProjectManager/WindowManager.h@ 629

#pragma once


namespace ActiveBasic{ namespace PM{


struct ImageReferenceType
{
    enum EnumType
    {
        File = 0,
        Resource,
    };
};

class ImageControlInfo
{
public:
    ImageReferenceType::EnumType type;
    std::string path;

    bool IsFile() const
    {
        return ( type == ImageReferenceType::File );
    }
    bool IsResource() const
    {
        return ( type == ImageReferenceType::Resource );
    }
};

class WindowInfoBase
{
public:
    const std::string &GetName() const
    {
        return name;
    }
    void SetName( const std::string &name )
    {
        this->name = name;
    }

    const std::string &GetCaption() const
    {
        return caption;
    }
    void SetCaption( const std::string &caption )
    {
        this->caption = caption;
    }

    DWORD GetStyle() const
    {
        return style;
    }
    void SetStyle( DWORD style )
    {
        this->style = style;
    }
    void AddStyle( DWORD style )
    {
        this->style |= style;
    }
    void AndStyle( DWORD style )
    {
        this->style &= style;
    }
    void DeleteStyle( DWORD style )
    {
        this->style &= ~style;
    }

    DWORD GetExStyle() const
    {
        return exstyle;
    }
    void SetExStyle( DWORD exstyle )
    {
        this->exstyle = exstyle;
    }
    void AddExStyle( DWORD exstyle )
    {
        this->exstyle |= exstyle;
    }

private:
    std::string name;
    std::string caption;
    DWORD style;
    DWORD exstyle;

public:
    POINT pos;
    SIZE size;
};

class ChildWindowInfo
    : public WindowInfoBase
{
public:
    int Control;

    ImageControlInfo image;
};
typedef std::vector<ChildWindowInfo *> ChildWindowInfos;

struct WindowType
{
    enum EnumType
    {
        Default = 0,
        ModalDlg = 1,
        ModelessDlg = 3,
    };
};

class WindowInfo
    : public WindowInfoBase
{
public:

    const std::string GetSourceFileName() const
    {
        return this->GetName() + ".ab";
    }

    const std::string GetSourceFileNameForOldVer( const std::string &baseDir ) const
    {
        if( Jenga::Common::Path( baseDir + this->GetName() + ".ab" ).IsExistFile() )
        {
            return this->GetName() + ".ab";
        }
        if( Jenga::Common::Path( baseDir + this->GetName() + ".abp" ).IsExistFile() )
        {
            return this->GetName() + ".abp";
        }
        if( Jenga::Common::Path( baseDir + this->GetName() + ".sbp" ).IsExistFile() )
        {
            return this->GetName() + ".sbp";
        }
        return this->GetName() + ".ab";
    }

    const std::string &GetClassName() const
    {
        return className;
    }
    void SetClassName( const std::string &className )
    {
        this->className = className;
    }

    const std::string GetHandleName() const
    {
        return "h" + this->GetName();
    }

    const std::string GetCallbackName() const
    {
        return this->GetName() + "Proc";
    }

    const std::string &GetMenuIdName() const
    {
        return menuIdName;
    }
    void SetMenuIdName( const std::string &menuIdName )
    {
        this->menuIdName = menuIdName;
    }
    bool HasMenu() const
    {
        return !menuIdName.empty();
    }

    int GetBackgroundColor() const
    {
        return backgroundColor;
    }
    void SetBackgroundColor( int backgroundColor )
    {
        this->backgroundColor = backgroundColor;
    }

    const std::string &GetIconResourceName() const
    {
        return iconResourceName;
    }
    void SetIconResourceName( const std::string &iconResourceName )
    {
        this->iconResourceName = iconResourceName;
    }
    bool HasIcon() const
    {
        return !iconResourceName.empty();
    }

    WindowType::EnumType GetType() const
    {
        return type;
    }
    void SetType( WindowType::EnumType type )
    {
        this->type = type;
    }
    bool IsDefaultWindow() const
    {
        return ( type == WindowType::Default );
    }
    bool IsModalDlg() const
    {
        return ( type == WindowType::ModalDlg );
    }
    bool IsModelessDlg() const
    {
        return ( type == WindowType::ModelessDlg );
    }

    //ウィンドウデータ
    LOGFONT LogFont;

    //子ウィンドウ管理
    ChildWindowInfos childWindowInfos;

    //ツリー項目
    HTREEITEM hTreeItem;

private:
    std::string className;
    std::string handleName;
    std::string menuIdName;
    int backgroundColor;
    std::string iconResourceName;
    WindowType::EnumType type;
};

class WindowInfos
    : public std::vector<WindowInfo *>
{
public:
    WindowInfos()
    {
    }
    ~WindowInfos()
    {
    }

    void Clear()
    {
        WindowInfos &windowInfos = *this;
        BOOST_FOREACH( WindowInfo *pWindowInfo, windowInfos )
        {
            delete pWindowInfo;
        }
        this->clear();
    }
    void Erase( int index )
    {
        WindowInfos::iterator it = this->begin();
        int i = 0;
        while( i < index )
        {
            i ++;
            it ++;
        }
        this->erase( it );
    }
};


}}