Example 3.1. Boot loader and Factory function

//
//  helloworld.cpp
//

#include "helloworld.hpp"

// boot loader
SFCApplet::FactorySPP SFCApplet::Boot(AEECLSID id, SFXAnsiStringPtr license)
{
    // here describe the license code for this applet
    // this license code must correspond to the class ID of this applet
    *license = "heap://"
      "TIXDRQXNU5WHU8Y3Z9WOHWQR6Z3VPSDHDV5CR1S4XASPWLUHWAS7Z5Z2TGS3XMSAT3UPUQTLTARCYPSF"
      "UEJZ6ROSJWGUQSEYKR6V2U4VESMTQLHKZ6X7Y2VKXHWIX3XBU0Z7VHWHXIZBSGT5SPU3XLX0Z1Y4R3TC"
      "U6WGT9WHWIVNYHYCUCR9T3SMTEWPRNVAX1Y4VPW2YCY9YQV5R7Z9UIVHT6SDUPU2SIW6VCRCWBR2S4WQ"
      "UPYFWCYGT4VIT1WHXGYPTQSFYPWNV3ULRNWFW7RBRFVKUKS2YQSQYHW1TPUPXBZ6UEY2WOYKR7S3TAU4"
      "TQS6UHVFVEVLU3R5SDSKW7RPTNTPVQU2T4R8Z4VLUGEW3U98TLDR8/";

    return (id == AEECLSID_HELLOWORLD) ? (&helloworld::Factory) : (null);
}

// factory function
SFCInvokerPtr helloworld::Factory(Void)
{
    return ::new helloworld; // create the instance of the helloworld application class
}

Example 3.2. Define the helloworld application class

//
//      helloworld.hpp
//

#ifndef __HELLOWORLD_HPP
#define __HELLOWORLD_HPP

#include <SophiaFramework.hpp>
#include "helloworld.bid"

//
// define the helloworld class
//

SFMTYPEDEFCLASS(helloworld)  //  macro to generate the useful types
class helloworld : public SFYApplication {

    SFMSEALCOPY(helloworld)  //  macro to prohibit the developer from copying this instance
public:
    static SFCInvokerPtr Factory(Void);
private:
    explicit helloworld(Void) static_throws;
    virtual ~helloworld(Void);

    XANDLER_DECLARE_VOIDRENDER(OnRenderRequest) // declare the drawing handler
    XANDLER_DECLARE_BOOLEVENT(OnKey)            // declare the key handler 
};

#endif // __HELLOWORLD_HPP //

	Application name including the capital alphabets(BREW 4.0 or above)
	In general, the application class name such as "helloworld" will be the same with the applet name. From BREW 4.0, the capital alphabets cannot be used for the applet name. When you use the capital alphabet for the application class name such as "HelloWorld"or "USRApplication", you have to convert the capital alphabets into the small alphabets in the applet name.

	SFMTYPEDEFCLASS macro
	SFMTYPEDEFCLASS is the macro to generate user-defined types for the helloworld application class automatically.

	SFMSEALCOPY macro
	SFMSEALCOPY is the macro to prevent the application instance from being copied(i.e., the "helloworld" instance must not be copied in the above code).

	XANDLER_DECLARE_VOIDRENDER macro
	XANDLER_DECLARE_VOIDRENDER is the macro to declare the drawing handler.

	XANDLER_DECLARE_BOOLEVENT macro
	XANDLER_DECLARE_BOOLEVENT is the general purpose macro to declare the handler which returns the value of the Bool type.

Example 3.3. Implement the Constructor

// constructor
helloworld::helloworld(Void) static_throws
{
    if (static_try()) {
        static_throw(RegisterHandler(
            SFXEventRange(SFEVT_RESPONDER_RENDER, SFEVT_RESPONDER_RENDER,
            SFP16_RENDER_REQUEST, SFP16_RENDER_REQUEST),
            XANDLER_INTERNAL(OnRenderRequest)
        ));
    }
    if (static_try()) {
        static_throw(RegisterHandler(
            SFXEventRange(SFEVT_KEY, SFEVT_KEY, SFP16_BEGIN, SFP16_END),
            XANDLER_INTERNAL(OnKey)
        ));
    }
}

	SFYApplication::RegisterHandler function
	The SFYApplication::RegisterHandler function is used to register a handler into the application, which essentially equals registering it into the root (SFZRoot) which the application class contains by default.

Event

An event(SFXEvent) consists of an event type and two parameters(i.e., P16 parameter and P32 parameter). A handler to handle the corresponding event will be registered into the responder with the SFYApplication::RegisterHandler or the SFYResponder::RegisterHandler function. There are three kind of events as follows: BREW-defined event of BREW SDK Responder-defined event of SophiaFramework UNIVERSE User-defined event The event type name of the BREW-defined event has the SF prefix before the corresponding event type name of BREW SDK. For instance, the SFEVT_KEY event(key event[SFEVT_KEY]) is the BREW-defined event. On the other hand, the event type name for the responder-defined event has the SFEVT_RESPONDER_ prefix. For instance, the SFEVT_RESPONDER_RENDER event(drawing event) is the responder-defined event.

	Notation of the event
	In this manual, an event is described with one of the following three notations depending on the situation. event type name (event type name, P16 parameter) (event type name, P16 parameter, P32 parameter) [or SFXEvent(event type name, P16 parameter, P32 parameter)]

SFXEventRange

To register the handler into the responder, a range of events must be specified in the argument of RegisterHandler() with SFXEventRange. Events from (sEventType, sP16, *) to (eEventType, eP16, *) are specified as follows: // events from (sEventType, sP16) to (sEventType, sP16) SFXEventRange(sEventType, eEventType, sP16, eP16) Key events from (SFEVT_KEY, SFP16_BEGIN) to (SFEVT_KEY, SFP16_END) are specified as follows: // all key events SFXEventRange(SFEVT_KEY, SFEVT_KEY, SFP16_BEGIN, SFP16_END) When only the (EventType, P16) event should be handled, it is specified as below // (EventType, P16) event SFXEventRange(EventType, EventType, P16, P16) In case of the drawing event, it is specified as follows: // (SFEVT_RESPONDER_RENDER, SFP16_RENDER_REQUEST) drawing event SFXEventRange(SFEVT_RESPONDER_RENDER, SFEVT_RESPONDER_RENDER, SFP16_RENDER_REQUEST, SFP16_RENDER_REQUEST)

	XANDLER_INTERNAL macro
	The XANDLER_INTERNAL macro macro is used to get the handler referring to the internal instance(i.e., this instance), which is to be specified in the argument of the RegisterHandler function.

	Return statement
	In general, the return statement should not be described in the constructor nor in the destructor with C++. The following bug is confirmed when GCC is used. If the return statement is described in the constructor or destructor, the compiler will freeze when a particular inheritance relation exists.

Example 3.4. Implement the destructor

// destructor
helloworld::~helloworld(Void)
{
}

Example 3.7. Define and Access the Global Variable

//
// define the helloworld class
//
SFMTYPEDEFCLASS(helloworld)  //  macro to generate the useful types
class helloworld : public SFYApplication
{
    SFMSEALCOPY(helloworld)  //  macro to prohibit the developer from copying this instance

public:

    static SFCInvokerPtr Factory(Void);

private:

    explicit helloworld(Void) static_throws;
    virtual ~helloworld(Void);

    // define the "global_something_val" global variable 
    SInt32 global_something_val;

public:

    // declare GetGlobalSomethingVal() to access the "global_something_val" global variable 
    SInt32 GetGlobalSomethingVal() const;
};

// implement GetGlobalSomethingVal() to access the "global_something_val" global variable 
SInt32 helloworld::GetGlobalSomethingVal(Void) const
{
    return global_something_val;
}

// get the value of the "global_something_val" global variable via GetGlobalSomethingVal()
static_cast<helloworldPtr>(SFYApplication::GetInstance())->GetGlobalSomethingVal();

Example 3.8. Handle the error in the constructor

 // handle the error which occurs in MyResponder constructor outside the MyResponder constructor
myResponder = MyResponder::NewInstance()
switch( myResponder->static_catch() ){

        // handle the error depending on the value

       ...

};