vdr-plugin-skindesigner/coreengine/viewdisplaychannel.c

#include "viewdisplaychannel.h"
#include "../config.h"

/************************************************************************************
* cViewChannel
************************************************************************************/

cViewChannel::cViewChannel(void) {
    veCustomTokens = NULL;
    ClearVariables();
    viewId = eViewType::DisplayChannel;
    viewName = strdup("displaychannel");
    numViewElements = (int)eVeDisplayChannel::count;
    viewElements = new cViewElement*[numViewElements];
    for (int i=0; i < numViewElements; i++) {
        viewElements[i] = NULL;
    }
    SetViewElements();
    veMessage = NULL;
    veChannelInfo = NULL;
    veChannelGroup = NULL;
    veEpgInfo = NULL;
    veProgressBar = NULL;
    veStatusInfo = NULL;
    veScraperContent = NULL;
    veEcmInfo = NULL;
#ifdef USE_ZAPCOCKPIT
    veChannelHints = NULL;
    veChannelDetail = NULL;
    veChannelListDetail = NULL;
    veGroupChannelListDetail = NULL;
    channelList = NULL;
    groupList = NULL;
    groupChannelList = NULL;
#endif
}

cViewChannel::~cViewChannel() {
#ifdef USE_ZAPCOCKPIT
    delete channelList;
    delete groupList;
    delete groupChannelList;
#endif
}

void cViewChannel::SetGlobals(cGlobals *globals) {
    cView::SetGlobals(globals);
#ifdef USE_ZAPCOCKPIT
    if (channelList)
        channelList->SetGlobals(globals);
    if (groupList)
        groupList->SetGlobals(globals);
    if (groupChannelList)
        groupChannelList->SetGlobals(globals);
#endif
}

void cViewChannel::PreCache(void) {
    cView::PreCache();
#ifdef USE_ZAPCOCKPIT
    if (channelList) {
        channelList->SetContainer(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
        channelList->PreCache();
    }
    if (groupList) {
        groupList->SetContainer(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
        groupList->PreCache();
    }
    if (groupChannelList) {
        groupChannelList->SetContainer(attribs->X(), attribs->Y(), attribs->Width(), attribs->Height());
        groupChannelList->PreCache();
    }
#endif
}

void cViewChannel::AddChannelViewList(const char *listName, cViewList *viewList) {
#ifdef USE_ZAPCOCKPIT
    if (!strcmp(listName, "channellist"))
        channelList = dynamic_cast<cViewListChannelList*>(viewList);
    else if (!strcmp(listName, "grouplist"))
        groupList = dynamic_cast<cViewListGroupList*>(viewList);
    else if (!strcmp(listName, "groupchannellist"))
        groupChannelList = dynamic_cast<cViewListChannelList*>(viewList);
    else
        esyslog("skindesigner: invalid view list %s in displaychannel", listName);
#endif
}

void cViewChannel::SetViewElements(void) {
    viewElementNames.insert(pair<string, int>("background", (int)eVeDisplayChannel::background));
    viewElementNames.insert(pair<string, int>("channelgroup", (int)eVeDisplayChannel::channelgroup));
    viewElementNames.insert(pair<string, int>("channelinfo", (int)eVeDisplayChannel::channelinfo));
    viewElementNames.insert(pair<string, int>("epginfo", (int)eVeDisplayChannel::epginfo));
    viewElementNames.insert(pair<string, int>("progressbar", (int)eVeDisplayChannel::progressbar));
    viewElementNames.insert(pair<string, int>("statusinfo", (int)eVeDisplayChannel::statusinfo));
    viewElementNames.insert(pair<string, int>("audioinfo", (int)eVeDisplayChannel::audioinfo));
    viewElementNames.insert(pair<string, int>("ecminfo", (int)eVeDisplayChannel::ecminfo));
    viewElementNames.insert(pair<string, int>("screenresolution", (int)eVeDisplayChannel::screenresolution));
    viewElementNames.insert(pair<string, int>("signalquality", (int)eVeDisplayChannel::signalquality));
    viewElementNames.insert(pair<string, int>("devices", (int)eVeDisplayChannel::devices));
    viewElementNames.insert(pair<string, int>("currentweather", (int)eVeDisplayChannel::currentweather));
    viewElementNames.insert(pair<string, int>("scrapercontent", (int)eVeDisplayChannel::scrapercontent));
    viewElementNames.insert(pair<string, int>("channelhints", (int)eVeDisplayChannel::channelhints));
    viewElementNames.insert(pair<string, int>("channeldetail", (int)eVeDisplayChannel::channeldetail));
    viewElementNames.insert(pair<string, int>("channellistback", (int)eVeDisplayChannel::channellistback));
    viewElementNames.insert(pair<string, int>("channellistdetail", (int)eVeDisplayChannel::channellistdetail));
    viewElementNames.insert(pair<string, int>("grouplistback", (int)eVeDisplayChannel::grouplistback));
    viewElementNames.insert(pair<string, int>("groupchannellistback", (int)eVeDisplayChannel::groupchannellistback));
    viewElementNames.insert(pair<string, int>("groupchannellistdetail", (int)eVeDisplayChannel::groupchannellistdetail));
    viewElementNames.insert(pair<string, int>("datetime", (int)eVeDisplayChannel::datetime));
    viewElementNames.insert(pair<string, int>("time", (int)eVeDisplayChannel::time));
    viewElementNames.insert(pair<string, int>("message", (int)eVeDisplayChannel::message));
    viewElementNames.insert(pair<string, int>("customtokens", (int)eVeDisplayChannel::customtokens));
}

void cViewChannel::SetViewElementObjects(void) {
    for (int i = 0; i < numViewElements; i++) {
        if (!viewElements[i])
            continue;
        if (dynamic_cast<cVeMessage*>(viewElements[i])) 
        {
            veMessage = dynamic_cast<cVeMessage*>(viewElements[i]);
        }
        else if (dynamic_cast<cVeDcChannelInfo*>(viewElements[i])) {

            veChannelInfo = dynamic_cast<cVeDcChannelInfo*>(viewElements[i]);
        }
        else if (dynamic_cast<cVeDcChannelGroup*>(viewElements[i])) 
        {
            veChannelGroup = dynamic_cast<cVeDcChannelGroup*>(viewElements[i]);
        }
        else if (dynamic_cast<cVeDcEpgInfo*>(viewElements[i])) 
        {
            veEpgInfo = dynamic_cast<cVeDcEpgInfo*>(viewElements[i]);
            veEpgInfo->SetGlobalTimers(&globalTimers);
        }
        else if (dynamic_cast<cVeDcProgressBar*>(viewElements[i])) 
        {
            veProgressBar = dynamic_cast<cVeDcProgressBar*>(viewElements[i]);
        }
        else if (dynamic_cast<cVeDcStatusInfo*>(viewElements[i])) 
        {
            veStatusInfo = dynamic_cast<cVeDcStatusInfo*>(viewElements[i]);
            veStatusInfo->SetGlobalTimers(&globalTimers);
        }
        else if (dynamic_cast<cVeDcScraperContent*>(viewElements[i])) 
        {
            veScraperContent = dynamic_cast<cVeDcScraperContent*>(viewElements[i]);
        }
#ifdef USE_ZAPCOCKPIT
        else if (dynamic_cast<cVeDcChannelListDetail*>(viewElements[i])) 
        {
            veChannelListDetail = dynamic_cast<cVeDcChannelListDetail*>(viewElements[i]);
        }
        else if (dynamic_cast<cVeDcGroupChannelListDetail*>(viewElements[i])) 
        {
            veGroupChannelListDetail = dynamic_cast<cVeDcGroupChannelListDetail*>(viewElements[i]);
        }
        else if (dynamic_cast<cVeDcChannelHints*>(viewElements[i])) 
        {
            veChannelHints = dynamic_cast<cVeDcChannelHints*>(viewElements[i]);
        }
        else if (dynamic_cast<cVeDcChannelDetail*>(viewElements[i])) 
        {
            veChannelDetail = dynamic_cast<cVeDcChannelDetail*>(viewElements[i]);
        }
#endif
        else if (dynamic_cast<cVeDcEcmInfo*>(viewElements[i])) 
        {
            veEcmInfo = dynamic_cast<cVeDcEcmInfo*>(viewElements[i]);
        }
        else if (dynamic_cast<cVeCustomTokens*>(viewElements[i])) 
        {
            veCustomTokens = dynamic_cast<cVeCustomTokens*>(viewElements[i]);
        }
        else if (dynamic_cast<cVeDevices*>(viewElements[i])) 
        {
            viewElements[i]->SetDetached();
        }
    }
}

void cViewChannel::ClearVariables(void) {
    cView::ClearVariables();
#ifdef USE_ZAPCOCKPIT
    viewType = dcDefault;
    viewTypeLast = dcDefault;
    initExtended = true;
    displayList = false;
    initList = false;
    channelInput = false;
#endif
    channelChange = false;
    mode = dmDefault;
    if (veCustomTokens)
        veCustomTokens->Reset();
    timersLoaded = false;
    globalTimers.ClearTimers();
}

void cViewChannel::SetChannel(const cChannel *channel, int number) {
    if (!timersLoaded) {
        timersLoaded = true;
        globalTimers.LoadTimers();
    }
    channelChange = true;

    //check if channelgroups have to be cleared
    bool clearChannelGroups = (mode == dmChannelGroups) ? true : false;
    mode = dmDefault;

#ifdef USE_ZAPCOCKPIT
    //check if channel hints have to be cleared
    if (number) {
        channelInput = true;
    } else if (channelInput) {
        channelInput = false;
        if (veChannelHints)
            veChannelHints->Close();
    }
    if (veChannelDetail)
        veChannelDetail->Clear(true);
#endif

    if (veChannelInfo) {
        veChannelInfo->Clear();
        veChannelInfo->Set(channel, number);
    }

    if (channel) {
        if (!channel->GroupSep()) {
            if (clearChannelGroups)
                Clear((int)eVeDisplayChannel::channelgroup);
            if (veStatusInfo)
                veStatusInfo->Set(channel);
            if (veEcmInfo)
                veEcmInfo->Set(channel);
        } else {
            mode = dmChannelGroups;
            ClearBasic(false);
            if (veChannelGroup)
                veChannelGroup->Set(channel);
        }
    }
}

void cViewChannel::SetEvents(const cEvent *present, const cEvent *following) {
    if (!timersLoaded) {
        timersLoaded = true;
        globalTimers.LoadTimers();
    }
    Clear((int)eVeDisplayChannel::epginfo);
    Clear((int)eVeDisplayChannel::progressbar);
    Clear((int)eVeDisplayChannel::scrapercontent);
    if (veProgressBar)
        veProgressBar->Set(present);

    if (!present && !following)
        return;
    
    if (veEpgInfo)
        veEpgInfo->Set(present, following);

    if (veScraperContent)
        veScraperContent->Set(present);
}

void cViewChannel::SetMessage(eMessageType type, const char *text) {
    if (veMessage) {
        if (text)
            veMessage->Set(type, text);
        else
            veMessage->Clear();
    }
}

#ifdef USE_ZAPCOCKPIT

void cViewChannel::SetViewType(eDisplaychannelView viewType) {
    viewTypeLast = this->viewType;
    this->viewType = viewType;
}

int cViewChannel::MaxItems(void) {
    initList = true;
    if (viewType == dcChannelList && channelList)
        return channelList->NumItems();
    else if (viewType == dcGroupsList && groupList)
        return groupList->NumItems();
    else if (viewType == dcGroupsChannelList && groupChannelList)
        return groupChannelList->NumItems();
    return 0;
}

bool cViewChannel::KeyRightOpensChannellist(void) {
    if (channelList) {
        if (channelList->Button() == eButtonType::left)
            return false;
        else if (channelList->Button() == eButtonType::right)
            return true;
    }
    if (groupList) {
        if (groupList->Button() == eButtonType::left)
            return true;
        else if (groupList->Button() == eButtonType::right)
            return false;
    }
    return true;
}

void cViewChannel::SetChannelInfo(const cChannel *channel) {
    if (!channel)
        return;
    if (viewType == dcChannelInfo && veChannelDetail) {
        ClearOnDisplay();
        veChannelDetail->Set(channel);
        Render((int)eVeDisplayChannel::channeldetail);
    } else if (viewType == dcChannelListInfo && veChannelListDetail) {
        veChannelListDetail->Set(channel);
        Render((int)eVeDisplayChannel::channellistdetail);
    } else if (viewType == dcGroupsChannelListInfo && veGroupChannelListDetail) {
        veGroupChannelListDetail->Set(channel);
        Render((int)eVeDisplayChannel::groupchannellistdetail);
    }
}

void cViewChannel::SetChannelList(const cChannel *channel, int index, bool current) {
    displayList = true;
    if (viewType == dcChannelList && channelList) {
        channelList->Set(channel, index, current);
    } else if (viewType == dcGroupsChannelList && groupChannelList) {
        groupChannelList->Set(channel, index, current);
    }
}

void cViewChannel::SetGroupList(const char *group, int numChannels, int index, bool current) {
    displayList = true;
    if (groupList) {
        groupList->Set(group, numChannels, index, current);  
    }
}

void cViewChannel::ClearList(void) {
    if (viewType == dcChannelList && channelList)
        channelList->Clear();
    if (viewType == dcGroupsList && groupList)
        groupList->Clear();
    if (viewType == dcGroupsChannelList && groupChannelList)
        groupChannelList->Clear();
}

void cViewChannel::SetNumChannelHints(int num) {
    if (veChannelHints)
        veChannelHints->SetNumHints(num);
    channelHints = true;
}

void cViewChannel::SetChannelHint(const cChannel *channel) {
    if (veChannelHints)
        veChannelHints->SetHint(channel);
}

#endif //USE_ZAPCOCKPIT

void cViewChannel::Close(void) {
    delete fader;
    fader = NULL;
    delete shifter;
    shifter = NULL;
    bool doAnim = true;
#ifdef USE_ZAPCOCKPIT
    if (viewType != dcDefault)
        doAnim = false;
#endif
    if (initFinished && doAnim && ShiftTime() > 0) {
        cRect shiftbox = CoveredArea();
        cPoint ref = cPoint(shiftbox.X(), shiftbox.Y());
        cPoint end = ShiftStart(shiftbox);
        shifter = new cAnimation((cShiftable*)this, end, ref, false);
        shifter->Shift();
        delete shifter;
        shifter = NULL;
    } else if (initFinished && doAnim && FadeTime() > 0) {
        fader = new cAnimation((cFadable*)this, false);
        fader->Fade();
        delete fader;
        fader = NULL;
    }
    UnScaleTv();
    ClearVariables();
    for (int i=0; i < numViewElements; i++) {
        if (!viewElements[i])
            continue;
        viewElements[i]->Close();
    }
#ifdef USE_ZAPCOCKPIT
    if (channelList)
        channelList->Close();
    if (groupList)
        groupList->Close();
    if (groupChannelList)
        groupChannelList->Close();
#endif
    sdOsd.Flush();
    sdOsd.DeleteOsd();
}

void cViewChannel::ClearBasic(bool clearBackground) {
    if (clearBackground) {
        Clear((int)eVeDisplayChannel::background, true);
        Clear((int)eVeDisplayChannel::currentweather, true);
    }
    Clear((int)eVeDisplayChannel::channelinfo, true);
    Clear((int)eVeDisplayChannel::epginfo, true);
    Clear((int)eVeDisplayChannel::statusinfo, true);
    Clear((int)eVeDisplayChannel::scrapercontent, true);
    Clear((int)eVeDisplayChannel::progressbar, true);
    Clear((int)eVeDisplayChannel::screenresolution, true);
    Clear((int)eVeDisplayChannel::signalquality, true);
    Clear((int)eVeDisplayChannel::audioinfo, true);
    Clear((int)eVeDisplayChannel::ecminfo, true);
    Clear((int)eVeDisplayChannel::devices, true);
    Clear((int)eVeDisplayChannel::customtokens, true);
}

void cViewChannel::ClearExtended(void) {
#ifdef USE_ZAPCOCKPIT
    //exit from channel list
    if ((viewTypeLast == dcChannelList || viewTypeLast == dcChannelListInfo) && viewType == dcDefault && channelList) {
        channelList->Clear();
        Clear((int)eVeDisplayChannel::channellistback);
        Clear((int)eVeDisplayChannel::channellistdetail);
        SetDirty((int)eVeDisplayChannel::channellistback);
        initExtended = true;
        ShowBasic();
    }
    //exit from channellist info to channel list
    if (viewTypeLast == dcChannelListInfo && viewType == dcChannelList) {
        Clear((int)eVeDisplayChannel::channellistdetail);
        SetDirty((int)eVeDisplayChannel::channellistdetail);
    }
    //exit from group list
    if (viewTypeLast == dcGroupsList && viewType == dcDefault && groupList) {
        groupList->Clear();
        Clear((int)eVeDisplayChannel::grouplistback);
        SetDirty((int)eVeDisplayChannel::grouplistback);
        initExtended = true;
        ShowBasic();
    }
    //exit from group channel list to group list
    if (viewTypeLast == dcGroupsChannelList && viewType == dcGroupsList && groupChannelList) {
        groupChannelList->Clear();
        Clear((int)eVeDisplayChannel::groupchannellistback);
        SetDirty((int)eVeDisplayChannel::groupchannellistback);
    }
    //exit from groupchannellist info to groupchannel list
    if (viewTypeLast == dcGroupsChannelListInfo && viewType == dcGroupsChannelList) {
        Clear((int)eVeDisplayChannel::groupchannellistdetail);
        SetDirty((int)eVeDisplayChannel::groupchannellistdetail);
    }
    //exit from channel list
    if ((viewTypeLast == dcGroupsChannelList || viewTypeLast == dcGroupsChannelListInfo) && viewType == dcDefault && groupList && groupChannelList) {
        groupList->Clear();
        groupChannelList->Clear();
        Clear((int)eVeDisplayChannel::grouplistback);
        Clear((int)eVeDisplayChannel::groupchannellistback);
        Clear((int)eVeDisplayChannel::groupchannellistdetail);
        SetDirty((int)eVeDisplayChannel::groupchannellistback);
        SetDirty((int)eVeDisplayChannel::grouplistback);
        SetDirty((int)eVeDisplayChannel::groupchannellistdetail);
        initExtended = true;
        ShowBasic();
    }
    //exit from channel info to channel or group list
    if (viewTypeLast == dcChannelInfo && (viewType == dcChannelList || viewType == dcGroupsList)) {
        Clear((int)eVeDisplayChannel::channeldetail, true);
    }
    viewTypeLast = dcDefault;
#endif
}

void cViewChannel::ClearOnDisplay(void) {
#ifdef USE_ZAPCOCKPIT
    if (viewType == dcChannelInfo && veChannelDetail) {
        vector<int> clear = veChannelDetail->GetClearOnDisplay();
        for (vector<int>::iterator ve = clear.begin(); ve != clear.end(); ve++) {
            Hide(*ve);
        }
    } else {
        cViewElement *listBack = NULL;
        if (viewType == dcChannelList)
            listBack = viewElements[(int)eVeDisplayChannel::channellistback];
        else if (viewType == dcGroupsList)
            listBack = viewElements[(int)eVeDisplayChannel::grouplistback];
        if (!listBack)
            return;
        if (listBack->DoClearAll()) {
            HideBasic();
            return;
        }
        vector<int> clear = listBack->GetClearOnDisplay();
        for (vector<int>::iterator ve = clear.begin(); ve != clear.end(); ve++) {
            Hide(*ve);
        }
    }
#endif
}

void cViewChannel::DrawBasic(bool initial) {
    if (initial) {
        Render((int)eVeDisplayChannel::background);
        Render((int)eVeDisplayChannel::currentweather);
    }
    Render((int)eVeDisplayChannel::channelinfo);
    Render((int)eVeDisplayChannel::epginfo);
    Render((int)eVeDisplayChannel::statusinfo);
    Render((int)eVeDisplayChannel::scrapercontent);
    Render((int)eVeDisplayChannel::progressbar, channelChange);
    Render((int)eVeDisplayChannel::screenresolution);
    Render((int)eVeDisplayChannel::signalquality);
    Render((int)eVeDisplayChannel::audioinfo);
    Render((int)eVeDisplayChannel::ecminfo);
    Render((int)eVeDisplayChannel::devices);
    Render((int)eVeDisplayChannel::customtokens);
    Render((int)eVeDisplayChannel::message);

#ifdef USE_ZAPCOCKPIT
    if (channelHints) {
        channelHints = false;
        if (veChannelHints) {
            if (veChannelHints->Active())
                veChannelHints->Close();
            veChannelHints->Parse();
            veChannelHints->Render();            
        }
    }
#endif
}

void cViewChannel::HideBasic(void) {
    for (int ve = (int)eVeDisplayChannel::background; ve <= (int)eVeDisplayChannel::ecminfo; ve++) {
        Hide(ve);
    }
}

void cViewChannel::ShowBasic(void) {
    for (int ve = (int)eVeDisplayChannel::background; ve <= (int)eVeDisplayChannel::ecminfo; ve++) {
        Show(ve);
    }
}

void cViewChannel::DrawExtended(void) {
#ifdef USE_ZAPCOCKPIT
    if (!displayList)
        return;
    if (initExtended) {
        ClearOnDisplay();
        initExtended = false;
    }
    if (!init && initList)
        sdOsd.LockFlush();
    if (viewType == dcChannelList && channelList) {
        Render((int)eVeDisplayChannel::channellistback);
        channelList->Draw(mcUndefined);
        if (initList)
            channelList->StartAnimation();
    } else if (viewType == dcGroupsList && groupList) {
        Render((int)eVeDisplayChannel::grouplistback);
        groupList->Draw(mcUndefined);
        if (initList)
            groupList->StartAnimation();
    } else if (viewType == dcGroupsChannelList && groupChannelList) {
        Render((int)eVeDisplayChannel::groupchannellistback);
        groupChannelList->Draw(mcUndefined);
        if (initList)
            groupChannelList->StartAnimation();
    }
    if (!init && initList)
        sdOsd.UnlockFlush();
    displayList = false;
    initList = false;
#endif
}

void cViewChannel::Flush(bool animFlush) {
    if (init) {
        sdOsd.LockFlush();
    }
    
#ifdef USE_ZAPCOCKPIT
    ClearExtended();
#endif

    //Basic Display Handling
    if (mode == dmDefault) {
        if (!shifting) {
            DrawBasic(init);
        }
    } else if (mode == dmChannelGroups) {
        if (init) {
            Render((int)eVeDisplayChannel::background);
            Render((int)eVeDisplayChannel::currentweather);
        }
        Render((int)eVeDisplayChannel::channelgroup);
    }
    if (!shifting) {
        Render((int)eVeDisplayChannel::datetime);
        Render((int)eVeDisplayChannel::time);
    }
    channelChange = false;

#ifdef USE_ZAPCOCKPIT
    DrawExtended();
#endif

    cView::Flush(animFlush);
}