/*
 * MdiFrame.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL++2000
#pragma once

#include <sol\Application.h>
#include <sol\Composite.h>
#include <sol\Menubar.h>
#include <sol\MdiClient.h>
#include <sol\accelerator.h>
#include <sol\Toolbar.h>
#include <sol\Statusbar.h>

//2009/10/11
#include <sol/AppEntry.h>


namespace SOL {

class MdiFrame :public Composite {
private:
    MenuBar*    menuBar;
    int            subMenuId;
    MdiClient*    mdiClient;
    Application& application;
    Accelerator* accel;
    ToolBar*     toolBar;
    StatusBar*     statusBar;

    static const long STYLE = (WS_OVERLAPPEDWINDOW|WS_CLIPCHILDREN);
  
protected:
    long size(Event& event)
    {
        int toolBarHeight = 0;
        RECT r;
        if(toolBar) {
            toolBar -> send(event.getMessage(), 
            event.getWParam(), event.getLParam());
            toolBar -> getClientRect(&r);
            toolBarHeight = r.bottom - r.top;
        }
        int statusBarHeight = 0;
        if(statusBar) {
            statusBar -> send(event.getMessage(),
                event.getWParam(), event.getLParam());
            statusBar -> getClientRect(&r);
            statusBarHeight = r.bottom - r.top;
        }
        if(mdiClient) {
            getClientRect(&r);
            mdiClient -> reshape(0, toolBarHeight, 
                r.right, r.bottom - toolBarHeight - statusBarHeight);          
        }
        return NULL;
    }

protected:
    long    command(Event& event)
    {
        if(event.isMenuSelected() == TRUE ||
         event.fromAccelerator() == TRUE) {
            int key = event.getMenuId();
            callCallback(XmNmenuCallback, key, NULL, event);
            return defaultProc(event);
        }
        else {
            HWND child = event.getChild();
            View* view = (View*)Application::lookup(child);
            const TCHAR* name = XmNactivateCallback;
            if(view) {
                name = view -> getCallbackName(event);
            }
            callCallback(name, (Key)child, NULL, event);
        }

        HWND child = mdiClient->getActiveWindow();

        if(::IsWindow(child)) {
            return ::SendMessage(child, WM_COMMAND,
                event.getWParam(),
                event.getLParam());
        }
        return defaultProc(event);
    }

protected:
    void    cascade(Action& action) {
            mdiClient -> cascade();
    }

protected:
    void    iconArrange(Action& action) {
            mdiClient -> iconArrange();
    }

protected:
    void    tile(Action& action) {
            mdiClient -> tile();
    }

protected:
    virtual long defaultProc(Event& event)
    {
        HWND hclient = NULL;
        if(mdiClient) {
            hclient = mdiClient->getWindow();
        }

        if(::IsWindow(hclient)) {
            return ::DefFrameProc(getWindow(), hclient,
                event.getMessage(), 
                event.getWParam(),
                event.getLParam());
        }
        else { 
            return View::defaultProc(event);
        }
    }

public:
    /**
     * Constructor
     */
    MdiFrame(Application& applet, const TCHAR* caption, Args& args)
    :Composite(NULL, caption, 
        args.set(XmNx,      (ulong)CW_USEDEFAULT)
            .set(XmNy,      (ulong)CW_USEDEFAULT)
            .set(XmNwidth,  (ulong)CW_USEDEFAULT)
            .set(XmNheight, (ulong)CW_USEDEFAULT)
            .set(XmNstyle,  (ulong)STYLE)
            .set(XmNclassName, _T("MdiFrame"))),

            application(applet),
            mdiClient(NULL),
            menuBar(NULL),
            toolBar(NULL),
            statusBar(NULL),
            accel(NULL)
    {
        applet.setToplevel(this);

        ulong val;

        const TCHAR* menuName = caption;
        if(args.get(XmNmenuName, &val)) {
            menuName = (TCHAR*)val;
        }
        menuBar   = new MenuBar(this, menuName);

        const TCHAR* accelName = caption;
        if (args.get(XmNacceleratorName, &val)) {
            accelName = (TCHAR*)val;
        }
        accel =  new Accelerator(accelName);
    
        int firstChildId = 1000;
        subMenuId = 0;

        if (args.get(XmNchildId, &val))    {
            firstChildId = (int)val;
        }
        if (args.get(XmNmenuId, &val)) {
            subMenuId = (int)val;
        }

        CLIENTCREATESTRUCT cs;
        memset(&cs, 0, sizeof(cs));

        cs.idFirstChild = firstChildId;
        cs.hWindowMenu  = ::GetSubMenu(menuBar->get(), subMenuId);

        DWORD style = WS_VSCROLL|WS_HSCROLL;
        style |= args.get(XmNmdiClientStyle);
        Args ar;
        ar.set(XmNparam, &cs);
        ar.set(XmNstyle, style);
        mdiClient   = new MdiClient(this, _T("mdi"), ar);
    }

public:
    ~MdiFrame()
    {
        delete menuBar;
        delete accel;
        delete mdiClient;
    }

public:
    void exit(Action& action)
    {
        send(WM_CLOSE, 0, 0L);
    }

    
public:
    MenuBar*    getMenuBar()   { return menuBar; }

public:
    int         getSubMenuId() { return subMenuId; }

public:
    MdiClient*  getClient() { return mdiClient; }


public:    
    void        setToolBar(ToolBar* bar) { toolBar = bar; }

public:
    void        setStatusBar(StatusBar* bar) { statusBar = bar; }

public:
    void realize()
    {
        int cmdShow = application.getShowCommand();
        show(cmdShow);
    }

public:
    BOOL translate(MSG* msg)
    {
        HACCEL haccel = accel->get();

        if(mdiClient &&  ::TranslateMDISysAccel(mdiClient->getWindow(), msg) ) {
            return TRUE;
        }

        if (haccel && ::TranslateAccelerator(getWindow(), haccel, msg)) {
            return TRUE;
        }
        else {
            return FALSE;
        }
    }


public:
    void setViewId(int vid)
    {
        setId(vid);
    }


public:
    virtual void childActivated(View* child)
    {
        // Do nothing here.
    }
};

}