Example 900. Sample code to attach a frame to a window [SFZWindow and SFZTitleBevelFrame]

// define the class
SFMTYPEDEFCLASS(helloworld)
class helloworld : public SFYApplication {
  SFMSEALCOPY(helloworld)
public:
  static SFCInvokerPtr Factory(Void);
private:
  explicit helloworld(Void) static_throws; 
  virtual ~helloworld(Void);

  XANDLER_DECLARE_VOIDRENDER(OnRenderRequest)          // root's drawing handler
  XANDLER_DECLARE_BOOLEVENT(OnKey)                     // root's key handler
  XANDLER_DECLARE_VOIDRENDER(OnRenderRequestSFZWindow) // window's drawing handler
  XANDLER_DECLARE_BOOLEVENT(OnKeySFZWindow)            // window's key handler
};


// constructor
helloworld::helloworld(Void) static_throws
{

  // ..... (omitted) .....

  SFCError              error(SFERR_NO_ERROR);
  SFZTitleBevelFrameSmp frame;  // smart pointer to SFZTitleBevelFrame
  SFZWindowSmp          window; // smart pointer to SFZWindow

  // create the frame
  if ((frame = SFZTitleBevelFrame::NewInstance(&error)) != null) {

    // set the frame title
    frame->SetText("Title for SFZWindow");

    // In general, the frame's state is set to "visible" + "active" + "enable" + "focus".
    frame->SetState(true, true, true, true);

    // create the window
    if ((window = SFZWindow::NewInstance(&error)) != null) {

      // register the drawing handler into the window: draw "Hello World!"
      error = window->RegisterHandler(
                SFXEventRange(SFEVT_RESPONDER_RENDER, SFEVT_RESPONDER_RENDER, SFP16_RENDER_REQUEST, SFP16_RENDER_REQUEST),
                XANDLER_INTERNAL(OnRenderRequestSFZWindow)
      );
      if (error == SFERR_NO_ERROR) {

        // register the key handler into the window: close the window when the SELECT key is pressed
        error = window->RegisterHandler(
                  SFXEventRange(SFEVT_KEY, SFEVT_KEY, SFP16_BEGIN, SFP16_END),
                  XANDLER_INTERNAL(OnKeySFZWindow)
        );
        if (error == SFERR_NO_ERROR) { 

          // set the window's parent responder to the application class(root)
          error = window->SetParent(GetThis());
          if (error == SFERR_NO_ERROR) {

            // attach the frame to the window
            error = window->SetFrame(frame);
            if (error == SFERR_NO_ERROR) {


              // Set the frame's real region to the region obtained by deflating the screen device region by (30, 30)
              // * Automatically, the window's real region will be set to the region obtained by deflating it by the frame margin.
              frame->SetRealBound(GetLocalBound().Deflate(30, 30));

              // set windows's state to "visible" + "active" + "enable" + "focus" together
              window->SetState(true, true, true, true);

              // move the window foremost
              // * automatically, the frame will be moved foremost together
              window->ToFront();
            }
          }
        }
      }
    }
  }
  static_throw(error);
}


// implement SFZWindow's drawing handler
#define TROPICALBLUE_COLOR (SFXRGBColor(0xCE, 0xD8, 0xF8, 0x00))
#define COLOR_BLACK        (SFXRGBColor(0x00, 0x00, 0x00, 0x00))
XANDLER_IMPLEMENT_VOIDRENDER(helloworld, OnRenderRequestSFZWindow, invoker, reason, graphics)
{
  unused(invoker);
  unused(reason);

  // fill the window's local region in tropical bule color
  graphics->FillRectangle(GetLocalBound(), TROPICALBLUE_COLOR);

  // draw "Hello World!" in black color in the center of the window
  graphics->DrawSingleText("Hello World!", invoker->GetLocalBound(), COLOR_BLACK);

  return;
}

// implement SFZWindow's key handler
XANDLER_IMPLEMENT_BOOLEVENT(helloworld, OnKeySFZWindow, invoker, event)
{
  Bool result(false);
  unused(invoker);

  switch (event.GetP16()) {

    case AVK_SELECT:  // when the SELECT key is pressed

         // close the window only
         // * automatically, the frame will be detached from the window and become invisible
         invoker->Terminate();

         result = true;  // return "true" since the event has been handled

         break;
  }

  return result;
}

Example 901. Declaration

SFMTYPEDEFRESPONDER(USRWindow)
class USRWindow: public SFZWindow {
    SFMSEALRESPONDER(USRWindow)
    SFMRESPONDERINSTANTIATEFOUR(USRWindow, SFZWindow, SFYContainer, SFYWidget, SFYResponder)
public:

    // define responder type
    // small alphabet and symbol must not be used since they are reserved for SophiaFramework UNIVERSE
    enum CodeEnum {
        CODE_TYPE = four_char_code('U', 'W', 'N', 'D')
    };
    SFMTYPEDEFTYPE(CodeEnum)

public:
    static USRWindowSmp NewInstance(SFCErrorPtr exception = null);
protected:
    explicit USRWindow(Void) static_throws;
    virtual ~USRWindow(Void);

    // virtual functions defined in the parent class and recommended to be implemented
    virtual Void HandleBoundRequest(SFXRectanglePtr rectangle) const;
    virtual Void HandleBoundOptimize(SFXRectanglePtr rectangle) const;
    virtual Void HandleBoundReal(Void);
    virtual Void HandleBoundVirtual(Void);
    virtual Void HandleRenderRequest(SFXGraphicsPtr graphics) const;
};

Example 902. Implementation

// constructor
USRWindow::USRWindow(Void) static_throws
{
    if (static_try()) {

        // set the responder type
 SetType(CODE_TYPE);

        // here describe the initialization
    }
}

// destructor
USRWindow::~USRWindow(Void)
{
    // here describe the finalization
}

// function to create instance managed by smart pointer
USRWindowSmp USRWindow::NewInstance(SFCErrorPtr exception)
{
    return static_pointer_cast<USRWindow>(Factory(::new USRWindow, exception));
}

Void USRWindow::HandleBoundRequest(SFXRectanglePtr rectangle) const
{
    // calculate the suitable window size
    // set the rectangle argument to the calculated suitable window size
    // for the rectangle argument, it is recommended to set only its size and not to change its origin in this function
    return;
}

Void USRWindow::HandleBoundOptimize(SFXRectanglePtr rectangle) const
{
    // calculate the suitable window size within rectangular region given by the rectangle argument
    // set the rectangle argument to the calculated suitable window size
    // for the rectangle argument, it is recommended to set only its size and not to change its origin in this function
    return;
}

Void USRWindow::HandleBoundReal(Void)
{
    // here describe the size recalculation if necessary when the real region is changed
    return;
}

Void USRWindow::HandleBoundVirtual(Void)
{
    // here describe the size recalculation if necessary when the virtual region is changed
    return;
}

Void USRWindow::HandleRenderRequest(SFXGraphicsPtr graphics) const
{
    // draw window
    return;
}