Inheritance diagram

Collaboration diagram

Description

How to use

SFZDialog is the general purpose container and the abstract base class for all dialogs with functions to scroll the virtual region larger than the real region, move the focus, automatically close itself after specified period elapses, and handle some key events by default.

For instance, dialogs such as SFZMessageDialog or SFZQuestionDialog is implemented by inheriting from SFZDialog.

	Note
	Dialog is the responder designed to be placed in the root[SFZRoot].

Though a dialog can be used as a container to place controls like a window, it is used for user to select a result from screen displayed temporarily.

The concrete dialog is the part class which can be used as it is in the applet development. On the other hand, the abstract dialog is the base class to define and implement a user-defined dialog.

IMPORTANT

In the concrete dialog, the SFYResponder::SetParent, SFYResponder::SetState, and SFYResponder::SetRealBound functions must be always called. Other functions are optionally called. * When a frame is attached to a dialog with the SFYResponder::SetFrame function, calling the SFYResponder::SetRealBound function of the dialog can be omitted by setting the real region of the frame with the SFYResponder::SetRealBound function since that of the dialog will be internally set to the region obtained by deflating it by the frame margin.

	Default background color
	In SFZDialog, the default background color set with the SFYWidget::SetBackgroundColor function is the gray color[SFXRGBColor(0xEE, 0xEE, 0xEE,0x00)].

General purpose dialog to place controls, containers etc. [SFZDialog]

SFZDialog is the general purpose dialog to place various controls or containers.

When controls and/or containers are placed, the focus can be moved using the scroll key set with the SFYContainer::SetScrollDownKey / SFYContainer::SetScrollUpKey / SFYContainer::SetPageDownKey / SFYContainer::SetPageUpKey / SFYContainer::SetSnapDownKey / SFYContainer::SetSnapUpKey functions.

The virtual region larger than the real region can be scrolled up and down, and the focus can be moved among responders in the window. At this time, scrolling is performed in cooperation with moving the focus.

In the default implementation, the general purpose dialog[SFZDialog] will receive the following result events[SFEVT_RESPONDER_RESULT].

The developer can register handlers for these events. The default handler closes the dialog only.

The operation key of the dialog is set with the SFZDialog::SetOperateKey function. By default, the operation key of the dialog is set to the SELECT key.

The ESCAPE key is set with the SFZDialog::SetEscapeKey function. By default, the ESCAPE key is set to the CLEAR key.

	Note
	The timer processing callback scheduled with the SFZDialog::ScheduleTimer function will be canceled automatically when the operation key of the dialog or the ESCAPE key is pressed.

Figure 322. Example: The bahaviour of SFZDialog

Sample code of the dialog

The sample code of the dialog(SFZDialog) is as follows:

SFMTYPEDEFCLASS(USRApplication)
class USRApplication: public SFYApplication {
    SFMSEALCOPY(USRApplication)
private:
    static SFCInvokerPtr Factory(Void);
private:
  explicit USRApplication(Void) static_throws; 
  virtual ~USRApplication(Void);

  // result handler
  XANDLER_DECLARE_VOIDRESULT(OnResult)
};

USRApplication::USRApplication(Void) static_throws
{
  // ... (omitted) ...

  SFZDialogSmp dialog;  // smart pointer of SFZDialog
  SFCError error(SFERR_NO_ERROR);

  // create the dialog
  if ((dialog = SFZDialog::NewInstance(&error)) != null) {

    // set the dialog's parent responder to USRApplication
    error = dialog->SetParent(GetThis());
    if (error == SFERR_NO_ERROR) {

      // register the result handler into the dialog
      error = dialog->RegisterHandler(
        SFXEventRange(SFEVT_RESPONDER_RESULT, SFEVT_RESPONDER_RESULT, SFP16_BEGIN, SFP16_END),
        XANDLER_INTERNAL(OnResult)
      );
      if (error == SFERR_NO_ERROR) {

        // Calculate the suitable dialog region within the hint region obtained by deflating the screen device region by (20, 20), 
        // which will be aligned at the center and the middle of the hint region.
        // Set the dialog's real region to it.
        dialog->SetRealBound(dialog->GetSuitableBound(GetLocalBound().Deflate(20, 20), SFYResponder::HORIZONTAL_CENTER, SFYResponder::VERTICAL_MIDDLE));

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

        // move the dialog foremost
        dialog->ToFront();
      }
    }
  }
  static_throw(error);
}

// result handler
XANDLER_IMPLEMENT_VOIDRESULT(USRApplication, OnResult, invoker, reason, result)
{
  // the dialog will be passed via the invoker argument
  // the P16 value of the result event will be passed via the reason argument
  // "0" will be passed via the result argument

    switch (reason) {

        case SFP16_RESULT_OK:

            // when the operation key is pressed

            ...

            break;

        case SFP16_RESULT_ESCAPE:

            // when the ESCAPE key is pressed or the time scheduled with ScheduleTimer() elapses

            ...

            break;
    }

    // close the dialog
    invoker->Terminate();

    return;
}

Figure 323. Execution result of the above code [SFZDialog]

Sample code of this dialog with a title and a border

A frame with a border and/or a title can be attached to this dialog

The below is the code to attach a bevel frame with a title[SFZTitleBevelFrame] to this dialog.

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

  XANDLER_DECLARE_VOIDRESULT(OnResult)        // dialog's result handler
};


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

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

  SFCError error(SFERR_NO_ERROR);
  SFZTitleBevelFrameSmp frame;  // smart pointer to SFZTitleBevelFrame
  SFZDialogSmp          dialog; // smart pointer to SFZDialog
 
  // create the frame
  if ((frame = SFZTitleBevelFrame::NewInstance(&error)) != null) {

    // set the frame title
    frame->SetText("SFZMessageDialog");

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

    // create the dialog
    if ((dialog = SFZDialog::NewInstance(&error)) != null) {

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

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

          // register the result handler into the dialog
          error = dialog->RegisterHandler(
               SFXEventRange(SFEVT_RESPONDER_RESULT, SFEVT_RESPONDER_RESULT, SFP16_BEGIN, SFP16_END),
                      XANDLER_INTERNAL(OnResult)
          );
          if (error == SFERR_NO_ERROR) {

            // Calculate the suitable dialog region within the hint region obtained by deflating the screen device region by (20, 20) margin, 
            // which will be aligned at the center and the middle of the hint region.
            // Set the dialog's real region to it.
            // * Automatically, the frame's real region will be set to the region obtained by inflating it by the frame margin.
            dialog->SetRealBound(dialog->GetSuitableBound(GetLocalBound().Deflate(20, 20), SFYResponder::HORIZONTAL_CENTER, SFYResponder::VERTICAL_MIDDLE));

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

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


// result handler
XANDLER_IMPLEMENT_VOIDRESULT(USRApplication, OnResult, invoker, reason, result)
{
  // the dialog will be passed via the invoker argument
  // the P16 value of the result event will be passed via the reason argument
  // "0" will be passed via the result argument

  switch (reason) {
    case SFP16_RESULT_OK:

      // when the operation key is pressed

      ...

      break;

    case SFP16_RESULT_ESCAPE:

      // when the ESCAPE key is pressed or the time scheduled with ScheduleTimer() elapses

      ...

      break;
  }

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

  return;
}

Figure 324. Execution result of the above code [SFZDialog and SFZTitleBevelFrame]

General purpose dialog as abstract class which represents a dialog [SFZDialog]

SFZDialog is the base class, which the user-defined dialog inherits from to implement itself.

For instance, the dialog such as SFZMessageDialog or SFZQuestionDialog is implemented by inheriting from the SFZDialog class.

In SFZDialog, there are functions to close itself after the specified period, to scroll up and down the virtual region larger than the real region in cooperation with the move-focus function, manage the dialog operation, ESCAPE key, and scroll keys, and implement some default handlers(virtual functions).

When controls and/or containers are placed in the dialog, the focus can be moved among the child responders of the dialog using the scroll key set with the SFYContainer::SetScrollDownKey and SFYContainer::SetScrollUpKey functions.

The virtual region larger than the real region can be scrolled up and down, and the focus can be moved among the child responders of the dialog . At this time, scrolling is performed in cooperation with moving the focus.

In the default implementation, the abstract dialog[SFZDialog] will receive the following result events[SFEVT_RESPONDER_RESULT].

The developer can register handlers for these events. The default handler closes the dialog only.

The operation key of the dialog is set with the SFZDialog::SetOperateKey function. By default, the operation key of the dialog is set to the SELECT key.

The ESCAPE key is set with the SFZDialog::SetEscapeKey function. By default, the ESCAPE key is set to the CLEAR key.

	Note
	The timer processing callback scheduled with the SFZDialog::ScheduleTimer function will be canceled automatically when the operation key of the dialog or the ESCAPE key is pressed.

Events and their handlers

The handlers(virtual functions) below for the key event[SFEVT_KEY] on the dialog operation, ESCAPE, and scroll keys, the region event[SFEVT_RESPONDER_BOUND], and the drawing event[SFEVT_RESPONDER_RENDER] are registered.

In a dialog inheriting from SFZDialog, the following handlers(virtual functions) will be booted up first when the event is received.

* "-" in the default behaviour column represents that nothing is implemented.

NOTE

*1. Execute SFYResponder::InvokeForward(SFXEvent(SFEVT_RESPONDER_RESULT, SFP16_RESULT_OK, 0), false). And cancel the timer processing callback scheduled with the SFZDialog::ScheduleTimer function, if any. *2. Execute SFYResponder::InvokeForward(SFXEvent(SFEVT_RESPONDER_RESULT, SFP16_RESULT_ESCAPE, 0), false). And cancel the timer processing callback scheduled with the SFZDialog::ScheduleTimer function, if any. *3. Execute the SFYContainer::ScrollUp function. *4. Execute the SFYContainer::ScrollDown function. *5. Execute the SFYContainer::PageUp function. *6. Execute the SFYContainer::PageDown function. *7. Execute the SFYContainer::SnapUp function. *8. Execute the SFYContainer::SnapDown function.

The minimum code necessary to make a user-defined dialog is as follows:

SFMTYPEDEFRESPONDER(USRDialog)
class USRDialog: public SFZDialog {
    SFMSEALRESPONDER(USRDialog)
    SFMRESPONDERINSTANTIATEFIVE(USRDialog, SFZDialog, 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', 'D', 'L', 'G')
    };
    SFMTYPEDEFTYPE(CodeEnum)

public:
    static USRDialogSmp NewInstance(SFCErrorPtr exception = null);
protected:
    explicit USRDialog(Void) static_throws;
    virtual ~USRDialog(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;
};

USRDialog::USRDialog(Void) static_throws
{
    if (static_try()) {

        // set the responder type
 SetType(CODE_TYPE);

        // here describe the initialization
    }
}

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

USRDialogSmp USRDialog::NewInstance(SFCErrorPtr exception)
{
    return static_pointer_cast<USRDialog>(Factory(::new USRDialog, exception));
}

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

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

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

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

Void USRDialog::HandleRenderRequest(SFXGraphicsPtr graphics) const
{
    // draw the dialog
    return;
}

Reference

Dialog(Basic) | SFZMessageDialog | SFZQuestionDialog | SFZWindow | SFYContainer | SFYWidget | SFXRGBColor | SFYWidget::SetBackgroundColor | Frame | SFYResponder::ToFront | SFYResponder::Terminate | Virtual Region | Real Region | Local Region | SFZDialog::SetOperateKey | SFZDialog::SetEscapeKey | SFYContainer::SetScrollDownKey | SFYContainer::SetScrollUpKey | SFYContainer::SetPageDownKey | SFYContainer::SetPageUpKey | SFYContainer::SetSnapDownKey | SFYContainer::SetSnapUpKey | Key Event[SFEVT_KEY] | Region Event[SFEVT_RESPONDER_BOUND] | Drawing Event[SFEVT_RESPONDER_RENDER]

Member

Description

This constructor performs the initializations as follows:

	Note
	In a responder inheriting from SFZDialog, the corresponding handler will be called when one of the above events occurs.

Internal Implementation

Internal implementation of this constructor is as follows:

/*protected */SFZDialog::SFZDialog(Void) static_throws : _state(STATE_IDLE)
{
    static SFXRGBColor::AtomRecConst            rgb[] = {
        {{{0x00, 0xEE, 0xEE, 0xEE}}}
    };
    static SFXEventRange::AtomRecConst          trange[] = {
        {     SFEVT_APP_RESUME,       SFEVT_APP_RESUME,           SFP16_BEGIN,            SFP16_END},
        {     SFEVT_APP_SUSPEND,      SFEVT_APP_SUSPEND,          SFP16_BEGIN,            SFP16_END},
        #if TARGET_VERSION_GE(3, 0, 0)
        {       SFEVT_KEY_PRESS,      SFEVT_KEY_RELEASE,          SFP16_BEGIN,            SFP16_END},
        #else
        {       SFEVT_KEY_PRESS,         SFEVT_KEY_HELD,          SFP16_BEGIN,            SFP16_END},
        #endif
        {             SFEVT_KEY,              SFEVT_KEY,          SFP16_BEGIN,            SFP16_END},
        {             SFEVT_KEY,              SFEVT_KEY,          SFP16_BEGIN,            SFP16_END},
        { SFEVT_RESPONDER_STATE,  SFEVT_RESPONDER_STATE,    SFP16_STATE_VALID,    SFP16_STATE_VALID},
        {SFEVT_RESPONDER_RESULT, SFEVT_RESPONDER_RESULT,          SFP16_BEGIN,            SFP16_END}
    };
    SFYHandler::RuleRec                         trule[lengthof(trange)];

    if (static_try()) {
        SetType(CODE_TYPE);
        trule[0].spp = XANDLER_FUNCTION(OnAppResume);
        trule[0].reference = this;
        trule[1].spp = XANDLER_FUNCTION(OnAppSuspend);
        trule[1].reference = this;
        trule[2].spp = XANDLER_FUNCTION(OnShield);
        trule[2].reference = this;
        trule[3].spp = XANDLER_FUNCTION(OnKey);
        trule[3].reference = this;
        trule[4].spp = XANDLER_FUNCTION(OnRewind);
        trule[4].reference = this;
        trule[5].spp = XANDLER_FUNCTION(OnStateValid);
        trule[5].reference = this;
        trule[6].spp = XANDLER_FUNCTION(OnDialogResult);
        trule[6].reference = this;
        static_throw(RegisterHandler(atomic_cast(trange), trule, lengthof(trange)));
        if (static_try()) {
            SetBackgroundColor(rgb[0]);
            _timer.Set(XALLBACK_INTERNAL(OnTimer));
            _msec = 0;
            _key.operate = AVK_SELECT;
            _key.escape = AVK_CLR;
        }
    }
}// SFZDialog::SFZDialog //

/*private */XANDLER_IMPLEMENT_VOIDRESUME(SFZDialog, OnAppResume, invoker, environment)
{
    unused(invoker);
    unused(environment);
    if (_state == STATE_FIRE) {
        _timer.Schedule(_msec);
    }
    return;
}// XANDLER_IMPLEMENT_VOIDRESUME(SFZDialog, OnAppResume) //

/*private */XANDLER_IMPLEMENT_VOIDSUSPEND(SFZDialog, OnAppSuspend, invoker, reason, info)
{
    unused(invoker);
    unused(reason);
    unused(info);
    if (_state != STATE_IDLE) {
        _timer.Cancel();
    }
    return;
}// XANDLER_IMPLEMENT_VOIDSUSPEND(SFZDialog, OnAppSuspend) //

/*private */XANDLER_IMPLEMENT_BOOLEVENT(SFZDialog, OnShield, invoker, event)
{
    unused(invoker);
    return (event.GetP16() == _key.operate || event.GetP16() == _key.escape);
}// XANDLER_IMPLEMENT_BOOLEVENT(SFZDialog, OnShield) //

/*private */XANDLER_IMPLEMENT_BOOLEVENT(SFZDialog, OnKey, invoker, event)
{
    Bool                                        result(false);

    unused(invoker);
    if (event.GetP16() == _key.operate) {
        CancelTimer();
        HandleOperateKey();
        result = true;
    }
    else if (event.GetP16() == _key.escape) {
        CancelTimer();
        HandleEscapeKey();
        result = true;
    }
    return result;
}// XANDLER_IMPLEMENT_BOOLEVENT(SFZDialog, OnKey) //

/*private */XANDLER_IMPLEMENT_BOOLEVENT(SFZDialog, OnRewind, invoker, event)
{
    unused(invoker);
    unused(event);
    RewindTimer();
    return false;
}// XANDLER_IMPLEMENT_BOOLEVENT(SFZDialog, OnRewind) //

/*private */XANDLER_IMPLEMENT_VOIDSTATE(SFZDialog, OnStateValid, invoker, reason, state)
{
    unused(invoker);
    unused(reason);
    if (!state) {
        CancelTimer();
    }
    return;
}// XANDLER_IMPLEMENT_VOIDSTATE(SFZDialog, OnStateValid) //

/*private */XANDLER_IMPLEMENT_VOIDRESULT(SFZDialog, OnDialogResult, invoker, reason, result)
{
    unused(invoker);
    unused(reason);
    unused(result);
    Terminate();
    return;
}// XANDLER_IMPLEMENT_VOIDRESULT(SFZDialog, OnDialogResult) //

/*private */XALLBACK_IMPLEMENT_SFXTIMER(SFZDialog, OnTimer)
{
    SFYResponderSmp                             root;
    SFCError                                    error;

    error = SFERR_NO_ERROR;
    if ((root = GetRoot()) != null) {
        if (_state == STATE_FIRE) {
            _state = STATE_IDLE;
            _msec = 0;
            Invalidate();
            HandleEscapeKey();
            error = root->Render();
        }
    }
    else {
        error = SFERR_FAILED;
    }
    if (error != SFERR_NO_ERROR) {
        // internal fault!
    }
    return;
}// XALLBACK_IMPLEMENT_SFXTIMER(SFZDialog, OnTimer) //

Reference

SFYResponder::SetType | SFZDialog::CodeEnum | SFYWidget::SetBackgroundColor | SFZDialog::SetOperateKey | SFZDialog::SetEscapeKey | SFZDialog::HandleOperateKey | SFZDialog::HandleEscapeKey | SFZDialog::ScheduleTimer | SFXEvent | SFXRGBColor | Type | Event | Key Event[SFEVT_KEY] | Result Event[SFEVT_RESPONDER_RESULT] | Applet-Suspend Event[SFEVT_APP_SUSPEND] | Applet-Resume Event[SFEVT_APP_RESUME]

Description

This destructor cancels the timer processing.

Reference

SFZDialog::CancelTimer

Description

If this function is called, the dialog will not be closed after the time set with the SFZDialog::ScheduleTimer function elapses.

Reference

SFZDialog::ScheduleTimer | SFZDialog::RewindTimer

Description

This function gets the ESCAPE key of this dialog set with the SFZDialog::SetEscapeKey function.

Reference

SFZDialog::SetEscapeKey

Description

This function gets the operation key of this dialog set with the SFZDialog::SetOperateKey function.

Reference

SFZDialog::SetOperateKey

Description

This function will be called when the SFEVT_KEY event(key event[SFEVT_KEY]) of the ESCAPE key set with the SFZDialog::SetEscapeKey function is received or the time scheduled by the SFZDialog::ScheduleTimer elapses without the operation nor ESCAPE key press.

In case you want to perform your own processing, override this function.

The default implementation is to send the result event [SFXEvent(SFEVT_RESPONDER_RESULT, SFP16_RESULT_ESCAPE, 0)], which will boot up the result handler.

	Note
	Implementation of the default result handler is only to close this dialog.

Internal Implementation

Internal implementation of the SFZDialog::HandleEscapeKey function is as follows:

/*protected virtual */Void SFZDialog::HandleEscapeKey(Void)
{
    InvokeForward(SFXEvent(SFEVT_RESPONDER_RESULT, SFP16_RESULT_ESCAPE, 0), false);
    return;
}// SFZDialog::HandleEscapeKey //

Reference

SFZDialog::SetEscapeKey | SFZDialog::ScheduleTimer | SFZDialog::SetOperateKey | SFXEvent | Result Event[SFEVT_RESPONDER_RESULT] | Key Event[SFEVT_KEY]

Description

This function will be called when the SFEVT_KEY event(key event[SFEVT_KEY]) of the operaion key set with the SFZDialog::SetOperateKey function is received.

In case you want to perform your own processing, override this function.

The default implementation is to send the result event [SFXEvent(SFEVT_RESPONDER_RESULT, SFP16_RESULT_OK, 0)], which will boot up the result handler.

	Note
	Implementation of the default result handler is only to close this dialog.

Internal Implementation

Internal implementation of the SFZDialog::HandleOperateKey function is as follows:

/*protected virtual */Void SFZDialog::HandleOperateKey(Void)
{
    InvokeForward(SFXEvent(SFEVT_RESPONDER_RESULT, SFP16_RESULT_OK, 0), false);
    return;
}// SFZDialog::HandleOperateKey //

Reference

SFZDialog::SetOperateKey | SFXEvent | Result Event[SFEVT_RESPONDER_RESULT] | Key Event[SFEVT_KEY]

Argument

Return value

Description

This function creates a new instance of this responder class.

If succeeds, a not null pointer will be returned, and the "exception" argument is SFERR_NO_ERROR. If fails such as insufficient memory, a null pointer will be returned, and the "exception" argument holds the error value.

Example

The code to create a new instance of this responder class is as follows:

SFZDialogSmp _dialog;
SFCError error;

if ((_dialog = SFZDialog::NewInstance(&error)) != null) {

    ...
}

Description

This function resets the time until this dialog is automatically closed, which has been set with the SFZDialog::ScheduleTimer function.

Reference

SFZDialog::ScheduleTimer | SFZDialog::CancelTimer

Description

This function schedules the timer that the SFZDialog::HandleEscapeKey function will be called and the screen will be redrawn when neither the operation key nor the ESCAPE key has been pressed for the specified time. [milliseconds]

	Note
	In case of SFZMessageDialog or SFZQuestionDialog class, this function schedules the timer that the SFZDialog::HandleEscapeKey function will be called and the screen will be redrawn when neither the operation key, the ESCAPE key, nor any button has been pressed for the specified time.

Scheduling of timer processing callback

This function registers the timer processing callback that the SFZDialog::HandleEscapeKey function will be called and the screen will be redrawn when the specified time elapses. If the operation key set with the SFZDialog::SetOperateKey function or the ESCAPE key set with the SFZDialog::SetEscapeKey function is pressed before the specified time elapses, this timer processing callback will be canceled. If this timer processing callback is scheduled at the suspend time, it will be canceled and re-scheduled at the resume time automatically. When the valid state of this dialog becomes invalid, if this timer processing callback is scheduled, it will be canceled automatically.

Reference

SFZDialog::HandleEscapeKey | SFZDialog::CancelTimer | SFZDialog::RewindTimer | SFZDialog::SetOperateKey | SFZDialog::SetEscapeKey | State

Description

This function sets the ESCAPE key of this dialog to the specified value.

The SFZDialog::HandleEscapeKey function will be called when this key is pressed.

Default: AVK_CLR

Reference

SFZDialog::GetEscapeKey | SFZDialog::HandleEscapeKey

Description

This function sets the operation key of this dialog to the specified value.

The SFZDialog::HandleOperateKey function will be called when this key is pressed.

Default: AVK_SELECT

Reference

SFZDialog::GetOperateKey | SFZDialog::HandleOperateKey

Reference

SFYResponder::GetType | SFYResponder::SetType