Subversion Repositories tpanel

/*
 * Copyright (C) 2020, 2021 by Andreas Theofilu <andreas@theosys.at>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "tresources.h"
#include "tpagemanager.h"
#include "tpage.h"

using std::string;
using namespace Button;

extern TPageManager *gPageManager;

TPage::TPage(const string& name)
{
    DECL_TRACER("TPage::TPage(const string& name)");
    TError::clear();
    initialize(name);
}

TPage::~TPage()
{
    DECL_TRACER("TPage::~TPage()");

    MSG_DEBUG("Destroing page " << pageID << ": " << name);
    BUTTONS_T *p = mButtons;
    BUTTONS_T *next = nullptr;

    while (p)
    {
        next = p->next;
        delete p->button;
        delete p;
        p = next;
    }

    mButtons = nullptr;

    PAGECHAIN_T *pc = mSubPages;
    PAGECHAIN_T *pc_next = nullptr;

    // We're not allowd to delete the subpages here, because they're managed
    // by the TPageManager.
    while (pc)
    {
        pc_next = pc->next;
        delete pc;
        pc = pc_next;
    }

    mSubPages = nullptr;
}

void TPage::initialize(const string& nm)
{
    DECL_TRACER("TPage::initialize(const string& name)");
    makeFileName(TConfig::getProjectPath(), nm);

    if (isValidFile())
        mPath = getFileName();

    TReadXML reader(mPath);

    if (TError::isError())
        return;

    reader.findElement("page", "type");

    if (!reader.success())
    {
        MSG_ERROR("Element \"page\" with attribute \"type\" was not found!");
        TError::setError();
        return;
    }

    string type = reader.getAttribute("type");

    if (type.compare("page") != 0)
    {
        MSG_ERROR("Invalid page type \"" << type << "\"!");
        TError::setError();
        return;
    }

    mxml_node_t *node = reader.getFirstChild();

    while (node)
    {
        string e = reader.getElementName(node);

        if (e.compare("pageID") == 0)
            pageID = reader.getIntFromNode(node);
        else if (e.compare("name") == 0)
            name = reader.getTextFromNode(node);
        else if (e.compare("width") == 0)
            width = reader.getIntFromNode(node);
        else if (e.compare("height") == 0)
            height = reader.getIntFromNode(node);
        else if (e.compare("button") == 0)
        {
            TButton *button = new TButton();
            button->setPalette(mPalette);
            button->setFonts(mFonts);
            button->registerCallback(_displayButton);
            button->registerCallbackFT(_setText);
            button->regCallPlayVideo(_playVideo);
            button->initialize(&reader, node);

            if (TError::isError())
            {
                MSG_WARNING("Button \"" << button->getButtonName() << "\" deleted because of an error!");
                delete button;
                return;
            }

            button->setHandle(((pageID << 16) & 0xffff0000) | button->getButtonIndex());
            button->createButtons();
            addButton(button);
        }
        else if (e.compare("sr") == 0)
        {
            SR_T bsr;
            bsr.number = atoi(reader.getAttributeFromNode(node, "number").c_str());
            mxml_node_t *n = reader.getFirstChild(node);

            while (n)
            {
                string ename = reader.getElementName(n);

                if (ename.compare("bs") == 0)
                    bsr.bs = reader.getTextFromNode(n);
                else if (ename.compare("cb") == 0)
                    bsr.cb = reader.getTextFromNode(n);
                else if (ename.compare("cf") == 0)
                    bsr.cf = reader.getTextFromNode(n);
                else if (ename.compare("ct") == 0)
                    bsr.ct = reader.getTextFromNode(n);
                else if (ename.compare("ec") == 0)
                    bsr.ec = reader.getTextFromNode(n);
                else if (ename.compare("bm") == 0)
                    bsr.bm = reader.getTextFromNode(n);
                else if (ename.compare("fi") == 0)
                    bsr.fi = reader.getIntFromNode(n);

                n = reader.getNextChild(n);
            }

            sr.push_back(bsr);
        }

        node = reader.getNextChild();
    }

    sortButtons();
}

void TPage::show()
{
    DECL_TRACER("TPage::show()");

    if (!_setBackground)
    {
        if (gPageManager && gPageManager->getCallbackBG())
            _setBackground = gPageManager->getCallbackBG();
        else
        {
            MSG_WARNING("No callback \"setBackground\" was set!");
            return;
        }
    }

    ulong handle = (pageID << 16) & 0xffff0000;
    MSG_DEBUG("Processing page " << pageID);

    if (!sr[0].bm.empty())
    {
        sk_sp<SkData> rawImage = readImage(sr[0].bm);

        if (rawImage)
        {
            SkBitmap bm;
            int l, t;

            DecodeDataToBitmap(rawImage, &bm);
            SkImageInfo info = bm.info();
            size_t rowBytes = info.minRowBytes();
            size_t size = info.computeByteSize(rowBytes);
            calcPosition(info.width(), info.height(), &l, &t);
            MSG_DEBUG("Background image size: l=" << l << ", t=" << t << ", w=" << info.width() << ", h=" << info.height());
            sk_sp<SkImage> im = SkImage::MakeFromBitmap(bm);
            bm.allocN32Pixels(width, height);
            bm.eraseColor(TColor::getSkiaColor(sr[0].cf));
            SkCanvas can(bm, SkSurfaceProps(1, kUnknown_SkPixelGeometry));
            SkRect rect = SkRect::MakeXYWH(l, t, info.width(), info.height());
            SkPaint paint;
            paint.setBlendMode(SkBlendMode::kSrc);
            can.drawImageRect(im, rect, &paint);
            rowBytes = bm.info().minRowBytes();
            size = bm.info().computeByteSize(rowBytes);

            if (gPageManager && gPageManager->getScaleFactor() != 1.0)
            {
                paint.setFilterQuality(kHigh_SkFilterQuality);
                // Calculate new dimension
                double scaleFactor = gPageManager->getScaleFactor();
                MSG_DEBUG("Using scale factor " << scaleFactor);
                int lwidth = (int)((double)info.width() * scaleFactor);
                int lheight = (int)((double)info.height() * scaleFactor);
                int twidth = (int)((double)width * scaleFactor);
                int theight = (int)((double)height * scaleFactor);
                calcPosition(lwidth, lheight, &l, &t, true);
                MSG_DEBUG("Scaled background image: l=" << l << ", t=" << t << ", w=" << lwidth << ", h=" << lheight << ", total w=" << twidth << ", total h=" << theight);
                // Create a canvas and draw new image
                sk_sp<SkImage> im = SkImage::MakeFromBitmap(bm);
                bm.allocN32Pixels(twidth, theight);
                bm.eraseColor(TColor::getSkiaColor(sr[0].cf));
                SkCanvas can1(bm, SkSurfaceProps(1, kUnknown_SkPixelGeometry));
                SkRect rect = SkRect::MakeXYWH(l, t, lwidth, lheight);
                can1.drawImageRect(im, rect, &paint);
                rowBytes = bm.info().minRowBytes();
                size = bm.info().computeByteSize(rowBytes);
            }

            _setBackground(handle, (unsigned char *)bm.getPixels(), size, rowBytes, TColor::getColor(sr[0].cf));
        }
        else
        {
            MSG_WARNING("Couldn't read image " << sr[0].bm);
            _setBackground(handle, nullptr, 0, 0, TColor::getColor(sr[0].cf));
        }
    }
    else
    {
        MSG_DEBUG("Calling \"setBackground\" with no image ...");
        _setBackground(handle, nullptr, 0, 0, TColor::getColor(sr[0].cf));
    }

    // Draw the buttons
    BUTTONS_T *button = mButtons;

    while (button)
    {
        if (button->button)
        {
            MSG_DEBUG("Drawing button " << button->button->getButtonIndex() << ": " << button->button->getButtonName());
            button->button->registerCallback(_displayButton);
            button->button->registerCallbackFT(_setText);
            button->button->regCallPlayVideo(_playVideo);
            button->button->setFonts(mFonts);
            button->button->setPalette(mPalette);
            button->button->createButtons();

            if (sr.size() > 0)
                button->button->setGlobalOpacity(sr[0].oo);

            button->button->show();
        }

        button = button->next;
    }

    mVisible = true;
}

PAGECHAIN_T *TPage::addSubPage(TSubPage* pg)
{
    DECL_TRACER("TPage::addSubPage(TSubPage* pg)");

    if (!pg)
    {
        MSG_ERROR("Parameter is NULL!");
        TError::setError();
        return nullptr;
    }

    PAGECHAIN_T *chain = new PAGECHAIN_T;
    chain->subpage = pg;
    chain->next = nullptr;
    PAGECHAIN_T *spg = mSubPages;

    if (spg)
    {
        // First make sure that the new page is not already in the chain.
        PAGECHAIN_T *p = spg;

        while (p)
        {
            if (p->subpage->getNumber() == pg->getNumber())
            {
                MSG_TRACE("Page " << pg->getNumber() << " is already in chain. Don't add it again.");
                delete chain;
                return p;
            }

            p = p->next;
        }

        // The subpage is not in chain. So we add it now.
        p = spg;
        // Find the last element in chain
        while (p->next)
            p = p->next;

        p->next = chain;
    }
    else
    {
        mZOrder = 0;
        mSubPages = chain;
    }

    mLastSubPage = 0;
    return chain;
}

bool TPage::removeSubPage(int ID)
{
    DECL_TRACER("TPage::removeSubPage(int ID)");

    PAGECHAIN_T *p = mSubPages;
    PAGECHAIN_T *prev = nullptr;

    while (p)
    {
        if (p->subpage->getNumber() == ID)
        {
            PAGECHAIN_T *next = p->next;

            if (prev)
                prev->next = next;
            else
                mSubPages = next;

            delete p;
            mLastSubPage = 0;
            return true;
        }

        prev = p;
        p = p->next;
    }

    return false;
}

bool TPage::removeSubPage(const std::string& nm)
{
    DECL_TRACER("TPage::removeSubPage(const std::string& nm)");

    PAGECHAIN_T *p = mSubPages;
    PAGECHAIN_T *prev = nullptr;

    while (p)
    {
        if (p->subpage->getName().compare(nm) == 0)
        {
            PAGECHAIN_T *next = p->next;

            if (prev)
                prev->next = next;
            else
                mSubPages = next;

            delete p;
            mLastSubPage = 0;
            return true;
        }

        prev = p;
        p = p->next;
    }

    return false;
}

TSubPage *TPage::getSubPage(int pageID)
{
    DECL_TRACER("TPage::getSubPage(int pageID)");

    PAGECHAIN_T *pg = mSubPages;

    while (pg)
    {
        if (pg->subpage->getNumber() == pageID)
        {
            mLastSubPage = pageID;
            return pg->subpage;
        }

        pg = pg->next;
    }

    mLastSubPage = 0;
    return nullptr;
}

TSubPage *TPage::getSubPage(const std::string& name)
{
    DECL_TRACER("TPage::getSubPage(const std::string& name)");

    PAGECHAIN_T *pg = mSubPages;

    while (pg)
    {
        if (pg->subpage->getName().compare(name) == 0)
        {
            mLastSubPage = pg->subpage->getNumber();
            return pg->subpage;
        }

        pg = pg->next;
    }

    mLastSubPage = 0;
    return nullptr;
}

TSubPage *TPage::getFirstSubPage()
{
    DECL_TRACER("TPage::getFirstSubPage()");

    PAGECHAIN_T *pg = mSubPages;

    if (pg)
    {
        if (pg->subpage)
        {
            mLastSubPage = pg->subpage->getNumber();
            MSG_DEBUG("Subpage " << pg->subpage->getNumber() << ". " << pg->subpage->getName());
            return pg->subpage;
        }
    }

    MSG_DEBUG("No subpages in chain.");
    mLastSubPage = 0;
    return nullptr;
}

TSubPage *TPage::getNextSubPage()
{
    DECL_TRACER("TPage::getNextSubPage()");

    if (mLastSubPage > 0)
    {
        PAGECHAIN_T *p = mSubPages;

        while (p)
        {
            if (p->subpage->getNumber() == mLastSubPage)
            {
                if (p->next && p->next->subpage)
                {
                    TSubPage *page = p->next->subpage;
                    mLastSubPage = page->getNumber();
                    MSG_DEBUG("Subpage " << page->getNumber() << ". " << page->getName());
                    return page;
                }
            }

            p = p->next;
        }
    }

    MSG_DEBUG("No more subpages in chain.");
    mLastSubPage = 0;
    return nullptr;
}

BUTTONS_T *TPage::addButton(TButton* button)
{
    DECL_TRACER("*TPage::addButton(TButton* button)");

    if (!button)
    {
        MSG_ERROR("Parameter is NULL!");
        TError::setError();
        return nullptr;
    }

    BUTTONS_T *chain = new BUTTONS_T;
    BUTTONS_T *bts = mButtons;
    chain->button = button;

    if (bts)
    {
        BUTTONS_T *p = bts;

        while (p->next)
            p = p->next;

        p->next = chain;
        chain->previous = p;
    }
    else
        mButtons = chain;

    return chain;
}

bool TPage::hasButton(int id)
{
    DECL_TRACER("TPage::hasButton(int id)");

    BUTTONS_T *bt = mButtons;

    while (bt)
    {
        if (bt->button && bt->button->getButtonIndex() == id)
            return true;

        bt = bt->next;
    }

    return false;
}

TButton *TPage::getButton(int id)
{
    DECL_TRACER("TPage::getButton(int id)");

    BUTTONS_T *bt = mButtons;

    while (bt)
    {
        if (bt->button && bt->button->getButtonIndex() == id)
            return bt->button;

        bt = bt->next;
    }

    return nullptr;
}

std::vector<TButton *> TPage::getButtons(int ap, int ad)
{
    DECL_TRACER("TSubPage::getButtons(int ap, int ad)");

    std::vector<TButton *> list;
    BUTTONS_T *bt = mButtons;

    while (bt)
    {
        if (bt->button->getAddressPort() == ap && bt->button->getAddressChannel() == ad)
            list.push_back(bt->button);

        bt = bt->next;
    }

    return list;
}

void TPage::drop()
{
    DECL_TRACER("TPage::drop()");

    PAGECHAIN_T *pc = mSubPages;

    while (pc)
    {
        pc->subpage->drop();
        pc = pc->next;
    }

    mZOrder = ZORDER_INVALID;
    mVisible = false;
}

void TPage::calcPosition(int im_width, int im_height, int *left, int *top, bool scale)
{
    DECL_TRACER("TPage::calcPosition(int im_width, int im_height, int *left, int *top)");

    int nw = width;
    int nh = height;

    if (scale && gPageManager && gPageManager->getScaleFactor() != 1.0)
    {
        nw = (int)((double)width * gPageManager->getScaleFactor());
        nh = (int)((double)height * gPageManager->getScaleFactor());
    }

    switch (sr[0].jb)
    {
        case 0: // absolute position
            *left = sr[0].bx;
            *top = sr[0].by;

            if (scale && gPageManager && gPageManager->getScaleFactor() != 1.0)
            {
                *left = (int)((double)sr[0].bx * gPageManager->getScaleFactor());
                *left = (int)((double)sr[0].by * gPageManager->getScaleFactor());
            }
        break;

        case 1: // top, left
            *left = 0;
            *top = 0;
        break;

        case 2: // center, top
            *left = (nw - im_width) / 2;
            *top = 0;
        break;

        case 3: // right, top
            *left = nw - im_width;
            *top = 0;
        break;

        case 4: // left, middle
            *left = 0;
            *top = (nh - im_height) / 2;
        break;

        case 6: // right, middle
            *left = nw - im_width;
            *top = (nh - im_height) / 2;
        break;

        case 7: // left, bottom
            *left = 0;
            *top = nh - im_height;
        break;

        case 8: // center, bottom
            *left = (nw - im_width) / 2;
            *top = nh - im_height;
        break;

        case 9: // right, bottom
            *left = nw - im_width;
            *top = nh - im_height;
        break;

        default:    // center middle
            *left = (nw - im_width) / 2;
            *top = (nh - im_height) / 2;
    }

    if (*left < 0)
        *left = 0;

    if (*top < 0)
        *top = 0;
}

/*
 * Sort the button according to their Z-order.
 * The button with the highest Z-order will be the last button in the chain.
 * The algorithm is a bubble sort algorithm.
 */
bool TPage::sortButtons()
{
    DECL_TRACER("TPage::sortButtons()");

    bool turned = true;

    while (turned)
    {
        BUTTONS_T *button = mButtons;
        turned = false;

        while (button)
        {
            int zo = button->button->getZOrder();

            if (button->previous)
            {
                if (zo < button->previous->button->getZOrder())
                {
                    BUTTONS_T *pprev = button->previous->previous;
                    BUTTONS_T *prev = button->previous;
                    BUTTONS_T *next = button->next;

                    if (pprev)
                        pprev->next = button;

                    prev->next = next;
                    prev->previous = button;
                    button->next = prev;
                    button->previous = pprev;

                    if (!pprev)
                        mButtons = button;

                    button = next;

                    if (next)
                        next->previous = prev;

                    turned = true;
                    continue;
                }
            }

            button = button->next;
        }
    }

    return true;
}