Inheritance diagram

Collaboration diagram

Description

How to use

SFYRadiobuttonControl is the abstract base class to define and implement a user-defined radio button control.

In SFYRadiobuttonControl, functions to draw the check box, switch the checked state exclusively 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 SFYRadiobuttonControl, 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 radio button control inheriting from SFYRadiobuttonControl, 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 exclusively, 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 radio button is as follows:

SFMTYPEDEFRESPONDER(USRRadiobuttonControl)
class USRRadiobuttonControl: public SFYRadiobuttonControl {
    SFMSEALRESPONDER(USRRadiobuttonControl)
    SFMRESPONDERINSTANTIATESIX(USRRadiobuttonControl, SFYRadiobuttonControl, 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', 'R', 'D', 'O')
    };
    SFMTYPEDEFTYPE(CodeEnum)

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

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

        // set the responder type
 SetType(CODE_TYPE);

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

        // here describe the initialization
    }
}

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

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

Void USRRadiobuttonControl::HandleBoundRequest(SFXRectanglePtr rectangle) const
{
    // calculate the suitable radio button control size
    // set the rectangle argument to the calculated suitable radio button 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 USRRadiobuttonControl::HandleBoundOptimize(SFXRectanglePtr rectangle) const
{
    // calculate the suitable radio button control size within rectangular region given by the rectangle argument
    // set the rectangle argument to the calculated suitable radio button 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 USRRadiobuttonControl::HandleBoundVirtual(Void)
{
    // here describe the size recalculation if necessary when the virtual region is changed

    return;
}

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

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

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

    if (_height >= 28) {
        grid.Set(DrawShadow28(graphics, _origin));
        DrawButton27(graphics, grid);
        grid.Add(8, 8);
        DrawCheckmark11(graphics, grid);
    }
    else if (_height >= 14) {
        grid.Set(DrawShadow14(graphics, _origin));
        DrawButton13(graphics, grid);
        grid.Add(4, 4);
        DrawCheckmark05(graphics, grid);
    }

    // draw radio button control's label

    return;
}

Reference

Member

Description

This constructor sets the type of this responder to ".rdo".

Reference

SFYResponder::SetType | SFYRadiobuttonControl::CodeEnum | Type

Description

This destructor unregisters this radio button from the group.

Reference

SFYRadiobuttonControl::Ungroup

Description

This function draws the 13x13 button of this radio button 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 radio button control.

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

Internal Implementation

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

/*protected */Void SFYRadiobuttonControl::DrawButton13(SFXGraphicsPtr graphics, SFXGridConstRef grid) const
{
    static SFXRectangle::AtomRecConst           rectangle[] = {
        {{ 3,  3}, { 7,  7}}
    };
    static SFXLine::AtomRecConst                line[] = {
        {{ 2,  1}, { 3,  1}}, {{ 4,  0}, { 8,  0}}, {{ 1,  2}, { 1,  3}}, {{ 0,  4}, { 0,  8}},
        {{ 9,  1}, {10,  1}}, {{ 1,  9}, { 1, 10}}, {{ 2,  2}, { 4,  2}}, {{ 4,  1}, { 8,  1}},
        {{ 8,  2}, {10,  2}}, {{10,  2}, {10,  4}}, {{11,  4}, {11,  8}}, {{10,  8}, {10, 10}},
        {{ 2,  2}, { 2,  4}}, {{ 1,  4}, { 1,  8}}, {{ 2,  8}, { 2, 10}}, {{ 2, 10}, { 4, 10}},
        {{ 4, 11}, { 8, 11}}, {{ 8, 10}, {10, 10}}, {{11,  2}, {11,  3}}, {{ 2, 11}, { 3, 11}},
        {{12,  4}, {12,  8}}, {{11,  9}, {11, 10}}, {{ 4, 12}, { 8, 12}}, {{ 9, 11}, {10, 11}},
        {{ 5,  2}, { 7,  2}}, {{10,  5}, {10,  7}}, {{ 2,  5}, { 2,  7}}, {{ 5, 10}, { 7, 10}}
    };
    static SInt16Const                          color[] = {
        0,  0,  4,  6, 18, 20, 24
    };

    RenderButton(graphics, grid, atomic_cast(rectangle), lengthof(rectangle), atomic_cast(line), lengthof(line), color);
    return;
}// SFYRadiobuttonControl::DrawButton13 //

/*private */Void SFYRadiobuttonControl::RenderButton(SFXGraphicsPtr graphics, SFXGridConstRef grid, SFXRectangleConstPtr rectangle, SInt32 rlength, SFXLineConstPtr line, SInt32 llength, SInt16Const color[7]) const
{
    SFXBevelColor                               bevel;
    SFXRGBColor                                 rgb;
    SInt32                                      r0;
    Bool                                        baseBright;

    graphics->SetTranslate(-grid);
    bevel.Set((GetStateFocus(true)) ? (GetFocusColor()) : (GetButtonColor()));
    rgb.Set(GetButtonColor().GetBase());
    baseBright = rgb.GetBrightness() > 0x7F;
    if (!GetStateActive(true)) {
        bevel.SetLight(bevel.GetBase());
        bevel.SetDark(bevel.GetBase());
    }
    if (GetStatePress()) {
        if (baseBright) {
            bevel.SubRGB(0x11);
            rgb.SubRGB(0x11);
        }
        else {
            bevel.AddRGB(0x11);
            rgb.AddRGB(0x11);
        }
    }
    graphics->SetFillMode(true);
    for (r0 = 0; r0 < rlength; ++r0) {
        if (r0 == color[0]) {
            graphics->SetForeColor(rgb);
            graphics->SetFillColor(rgb);
        }
        graphics->DrawRectangle(rectangle[r0]);
    }
    for (r0 = 0; r0 < llength; ++r0) {
        if (r0 == color[1]) {
            graphics->SetForeColor(bevel.GetLight());
        }
        else if (r0 == color[2]) {
     SFXRGBColor light(bevel.GetLight());
            graphics->SetForeColor(
                (baseBright) ? light.SubRGB(0x11) : light.AddRGB(0x11)
            );
        }
        else if (r0 == color[3]) {
            graphics->SetForeColor(bevel.GetBase());
        }
        else if (r0 == color[4]) {
     SFXRGBColor dark(bevel.GetDark());
            graphics->SetForeColor(
                (baseBright) ? dark.AddRGB(0x11) : dark.SubRGB(0x11)
            );
        }
        else if (r0 == color[5]) {
            graphics->SetForeColor(bevel.GetDark());
        }
        else if (r0 == color[6]) {
            graphics->SetForeColor(rgb);
        }
        graphics->DrawLine(line[r0]);
    }
    graphics->SetTranslate(grid);
    return;
}// SFYRadiobuttonControl::RenderButton //

Reference

SFZRadiobuttonControl::HandleRenderRequest

Description

This function draws the 27x27 button of this radio button 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 radio button control.

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

Internal Implementation

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

/*protected */Void SFYRadiobuttonControl::DrawButton27(SFXGraphicsPtr graphics, SFXGridConstRef grid) const
{
    static SFXRectangle::AtomRecConst           rectangle[] = {
        {{ 5,  5}, {17, 17}}
    };
    static SFXLine::AtomRecConst                line[] = {
        {{ 4,  3}, { 5,  3}}, {{ 6,  2}, { 6,  2}}, {{ 7,  1}, { 9,  1}}, {{10,  0}, {16,  0}},
        {{ 3,  4}, { 3,  5}}, {{ 2,  6}, { 2,  6}}, {{ 1,  7}, { 1,  9}}, {{ 0, 10}, { 0, 16}},
        {{17,  1}, {19,  1}}, {{20,  2}, {20,  2}}, {{21,  3}, {22,  3}}, {{ 1, 17}, { 1, 19}},
        {{ 2, 20}, { 2, 20}}, {{ 3, 21}, { 3, 22}}, {{ 4,  4}, { 6,  4}}, {{ 6,  3}, { 7,  3}},
        {{ 7,  2}, {10,  2}}, {{10,  1}, {16,  1}}, {{16,  2}, {19,  2}}, {{19,  3}, {20,  3}},
        {{20,  4}, {22,  4}}, {{22,  4}, {22,  6}}, {{23,  6}, {23,  7}}, {{24,  7}, {24, 10}},
        {{25, 10}, {25, 16}}, {{24, 16}, {24, 19}}, {{23, 19}, {23, 20}}, {{22, 20}, {22, 22}},
        {{ 4,  4}, { 4,  6}}, {{ 3,  6}, { 3,  7}}, {{ 2,  7}, { 2, 10}}, {{ 1, 10}, { 1, 16}},
        {{ 2, 16}, { 2, 19}}, {{ 3, 19}, { 3, 20}}, {{ 4, 20}, { 4, 22}}, {{ 4, 22}, { 6, 22}},
        {{ 6, 23}, { 7, 23}}, {{ 7, 24}, {10, 24}}, {{10, 25}, {16, 25}}, {{16, 24}, {19, 24}},
        {{19, 23}, {20, 23}}, {{20, 22}, {22, 22}}, {{23,  4}, {23,  5}}, {{24,  6}, {24,  6}},
        {{25,  7}, {25,  9}}, {{ 4, 23}, { 5, 23}}, {{ 6, 24}, { 6, 24}}, {{ 7, 25}, { 9, 25}},
        {{26, 10}, {26, 16}}, {{25, 17}, {25, 19}}, {{24, 20}, {24, 20}}, {{23, 21}, {23, 22}},
        {{10, 26}, {16, 26}}, {{17, 25}, {19, 25}}, {{20, 24}, {20, 24}}, {{21, 23}, {22, 23}},
        {{11,  2}, {15,  2}}, {{ 8,  3}, {18,  3}}, {{ 7,  4}, {19,  4}}, {{24, 11}, {24, 15}},
        {{23,  8}, {23, 18}}, {{22,  7}, {22, 19}}, {{ 2, 11}, { 2, 15}}, {{ 3,  8}, { 3, 18}},
        {{ 4,  7}, { 4, 19}}, {{11, 24}, {15, 24}}, {{ 8, 23}, {18, 23}}, {{ 7, 22}, {19, 22}}
    };
    static SInt16Const                          color[] = {
        0,  0,  8, 14, 42, 48, 56
    };

    RenderButton(graphics, grid, atomic_cast(rectangle), lengthof(rectangle), atomic_cast(line), lengthof(line), color);
    return;
}// SFYRadiobuttonControl::DrawButton27 //

/*private */Void SFYRadiobuttonControl::RenderButton(SFXGraphicsPtr graphics, SFXGridConstRef grid, SFXRectangleConstPtr rectangle, SInt32 rlength, SFXLineConstPtr line, SInt32 llength, SInt16Const color[7]) const
{
    SFXBevelColor                               bevel;
    SFXRGBColor                                 rgb;
    SInt32                                      r0;
    Bool                                        baseBright;

    graphics->SetTranslate(-grid);
    bevel.Set((GetStateFocus(true)) ? (GetFocusColor()) : (GetButtonColor()));
    rgb.Set(GetButtonColor().GetBase());
    baseBright = rgb.GetBrightness() > 0x7F;
    if (!GetStateActive(true)) {
        bevel.SetLight(bevel.GetBase());
        bevel.SetDark(bevel.GetBase());
    }
    if (GetStatePress()) {
        if (baseBright) {
            bevel.SubRGB(0x11);
            rgb.SubRGB(0x11);
        }
        else {
            bevel.AddRGB(0x11);
            rgb.AddRGB(0x11);
        }
    }
    graphics->SetFillMode(true);
    for (r0 = 0; r0 < rlength; ++r0) {
        if (r0 == color[0]) {
            graphics->SetForeColor(rgb);
            graphics->SetFillColor(rgb);
        }
        graphics->DrawRectangle(rectangle[r0]);
    }
    for (r0 = 0; r0 < llength; ++r0) {
        if (r0 == color[1]) {
            graphics->SetForeColor(bevel.GetLight());
        }
        else if (r0 == color[2]) {
     SFXRGBColor light(bevel.GetLight());
            graphics->SetForeColor(
                (baseBright) ? light.SubRGB(0x11) : light.AddRGB(0x11)
            );
        }
        else if (r0 == color[3]) {
            graphics->SetForeColor(bevel.GetBase());
        }
        else if (r0 == color[4]) {
     SFXRGBColor dark(bevel.GetDark());
            graphics->SetForeColor(
                (baseBright) ? dark.AddRGB(0x11) : dark.SubRGB(0x11)
            );
        }
        else if (r0 == color[5]) {
            graphics->SetForeColor(bevel.GetDark());
        }
        else if (r0 == color[6]) {
            graphics->SetForeColor(rgb);
        }
        graphics->DrawLine(line[r0]);
    }
    graphics->SetTranslate(grid);
    return;
}// SFYRadiobuttonControl::RenderButton //

Reference

SFZRadiobuttonControl::HandleRenderRequest

Description

This function draws the 5x5 pixel check mark of this radio button control.

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

The default implementation is to draw the 5x5 pixel check mark of this radio button control.

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

Internal Implementation

Internal implementation of the SFYRadiobuttonControl::DrawCheckmark05 function is as follows:

/*protected */Void SFYRadiobuttonControl::DrawCheckmark05(SFXGraphicsPtr graphics, SFXGridConstRef grid) const
{
    static SFXRectangle::AtomRecConst           rectangle[] = {
        {{ 1,  1}, { 3,  3}}
    };
    static SFXLine::AtomRecConst                line[] = {
        {{ 1,  0}, { 3,  0}}, {{ 4,  1}, { 4,  3}}, {{ 0,  1}, { 0,  3}}, {{ 1,  4}, { 3,  4}}
    };

    RenderCheckmark(graphics, grid, atomic_cast(rectangle), lengthof(rectangle), atomic_cast(line), lengthof(line));
    return;
}// SFYRadiobuttonControl::DrawCheckmark05 //

/*private */Void SFYRadiobuttonControl::RenderCheckmark(SFXGraphicsPtr graphics, SFXGridConstRef grid, SFXRectangleConstPtr rectangle, SInt32 rlength, SFXLineConstPtr line, SInt32 llength) const
{
    SFXRGBColor                                 rgb;
    SInt32                                      r0;

    if (GetCurrentValue()) {
        graphics->SetTranslate(-grid);
        rgb.Set(GetCheckmarkColor());
        if (!GetStateActive(true)) {
            (rgb.GetBrightness() > 0x7F) ? rgb.SubRGB(0x44) : rgb.AddRGB(0x44);
        }
        graphics->SetFillMode(true);
        graphics->SetForeColor(rgb);
        graphics->SetFillColor(rgb);
        for (r0 = 0; r0 < rlength; ++r0) {
            graphics->DrawRectangle(rectangle[r0]);
        }
        for (r0 = 0; r0 < llength; ++r0) {
            graphics->DrawLine(line[r0]);
        }
        graphics->SetTranslate(grid);
    }
    return;
}// SFYRadiobuttonControl::RenderCheckmark //

Reference

SFZRadiobuttonControl::HandleRenderRequest

Description

This function draws the 11x11 pixel check mark of this radio button control.

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

The default implementation is to draw the 11x11 pixel check mark of this radio button control.

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

Internal Implementation

Internal implementation of the SFYRadiobuttonControl::DrawCheckmark11 function is as follows:

/*protected */Void SFYRadiobuttonControl::DrawCheckmark11(SFXGraphicsPtr graphics, SFXGridConstRef grid) const
{
    static SFXRectangle::AtomRecConst           rectangle[] = {
        {{ 2,  2}, { 7,  7}}
    };
    static SFXLine::AtomRecConst                line[] = {
        {{ 4,  0}, { 6,  0}}, {{ 2,  1}, { 8,  1}}, {{10,  4}, {10,  6}}, {{ 9,  2}, { 9,  8}},
        {{ 0,  4}, { 0,  6}}, {{ 1,  2}, { 1,  8}}, {{ 4, 10}, { 6, 10}}, {{ 2,  9}, { 8,  9}}
    };

    RenderCheckmark(graphics, grid, atomic_cast(rectangle), lengthof(rectangle), atomic_cast(line), lengthof(line));
    return;
}// SFYRadiobuttonControl::DrawCheckmark11 //

/*private */Void SFYRadiobuttonControl::RenderCheckmark(SFXGraphicsPtr graphics, SFXGridConstRef grid, SFXRectangleConstPtr rectangle, SInt32 rlength, SFXLineConstPtr line, SInt32 llength) const
{
    SFXRGBColor                                 rgb;
    SInt32                                      r0;

    if (GetCurrentValue()) {
        graphics->SetTranslate(-grid);
        rgb.Set(GetCheckmarkColor());
        if (!GetStateActive(true)) {
            (rgb.GetBrightness() > 0x7F) ? rgb.SubRGB(0x44) : rgb.AddRGB(0x44);
        }
        graphics->SetFillMode(true);
        graphics->SetForeColor(rgb);
        graphics->SetFillColor(rgb);
        for (r0 = 0; r0 < rlength; ++r0) {
            graphics->DrawRectangle(rectangle[r0]);
        }
        for (r0 = 0; r0 < llength; ++r0) {
            graphics->DrawLine(line[r0]);
        }
        graphics->SetTranslate(grid);
    }
    return;
}// SFYRadiobuttonControl::RenderCheckmark //

Reference

SFZRadiobuttonControl::HandleRenderRequest

Description

This function draws the 14x14 pixel shadow of this radio button 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 radio button control.

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

Internal Implementation

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

/*protected */SFXGrid SFYRadiobuttonControl::DrawShadow14(SFXGraphicsPtr graphics, SFXGridConstRef grid) const
{
    static SFXLine::AtomRecConst                line[][9] = {
        {
            {{11,  1}, {11,  1}}, {{ 1, 11}, { 1, 11}}, {{12,  2}, {12,  3}}, {{ 2, 12}, { 3, 12}},
            {{13,  4}, {13,  8}}, {{12,  9}, {12, 10}}, {{ 4, 13}, { 8, 13}}, {{ 9, 12}, {10, 12}},
            {{11, 11}, {11, 11}}
        },
        {
            {{12,  2}, {12,  2}}, {{ 2, 12}, { 2, 12}}, {{10,  1}, {11,  1}}, {{ 1, 10}, { 1, 11}},
            {{ 3,  1}, { 4,  1}}, {{ 5,  0}, { 9,  0}}, {{ 1,  3}, { 1,  4}}, {{ 0,  5}, { 0,  9}},
            {{ 2,  2}, { 2,  2}}
        }
    };
    static SInt16Const                          color[] = {
        0,  2,  4
    };
    SFXGrid                                     result(grid);

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

/*private */Void SFYRadiobuttonControl::RenderShadow(SFXGraphicsPtr graphics, SFXGridConstRef grid, SFXLineConstPtr line, SInt32 llength, SInt16Const color[3]) const
{
    SFXRGBColor                                 rgb;
    SInt32                                      r0;
    Bool                                        shadowBright;

    graphics->SetTranslate(-grid);
    rgb.Set(GetShadowColor());
    shadowBright = rgb.GetBrightness() > 0x7F;
    if (!GetStateActive(true)) {
        (shadowBright) ? rgb.SubRGB(0x44) : rgb.AddRGB(0x44);
    }
    for (r0 = 0; r0 < llength; ++r0) {
        if (r0 == color[0]) {
            graphics->SetForeColor(
                (shadowBright) ? SFXRGBColor(rgb).SubRGB(0x44) : SFXRGBColor(rgb).AddRGB(0x44)
            );
        }
        else if (r0 == color[1]) {
            graphics->SetForeColor(
                (shadowBright) ? SFXRGBColor(rgb).SubRGB(0x22) : SFXRGBColor(rgb).AddRGB(0x22)
            );
        }
        else if (r0 == color[2]) {
            graphics->SetForeColor(rgb);
        }
        graphics->DrawLine(line[r0]);
    }
    graphics->SetTranslate(grid);
    return;
}// SFYRadiobuttonControl::RenderShadow //

Reference

SFZRadiobuttonControl::HandleRenderRequest

Description

This function draws the 28x28 pixel shadow of this radio button 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 radio button control.

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

Internal Implementation

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

/*protected */SFXGrid SFYRadiobuttonControl::DrawShadow28(SFXGraphicsPtr graphics, SFXGridConstRef grid) const
{
    static SFXLine::AtomRecConst                line[][17] = {
        {
            {{23,  3}, {23,  3}}, {{24,  4}, {24,  5}}, {{ 3, 23}, { 3, 23}}, {{ 4, 24}, { 5, 24}},
            {{25,  6}, {25,  6}}, {{26,  7}, {26,  9}}, {{ 6, 25}, { 6, 25}}, {{ 7, 26}, { 9, 26}},
            {{27, 10}, {27, 16}}, {{26, 17}, {26, 19}}, {{25, 20}, {25, 20}}, {{24, 21}, {24, 22}},
            {{10, 27}, {16, 27}}, {{17, 26}, {19, 26}}, {{20, 25}, {20, 25}}, {{21, 24}, {22, 24}},
            {{23, 23}, {23, 23}}
        },
        {
            {{22,  3}, {23,  3}}, {{24,  4}, {24,  4}}, {{ 3, 22}, { 3, 23}}, {{ 4, 24}, { 4, 24}},
            {{18,  1}, {20,  1}}, {{21,  2}, {21,  2}}, {{ 1, 18}, { 1, 20}}, {{ 2, 21}, { 2, 21}},
            {{ 5,  3}, { 6,  3}}, {{ 7,  2}, { 7,  2}}, {{ 8,  1}, {10,  1}}, {{11,  0}, {17,  0}},
            {{ 3,  5}, { 3,  6}}, {{ 2,  7}, { 2,  7}}, {{ 1,  8}, { 1, 10}}, {{ 0, 11}, { 0, 17}},
            {{ 4,  4}, { 4,  4}}
        }
    };
    static SInt16Const                          color[] = {
        0,  4,  8
    };
    SFXGrid                                     result(grid);

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

/*private */Void SFYRadiobuttonControl::RenderShadow(SFXGraphicsPtr graphics, SFXGridConstRef grid, SFXLineConstPtr line, SInt32 llength, SInt16Const color[3]) const
{
    SFXRGBColor                                 rgb;
    SInt32                                      r0;
    Bool                                        shadowBright;

    graphics->SetTranslate(-grid);
    rgb.Set(GetShadowColor());
    shadowBright = rgb.GetBrightness() > 0x7F;
    if (!GetStateActive(true)) {
        (shadowBright) ? rgb.SubRGB(0x44) : rgb.AddRGB(0x44);
    }
    for (r0 = 0; r0 < llength; ++r0) {
        if (r0 == color[0]) {
            graphics->SetForeColor(
                (shadowBright) ? SFXRGBColor(rgb).SubRGB(0x44) : SFXRGBColor(rgb).AddRGB(0x44)
            );
        }
        else if (r0 == color[1]) {
            graphics->SetForeColor(
                (shadowBright) ? SFXRGBColor(rgb).SubRGB(0x22) : SFXRGBColor(rgb).AddRGB(0x22)
            );
        }
        else if (r0 == color[2]) {
            graphics->SetForeColor(rgb);
        }
        graphics->DrawLine(line[r0]);
    }
    graphics->SetTranslate(grid);
    return;
}// SFYRadiobuttonControl::RenderShadow //

Reference

SFZRadiobuttonControl::HandleRenderRequest

Description

This function groups multiple radio buttons. As a result, selecting a button exclusively among the grouped radio button controls is done automatically.

Reference

SFYRadiobuttonControl::Ungroup

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 select this radio button exclusively among the grouped radio button controls and 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 SFYRadiobuttonControl::HandleOperateKeyRelease function is as follows:

/*protected virtual */Void SFYRadiobuttonControl::HandleOperateKeyRelease(Void)
{
    SFYRadiobuttonControlPtr                    responder;

    for (responder = _forward; responder != this; responder = responder->_forward) {
        responder->SetCurrentValue(false);
    }
    SetCurrentValue(true);
    InvokeForward(SFXEvent(SFEVT_RESPONDER_RESULT, SFP16_RESULT_OK, GetCurrentValue()), false);
    return;
}// SFYRadiobuttonControl::HandleOperateKeyRelease //

Reference

SFYButtonControl::SetOperateKey | Key Event[SFEVT_KEY]

Reference

SFYRadiobuttonControl::Group

Reference

SFYResponder::GetType | SFYResponder::SetType