Inheritance diagram

Collaboration diagram

Description

How to use

SFYImageWidget is a responder with the function of displaying an image.

In general, this class is used as a child responder contained internally by the parent responder such as SFZImageBoxControl, SFZImageButtonControl, or SFZImageLabelControl which will display an image.

In these responders, all processings such as setting an image and its alignment etc. are delegated to this class.

	Default value of the transparency attribute
	Since the default value of the transparency attribute of this class is set to "true", the background will be never drawn in the color set with the SFYWidget::SetBackgroundColor function unless the transparency attribute is set to "false" using the SFYResponder::SetPropertyTransparent function.

	The state of this responder when used
	When this class is used, its state is set to "visible"+"active"+"disable"+"unfocus". In general, this class is used as a responder which will not handle the key event.

	About the virtual region
	In this class, it is recommended to equalize the virtual region with the real region for the intuitive text alignment or scroll. For instance, when [Width of virtual region] ≧ [Width of image] ＞ [Width of real region] or [Height of virtual region] ≧ [Height of image] ＞ [Height of real region] stands up, all of the image cannot be displayed.

Reference

SFZImageBoxControl | SFZImageButtonControl | SFZImageLabelControl | SFZMessageDialog | SFZQuestionDialog | Virtual Region | Real Region | Local Region

Member

Description

This constructor performs the initializations as follows:

Reference

SFYResponder::SetType | SFYResponder::SetPropertyTransparent | SFYImageWidget::CodeEnum | SFYImageWidget::SetHorizontalAlign | SFYImageWidget::SetVerticalAlign | SFYImageWidget::HorizontalEnum | SFYImageWidget::VerticalEnum | Type | Attribute

Description

This destructor does nothing.

Description

This function draws the image.

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

Internal Implementation

Internal implementation of the SFYImageWidget::DrawImage function is as follows:

/*protected */Void SFYImageWidget::DrawImage(SFXGraphicsPtr graphics, SFXGridConstRef grid) const
{
    if (_image != null) {
        graphics->DrawImage(_image, grid);
    }
    return;
}// SFYImageWidget::DrawImage //

Reference

SFYImageWidget::HandleRenderRequest

Return value

Value of the horizontal alignment.

Reference

SFYImageWidget::SetHorizontalAlign | SFYImageWidget::HorizontalEnum

Reference

SFYImageWidget::SetImage | SFYImageWidget::GetImageSize

Reference

SFYImageWidget::SetImage | SFYImageWidget::GetImage

Return value

Value of the vertical alignment.

Reference

SFYImageWidget::SetVerticalAlign | SFYImageWidget::VerticalEnum

Description

This function will be called when the region event [SFXEvent(SFEVT_RESPONDER_BOUND, SFP16_BOUND_OPTIMIZE, rectangle)] is received.

This function calculates the suitable rectangle size of this responder within the specified hint rectangle[i.e., rectangle element (P32 parameter) of the region event].

The suitable rectangle size is stored into the size element of the rectangle argument as a result of calculation. It is recommended not to change the origin of the rectangle argument in this function.

	Region event[(SFEVT_RESPONDER_BOUND, SFP16_BOUND_OPTIMIZE) event]
	If the rectangle argument of the hint region is specified, the SFYResponder::GetSuitableBound function will send the region event [SFXEvent(SFEVT_RESPONDER_BOUND, SFP16_BOUND_OPTIMIZE, rectangle)] to this responder. Then, the SFYWidget::HandleBoundOptimize virtual function will be called. The rectangle element (P32 parameter) of the region event is set to the hint region as an initial value.

Internal Implementation

Internal implementation of the SFYImageWidget::HandleBoundOptimize function is as follows:

/*protected virtual */Void SFYImageWidget::HandleBoundOptimize(SFXRectanglePtr rectangle) const
{
    if (rectangle->GetWidth() > _bound.GetWidth()) {
        rectangle->SetWidth(_bound.GetWidth());
    }
    if (rectangle->GetHeight() > _bound.GetHeight()) {
        rectangle->SetHeight(_bound.GetHeight());
    }
    return;
}// SFYImageWidget::HandleBoundOptimize //

Reference

SFYResponder::GetSuitableBound | SFXEvent | Region Event[SFEVT_RESPONDER_BOUND] | Handler for the Region Event[XANDLER_DECLARE_VOIDBOUND]

Description

This function will be called when the (SFEVT_RESPONDER_BOUND, SFP16_BOUND_REAL) event is received.

In case you want to perform your own processing when the real region is updated, override this function.

The default implementation is to equalize the virtual region with the real region.

	Sending the (SFEVT_RESPONDER_BOUND, SFP16_BOUND_REAL) event
	The (SFEVT_RESPONDER_BOUND, SFP16_BOUND_REAL) event will occur when the real region is changed by calling the SFYResponder::SetRealBound function.

	Processing when the real region is changed
	Other than overriding this virtual function, there is another method to define and implement the handler for the region event[XANDLER_DECLARE_VOIDBOUND], and register it into the responder. In the processing when the real region is updated, this virtual function is executed first, and next the handlers for the region event are executed in the registered order.

Internal Implementation

Internal implementation of the SFYImageWidget::HandleBoundReal function is as follows:

/*protected virtual */Void SFYImageWidget::HandleBoundReal(Void)
{
    SetVirtualBound(SFXRectangle(SFXGrid::ZeroInstance(), GetRealBound().GetSize()));
    return;
}// SFYImageWidget::HandleBoundReal //

Reference

SFYResponder::SetRealBound | Region Event[SFEVT_RESPONDER_BOUND] | Handler for the Region Event[XANDLER_DECLARE_VOIDBOUND] | Real Region | Virtual Region | Local Region

Description

This function will be called when the region event [SFXEvent(SFEVT_RESPONDER_BOUND, SFP16_BOUND_REQUEST, rectangle)] is received.

This function calculates the suitable rectangle size of this responder.

The suitable rectangle size is stored into the size element of the rectangle argument as a result of calculation. It is recommended not to change the origin element of the rectangle argument within this function.

Region event[(SFEVT_RESPONDER_BOUND, SFP16_BOUND_REQUEST) event]

If the rectangle argument of the hint region is not specified, the SFYResponder::GetSuitableBound function will send the region event [SFXEvent(SFEVT_RESPONDER_BOUND, SFP16_BOUND_REQUEST, rectangle)] to this responder. Then, the SFYWidget::HandleBoundRequest virtual function will be called. The rectangle element (P32 parameter) of the region event is set to the real region as an initial value. Tip Default value of the real region: SFXRectangle(0, 0, 0, 0)

Internal Implementation

Internal implementation of the SFYImageWidget::HandleBoundRequest function is as follows:

/*protected virtual */Void SFYImageWidget::HandleBoundRequest(SFXRectanglePtr rectangle) const
{
    rectangle->SetSize(_bound.GetSize());
    return;
}// SFYImageWidget::HandleBoundRequest //

Reference

SFYResponder::GetSuitableBound | SFXEvent | Real Region Region Event[SFEVT_RESPONDER_BOUND] | Handler for the Region Event[XANDLER_DECLARE_VOIDBOUND]

Description

This function will be called when the (SFEVT_RESPONDER_BOUND, SFP16_BOUND_VIRTUAL) event is received.

In case you want to perform your own processing when the virtual region is changed, override this virtual function.

The default implementation is to equalize the real region with the new local region and relocate this responder to fit into the new virtual region.

	Sending the (SFEVT_RESPONDER_BOUND, SFP16_BOUND_VIRTUAL) event
	The (SFEVT_RESPONDER_BOUND, SFP16_BOUND_VIRTUAL) event will occur when the virtual region is changed by calling the SFYResponder::SetRealBound or SFYResponder::SetVirtualBound function.

Another method when the virtual region is changed

Other than overriding this virtual function, it is possible to define and implement the handler for region event[XANDLER_DECLARE_VOIDBOUND], and register it into the responder. In the processing when the virtual region is updated, this virtual function is executed first, and next the handlers for region event are executed in the registered order. In almost all cases, the method to override this virtual function is adopted since defining, implementing and registering the handler for region event can be omitted.

Internal Implementation

Internal implementation of the SFYImageWidget::HandleBoundVirtual function is as follows:

/*protected virtual */Void SFYImageWidget::HandleBoundVirtual(Void)
{
    Relocate();
    return;
}// SFYImageWidget::HandleBoundVirtual //

/*private */Void SFYImageWidget::Relocate(Void)
{
    SFXRectangle                                lx;

    lx.Set(GetLocalBound());
    _bound.SetOrigin(lx.GetOrigin());
    switch (_align.horizontal) {
        case HORIZONTAL_LEFT:
            _bound.AddX(0);
            break;
        case HORIZONTAL_RIGHT:
            _bound.AddX(lx.GetWidth() - _bound.GetWidth());
            break;
        case HORIZONTAL_CENTER:
        default:
            _bound.AddX((lx.GetWidth() - _bound.GetWidth()) / 2);
            break;
    }
    switch (_align.vertical) {
        case VERTICAL_TOP:
            _bound.AddY(0);
            break;
        case VERTICAL_BOTTOM:
            _bound.AddY(lx.GetHeight() - _bound.GetHeight());
            break;
        case VERTICAL_MIDDLE:
        default:
            _bound.AddY((lx.GetHeight() - _bound.GetHeight()) / 2);
            break;
    }
    return;
}// SFYImageWidget::Relocate //

Reference

SFYResponder::SetRealBound | SFYResponder::SetVirtualBound | Region Event[SFEVT_RESPONDER_BOUND] | Handler for the Region Event[XANDLER_DECLARE_VOIDBOUND] | Virtual Region | Real Region | Local Region

Description

This function will be called when the (SFEVT_RESPONDER_RENDER, SFP16_RENDER_REQUEST) event is received.

In case you want to perform your own drawing of this responder, override this function.

The default implementation is to draw this responder.

The method to darw a responder

In addition to overriding this virtual function, it is possible to define and implement the handler for drawing event(drawing handler)[XANDLER_DECLARE_VOIDRENDER], and register it into the responder. Then, the overridden virtual function will be called first, and next the drawing handlers registered into the responder will be booted up in the registered order. In almost all cases, the method to override this function is used to draw the responder since there is no need to declare and register the drawing handler.

Procedure of drawing a responder

The drawing handler will be booted up when the drawing event(SFEVT_RESPONDER_RENDER) occurs. And then the drawing handler draw the responder actually. The drawing event will be sent to only the responders including the region to be redrawn out of the redraw regions registered into the renderer using the SFYResponder::InvokeBackward function after the SFYResponder::Render function boots up the renderer. Here, the SFYResponder::Render function will be called at the following situations: At the end of the event loop At the applet start / resume or the end of a highest priority event handler In the callback, which is outside the event loop. If calling the SFYResponder::Render function with specifying "true" as an argument, the drawing event will be sent to all the responders to be actually displayed on the screen which are located below the responder in the responder tree, regardless of the registration of redraw region.

Internal Implementation

Internal implementation of the SFYImageWidget::HandleRenderRequest function is as follows:

/*protected virtual */Void SFYImageWidget::HandleRenderRequest(SFXGraphicsPtr graphics) const
{
    DrawImage(graphics, _bound.GetOrigin());
    return;
}// SFYImageWidget::HandleRenderRequest //

Reference

SFYImageWidget::SetImage | SFYImageWidget::DrawImage | SFYImageWidget::SetHorizontalAlign | SFYImageWidget::SetVerticalAlign | SFYResponder::Invalidate | SFYResponder::Render | SFYResponder::InvokeBackward | Drawing Event[SFEVT_RESPONDER_RENDER] | Handler for the Drawing Event[XANDLER_DECLARE_VOIDRENDER] | Rendering | Event Loop | Responder Tree | Virtual Region | Real Region | Local Region

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:

SFYImageWidgetSmp _imagewidget;
SFCError error;

if ((_imagewidget = SFYImageWidget::NewInstance(&error)) != null) {

    ...
}

Description

This function sets the horizontal alignment to the specified value.

Default: SFYImageWidget::DEFAULT_HORIZONTAL

For the value of SFYImageWidget::DEFAULT_HORIZONTAL, refer to SFYImageWidget::HorizontalEnum.

Reference

SFYImageWidget::GetHorizontalAlign | SFYImageWidget::HorizontalEnum

Return value

Description

This function sets the image to the specified value.

The image is set directly in the argument, or read from the resource file.

This function cannot be used with the image such as the image of invalid size or the animation bitmap.

Reference

SFYImageWidget::GetImage | SFYImageWidget::GetImageSize | SFBImage | BREW API IImage

Description

This function sets the vertical alignment to the specified value.

Default: SFYImageWidget::DEFAULT_VERTICAL

For the value of SFYImageWidget::DEFAULT_VERTICAL, refer to SFYImageWidget::VerticalEnum.

Reference

SFYImageWidget::GetVerticalAlign | SFYImageWidget::VerticalEnum

Reference

SFYResponder::GetType | SFYResponder::SetType

Description

For the horizontal alignment:

Reference

SFYImageWidget::SetHorizontalAlign | Local Region

Description

For the vertical alignment:

Reference

SFYImageWidget::SetVerticalAlign | Local Region