Inheritance diagram

Collaboration diagram

Description

How to use

SFYCheckboxControl is the abstract base class to define and implement a user-defined check box control.

In SFYCheckboxControl, functions to draw the check box, switch the checked state and manage the operation key are implemented by default. Several handlers with default behaviour are also implemented as virtual functions.

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

Events and their handlers

In SFYCheckboxControl, the following handlers(virtual functions) are registered for the key event[SFEVT_KEY] on the operation key, the region event[SFEVT_RESPONDER_BOUND], and the drawing event[SFEVT_RESPONDER_RENDER].

In a check box control inheriting from SFYCheckboxControl, the following handlers(virtual functions) are booted up first.

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

	NOTE
	*1. After switching the checked state, execute SFYResponder::InvokeForward(SFXEvent(SFEVT_RESPONDER_RESULT, SFP16_RESULT_OK, GetCurrentValue()), false). *2. Execute SFYResponder::SetVirtualBound(SFXRectangle(SFXGrid::ZeroInstance(), GetRealBound().GetSize())). In other words, equalize the virtual region with the real region.

The code to make a user-defined check box control is as follows:

SFMTYPEDEFRESPONDER(USRCheckboxControl)
class USRCheckboxControl: public SFYCheckboxControl {
    SFMSEALRESPONDER(USRCheckboxControl)
    SFMRESPONDERINSTANTIATEFIVE(USRCheckboxControl, SFYCheckboxControl, SFYButtonControl, SFYControl, 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', 'C', 'H', 'K')
    };
    SFMTYPEDEFTYPE(CodeEnum)

public:
    static USRCheckboxControlSmp NewInstance(SFCErrorPtr exception = null);
protected:
    explicit USRCheckboxControl(Void) static_throws;
    virtual ~USRCheckboxControl(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 HandleBoundVirtual(Void);
    virtual Void HandleRenderRequest(SFXGraphicsPtr graphics) const;
};

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

        // set the responder type
 SetType(CODE_TYPE);

        // since check box control's label doesn't have background, set transparent mode to "true"
 SetPropertyTransparent(true);

        // here describe the initialization
    }
}

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

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

Void USRCheckboxControl::HandleBoundRequest(SFXRectanglePtr rectangle) const
{
    // calculate the suitable check box control size
    // set the rectangle argument to the calculated suitable check box control size
    // for the rectangle argument, it is recommended to set only its size and not to change its origin in this function

    return;
}

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

    return;
}

Void USRCheckboxControl::HandleBoundVirtual(Void)
{
    // here describe the size recalculation if necessary when the virtual region is changed

    return;
}

Void USRCheckboxControl::HandleRenderRequest(SFXGraphicsPtr graphics) const
{
    SFXGrid grid;

    // in case of using function of SFYCheckboxControl class to draw check box and shadow [i.e., SFYCheckboxControl::DrawButton**()/DrawShadow**()/DrawCheckmark**()],
    // draw check box and shadow as below

    // _height variable is hight of check box 
    // _origin variable is origin of check box
    // * these variable is calculated with font hight used for label

    if (_height >= 28) {
        grid.Set(DrawShadow28(graphics, _origin));
        DrawButton27(graphics, grid);
        grid.Add(3, 3);
        DrawCheckmark21(graphics, grid);
    }
    else if (_height >= 14) {
        grid.Set(DrawShadow14(graphics, _origin));
        DrawButton13(graphics, grid);
        grid.Add(2, 2);
        DrawCheckmark09(graphics, grid);
    }

    // draw check box control's label

    return;
}

Reference

Abstract Class that Represents a Check Box Control[SFYCheckboxControl] | SFYControl | SFYButtonControl | SFZCheckboxControl | SFZRadiobuttonControl | Key Event[SFEVT_KEY] | Region Event[SFEVT_RESPONDER_BOUND] | Drawing Event[SFEVT_RESPONDER_RENDER]

Member

Description

This constructor performs the initializations as follows:

Reference

SFYResponder::SetType | SFYCheckboxControl::CodeEnum | SFYControl::SetMaximumValue | SFYCheckboxControl::SetCheckmarkColor | SFXRGBColor | Type

Description

This destructor does nothing.

Description

This function draws the 13x13 button of this check box control.

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

The default implementation is to draw the 13x13 pixel button of this check box control.

	Tip
	This function will be called in the SFZCheckboxControl::HandleRenderRequest function.

Internal Implementation

Internal implementation of the SFYCheckboxControl::DrawButton13 function is as follows:

/*protected */Void SFYCheckboxControl::DrawButton13(SFXGraphicsPtr graphics, SFXGridConstRef grid) const
{
    static SFXRectangle::AtomRecConst           rectangle[] = {
        {{ 0,  0}, {13, 13}},
        {{ 2,  2}, { 9,  9}}
    };

    RenderButton(graphics, grid, atomic_cast(rectangle));
    return;
}// SFYCheckboxControl::DrawButton13 //

/*private */Void SFYCheckboxControl::RenderButton(SFXGraphicsPtr graphics, SFXGridConstRef grid, SFXRectangleConst rectangle[2]) const
{
    SFXBevelColor                               bevel;
    SFXRGBColorConstRef                         base(GetButtonColor().GetBase());
    SFXRGBColor                                 rgb;

    graphics->SetTranslate(-grid);
    bevel.Set((GetStateFocus(true)) ? (GetFocusColor()) : (GetButtonColor()));
    rgb.Set(base);
    if (!GetStateActive(true)) {
        bevel.SetLight(bevel.GetBase());
        bevel.SetDark(bevel.GetBase());
    }
    if (GetStatePress()) {
        if (base.GetBrightness() > 0x7F) {
            bevel.SubRGB(0x11);
            rgb.SubRGB(0x11);
        }
        else {
            bevel.AddRGB(0x11);
            rgb.AddRGB(0x11);
        }
    }
    graphics->FillBevelRectangle(rectangle[0], bevel);
    graphics->FillRectangle(rectangle[1], rgb);
    graphics->SetTranslate(grid);
    return;
}// SFYCheckboxControl::RenderButton //

Reference

SFZCheckboxControl::HandleRenderRequest

Description

This function draws the 27x27 button of this check box control.

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

The default implementation is to draw the 27x27 pixel button of this check box control.

	Tip
	This function will be called in the SFZCheckboxControl::HandleRenderRequest function.

Internal Implementation

Internal implementation of the SFYCheckboxControl::DrawButton27 function is as follows:

/*protected */Void SFYCheckboxControl::DrawButton27(SFXGraphicsPtr graphics, SFXGridConstRef grid) const
{
    static SFXRectangle::AtomRecConst           rectangle[] = {
        {{ 0,  0}, {27, 27}},
        {{ 2,  2}, {23, 23}}
    };

    RenderButton(graphics, grid, atomic_cast(rectangle));
    return;
}// SFYCheckboxControl::DrawButton27 //

/*private */Void SFYCheckboxControl::RenderButton(SFXGraphicsPtr graphics, SFXGridConstRef grid, SFXRectangleConst rectangle[2]) const
{
    SFXBevelColor                               bevel;
    SFXRGBColorConstRef                         base(GetButtonColor().GetBase());
    SFXRGBColor                                 rgb;

    graphics->SetTranslate(-grid);
    bevel.Set((GetStateFocus(true)) ? (GetFocusColor()) : (GetButtonColor()));
    rgb.Set(base);
    if (!GetStateActive(true)) {
        bevel.SetLight(bevel.GetBase());
        bevel.SetDark(bevel.GetBase());
    }
    if (GetStatePress()) {
        if (base.GetBrightness() > 0x7F) {
            bevel.SubRGB(0x11);
            rgb.SubRGB(0x11);
        }
        else {
            bevel.AddRGB(0x11);
            rgb.AddRGB(0x11);
        }
    }
    graphics->FillBevelRectangle(rectangle[0], bevel);
    graphics->FillRectangle(rectangle[1], rgb);
    graphics->SetTranslate(grid);
    return;
}// SFYCheckboxControl::RenderButton //

Reference

SFZCheckboxControl::HandleRenderRequest

Description

This function draws the 9x9 pixel check mark of this check box control.

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

The default implementation is to draw the 9x9 pixel check mark of this check box control.

	Tip
	This function will be called in the SFZCheckboxControl::HandleRenderRequest function.

Internal Implementation

Internal implementation of the SFYCheckboxControl::DrawCheckmark09 function is as follows:

/*protected */Void SFYCheckboxControl::DrawCheckmark09(SFXGraphicsPtr graphics, SFXGridConstRef grid) const
{
    static SFXLine::AtomRecConst                line[] = {
        {{ 0,  5}, { 2,  7}},
        {{ 3,  6}, { 8,  1}},
        {{ 0,  6}, { 2,  8}},
        {{ 3,  7}, { 8,  2}}
    };

    RenderCheckmark(graphics, grid, atomic_cast(line));
    return;
}// SFYCheckboxControl::DrawCheckmark09 //

/*private */Void SFYCheckboxControl::RenderCheckmark(SFXGraphicsPtr graphics, SFXGridConstRef grid, SFXLineConst line[4]) const
{
    SFXRGBColor                                 rgb;
    Bool                                        checkmarkBright;

    if (GetCurrentValue()) {
        graphics->SetTranslate(-grid);
        rgb.Set(_color.checkmark);
        checkmarkBright = _color.checkmark.GetBrightness() > 0x7F;
        if (!GetStateActive(true)) {
            (checkmarkBright) ? rgb.SubRGB(0x44) : rgb.AddRGB(0x44);
        }
        graphics->SetForeColor(rgb);
        graphics->DrawLine(line[0]);
        graphics->DrawLine(line[1]);
        (checkmarkBright) ? rgb.SubRGB(0x44) : rgb.AddRGB(0x44);
        graphics->SetForeColor(rgb);
        graphics->DrawLine(line[2]);
        graphics->DrawLine(line[3]);
        graphics->SetTranslate(grid);
    }
    return;
}// SFYCheckboxControl::RenderCheckmark //

Reference

SFZCheckboxControl::HandleRenderRequest

Description

This function draws the 21x21 pixel check mark of this check box control.

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

The default implementation is to draw the 21x21 pixel check mark of this check box control.

	Tip
	This function will be called in the SFZCheckboxControl::HandleRenderRequest function.

Internal Implementation

Internal implementation of the SFYCheckboxControl::DrawCheckmark21 function is as follows:

/*protected */Void SFYCheckboxControl::DrawCheckmark21(SFXGraphicsPtr graphics, SFXGridConstRef grid) const
{
    static SFXLine::AtomRecConst                line[] = {
        {{ 0, 15}, { 4, 19}},
        {{ 5, 18}, {20,  3}},
        {{ 0, 16}, { 4, 20}},
        {{ 5, 19}, {20,  4}}
    };

    RenderCheckmark(graphics, grid, atomic_cast(line));
    return;
}// SFYCheckboxControl::DrawCheckmark21 //

/*private */Void SFYCheckboxControl::RenderCheckmark(SFXGraphicsPtr graphics, SFXGridConstRef grid, SFXLineConst line[4]) const
{
    SFXRGBColor                                 rgb;
    Bool                                        checkmarkBright;

    if (GetCurrentValue()) {
        graphics->SetTranslate(-grid);
        rgb.Set(_color.checkmark);
        checkmarkBright = _color.checkmark.GetBrightness() > 0x7F;
        if (!GetStateActive(true)) {
            (checkmarkBright) ? rgb.SubRGB(0x44) : rgb.AddRGB(0x44);
        }
        graphics->SetForeColor(rgb);
        graphics->DrawLine(line[0]);
        graphics->DrawLine(line[1]);
        (checkmarkBright) ? rgb.SubRGB(0x44) : rgb.AddRGB(0x44);
        graphics->SetForeColor(rgb);
        graphics->DrawLine(line[2]);
        graphics->DrawLine(line[3]);
        graphics->SetTranslate(grid);
    }
    return;
}// SFYCheckboxControl::RenderCheckmark //

Reference

SFZCheckboxControl::HandleRenderRequest

Description

This function draws the 14x14 pixel shadow of this check box control.

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

The default implementation is to draw the 14x14 pixel shadow of this check box control.

	Tip
	This function will be called in the SFZCheckboxControl::HandleRenderRequest function.

Internal Implementation

Internal implementation of the SFYCheckboxControl::DrawShadow14 function is as follows:

/*protected */SFXGrid SFYCheckboxControl::DrawShadow14(SFXGraphicsPtr graphics, SFXGridConstRef grid) const
{
    static SFXLine::AtomRecConst                line[][2] = {
        {{{13,  0}, {13, 13}}, {{ 0, 13}, {13, 13}}},
        {{{ 0,  0}, {13,  0}}, {{ 0,  0}, { 0, 13}}}
    };
    SFXGrid                                     result(grid);

    if (GetStatePress()) {
        RenderShadow(graphics, grid, atomic_cast(line[1]));
        result.Add(1, 1);
    }
    else {
        RenderShadow(graphics, grid, atomic_cast(line[0]));
        result.Add(0, 0);
    }
    return result;
}// SFYCheckboxControl::DrawShadow14 //

/*private */Void SFYCheckboxControl::RenderShadow(SFXGraphicsPtr graphics, SFXGridConstRef grid, SFXLineConst line[2]) const
{
    SFXRGBColor                                 rgb;

    graphics->SetTranslate(-grid);
    rgb.Set(GetShadowColor());
    if (!GetStateActive(true)) {
        (rgb.GetBrightness() > 0x7F) ? rgb.SubRGB(0x44) : rgb.AddRGB(0x44);
    }
    graphics->SetForeColor(rgb);
    graphics->DrawLine(line[0]);
    graphics->DrawLine(line[1]);
    graphics->SetTranslate(grid);
    return;
}// SFYCheckboxControl::RenderShadow //

Reference

SFZCheckboxControl::HandleRenderRequest

Description

This function draws the 28x28 pixel shadow of this check box control.

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

The default implementation is to draw the 28x28 pixel shadow of this check box control.

	Tip
	This function will be called in the SFZCheckboxControl::HandleRenderRequest function.

Internal Implementation

Internal implementation of the SFYCheckboxControl::DrawShadow28 function is as follows:

/*protected */SFXGrid SFYCheckboxControl::DrawShadow28(SFXGraphicsPtr graphics, SFXGridConstRef grid) const
{
    static SFXLine::AtomRecConst                line[][2] = {
        {{{27,  0}, {27, 27}}, {{ 0, 27}, {27, 27}}},
        {{{ 0,  0}, {27,  0}}, {{ 0,  0}, { 0, 27}}}
    };
    SFXGrid                                     result(grid);

    if (GetStatePress()) {
        RenderShadow(graphics, grid, atomic_cast(line[1]));
        result.Add(1, 1);
    }
    else {
        RenderShadow(graphics, grid, atomic_cast(line[0]));
        result.Add(0, 0);
    }
    return result;
}// SFYCheckboxControl::DrawShadow28 //

/*private */Void SFYCheckboxControl::RenderShadow(SFXGraphicsPtr graphics, SFXGridConstRef grid, SFXLineConst line[2]) const
{
    SFXRGBColor                                 rgb;

    graphics->SetTranslate(-grid);
    rgb.Set(GetShadowColor());
    if (!GetStateActive(true)) {
        (rgb.GetBrightness() > 0x7F) ? rgb.SubRGB(0x44) : rgb.AddRGB(0x44);
    }
    graphics->SetForeColor(rgb);
    graphics->DrawLine(line[0]);
    graphics->DrawLine(line[1]);
    graphics->SetTranslate(grid);
    return;
}// SFYCheckboxControl::RenderShadow //

Reference

SFZCheckboxControl::HandleRenderRequest

Reference

SFYCheckboxControl::SetCheckmarkColor

Description

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

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

The default implementation is to send the SFXEvent(SFEVT_RESPONDER_RESULT, SFP16_RESULT_OK, current value) event, of which the current value can be obtained by calling the SFYControl::GetCurrentValue function.

Internal Implementation

Internal implementation of the SFYCheckboxControl::HandleOperateKeyRelease function is as follows:

/*protected virtual */Void SFYCheckboxControl::HandleOperateKeyRelease(Void)
{
    SetCurrentValue(!GetCurrentValue());
    InvokeForward(SFXEvent(SFEVT_RESPONDER_RESULT, SFP16_RESULT_OK, GetCurrentValue()), false);
    return;
}// SFYCheckboxControl::HandleOperateKeyRelease //

Reference

SFYButtonControl::SetOperateKey | SFYControl::GetCurrentValue | SFXEvent

Description

This function sets the color(SFXRGBColor) of the check mark to the specified value.

Default: SFXRGBColor(0x00, 0x00, 0x00, 0x00)[black color].

Reference

SFYCheckboxControl::GetCheckmarkColor | SFXRGBColor

Reference

SFYResponder::GetType | SFYResponder::SetType