Humble Framework for SkyOS

---

HApp.h

Go to the documentation of this file.

/****************************************************************************
**
**  $Header: /SkyOS.root/HFramework/HApp.h 5     4/17/05 12:29p Lee Neuse $
**
****************************************************************************/
#ifndef HAPP_H
#   define  HAPP_H

#include "HLayout.h"
#include "HMenu.h"
#include "HWindow.h"

#ifdef  RESOURCE_FILE
#   include "HResMgr.h"
#endif

#define DECLARE_HUMBLE_APP(x)                                               \
    x   theApp;                                                             \
    int main(int argc, char * argv[])                                       \
        { return theApp.Main(argc, argv); }
//  end of DECLARE_APP macro
class HApp : public HWindow<HApp>
    {
    typedef HWindow<HApp>   base_class;
    static StringPtr        ClassName(void) { return "HApp"; }
/*  ----------------------------------------------------------------------
    VARIABLES
    ----------------------------------------------------------------------  */
protected:
    s_gi_msg            m_msgLast;      
    HLayout             m_layout;       
    HMenuBar            m_menuBar;      
#ifdef  RESOURCE_FILE
    HResMgr             m_resources;    
#endif
/*  ----------------------------------------------------------------------
    CTOR / DTOR
    ----------------------------------------------------------------------  */
public:
    HApp(void) : base_class()
        { GI_init(); }
        
    virtual ~HApp(void)
        { /* EMPTY DTOR */ }
/*  ----------------------------------------------------------------------
    MESSAGE HANDLERS
    ----------------------------------------------------------------------  */
protected:
    BEGIN_MSG_MAP("HApp")
        MAP_MSG( MSG_DESTROY,           onDestroy )

        CHAIN_MAP( base_class )
    END_MSG_MAP
    bool
    onDestroy(const s_gi_msg & msg, HRESULT & hr)
        {
        ASSERT(msg.type == MSG_DESTROY);

        if (!Quit())        // if user canceled the quit request
            hr = S_FAILED;  // then fail to prevent window from closing

        return true;
        }
/*  ----------------------------------------------------------------------
    METHODS
    ----------------------------------------------------------------------  */
protected:
    virtual ErrCode
    parseCmdLine(int32 argc, TextPtr argv[])
        { return NO_ERROR; }
public:
    ErrCode
    Destroy(void)
        { 
        ErrCode     ec = HError::NoError();
        s_window *  pwMe = static_cast<s_window *>(m_hMe);

        DEBUG_LOG("HApp::Destroy() => %p\n", pwMe);
                    
        if (GOOD_PTR(pwMe) &&
            GI_destroy_window(pwMe->parent) != S_OK)
            {
            ec = HError::Set(ERR_API_ERROR, __FILE__, __LINE__);
            }

        return ec;
        }
    ErrCode
    Draw(HRect & rDirty)
        { 
#if __DEBUG__
        if (rDirty.IsNotEmpty())
            {
            (void) m_gc.SetClipRect(rDirty);
            (void) m_gc.SetColors(Humble::kClrDebug, Humble::kClrDebug);
            (void) m_gc.FillRect(rDirty);
            }
#endif
        return m_layout.Draw(rDirty); 
        }
    virtual ErrCode
    Init(int32 argc, TextPtr argv[])
        {
        ErrCode     ec = NO_ERROR;
        //
        //  Switch to the application's working directory
        //
        Text    szDir[MAX_PATH+1] = { 0x00 };

        if (GetApplicationDirectory(szDir) == S_OK &&
            chdir(szDir) == 0)
            {
            DEBUG_LOG("HApp::Init() => app directory is \"%s\".\n", szDir);
            }
        else
            {
            DEBUG_LOG("HApp::Init() => no app directory?\n");
            }
        //
        //  Open the resource file
        //
#ifdef  RESOURCE_FILE
        HFilename   fnResFile = RESOURCE_FILE;

        if ((ec = m_resources.Open(fnResFile)) != NO_ERROR)
            return ec;
#endif
        //
        //  Parse the command line arguments
        //
        return parseCmdLine(argc, argv);
        }
    virtual void
    Kill(ErrCode ec)
        {
        DEBUG_LOG("HApp::Kill() => %ld\n", int32(ec));
        //
        //  Close the resource file
        //
#ifdef  RESOURCE_FILE
        (void) m_resources.Close();
#endif
        }
    int32
    Main(int32 argc, TextPtr argv[])
        {
        ErrCode     ec = HError::NoError();

        try 
            {
#if __DEBUG__
            HFilename   fnLog = argv[0];
            
            fnLog += ".debug-log.txt";
            if (HDebug::GetLog().Open(fnLog))
                {
                DEBUG_LOG("HApp::Main() => %s (HFramework %s) as of %s %s\n",
                            GetAppName(), HUMBLE_VER, __TIME__, __DATE__);
                }
#endif

            if ((ec = Init(argc, argv)) != NO_ERROR)
                throw HError::GetLastError();

            DEBUG_LOG("HApp::Main() => before main event loop.\n");
        
            for (;;)
                {
                if (GI_wait_message(&m_msgLast, NULL))
                    GI_dispatch_message( static_cast<s_window *>(m_msgLast.win), &m_msgLast);
                else if (m_msgLast.win == m_hMe)
                    {
                    //
                    //  Destroy the main application window so that window
                    //  messages caused by the destruction are sent and
                    //  processed before Kill() is invoked.
                    //
                    DEBUG_LOG("HApp::Main() => destroying application\n");
                    (void) Destroy();
                    
                    break;
                    }
                }

            DEBUG_LOG("HApp::Main() => after main event loop.\n");
            
            Kill(ec);
            }
        catch (const std::exception & e)
            { 
            //
            //  This is the high-level catch block, which is effectively the
            //  last gasp of a dying application.  There's no going back from
            //  here, so put up a nastygram and die a horrible death.  
            //
            DEBUG_LOG("### Panic: %s ###\n", e.what());

            (void) GI_messagebox(   NULL, WGF_MB_ICON_STOP|WGF_MB_OK, 
                                    const_cast<TextPtr>("PANIC!"),  
                                    const_cast<TextPtr>(e.what()));
            ec = ErrCode( HError::GetLastError() );
            ASSERT( ec != NO_ERROR );
            }
            
        return ec;
        }
    bool                
    Quit(bool bForced = false)
        {
        bool    bQuitting = false;

        if (bForced || 
            Humble::PopUpYesNo(GetAppName(), "Do you really want to exit?") == ID_YES)
            {
            GI_post_quit( m_hMe );
            bQuitting = true;
            }
            
        return bQuitting;
        }
    ErrCode     
    Show(void) const
        {
        ErrCode     ec = HError::NoError();
        
        DEBUG_LOG("HApp[%p]::Show()\n", this);

        if (IsValid())
            {
            if (GI_ShowApplicationWindow(m_hMe) != S_OK)
                ec = HError::Set(ERR_API_ERROR, __FILE__, __LINE__);
            }
        else
            ec = HError::Set(ERR_BAD_WINDOW, __FILE__, __LINE__);
        
        return ec;
        }   
//  layout widget.
    ErrCode     
    UpdateLayout(void)
        {
        ErrCode     ec = HError::NoError();
        HRect       rBounds;
        
        if (m_layout.IsValid() && GetBounds(rBounds))
            ec = m_layout.SetBounds(rBounds);
            
        return ec;  
        }

/*  ----------------------------------------------------------------------
    GETTERS & SETTERS
    ----------------------------------------------------------------------  */
    virtual StringPtr   GetAppName(void) const 
                            { return kStrEmpty; }
/*  ----------------------------------------------------------------------
    INLINES
    ----------------------------------------------------------------------  */
    inline ErrCode      ExtractResource(StringPtr pstrSrc, StringPtr pstrDst = NULL)
                            { 
#ifdef  RESOURCE_FILE
                            return m_resources.Extract(pstrSrc, pstrDst); 
#else
                            return HError::Set(ERR_NOT_IMPLEMENTED, __FILE__, __LINE__);
#endif
                            }
    };
#endif  // HAPP_H
/****************************************************************************
**
**  $History: HApp.h $
 * 
 * *****************  Version 5  *****************
 * User: Lee Neuse    Date: 4/17/05    Time: 12:29p
 * Updated in $/SkyOS.root/HFramework
 * Development snapshot 050417
 * 
 * *****************  Version 4  *****************
 * User: Neusel       Date: 2/04/05    Time: 10:45a
 * Updated in $/SkyOS.root/pig/Humble
 * 
 * *****************  Version 3  *****************
 * User: Neusel       Date: 12/08/04   Time: 5:06p
 * Updated in $/SkyOS.root/pig/Humble
 * 20041208
 * 
 * *****************  Version 2  *****************
 * User: Neusel       Date: 11/30/04   Time: 1:01p
 * Updated in $/SkyOS.root/pig/Humble
 * Released as HUMBLE_VER 20041130.
 * 
 * *****************  Version 1  *****************
 * User: Neusel       Date: 11/23/04   Time: 8:24a
 * Created in $/SkyOS.root/pig/Humble
**
**  -------------------------------------------------------------------------
**
**  End of HApp.h
**
****************************************************************************/

---