WebSVN – tpanel – Diff – /trunk/tbutton.cpp

 using std::map;
 using std::pair;
 using std::thread;
 using std::atomic;
 using std::mutex;
+using std::bind;
 using namespace Button;
+#define MAX_BUFFER      65536
 extern TIcons *gIcons;
 extern amx::TAmxNet *gAmxNet;
-atomic<bool> TButton::mAniRunning = false;
+atomic<bool> TButton::mAniRunning;
+THR_REFRESH_t *TButton::mThrRefresh = nullptr;
 mutex mutex_button;
 mutex mutex_bargraph;
 mutex mutex_sysdraw;
 SYSBORDER_t sysBorders[] = {
 TButton::TButton()
+{
     DECL_TRACER("TButton::TButton()");
+    mAniRunning = false;
     mLastBlink.clear();
+}
 TButton::~TButton()
+{
         while (mTimer->isRunning())
             usleep(50);
         delete mTimer;
+    }
+    THR_REFRESH_t *next, *p = mThrRefresh;
+    while (p)
+    {
+        if (p->mImageRefresh)
+        {
+            p->mImageRefresh->stop();
+            while (p->mImageRefresh->isRunning())
+                usleep(50);
+            delete p->mImageRefresh;
+            p->mImageRefresh = nullptr;
+        }
+        next = p->next;
+        delete p;
+        p = next;
+    }
+}
 void TButton::initialize(TReadXML *xml, mxml_node_t *node)
+{
     DECL_TRACER("TButton::initialize(TReadXML *xml, mxml_node_t *node)");
     for (srIter = sr.begin(); srIter != sr.end(); srIter++)
+    {
         int number = srIter->number;
         IMAGE_t img;
+        if (srIter->sb > 0)
+            continue;
         if (!srIter->mi.empty())        // Do we have a chameleon image?
+        {
             sk_sp<SkData> image;
             if (!(image = readImage(srIter->mi)))
     lt = left;
     tp = top;
     makeElement(mActInstance);
+}
+void TButton::setResourceName(const string& name, int instance)
+{
+    DECL_TRACER("TButton::setResourceName(const string& name, int instance)");
+    if (instance < 0 || instance >= (int)sr.size())
+    {
+        MSG_ERROR("Invalid instance " << instance);
+        return;
+    }
+    if (!sr[instance].dynamic)
+    {
+        MSG_ERROR("Button " << bi << ": " << na << " is not a resource button!");
+        return;
+    }
+    sr[instance].bm = name;
+}
 bool TButton::setWorWrap(bool state, int instance)
+{
     DECL_TRACER("TButton::setWorWrap(bool state, int instance)");
     if (instance < 0 || instance >= (int)sr.size())
+    }
     funcTimer(mLastBlink);
+}
+void TButton::_imageRefresh(const string& url)
+{
+    DECL_TRACER("TButton::_imageRefresh(const string& url)");
+    ulong parent = mHandle & 0xffff0000;
+    getDrawOrder(sr[mActInstance]._do, (DRAW_ORDER *)&mDOrder);
+    if (TError::isError())
+    {
+        TError::clear();
+        return;
+    }
+    SkBitmap imgButton;
+    imgButton.allocN32Pixels(wt, ht);
+    for (int i = 0; i < ORD_ELEM_COUNT; i++)
+    {
+        if (mDOrder[i] == ORD_ELEM_FILL)
+        {
+            if (!buttonFill(&imgButton, mActInstance))
+                return;
+        }
+        else if (mDOrder[i] == ORD_ELEM_BITMAP)
+        {
+            RESOURCE_T resource = gPrjResources->findResource(sr[mActInstance].bm);
+            if (resource.protocol.empty())
+            {
+                MSG_ERROR("Resource " << sr[mActInstance].bm << " not found!");
+                return;
+            }
+            try
+            {
+                char *content = nullptr;
+                size_t length = 0, contentlen = 0;
+                if ((content = gPrjResources->tcall(&length, url, resource.user, resource.password)) == nullptr)
+                    return;
+                contentlen = gPrjResources->getContentSize();
+                if (content == nullptr)
+                {
+                    MSG_ERROR("Server returned no or invalid content!");
+                    return;
+                }
+                sk_sp<SkData> data = SkData::MakeWithCopy(content, contentlen);
+                if (!data)
+                {
+                    MSG_ERROR("Could not make an image!");
+                    return;
+                }
+                SkBitmap image;
+                if (!DecodeDataToBitmap(data, &image))
+                {
+                    MSG_ERROR("Error creating an image!");
+                    return;
+                }
+                loadImage(&imgButton, image, mActInstance);
+            }
+            catch (std::exception& e)
+            {
+                MSG_ERROR(e.what());
+                return;
+            }
+        }
+        else if (mDOrder[i] == ORD_ELEM_ICON)
+        {
+            if (!buttonIcon(&imgButton, mActInstance))
+                return;
+        }
+        else if (mDOrder[i] == ORD_ELEM_TEXT)
+        {
+            if (!buttonText(&imgButton, mActInstance))
+                return;
+        }
+        else if (mDOrder[i] == ORD_ELEM_BORDER)
+        {
+            if (!buttonBorder(&imgButton, mActInstance))
+                return;
+        }
+    }
+    if (mGlobalOO >= 0 || sr[mActInstance].oo >= 0) // Take overall opacity into consideration
+    {
+        SkBitmap ooButton;
+        int w = imgButton.width();
+        int h = imgButton.height();
+        ooButton.allocN32Pixels(w, h, true);
+        SkCanvas canvas(ooButton);
+        SkIRect irect = SkIRect::MakeXYWH(0, 0, w, h);
+        SkRegion region;
+        region.setRect(irect);
+        SkScalar oo;
+        if (mGlobalOO >= 0 && sr[mActInstance].oo >= 0)
+        {
+            oo = std::min((SkScalar)mGlobalOO, (SkScalar)sr[mActInstance].oo);
+            MSG_DEBUG("Set global overal opacity to " << oo);
+        }
+        else if (sr[mActInstance].oo >= 0)
+        {
+            oo = (SkScalar)sr[mActInstance].oo;
+            MSG_DEBUG("Set overal opacity to " << oo);
+        }
+        else
+        {
+            oo = (SkScalar)mGlobalOO;
+            MSG_DEBUG("Set global overal opacity to " << oo);
+        }
+        SkScalar alpha = 1.0 / 255.0 * oo;
+        MSG_DEBUG("Calculated alpha value: " << alpha);
+        SkPaint paint;
+        paint.setAlphaf(alpha);
+        paint.setImageFilter(SkImageFilters::AlphaThreshold(region, 0.0, alpha, nullptr));
+        canvas.drawBitmap(imgButton, 0, 0, &paint);
+        imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});
+        imgButton = ooButton;
+    }
+    mLastImage = imgButton;
+    size_t rowBytes = imgButton.info().minRowBytes();
+    if (!prg_stopped && visible && _displayButton)
+        _displayButton(mHandle, parent, (unsigned char *)imgButton.getPixels(), wt, ht, rowBytes, lt, tp);
+}
 void TButton::registerSystemButton()
+{
     DECL_TRACER("TButton::registerSystemButton()");
     if (mSystemReg)
 bool TButton::buttonBitmap(SkBitmap* bm, int instance)
+{
     DECL_TRACER("TButton::buttonBitmap(SkBitmap* bm, int instane)");
+    if (sr[instance].dynamic)
+        return buttonDynamic(bm, instance);
     if (!sr[instance].mi.empty() && !sr[instance].bm.empty())       // Chameleon image?
+    {
         MSG_TRACE("Chameleon image ...");
         map<int, IMAGE_t>::iterator iterImages = mImages.find(sr[instance].number);
         SkBitmap imgRed(iterImages->second.imageMi);
             return false;
+        }
         SkCanvas can(*bm, SkSurfaceProps(1, kUnknown_SkPixelGeometry));
         paint.setBlendMode(SkBlendMode::kSrc);
+        if (sr[instance].sb == 0)
-        can.drawBitmap(img, position.left, position.top, &paint);
+            can.drawBitmap(img, position.left, position.top, &paint);
+        else    // Scale to fit
+        {
+            SkRect rect = SkRect::MakeXYWH(position.left, position.top, position.width, position.height);
+            sk_sp<SkImage> im = SkImage::MakeFromBitmap(img);
+            can.drawImageRect(im, rect, &paint);
+        }
+    }
     else if (!sr[instance].bm.empty())
+    {
         MSG_TRACE("Drawing normal image ...");
         map<int, IMAGE_t>::iterator iterImages = mImages.find(sr[instance].number);
         MSG_DEBUG("Putting bitmap on top of image ...");
         SkPaint paint;
         paint.setBlendMode(SkBlendMode::kSrc);
         SkCanvas can(*bm, SkSurfaceProps(1, kUnknown_SkPixelGeometry));
+        if (sr[instance].sb == 0)
-        can.drawBitmap(image, position.left, position.top, &paint);
+            can.drawBitmap(image, position.left, position.top, &paint);
+        else    // Scale to fit
+        {
+            SkRect rect = SkRect::MakeXYWH(position.left, position.top, position.width, position.height);
+            sk_sp<SkImage> im = SkImage::MakeFromBitmap(image);
+            can.drawImageRect(im, rect, &paint);
+        }
+    }
     else
+    {
         MSG_DEBUG("No bitmap defined.");
+    }
     return true;
+}
+bool TButton::buttonDynamic(SkBitmap* bm, int instance)
+{
+    DECL_TRACER("TButton::buttonDynamic(SkBitmap* bm, int instance)");
+    if (!gPrjResources)
+    {
+        MSG_ERROR("Internal error: Global resource class not initialized!");
+        return false;
+    }
+    if (!sr[instance].dynamic)
+    {
+        MSG_WARNING("Button " << bi << ": \"" << na << "\" is not for remote image!");
+        return false;
+    }
+    RESOURCE_T resource = gPrjResources->findResource(1, sr[instance].bm);
+    if (resource.protocol.empty())
+    {
+        MSG_ERROR("Resource " << sr[instance].bm << " not found!");
+        return false;
+    }
+    string path = resource.path;
+    if (!resource.file.empty())
+        path += "/" + resource.file;
+    string url = gPrjResources->makeURL(toLower(resource.protocol), resource.host, 0, path);
+    try
+    {
+        MSG_TRACE("Starting thread for loading a dynamic image ...");
+        mThrRes = std::thread([=] { this->funcResource(&resource, url, bm, instance); });
+        MSG_TRACE("Thread started. Detaching ...");
+        mThrRes.detach();
+        MSG_TRACE("Thread is running and detached.");
+    }
+    catch (std::exception& e)
+    {
+        MSG_ERROR("Error starting the AmxNet thread: " << e.what());
+    }
+    return true;
+}
+void TButton::funcResource(const RESOURCE_T* resource, const std::string& url, SkBitmap* bm, int instance)
+{
+    DECL_TRACER("TButton::funcResource(RESOURCE_T* resource, std::string& url, SkBitmap* bm, int instance)");
+    if (resource->refresh > 0 && !resource->dynamo)      // Periodically refreshing image?
+    {
+        MSG_DEBUG("Retrieving periodicaly refreshed image");
+        ulong parent = (mHandle >> 16) & 0x0000ffff;
+        if (!mHandle || !parent || bi <= 1)
+        {
+            MSG_ERROR("Invalid button. Can't make a dynamo image!");
+            return;
+        }
+        THR_REFRESH_t *thref = _findResource(mHandle, parent, bi);
+        TImageRefresh *mImageRefresh = nullptr;
+        if (!thref)
+        {
+            MSG_DEBUG("Creating a new refresh thread");
+            mImageRefresh = new TImageRefresh();
+            mImageRefresh->registerCallback(bind(&TButton::_imageRefresh, this, std::placeholders::_1));
+            mImageRefresh->setInterval(std::chrono::seconds(resource->refresh));
+            mImageRefresh->setUsername(resource->user);
+            mImageRefresh->setPassword(resource->password);
+            if (resource->preserve)
+                mImageRefresh->setRunOnce();
+            _addResource(mImageRefresh, mHandle, parent, bi);
+        }
+        else
+        {
+            mImageRefresh = thref->mImageRefresh;
+            if (!mImageRefresh)
+            {
+                MSG_ERROR("Error creating a new refresh class!");
+                return;
+            }
+            mImageRefresh->setInterval(std::chrono::seconds(resource->refresh));
+            mImageRefresh->setUsername(resource->user);
+            mImageRefresh->setPassword(resource->password);
+            if (resource->preserve)
+                mImageRefresh->setRunOnce();
+        }
+        if (!mImageRefresh->isRunning())
+        {
+            MSG_DEBUG("Starting a refresh thread.");
+            mImageRefresh->run(url);
+        }
+    }
+    else if (resource->refresh == 0 && !resource->dynamo)
+    {
+        MSG_DEBUG("Retrieving single image");
+        try
+        {
+            char *content = nullptr;
+            size_t length = 0, contentlen = 0;
+            if ((content = gPrjResources->tcall(&length, url, resource->user, resource->password)) == nullptr)
+                return;
+            contentlen = gPrjResources->getContentSize();
+            MSG_DEBUG("Loaded " << contentlen << " bytes:");
+            sk_sp<SkData> data = SkData::MakeWithCopy(content, contentlen);
+            if (!data)
+            {
+                MSG_ERROR("Error making image data!");
+                return;
+            }
+            SkBitmap image;
+            if (!DecodeDataToBitmap(data, &image))
+            {
+                MSG_ERROR("Error creating an image!");
+                return;
+            }
+            loadImage(bm, image, instance);
+            return;
+        }
+        catch (std::exception& e)
+        {
+            MSG_ERROR(e.what());
+            return;
+        }
+    }
+    else
+    {
+        MSG_DEBUG("Retrieving a video");
+        if (_playVideo && !prg_stopped)
+        {
+            ulong parent = (mHandle >> 16) & 0x0000ffff;
+            _playVideo(mHandle, parent, lt, tp, wt, ht, url, resource->user, resource->password);
+        }
+    }
+}
+bool TButton::loadImage(SkBitmap* bm, SkBitmap& image, int instance)
+{
+    DECL_TRACER("TButton::loadImage(SkBitmap* bm, SkBitmap& image, int instance)");
+    SkImageInfo info = image.info();
+    POSITION_t position = calcImagePosition(info.width(), info.height(), SC_BITMAP, instance);
+    if (!position.valid)
+    {
+        MSG_ERROR("Error calculating the position of the image for button number " << bi);
+        return false;
+    }
+    MSG_DEBUG("Putting bitmap on top of image ...");
+    SkPaint paint;
+    paint.setBlendMode(SkBlendMode::kSrc);
+    SkCanvas can(*bm, SkSurfaceProps(1, kUnknown_SkPixelGeometry));
+    if (sr[instance].sb == 0)
+        can.drawBitmap(image, position.left, position.top, &paint);
+    else    // Scale to fit
+    {
+        SkRect rect = SkRect::MakeXYWH(position.left, position.top, position.width, position.height);
+        sk_sp<SkImage> im = SkImage::MakeFromBitmap(image);
+        can.drawImageRect(im, rect, &paint);
+    }
+    return true;
+}
 bool TButton::barLevel(SkBitmap* bm, int instance, int level)
+{
     DECL_TRACER("TButton::barLevel(SkBitmap* bm, int instance, int level)");
     if (!sr[0].mi.empty() && !sr[1].bm.empty())       // Chameleon image?
                 return false;
+            }
+        }
         else if (mDOrder[i] == ORD_ELEM_BITMAP)
+        {
-            if (!buttonBitmap(&imgButton, instance))
+            if (!sr[instance].dynamic && !buttonBitmap(&imgButton, instance))
+            {
+                mutex_button.unlock();
+                return false;
+            }
+            else if (sr[instance].dynamic && !buttonDynamic(&imgButton, instance))
+            {
                 mutex_button.unlock();
                 return false;
+            }
+        }
+    }
     mLastImage = imgButton;
     size_t rowBytes = imgButton.info().minRowBytes();
-    if (show && visible && instance == mActInstance && _displayButton)
+    if (!prg_stopped && show && visible && instance == mActInstance && _displayButton)
         _displayButton(mHandle, parent, (unsigned char *)imgButton.getPixels(), wt, ht, rowBytes, lt, tp);
     mutex_button.unlock();
     return true;
+}
+    }
     mLastImage = imgButton;
     size_t rowBytes = imgButton.info().minRowBytes();
-    if (show && visible && instance == mActInstance && _displayButton)
+    if (!prg_stopped && show && visible && instance == mActInstance && _displayButton)
         _displayButton(mHandle, parent, (unsigned char *)imgButton.getPixels(), wt, ht, rowBytes, lt, tp);
     mutex_bargraph.unlock();
     return true;
+}
     DECL_TRACER("TButton::showLastButton()");
     if (mLastImage.empty())
         return;
-    if (visible && _displayButton)
+    if (!prg_stopped && visible && _displayButton)
+    {
         ulong parent = mHandle & 0xffff0000;
         size_t rowBytes = mLastImage.info().minRowBytes();
         _displayButton(mHandle, parent, (unsigned char *)mLastImage.getPixels(), wt, ht, rowBytes, lt, tp);
+    }
     DECL_TRACER("TButton::hide()");
     if (type == MULTISTATE_GENERAL && ar == 1)
         mAniRunning = false;
-    if (total)
+    if (!prg_stopped && total)
+    {
         SkBitmap imgButton;
         imgButton.allocN32Pixels(wt, ht);
         imgButton.eraseColor(SK_ColorTRANSPARENT);
         ulong parent = mHandle & 0xffff0000;
         i++;
+    }
     return false;
+}
+THR_REFRESH_t *TButton::_addResource(TImageRefresh* refr, ulong handle, ulong parent, int bi)
+{
+    DECL_TRACER("TButton::_addResource(TImageRefresh* refr, ulong handle, ulong parent, int bi)");
+    THR_REFRESH_t *p = mThrRefresh;
+    THR_REFRESH_t *r, *last = p;
+    if (!refr || !handle || !parent || bi <= 0)
+    {
+        MSG_ERROR("Invalid parameter!");
+        return nullptr;
+    }
+    r = new THR_REFRESH_t;
+    r->mImageRefresh = refr;
+    r->handle = handle;
+    r->parent = parent;
+    r->bi = bi;
+    r->next = nullptr;
+    // If the chain is empty, add the new item;
+    if (!mThrRefresh)
+        mThrRefresh = r;
+    else    // Find the end and append the item
+    {
+        while (p)
+        {
+            last = p;
+            if (p->handle == handle && p->parent == parent && p->bi == bi)
+            {
+                MSG_WARNING("Duplicate button found! Didn't add it again.");
+                delete r;
+                return p;
+            }
+            p = p->next;
+        }
+        last->next = r;
+    }
+    MSG_DEBUG("New dynamic button added.");
+    return r;
+}
+THR_REFRESH_t *TButton::_findResource(ulong handle, ulong parent, int bi)
+{
+    DECL_TRACER("TButton::_findResource(ulong handle, ulong parent, int bi)");
+    THR_REFRESH_t *p = mThrRefresh;
+    while (p)
+    {
+        if (p->handle == handle && p->parent == parent && p->bi == bi)
+            return p;
+        p = p->next;
+    }
+    return nullptr;
+}

Subversion Repositories tpanel

(root)/trunk/tbutton.cpp @ 21 – Rev 20 → 21