sgrsoftkeywindow.cpp

一个基于BREW上的电子时钟程序,通过太阳历计算当前时间,并有闹铃和日志功能.

//
//      SGRSoftkeyWindow.cpp
//
//      Copyright (C) 2006 Sophia Cradle Incorporated

#include "SGRSoftkeyWindow.hpp"

#define     MINIMUM_HEIGHT      (12)
#define     BASE_MARGIN         (2)
#define     RING_MARGIN         (3)
#define     RING_SIZE           (1)
#define     FONT_MARGIN         (1)

SGRSoftkeyWindow::SGRSoftkeyWindow(SFRApplicationPtr director) static_throws : SFRPlainWindow(director, SFXRectangle(0, 0, 0, 0), BEHAVIOR_PLAINWINDOW, ATTRIBUTE_SOFTKEYWINDOW), _bind(null)
{
    static SFXRGBColor::AtomRecConst theme = {
        0x00, 0xCC, 0xCC, 0xCC
    };
    SFXRectangle rect;
    SInt16 height;

    if (static_try()) {
        #if TARGET_VERSION_GT(3, 1, 0)
        static_throw(director->RegisterTracer(SFEVT_KEY, SFEVT_KEY_RELEASE, AVK_SOFT1, AVK_SOFT3, BEHAVIOR_NONE, TRACER_BACKWARD));
        #else
        static_throw(director->RegisterTracer(SFEVT_KEY, SFEVT_KEY_HELD, AVK_SOFT1, AVK_SOFT3, BEHAVIOR_NONE, TRACER_BACKWARD));
        #endif
        if (static_try()) {
            static_throw(director->RegisterTracer(static_cast<SFCEventEnum>(USEREVT_SOFTKEY), BEHAVIOR_NONE, TRACER_NONE));
            if (static_try()) {
                static_throw(RegisterHandler(SREVT_RESPONDER_RENDER, SRP16_RENDER_CONTENT, HANDLER_BEFORE, HANDLER_FUNCTION(OnRender)));
                if (static_try()) {
                    #if TARGET_VERSION_GT(3, 1, 0)
                    static_throw(RegisterHandler(SFEVT_KEY, SFEVT_KEY_RELEASE, AVK_SOFT1, AVK_SOFT3, HANDLER_AFTER, HANDLER_NULL));
                    #else
                    static_throw(RegisterHandler(SFEVT_KEY, SFEVT_KEY_HELD, AVK_SOFT1, AVK_SOFT3, HANDLER_AFTER, HANDLER_NULL));
                    #endif
                    if (static_try()) {
                        static_throw(RegisterHandler(SFEVT_KEY, AVK_SOFT1, AVK_SOFT3, HANDLER_AFTER, HANDLER_FUNCTION(OnSoftkey)));
                        if (static_try()) {
                            rect = director->GetContentWorld();
                            height = SFXGraphics::GetFontHeight(AEE_FONT_NORMAL) - FONT_MARGIN;
                            if (height < MINIMUM_HEIGHT) {
                                height = MINIMUM_HEIGHT;
                            }
                            height += (BASE_MARGIN + RING_MARGIN) * 2;
                            rect.SetTop(rect.GetBottom() - height);
                            SetBaseBound(rect);
                            SetColor(COLOR_CONTENT_BASE, theme);
                        }
                    }
                }
            }
        }
    }
    return;
}

SGRSoftkeyWindow::~SGRSoftkeyWindow(Void)
{
    SFXList<ItemRecPtr>::Enumerator it(_item.GetEnumerator());

    if (it.IsValid()) {
        while (it.HasNext()) {
            ::delete it.GetNext();
        }
    }
    return;
}

SGRSoftkeyWindowPtr SGRSoftkeyWindow::GetInstance(Void)
{
    return static_cast<SGRSoftkeyWindowPtr>(SFRApplication::GetInstance()->GetFront(TYPE_WINDOW, ATTRIBUTE_SOFTKEYWINDOW, BEHAVIOR_NONE));
}

SFRResponderPtr SGRSoftkeyWindow::Bind(SFRResponderPtr responder)
{
    SFRResponderPtr result(_bind);

    if (responder != _bind) {
        _bind = responder;
        InvalidateContent();
    }
    return result;
}

SFCError SGRSoftkeyWindow::Register(SFRResponderPtr responder, SoftkeyEnum index, SFXWideStringConstRef label, Bool enable)
{
    ItemRecPtr item;
    SInt16 i;
    SFCError error(SFERR_NO_ERROR);

    if (0 <= index && index < SOFTKEY_LIMIT) {
        if ((item = Find(responder)) != null) {
            item->label[index] = label;
            item->enable[index] = enable;
            InvalidateContent();
        }
        else if ((item = ::new ItemRec) != null) {
            item->responder = responder;
            for (i = 0; i < SOFTKEY_LIMIT; ++i) {
                item->label[i] = "";
                item->enable[i] = false;
            }
            item->label[index] = label;
            item->enable[index] = enable;
            if (_item.Append(item) == SFERR_NO_ERROR) {
                InvalidateContent();
            }
            else {
                error = SFERR_NO_MEMORY;
                ::delete item;
            }
        }
        else {
            error = SFERR_NO_MEMORY;
        }
    }
    else {
        error = SFERR_INVALID_PARAM;
    }
    return error;
}

Void SGRSoftkeyWindow::Unregister(SFRResponderPtr responder)
{
    SFXList<ItemRecPtr>::Iterator it(_item.GetIterator());
    ItemRecPtr temp;

    if (it.IsValid()) {
        while (it.HasNext()) {
            temp = it.GetNext();
            if (temp->responder == responder) {
                it.Remove();
                ::delete temp;
                if (responder == _bind) {
                    _bind = null;
                }
                InvalidateContent();
                break;
            }
        }
    }
    return;
}

Void SGRSoftkeyWindow::Initialize(SFRResponderPtr responder)
{
    responder->SetReference(responder);
    return;
}

Void SGRSoftkeyWindow::Terminate(SFRResponderPtr responder)
{
    SGRSoftkeyWindowPtr softkey;

    if ((softkey = GetInstance()) != null) {
        if (responder->GetReference() != responder) {
            softkey->Bind(static_cast<SFRResponderPtr>(responder->GetReference()));
        }
        softkey->Unregister(responder);
    }
    return;
}

HANDLER_IMPLEMENT_VOIDRENDER(SGRSoftkeyWindow, OnRender, graphics)
{
    SFXRectangle rect;
    SFXRectangle temp;
    ItemRecPtr item;
    SInt16 width;

    SFRPlainWindow::ContentHandler(graphics);
    if ((item = Find(_bind)) != null) {
        rect = GetContentWorld();
        width = (rect.GetWidth() - BASE_MARGIN * (SOFTKEY_LIMIT + 1)) / SOFTKEY_LIMIT + BASE_MARGIN * 2;
        if (item->enable[SOFTKEY_1]) {
            temp = rect;
            temp.SubRight(temp.GetWidth() - width);
            DrawButton(graphics, temp, item->label[SOFTKEY_1]);
        }
        if (item->enable[SOFTKEY_3]) {
            temp = rect;
            temp.Deflate(width - BASE_MARGIN, 0);
            DrawButton(graphics, temp, item->label[SOFTKEY_3]);
        }
        if (item->enable[SOFTKEY_2]) {
            temp = rect;
            temp.AddLeft(temp.GetWidth() - width);
            DrawButton(graphics, temp, item->label[SOFTKEY_2]);
        }
    }
    return;
}

HANDLER_IMPLEMENT_BOOLEVENT(SGRSoftkeyWindow, OnSoftkey, event)
{
    SFRResponderPtr front;
    ItemRecPtr item;
    Bool result(false);

    if ((front = GetDirector()->GetFront()) != null) {
        if (front->GetAttribute() != ATTRIBUTE_COMBOBOXMENU) {
            if ((item = Find(_bind)) != null) {
                switch (event.GetP16()) {
                    case AVK_SOFT1:
                        if (item->enable[SOFTKEY_1]) {
                            result = _bind->Invoke(SFXEvent(static_cast<SFCEventEnum>(USEREVT_SOFTKEY), SOFTKEY_1, 0));
                        }
                        break;
                    case AVK_SOFT2:
                        if (item->enable[SOFTKEY_2]) {
                            result = _bind->Invoke(SFXEvent(static_cast<SFCEventEnum>(USEREVT_SOFTKEY), SOFTKEY_2, 0));
                        }
                        break;
                    case AVK_SOFT3:
                        if (item->enable[SOFTKEY_3]) {
                            result = _bind->Invoke(SFXEvent(static_cast<SFCEventEnum>(USEREVT_SOFTKEY), SOFTKEY_3, 0));
                        }
                        break;
                }
            }
        }
    }
    return result;
}

Void SGRSoftkeyWindow::DrawButton(SFXGraphicsPtr graphics, SFXRectangleConstRef rect, SFXWideStringConstRef string)
{
    static SFXRGBColor::AtomRecConst theme[] = {
        {0x00, 0x77, 0x77, 0x77},
        {0x00, 0x66, 0x66, 0x66},
        {0x00, 0xDD, 0xDD, 0xDD},
        {0x00, 0xFF, 0xFF, 0xFF}
    };
    SFXRectangle temp(rect);

    temp.Deflate(BASE_MARGIN, BASE_MARGIN);
    graphics->DrawRoundRectangle(temp, SFXSize(9, 9), theme[0]);
    temp.Deflate(RING_SIZE, RING_SIZE);
    graphics->FillRoundRectangle(temp, SFXSize(7, 7), theme[1]);
    graphics->DrawRoundRectangle(temp, SFXSize(7, 7), theme[2]);
    temp.Deflate(RING_SIZE, RING_SIZE);
    temp.AddY(FONT_MARGIN);
    graphics->DrawText(string, temp, theme[3]);
    return;
}

SGRSoftkeyWindow::ItemRecPtr SGRSoftkeyWindow::Find(SFRResponderPtr responder) const
{
    SFXList<ItemRecPtr>::Enumerator it(_item.GetEnumerator());
    ItemRecPtr temp;
    ItemRecPtr result(null);

    if (it.IsValid()) {
        while (it.HasNext()) {
            temp = it.GetNext();
            if (temp->responder == responder) {
                result = temp;
                break;
            }
        }
    }
    return result;
}