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



#include <include/core/SkRegion.h>
#include <include/core/SkImageFilter.h>
#include <include/effects/SkImageFilters.h>
#include <include/core/SkPath.h>
#include <include/core/SkSurfaceProps.h>
//#ifndef __MACH__
//#include <include/core/SkFilterQuality.h>
//#endif
#include <include/core/SkMaskFilter.h>
//#include <include/core/SkImageEncoder.h>
#include <include/core/SkRRect.h>
#include <include/core/SkBlurTypes.h>
 
//#ifdef __ANDROID__
//#include <QtAndroidExtras/QAndroidJniObject>
//#include <QtAndroid>
//#endif

 
        SkScalar alpha = 1.0 / 255.0 * oo;
        MSG_DEBUG("Calculated alpha value: " << alpha);
        SkPaint paint;
        paint.setAlphaf(alpha);
        //(SkImageFilters::AlphaThreshold(region, 0.0, alpha, nullptr));
        sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgButton);
        canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);
        imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});
        imgButton = ooButton;
    }
 

 
    bitmap.eraseColor(color);                       // Fill the new bitmap with the fill color
    SkCanvas ctx(*bm, SkSurfaceProps());            // Create a canvas
    SkPaint paint;                                  // The paint "device"
    paint.setBlendMode(SkBlendMode::kSrcOver);      // We're overwriting each pixel
    sk_sp<SkImage> _image = SkImages::RasterFromBitmap(bitmap);    // Technically we need an image. So we convert our new bitmap into an image.
    ctx.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);   // Now we put the new image over the existing one.
    return true;
}
 
bool TButton::buttonBitmap(SkBitmap* bm, int inst)

        MSG_DEBUG("Have both images: " << (haveBothImages ? "YES" : "NO"));
        SkCanvas ctx(img, SkSurfaceProps());
        SkImageInfo info = img.info();
        SkPaint paint;
        paint.setBlendMode(SkBlendMode::kSrcOver);
        sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgMask);
        ctx.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);
 
        POSITION_t position = calcImagePosition(sr[instance].mi_width, sr[instance].mi_height, SC_BITMAP, instance);
 
        if (!position.valid)

 
        if (sr[instance].sb == 0)
        {
            if (!haveBothImages)
            {
                sk_sp<SkImage> _image = SkImages::RasterFromBitmap(img);
                can.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);
 
                if (!sr[instance].bm.empty())
                {
                    imgMask.installPixels(bmBm.pixmap());
                    paint.setBlendMode(SkBlendMode::kSrcOver);
                    _image = SkImages::RasterFromBitmap(imgMask);
                    can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);
                }
            }
            else
            {
                sk_sp<SkImage> _image = SkImages::RasterFromBitmap(img);
                can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);
            }
        }
        else    // Scale to fit
        {
            if (!haveBothImages)
            {
                SkRect rect;
                rect.setXYWH(0, 0, imgRed.info().width(), imgRed.info().height());
                sk_sp<SkImage> im = SkImages::RasterFromBitmap(img);
                can.drawImageRect(im, rect, SkSamplingOptions(), &paint);
 
                if (!sr[instance].bm.empty())
                {
                    imgMask.installPixels(bmBm.pixmap());
                    rect.setXYWH(position.left, position.top, position.width, position.height);
                    im = SkImages::RasterFromBitmap(imgMask);
                    paint.setBlendMode(SkBlendMode::kSrcOver);
                    can.drawImageRect(im, rect, SkSamplingOptions(), &paint);
                }
            }
            else
            {
                SkRect rect = SkRect::MakeXYWH(position.left, position.top, position.width, position.height);
                sk_sp<SkImage> im = SkImages::RasterFromBitmap(img);
                can.drawImageRect(im, rect, SkSamplingOptions(), &paint);
            }
        }
    }
    else if (!sr[instance].bm.empty())

 
        if (sr[instance].sb == 0)   // Scale bitmap?
        {                           // No, keep size
            if ((sr[instance].jb == 0 && sr[instance].bx >= 0 && sr[instance].by >= 0) || sr[instance].jb != 0)  // Draw the full image
            {
                sk_sp<SkImage> _image = SkImages::RasterFromBitmap(image);
                can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);
            }
            else    // We need only a subset of the image
            {
                MSG_DEBUG("Create a subset of an image ...");

 
                MSG_DEBUG("Rectangle of part: x: " << position.left << ", y: " << position.top << ", w: " << position.width << ", h: " << position.height);
                SkBitmap part;      // Bitmap receiving the wanted part from the whole image
                SkIRect irect = SkIRect::MakeXYWH(position.left, position.top, position.width, position.height);
                image.extractSubset(&part, irect);  // Extract the part of the image containg the pixels we want
                sk_sp<SkImage> _image = SkImages::RasterFromBitmap(part);
                can.drawImage(_image, 0, 0, SkSamplingOptions(), &paint); // Draw the image
            }
        }
        else    // Scale to fit
        {
            SkRect rect = SkRect::MakeXYWH(position.left, position.top, isize.width, isize.height);
            sk_sp<SkImage> im = SkImages::RasterFromBitmap(image);
            can.drawImageRect(im, rect, SkSamplingOptions(), &paint);
        }
    }
    else
    {

 
        if (sr[instance].sb == 0)   // Scale bitmap?
        {                           // No, keep size
            if ((sr[instance].jb == 0 && sr[instance].bx >= 0 && sr[instance].by >= 0) || sr[instance].jb != 0)  // Draw the full image
            {
                sk_sp<SkImage> _image = SkImages::RasterFromBitmap(image);
                can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);
            }
            else    // We need only a subset of the image
            {
                MSG_DEBUG("Create a subset of an image ...");

 
                MSG_DEBUG("Rectangle of part: x: " << position.left << ", y: " << position.top << ", w: " << position.width << ", h: " << position.height);
                SkBitmap part;      // Bitmap receiving the wanted part from the whole image
                SkIRect irect = SkIRect::MakeXYWH(position.left, position.top, position.width, position.height);
                image.extractSubset(&part, irect);  // Extract the part of the image containg the pixels we want
                sk_sp<SkImage> _image = SkImages::RasterFromBitmap(part);
                can.drawImage(_image, 0, 0, SkSamplingOptions(), &paint); // Draw the image
            }
        }
        else    // Scale to fit
        {
            SkRect rect = SkRect::MakeXYWH(position.left, position.top, isize.width, isize.height);
            sk_sp<SkImage> im = SkImages::RasterFromBitmap(image);
            can.drawImageRect(im, rect, SkSamplingOptions(), &paint);
        }
 
        return true;
    }

 
    SkCanvas can(*bm, SkSurfaceProps());
 
    if (sr[instance].sb == 0)
    {
        sk_sp<SkImage> _image = SkImages::RasterFromBitmap(image);
        can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);
    }
    else    // Scale to fit
    {
//        paint.setFilterQuality(kHigh_SkFilterQuality);
        SkRect rect = SkRect::MakeXYWH(position.left, position.top, isize.width, isize.height);
        sk_sp<SkImage> im = SkImages::RasterFromBitmap(image);
        can.drawImageRect(im, rect, SkSamplingOptions(), &paint);
    }
 
    return true;
}

        }
 
        SkCanvas ctx(img, SkSurfaceProps());
        SkPaint paint;
        paint.setBlendMode(SkBlendMode::kSrcATop);
        sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgMask);
        ctx.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);
 
        POSITION_t position = calcImagePosition(sr[0].mi_width, sr[0].mi_height, SC_BITMAP, 0);
 
        if (!position.valid)

            return false;
        }
 
        SkCanvas can(*bm, SkSurfaceProps());
        paint.setBlendMode(SkBlendMode::kSrc);
        _image = SkImages::RasterFromBitmap(img);
        can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);
    }
    else if (!sr[0].bm.empty() && !sr[1].bm.empty())
    {
        MSG_TRACE("Drawing normal image ...");

            }
        }
 
        SkPaint paint;
        paint.setBlendMode(SkBlendMode::kSrc);
        sk_sp<SkImage> _image = SkImages::RasterFromBitmap(image1);
        can_bm.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);
        paint.setBlendMode(SkBlendMode::kSrcATop);
        _image = SkImages::RasterFromBitmap(img_bar);
        can_bm.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);       // Draw the above created image over the 0% image
    }
    else if (sr[0].bm.empty() && !sr[1].bm.empty())     // Only one bitmap in the second instance
    {
        MSG_TRACE("Drawing second image " << sr[1].bm << " ...");

            }
        }
 
        SkPaint paint;
        paint.setBlendMode(SkBlendMode::kSrcOver);
        sk_sp<SkImage> _image = SkImages::RasterFromBitmap(img_bar);
        can_bm.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);      // Draw the above created image over the 0% image
    }
    else
    {
        MSG_TRACE("No bitmap defined.");

                    dst.setXYWH(border_size, pos - h / 2, w, h);
                }
 
                SkPaint pnt;
                pnt.setBlendMode(SkBlendMode::kSrcOver);
                sk_sp<SkImage> _image = SkImages::RasterFromBitmap(slButton);
                can.drawImageRect(_image, dst, SkSamplingOptions(), &pnt);
            }
        }
    }
 

 
                default:
                    MSG_WARNING("Invalid type " << sltIter->type << " found!");
            }
 
            sk_sp<SkImage> _image = SkImages::RasterFromBitmap(sl);
            slCan.drawImageRect(_image, dst, SkSamplingOptions(), &paint);
        }
        else if (dr.compare("horizontal") == 0 && (sltIter->type == SGR_TOP || sltIter->type == SGR_BOTTOM || sltIter->type == SGR_HORIZONTAL)) // horizontal slider
        {
            if (!retrieveImage(sltIter->path, &slPart))

 
                default:
                    MSG_WARNING("Invalid type " << sltIter->type << " found!");
            }
 
            sk_sp<SkImage> _image = SkImages::RasterFromBitmap(sl);
            slCan.drawImageRect(_image, dst, SkSamplingOptions(), &paint);
        }
    }
 
    return slButton;

        int top = (position.top >= 0) ? 0 : position.top * -1;
        int width = std::min(wt, info.width());
        int height = std::min(ht, info.height());
        irect.setXYWH(left, top, width, height);
        bm->getBounds(&bdst);
        sk_sp<SkImage> _image = SkImages::RasterFromBitmap(icon);
        can.drawImageRect(_image, irect, bdst, SkSamplingOptions(), &paint, SkCanvas::kStrict_SrcRectConstraint);
    }
    else
    {
        sk_sp<SkImage> _image = SkImages::RasterFromBitmap(icon);
        can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);
    }
 
    return true;
}

        yDrop = gap;
        SkPaint blur(paint);
        blur.setAlpha(blurAlpha);
        blur.setColor(TColor::getSkiaColor(sr[instance].ec));
        blur.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, sigma, 0));
//        blur.setMaskFilter(SkImageFilters::Blur(sigma, sigma, 0));
        canvas->drawTextBlob(blob.get(), startX + xDrop, startY + yDrop, blur);
        canvas->drawTextBlob(blob.get(), startX, startY, paint);
        return true;
    }
    else if (sr[instance].et >= 5 && sr[instance].et <= 8)  // Glow

        SkCanvas target(*bm, SkSurfaceProps());
        SkCanvas canvas(frame, SkSurfaceProps());
        SkPaint paint;
 
        paint.setBlendMode(SkBlendMode::kSrcOver);
        sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgB);
        canvas.drawImage(_image, imgBL.info().width(), ht - imgB.info().height(), SkSamplingOptions(), &paint);
        _image = SkImages::RasterFromBitmap(imgBR);
        canvas.drawImage(_image, wt - imgBR.info().width(), ht - imgBR.info().height(), SkSamplingOptions(), &paint);
        _image = SkImages::RasterFromBitmap(imgR);
        canvas.drawImage(_image, wt - imgR.info().width(), imgTR.info().height(), SkSamplingOptions(), &paint);
        _image = SkImages::RasterFromBitmap(imgTR);
        canvas.drawImage(_image, wt - imgTR.info().width(), 0, SkSamplingOptions(), &paint);
        _image = SkImages::RasterFromBitmap(imgT);
        canvas.drawImage(_image, imgTL.info().width(), 0, SkSamplingOptions(), &paint);
        _image = SkImages::RasterFromBitmap(imgTL);
        canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);
        _image = SkImages::RasterFromBitmap(imgL);
        canvas.drawImage(_image, 0, imgTL.info().height(), SkSamplingOptions(), &paint);
        _image = SkImages::RasterFromBitmap(imgBL);
        canvas.drawImage(_image, 0, ht - imgBL.info().height(), SkSamplingOptions(), &paint);
 
        erasePart(bm, frame, Border::ERASE_OUTSIDE);
        backgroundFrame(bm, frame, color);
        _image = SkImages::RasterFromBitmap(frame);
        paint.setBlendMode(SkBlendMode::kSrcATop);
        target.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);
    }
    else    // We try to draw a frame by forcing it to draw even the not to draw marked frames.
        drawBorder(bm, bname, wt, ht, sr[instance].cb, true);

 
        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));
        sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgButton);
        canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);
        imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});
        imgButton = ooButton;
    }
 

 
        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));
        sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgButton);
        canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);
        imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});
        imgButton = ooButton;
    }
 

 
        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));
        sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgButton);
        canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);
        imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});
        imgButton = ooButton;
    }
 

 
        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));
        sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgButton);
        canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);
        imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});
        imgButton = ooButton;
    }
 

 
        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));
        sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgButton);
        canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);
        imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});
        imgButton = ooButton;
    }
 

    }
 
    SkPaint paint;
    paint.setBlendMode(SkBlendMode::kSrcOver);
    SkCanvas can(Bm);
    sk_sp<SkImage> _image = SkImages::RasterFromBitmap(base);
    can.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);
    return Bm;
}
 
/**

    if (!alpha.empty())
    {
        SkPaint paint;
        paint.setBlendMode(SkBlendMode::kSrcOver);
        SkCanvas can(maskBm);
        sk_sp<SkImage> _image = SkImages::RasterFromBitmap(base);
        can.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);
    }
 
    return maskBm;
}

    SkImageInfo info = bm->info();
    int width  = std::max(1, (int)((double)info.width() * scaleWidth));
    int height = std::max(1, (int)((double)info.height() * scaleHeight));
    MSG_DEBUG("Scaling image to size " << width << " x " << height);
    // Create a canvas and draw new image
    sk_sp<SkImage> im = SkImages::RasterFromBitmap(*bm);
 
    if (!allocPixels(width, height, bm))
        return false;
 
    bm->eraseColor(SK_ColorTRANSPARENT);

    SkPaint paint;
    paint.setBlendMode(SkBlendMode::kSrc);
//    paint.setFilterQuality(kHigh_SkFilterQuality);
 
    SkImageInfo info = bm->info();
    sk_sp<SkImage> im = SkImages::RasterFromBitmap(*bm);
 
    if (width <= 0)
        rwidth = info.width() + width;
 
    if (rwidth <= 0)

        rheight = info.height() + height;
 
    if (rheight <= 0)
        rheight = 1;
 
    sk_sp<SkImage> im = SkImages::RasterFromBitmap(*bm);
    MSG_DEBUG("Width: " << info.width() << ", Height: " << rheight);
 
    if (!allocPixels(info.width(), rheight, bm))
        return false;
 

        rheight = 1;
 
    if (rwidth <= 0)
        rwidth = 1;
 
    sk_sp<SkImage> im = SkImages::RasterFromBitmap(*bm);
    MSG_DEBUG("Width: " << rwidth << ", Height: " << rheight);
 
    if (!allocPixels(rwidth, rheight, bm))
        return false;
 

Rev 361	Rev 365
Line 32...	Line 32...
32	`#include <include/core/SkRegion.h>`	32	`#include <include/core/SkRegion.h>`
33	`#include <include/core/SkImageFilter.h>`	33	`#include <include/core/SkImageFilter.h>`
34	`#include <include/effects/SkImageFilters.h>`	34	`#include <include/effects/SkImageFilters.h>`
35	`#include <include/core/SkPath.h>`	35	`#include <include/core/SkPath.h>`
36	`#include <include/core/SkSurfaceProps.h>`	36	`#include <include/core/SkSurfaceProps.h>`
37	`#ifndef __MACH__`	37	`//#ifndef __MACH__`
38	`#include <include/core/SkFilterQuality.h>`	38	`//#include <include/core/SkFilterQuality.h>`
39	`#endif`	39	`//#endif`
40	`#include <include/core/SkMaskFilter.h>`	40	`#include <include/core/SkMaskFilter.h>`
41	`#include <include/core/SkImageEncoder.h>`	41	`//#include <include/core/SkImageEncoder.h>`
42	`#include <include/core/SkRRect.h>`	42	`#include <include/core/SkRRect.h>`
-		43	`#include <include/core/SkBlurTypes.h>`
43		44
44	`//#ifdef __ANDROID__`	45	`//#ifdef __ANDROID__`
45	`//#include <QtAndroidExtras/QAndroidJniObject>`	46	`//#include <QtAndroidExtras/QAndroidJniObject>`
46	`//#include <QtAndroid>`	47	`//#include <QtAndroid>`
47	`//#endif`	48	`//#endif`
Line 3232...	Line 3233...
3232		3233
3233	`SkScalar alpha = 1.0 / 255.0 * oo;`	3234	`SkScalar alpha = 1.0 / 255.0 * oo;`
3234	`MSG_DEBUG("Calculated alpha value: " << alpha);`	3235	`MSG_DEBUG("Calculated alpha value: " << alpha);`
3235	`SkPaint paint;`	3236	`SkPaint paint;`
3236	`paint.setAlphaf(alpha);`	3237	`paint.setAlphaf(alpha);`
3237	`paint.setImageFilter(SkImageFilters::AlphaThreshold(region, 0.0, alpha, nullptr));`	3238	`//(SkImageFilters::AlphaThreshold(region, 0.0, alpha, nullptr));`
3238	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(imgButton);`	3239	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgButton);`
3239	`canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`	3240	`canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`
3240	`imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});`	3241	`imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});`
3241	`imgButton = ooButton;`	3242	`imgButton = ooButton;`
3242	`}`	3243	`}`
3243		3244
Line 3496...	Line 3497...
3496		3497
3497	`bitmap.eraseColor(color); // Fill the new bitmap with the fill color`	3498	`bitmap.eraseColor(color); // Fill the new bitmap with the fill color`
3498	`SkCanvas ctx(*bm, SkSurfaceProps()); // Create a canvas`	3499	`SkCanvas ctx(*bm, SkSurfaceProps()); // Create a canvas`
3499	`SkPaint paint; // The paint "device"`	3500	`SkPaint paint; // The paint "device"`
3500	`paint.setBlendMode(SkBlendMode::kSrcOver); // We're overwriting each pixel`	3501	`paint.setBlendMode(SkBlendMode::kSrcOver); // We're overwriting each pixel`
3501	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(bitmap); // Technically we need an image. So we convert our new bitmap into an image.`	3502	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(bitmap); // Technically we need an image. So we convert our new bitmap into an image.`
3502	`ctx.drawImage(_image, 0, 0, SkSamplingOptions(), &paint); // Now we put the new image over the existing one.`	3503	`ctx.drawImage(_image, 0, 0, SkSamplingOptions(), &paint); // Now we put the new image over the existing one.`
3503	`return true;`	3504	`return true;`
3504	`}`	3505	`}`
3505		3506
3506	`bool TButton::buttonBitmap(SkBitmap* bm, int inst)`	3507	`bool TButton::buttonBitmap(SkBitmap* bm, int inst)`
Line 3631...	Line 3632...
3631	`MSG_DEBUG("Have both images: " << (haveBothImages ? "YES" : "NO"));`	3632	`MSG_DEBUG("Have both images: " << (haveBothImages ? "YES" : "NO"));`
3632	`SkCanvas ctx(img, SkSurfaceProps());`	3633	`SkCanvas ctx(img, SkSurfaceProps());`
3633	`SkImageInfo info = img.info();`	3634	`SkImageInfo info = img.info();`
3634	`SkPaint paint;`	3635	`SkPaint paint;`
3635	`paint.setBlendMode(SkBlendMode::kSrcOver);`	3636	`paint.setBlendMode(SkBlendMode::kSrcOver);`
3636	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(imgMask);`	3637	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgMask);`
3637	`ctx.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`	3638	`ctx.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`
3638		3639
3639	`POSITION_t position = calcImagePosition(sr[instance].mi_width, sr[instance].mi_height, SC_BITMAP, instance);`	3640	`POSITION_t position = calcImagePosition(sr[instance].mi_width, sr[instance].mi_height, SC_BITMAP, instance);`
3640		3641
3641	`if (!position.valid)`	3642	`if (!position.valid)`
Line 3650...	Line 3651...
3650		3651
3651	`if (sr[instance].sb == 0)`	3652	`if (sr[instance].sb == 0)`
3652	`{`	3653	`{`
3653	`if (!haveBothImages)`	3654	`if (!haveBothImages)`
3654	`{`	3655	`{`
3655	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(img);`	3656	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(img);`
3656	`can.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`	3657	`can.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`
3657		3658
3658	`if (!sr[instance].bm.empty())`	3659	`if (!sr[instance].bm.empty())`
3659	`{`	3660	`{`
3660	`imgMask.installPixels(bmBm.pixmap());`	3661	`imgMask.installPixels(bmBm.pixmap());`
3661	`paint.setBlendMode(SkBlendMode::kSrcOver);`	3662	`paint.setBlendMode(SkBlendMode::kSrcOver);`
3662	`_image = SkImage::MakeFromBitmap(imgMask);`	3663	`_image = SkImages::RasterFromBitmap(imgMask);`
3663	`can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);`	3664	`can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);`
3664	`}`	3665	`}`
3665	`}`	3666	`}`
3666	`else`	3667	`else`
3667	`{`	3668	`{`
3668	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(img);`	3669	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(img);`
3669	`can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);`	3670	`can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);`
3670	`}`	3671	`}`
3671	`}`	3672	`}`
3672	`else // Scale to fit`	3673	`else // Scale to fit`
3673	`{`	3674	`{`
3674	`if (!haveBothImages)`	3675	`if (!haveBothImages)`
3675	`{`	3676	`{`
3676	`SkRect rect;`	3677	`SkRect rect;`
3677	`rect.setXYWH(0, 0, imgRed.info().width(), imgRed.info().height());`	3678	`rect.setXYWH(0, 0, imgRed.info().width(), imgRed.info().height());`
3678	`sk_sp<SkImage> im = SkImage::MakeFromBitmap(img);`	3679	`sk_sp<SkImage> im = SkImages::RasterFromBitmap(img);`
3679	`can.drawImageRect(im, rect, SkSamplingOptions(), &paint);`	3680	`can.drawImageRect(im, rect, SkSamplingOptions(), &paint);`
3680		3681
3681	`if (!sr[instance].bm.empty())`	3682	`if (!sr[instance].bm.empty())`
3682	`{`	3683	`{`
3683	`imgMask.installPixels(bmBm.pixmap());`	3684	`imgMask.installPixels(bmBm.pixmap());`
3684	`rect.setXYWH(position.left, position.top, position.width, position.height);`	3685	`rect.setXYWH(position.left, position.top, position.width, position.height);`
3685	`im = SkImage::MakeFromBitmap(imgMask);`	3686	`im = SkImages::RasterFromBitmap(imgMask);`
3686	`paint.setBlendMode(SkBlendMode::kSrcOver);`	3687	`paint.setBlendMode(SkBlendMode::kSrcOver);`
3687	`can.drawImageRect(im, rect, SkSamplingOptions(), &paint);`	3688	`can.drawImageRect(im, rect, SkSamplingOptions(), &paint);`
3688	`}`	3689	`}`
3689	`}`	3690	`}`
3690	`else`	3691	`else`
3691	`{`	3692	`{`
3692	`SkRect rect = SkRect::MakeXYWH(position.left, position.top, position.width, position.height);`	3693	`SkRect rect = SkRect::MakeXYWH(position.left, position.top, position.width, position.height);`
3693	`sk_sp<SkImage> im = SkImage::MakeFromBitmap(img);`	3694	`sk_sp<SkImage> im = SkImages::RasterFromBitmap(img);`
3694	`can.drawImageRect(im, rect, SkSamplingOptions(), &paint);`	3695	`can.drawImageRect(im, rect, SkSamplingOptions(), &paint);`
3695	`}`	3696	`}`
3696	`}`	3697	`}`
3697	`}`	3698	`}`
3698	`else if (!sr[instance].bm.empty())`	3699	`else if (!sr[instance].bm.empty())`
Line 3750...	Line 3751...
3750		3751
3751	`if (sr[instance].sb == 0) // Scale bitmap?`	3752	`if (sr[instance].sb == 0) // Scale bitmap?`
3752	`{ // No, keep size`	3753	`{ // No, keep size`
3753	`if ((sr[instance].jb == 0 && sr[instance].bx >= 0 && sr[instance].by >= 0) \|\| sr[instance].jb != 0) // Draw the full image`	3754	`if ((sr[instance].jb == 0 && sr[instance].bx >= 0 && sr[instance].by >= 0) \|\| sr[instance].jb != 0) // Draw the full image`
3754	`{`	3755	`{`
3755	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(image);`	3756	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(image);`
3756	`can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);`	3757	`can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);`
3757	`}`	3758	`}`
3758	`else // We need only a subset of the image`	3759	`else // We need only a subset of the image`
3759	`{`	3760	`{`
3760	`MSG_DEBUG("Create a subset of an image ...");`	3761	`MSG_DEBUG("Create a subset of an image ...");`
Line 3772...	Line 3773...
3772		3773
3773	`MSG_DEBUG("Rectangle of part: x: " << position.left << ", y: " << position.top << ", w: " << position.width << ", h: " << position.height);`	3774	`MSG_DEBUG("Rectangle of part: x: " << position.left << ", y: " << position.top << ", w: " << position.width << ", h: " << position.height);`
3774	`SkBitmap part; // Bitmap receiving the wanted part from the whole image`	3775	`SkBitmap part; // Bitmap receiving the wanted part from the whole image`
3775	`SkIRect irect = SkIRect::MakeXYWH(position.left, position.top, position.width, position.height);`	3776	`SkIRect irect = SkIRect::MakeXYWH(position.left, position.top, position.width, position.height);`
3776	`image.extractSubset(&part, irect); // Extract the part of the image containg the pixels we want`	3777	`image.extractSubset(&part, irect); // Extract the part of the image containg the pixels we want`
3777	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(part);`	3778	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(part);`
3778	`can.drawImage(_image, 0, 0, SkSamplingOptions(), &paint); // Draw the image`	3779	`can.drawImage(_image, 0, 0, SkSamplingOptions(), &paint); // Draw the image`
3779	`}`	3780	`}`
3780	`}`	3781	`}`
3781	`else // Scale to fit`	3782	`else // Scale to fit`
3782	`{`	3783	`{`
3783	`SkRect rect = SkRect::MakeXYWH(position.left, position.top, isize.width, isize.height);`	3784	`SkRect rect = SkRect::MakeXYWH(position.left, position.top, isize.width, isize.height);`
3784	`sk_sp<SkImage> im = SkImage::MakeFromBitmap(image);`	3785	`sk_sp<SkImage> im = SkImages::RasterFromBitmap(image);`
3785	`can.drawImageRect(im, rect, SkSamplingOptions(), &paint);`	3786	`can.drawImageRect(im, rect, SkSamplingOptions(), &paint);`
3786	`}`	3787	`}`
3787	`}`	3788	`}`
3788	`else`	3789	`else`
3789	`{`	3790	`{`
Line 3875...	Line 3876...
3875		3876
3876	`if (sr[instance].sb == 0) // Scale bitmap?`	3877	`if (sr[instance].sb == 0) // Scale bitmap?`
3877	`{ // No, keep size`	3878	`{ // No, keep size`
3878	`if ((sr[instance].jb == 0 && sr[instance].bx >= 0 && sr[instance].by >= 0) \|\| sr[instance].jb != 0) // Draw the full image`	3879	`if ((sr[instance].jb == 0 && sr[instance].bx >= 0 && sr[instance].by >= 0) \|\| sr[instance].jb != 0) // Draw the full image`
3879	`{`	3880	`{`
3880	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(image);`	3881	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(image);`
3881	`can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);`	3882	`can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);`
3882	`}`	3883	`}`
3883	`else // We need only a subset of the image`	3884	`else // We need only a subset of the image`
3884	`{`	3885	`{`
3885	`MSG_DEBUG("Create a subset of an image ...");`	3886	`MSG_DEBUG("Create a subset of an image ...");`
Line 3897...	Line 3898...
3897		3898
3898	`MSG_DEBUG("Rectangle of part: x: " << position.left << ", y: " << position.top << ", w: " << position.width << ", h: " << position.height);`	3899	`MSG_DEBUG("Rectangle of part: x: " << position.left << ", y: " << position.top << ", w: " << position.width << ", h: " << position.height);`
3899	`SkBitmap part; // Bitmap receiving the wanted part from the whole image`	3900	`SkBitmap part; // Bitmap receiving the wanted part from the whole image`
3900	`SkIRect irect = SkIRect::MakeXYWH(position.left, position.top, position.width, position.height);`	3901	`SkIRect irect = SkIRect::MakeXYWH(position.left, position.top, position.width, position.height);`
3901	`image.extractSubset(&part, irect); // Extract the part of the image containg the pixels we want`	3902	`image.extractSubset(&part, irect); // Extract the part of the image containg the pixels we want`
3902	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(part);`	3903	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(part);`
3903	`can.drawImage(_image, 0, 0, SkSamplingOptions(), &paint); // Draw the image`	3904	`can.drawImage(_image, 0, 0, SkSamplingOptions(), &paint); // Draw the image`
3904	`}`	3905	`}`
3905	`}`	3906	`}`
3906	`else // Scale to fit`	3907	`else // Scale to fit`
3907	`{`	3908	`{`
3908	`SkRect rect = SkRect::MakeXYWH(position.left, position.top, isize.width, isize.height);`	3909	`SkRect rect = SkRect::MakeXYWH(position.left, position.top, isize.width, isize.height);`
3909	`sk_sp<SkImage> im = SkImage::MakeFromBitmap(image);`	3910	`sk_sp<SkImage> im = SkImages::RasterFromBitmap(image);`
3910	`can.drawImageRect(im, rect, SkSamplingOptions(), &paint);`	3911	`can.drawImageRect(im, rect, SkSamplingOptions(), &paint);`
3911	`}`	3912	`}`
3912		3913
3913	`return true;`	3914	`return true;`
3914	`}`	3915	`}`
Line 4324...	Line 4325...
4324		4325
4325	`SkCanvas can(*bm, SkSurfaceProps());`	4326	`SkCanvas can(*bm, SkSurfaceProps());`
4326		4327
4327	`if (sr[instance].sb == 0)`	4328	`if (sr[instance].sb == 0)`
4328	`{`	4329	`{`
4329	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(image);`	4330	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(image);`
4330	`can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);`	4331	`can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);`
4331	`}`	4332	`}`
4332	`else // Scale to fit`	4333	`else // Scale to fit`
4333	`{`	4334	`{`
4334	`// paint.setFilterQuality(kHigh_SkFilterQuality);`	4335	`// paint.setFilterQuality(kHigh_SkFilterQuality);`
4335	`SkRect rect = SkRect::MakeXYWH(position.left, position.top, isize.width, isize.height);`	4336	`SkRect rect = SkRect::MakeXYWH(position.left, position.top, isize.width, isize.height);`
4336	`sk_sp<SkImage> im = SkImage::MakeFromBitmap(image);`	4337	`sk_sp<SkImage> im = SkImages::RasterFromBitmap(image);`
4337	`can.drawImageRect(im, rect, SkSamplingOptions(), &paint);`	4338	`can.drawImageRect(im, rect, SkSamplingOptions(), &paint);`
4338	`}`	4339	`}`
4339		4340
4340	`return true;`	4341	`return true;`
4341	`}`	4342	`}`
Line 4425...	Line 4426...
4425	`}`	4426	`}`
4426		4427
4427	`SkCanvas ctx(img, SkSurfaceProps());`	4428	`SkCanvas ctx(img, SkSurfaceProps());`
4428	`SkPaint paint;`	4429	`SkPaint paint;`
4429	`paint.setBlendMode(SkBlendMode::kSrcATop);`	4430	`paint.setBlendMode(SkBlendMode::kSrcATop);`
4430	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(imgMask);`	4431	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgMask);`
4431	`ctx.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`	4432	`ctx.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`
4432		4433
4433	`POSITION_t position = calcImagePosition(sr[0].mi_width, sr[0].mi_height, SC_BITMAP, 0);`	4434	`POSITION_t position = calcImagePosition(sr[0].mi_width, sr[0].mi_height, SC_BITMAP, 0);`
4434		4435
4435	`if (!position.valid)`	4436	`if (!position.valid)`
Line 4439...	Line 4440...
4439	`return false;`	4440	`return false;`
4440	`}`	4441	`}`
4441		4442
4442	`SkCanvas can(*bm, SkSurfaceProps());`	4443	`SkCanvas can(*bm, SkSurfaceProps());`
4443	`paint.setBlendMode(SkBlendMode::kSrc);`	4444	`paint.setBlendMode(SkBlendMode::kSrc);`
4444	`_image = SkImage::MakeFromBitmap(img);`	4445	`_image = SkImages::RasterFromBitmap(img);`
4445	`can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);`	4446	`can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);`
4446	`}`	4447	`}`
4447	`else if (!sr[0].bm.empty() && !sr[1].bm.empty())`	4448	`else if (!sr[0].bm.empty() && !sr[1].bm.empty())`
4448	`{`	4449	`{`
4449	`MSG_TRACE("Drawing normal image ...");`	4450	`MSG_TRACE("Drawing normal image ...");`
Line 4518...	Line 4519...
4518	`}`	4519	`}`
4519	`}`	4520	`}`
4520		4521
4521	`SkPaint paint;`	4522	`SkPaint paint;`
4522	`paint.setBlendMode(SkBlendMode::kSrc);`	4523	`paint.setBlendMode(SkBlendMode::kSrc);`
4523	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(image1);`	4524	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(image1);`
4524	`can_bm.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`	4525	`can_bm.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`
4525	`paint.setBlendMode(SkBlendMode::kSrcATop);`	4526	`paint.setBlendMode(SkBlendMode::kSrcATop);`
4526	`_image = SkImage::MakeFromBitmap(img_bar);`	4527	`_image = SkImages::RasterFromBitmap(img_bar);`
4527	`can_bm.drawImage(_image, 0, 0, SkSamplingOptions(), &paint); // Draw the above created image over the 0% image`	4528	`can_bm.drawImage(_image, 0, 0, SkSamplingOptions(), &paint); // Draw the above created image over the 0% image`
4528	`}`	4529	`}`
4529	`else if (sr[0].bm.empty() && !sr[1].bm.empty()) // Only one bitmap in the second instance`	4530	`else if (sr[0].bm.empty() && !sr[1].bm.empty()) // Only one bitmap in the second instance`
4530	`{`	4531	`{`
4531	`MSG_TRACE("Drawing second image " << sr[1].bm << " ...");`	4532	`MSG_TRACE("Drawing second image " << sr[1].bm << " ...");`
Line 4590...	Line 4591...
4590	`}`	4591	`}`
4591	`}`	4592	`}`
4592		4593
4593	`SkPaint paint;`	4594	`SkPaint paint;`
4594	`paint.setBlendMode(SkBlendMode::kSrcOver);`	4595	`paint.setBlendMode(SkBlendMode::kSrcOver);`
4595	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(img_bar);`	4596	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(img_bar);`
4596	`can_bm.drawImage(_image, 0, 0, SkSamplingOptions(), &paint); // Draw the above created image over the 0% image`	4597	`can_bm.drawImage(_image, 0, 0, SkSamplingOptions(), &paint); // Draw the above created image over the 0% image`
4597	`}`	4598	`}`
4598	`else`	4599	`else`
4599	`{`	4600	`{`
4600	`MSG_TRACE("No bitmap defined.");`	4601	`MSG_TRACE("No bitmap defined.");`
Line 4693...	Line 4694...
4693	`dst.setXYWH(border_size, pos - h / 2, w, h);`	4694	`dst.setXYWH(border_size, pos - h / 2, w, h);`
4694	`}`	4695	`}`
4695		4696
4696	`SkPaint pnt;`	4697	`SkPaint pnt;`
4697	`pnt.setBlendMode(SkBlendMode::kSrcOver);`	4698	`pnt.setBlendMode(SkBlendMode::kSrcOver);`
4698	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(slButton);`	4699	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(slButton);`
4699	`can.drawImageRect(_image, dst, SkSamplingOptions(), &pnt);`	4700	`can.drawImageRect(_image, dst, SkSamplingOptions(), &pnt);`
4700	`}`	4701	`}`
4701	`}`	4702	`}`
4702	`}`	4703	`}`
4703		4704
Line 4793...	Line 4794...
4793		4794
4794	`default:`	4795	`default:`
4795	`MSG_WARNING("Invalid type " << sltIter->type << " found!");`	4796	`MSG_WARNING("Invalid type " << sltIter->type << " found!");`
4796	`}`	4797	`}`
4797		4798
4798	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(sl);`	4799	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(sl);`
4799	`slCan.drawImageRect(_image, dst, SkSamplingOptions(), &paint);`	4800	`slCan.drawImageRect(_image, dst, SkSamplingOptions(), &paint);`
4800	`}`	4801	`}`
4801	`else if (dr.compare("horizontal") == 0 && (sltIter->type == SGR_TOP \|\| sltIter->type == SGR_BOTTOM \|\| sltIter->type == SGR_HORIZONTAL)) // horizontal slider`	4802	`else if (dr.compare("horizontal") == 0 && (sltIter->type == SGR_TOP \|\| sltIter->type == SGR_BOTTOM \|\| sltIter->type == SGR_HORIZONTAL)) // horizontal slider`
4802	`{`	4803	`{`
4803	`if (!retrieveImage(sltIter->path, &slPart))`	4804	`if (!retrieveImage(sltIter->path, &slPart))`
Line 4830...	Line 4831...
4830		4831
4831	`default:`	4832	`default:`
4832	`MSG_WARNING("Invalid type " << sltIter->type << " found!");`	4833	`MSG_WARNING("Invalid type " << sltIter->type << " found!");`
4833	`}`	4834	`}`
4834		4835
4835	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(sl);`	4836	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(sl);`
4836	`slCan.drawImageRect(_image, dst, SkSamplingOptions(), &paint);`	4837	`slCan.drawImageRect(_image, dst, SkSamplingOptions(), &paint);`
4837	`}`	4838	`}`
4838	`}`	4839	`}`
4839		4840
4840	`return slButton;`	4841	`return slButton;`
Line 4911...	Line 4912...
4911	`int top = (position.top >= 0) ? 0 : position.top * -1;`	4912	`int top = (position.top >= 0) ? 0 : position.top * -1;`
4912	`int width = std::min(wt, info.width());`	4913	`int width = std::min(wt, info.width());`
4913	`int height = std::min(ht, info.height());`	4914	`int height = std::min(ht, info.height());`
4914	`irect.setXYWH(left, top, width, height);`	4915	`irect.setXYWH(left, top, width, height);`
4915	`bm->getBounds(&bdst);`	4916	`bm->getBounds(&bdst);`
4916	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(icon);`	4917	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(icon);`
4917	`can.drawImageRect(_image, irect, bdst, SkSamplingOptions(), &paint, SkCanvas::kStrict_SrcRectConstraint);`	4918	`can.drawImageRect(_image, irect, bdst, SkSamplingOptions(), &paint, SkCanvas::kStrict_SrcRectConstraint);`
4918	`}`	4919	`}`
4919	`else`	4920	`else`
4920	`{`	4921	`{`
4921	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(icon);`	4922	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(icon);`
4922	`can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);`	4923	`can.drawImage(_image, position.left, position.top, SkSamplingOptions(), &paint);`
4923	`}`	4924	`}`
4924		4925
4925	`return true;`	4926	`return true;`
4926	`}`	4927	`}`
Line 5251...	Line 5252...
5251	`yDrop = gap;`	5252	`yDrop = gap;`
5252	`SkPaint blur(paint);`	5253	`SkPaint blur(paint);`
5253	`blur.setAlpha(blurAlpha);`	5254	`blur.setAlpha(blurAlpha);`
5254	`blur.setColor(TColor::getSkiaColor(sr[instance].ec));`	5255	`blur.setColor(TColor::getSkiaColor(sr[instance].ec));`
5255	`blur.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, sigma, 0));`	5256	`blur.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, sigma, 0));`
-		5257	`// blur.setMaskFilter(SkImageFilters::Blur(sigma, sigma, 0));`
5256	`canvas->drawTextBlob(blob.get(), startX + xDrop, startY + yDrop, blur);`	5258	`canvas->drawTextBlob(blob.get(), startX + xDrop, startY + yDrop, blur);`
5257	`canvas->drawTextBlob(blob.get(), startX, startY, paint);`	5259	`canvas->drawTextBlob(blob.get(), startX, startY, paint);`
5258	`return true;`	5260	`return true;`
5259	`}`	5261	`}`
5260	`else if (sr[instance].et >= 5 && sr[instance].et <= 8) // Glow`	5262	`else if (sr[instance].et >= 5 && sr[instance].et <= 8) // Glow`
Line 5414...	Line 5416...
5414	`SkCanvas target(*bm, SkSurfaceProps());`	5416	`SkCanvas target(*bm, SkSurfaceProps());`
5415	`SkCanvas canvas(frame, SkSurfaceProps());`	5417	`SkCanvas canvas(frame, SkSurfaceProps());`
5416	`SkPaint paint;`	5418	`SkPaint paint;`
5417		5419
5418	`paint.setBlendMode(SkBlendMode::kSrcOver);`	5420	`paint.setBlendMode(SkBlendMode::kSrcOver);`
5419	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(imgB);`	5421	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgB);`
5420	`canvas.drawImage(_image, imgBL.info().width(), ht - imgB.info().height(), SkSamplingOptions(), &paint);`	5422	`canvas.drawImage(_image, imgBL.info().width(), ht - imgB.info().height(), SkSamplingOptions(), &paint);`
5421	`_image = SkImage::MakeFromBitmap(imgBR);`	5423	`_image = SkImages::RasterFromBitmap(imgBR);`
5422	`canvas.drawImage(_image, wt - imgBR.info().width(), ht - imgBR.info().height(), SkSamplingOptions(), &paint);`	5424	`canvas.drawImage(_image, wt - imgBR.info().width(), ht - imgBR.info().height(), SkSamplingOptions(), &paint);`
5423	`_image = SkImage::MakeFromBitmap(imgR);`	5425	`_image = SkImages::RasterFromBitmap(imgR);`
5424	`canvas.drawImage(_image, wt - imgR.info().width(), imgTR.info().height(), SkSamplingOptions(), &paint);`	5426	`canvas.drawImage(_image, wt - imgR.info().width(), imgTR.info().height(), SkSamplingOptions(), &paint);`
5425	`_image = SkImage::MakeFromBitmap(imgTR);`	5427	`_image = SkImages::RasterFromBitmap(imgTR);`
5426	`canvas.drawImage(_image, wt - imgTR.info().width(), 0, SkSamplingOptions(), &paint);`	5428	`canvas.drawImage(_image, wt - imgTR.info().width(), 0, SkSamplingOptions(), &paint);`
5427	`_image = SkImage::MakeFromBitmap(imgT);`	5429	`_image = SkImages::RasterFromBitmap(imgT);`
5428	`canvas.drawImage(_image, imgTL.info().width(), 0, SkSamplingOptions(), &paint);`	5430	`canvas.drawImage(_image, imgTL.info().width(), 0, SkSamplingOptions(), &paint);`
5429	`_image = SkImage::MakeFromBitmap(imgTL);`	5431	`_image = SkImages::RasterFromBitmap(imgTL);`
5430	`canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`	5432	`canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`
5431	`_image = SkImage::MakeFromBitmap(imgL);`	5433	`_image = SkImages::RasterFromBitmap(imgL);`
5432	`canvas.drawImage(_image, 0, imgTL.info().height(), SkSamplingOptions(), &paint);`	5434	`canvas.drawImage(_image, 0, imgTL.info().height(), SkSamplingOptions(), &paint);`
5433	`_image = SkImage::MakeFromBitmap(imgBL);`	5435	`_image = SkImages::RasterFromBitmap(imgBL);`
5434	`canvas.drawImage(_image, 0, ht - imgBL.info().height(), SkSamplingOptions(), &paint);`	5436	`canvas.drawImage(_image, 0, ht - imgBL.info().height(), SkSamplingOptions(), &paint);`
5435		5437
5436	`erasePart(bm, frame, Border::ERASE_OUTSIDE);`	5438	`erasePart(bm, frame, Border::ERASE_OUTSIDE);`
5437	`backgroundFrame(bm, frame, color);`	5439	`backgroundFrame(bm, frame, color);`
5438	`_image = SkImage::MakeFromBitmap(frame);`	5440	`_image = SkImages::RasterFromBitmap(frame);`
5439	`paint.setBlendMode(SkBlendMode::kSrcATop);`	5441	`paint.setBlendMode(SkBlendMode::kSrcATop);`
5440	`target.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`	5442	`target.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`
5441	`}`	5443	`}`
5442	`else // We try to draw a frame by forcing it to draw even the not to draw marked frames.`	5444	`else // We try to draw a frame by forcing it to draw even the not to draw marked frames.`
5443	`drawBorder(bm, bname, wt, ht, sr[instance].cb, true);`	5445	`drawBorder(bm, bname, wt, ht, sr[instance].cb, true);`
Line 5764...	Line 5766...
5764		5766
5765	`SkScalar alpha = 1.0 / 255.0 * oo;`	5767	`SkScalar alpha = 1.0 / 255.0 * oo;`
5766	`MSG_DEBUG("Calculated alpha value: " << alpha);`	5768	`MSG_DEBUG("Calculated alpha value: " << alpha);`
5767	`SkPaint paint;`	5769	`SkPaint paint;`
5768	`paint.setAlphaf(alpha);`	5770	`paint.setAlphaf(alpha);`
5769	`paint.setImageFilter(SkImageFilters::AlphaThreshold(region, 0.0, alpha, nullptr));`	5771	`// paint.setImageFilter(SkImageFilters::AlphaThreshold(region, 0.0, alpha, nullptr));`
5770	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(imgButton);`	5772	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgButton);`
5771	`canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`	5773	`canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`
5772	`imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});`	5774	`imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});`
5773	`imgButton = ooButton;`	5775	`imgButton = ooButton;`
5774	`}`	5776	`}`
5775		5777
Line 5979...	Line 5981...
5979		5981
5980	`SkScalar alpha = 1.0 / 255.0 * oo;`	5982	`SkScalar alpha = 1.0 / 255.0 * oo;`
5981	`MSG_DEBUG("Calculated alpha value: " << alpha);`	5983	`MSG_DEBUG("Calculated alpha value: " << alpha);`
5982	`SkPaint paint;`	5984	`SkPaint paint;`
5983	`paint.setAlphaf(alpha);`	5985	`paint.setAlphaf(alpha);`
5984	`paint.setImageFilter(SkImageFilters::AlphaThreshold(region, 0.0, alpha, nullptr));`	5986	`// paint.setImageFilter(SkImageFilters::AlphaThreshold(region, 0.0, alpha, nullptr));`
5985	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(imgButton);`	5987	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgButton);`
5986	`canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`	5988	`canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`
5987	`imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});`	5989	`imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});`
5988	`imgButton = ooButton;`	5990	`imgButton = ooButton;`
5989	`}`	5991	`}`
5990		5992
Line 6199...	Line 6201...
6199		6201
6200	`SkScalar alpha = 1.0 / 255.0 * oo;`	6202	`SkScalar alpha = 1.0 / 255.0 * oo;`
6201	`MSG_DEBUG("Calculated alpha value: " << alpha);`	6203	`MSG_DEBUG("Calculated alpha value: " << alpha);`
6202	`SkPaint paint;`	6204	`SkPaint paint;`
6203	`paint.setAlphaf(alpha);`	6205	`paint.setAlphaf(alpha);`
6204	`paint.setImageFilter(SkImageFilters::AlphaThreshold(region, 0.0, alpha, nullptr));`	6206	`// paint.setImageFilter(SkImageFilters::AlphaThreshold(region, 0.0, alpha, nullptr));`
6205	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(imgButton);`	6207	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgButton);`
6206	`canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`	6208	`canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`
6207	`imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});`	6209	`imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});`
6208	`imgButton = ooButton;`	6210	`imgButton = ooButton;`
6209	`}`	6211	`}`
6210		6212
Line 6340...	Line 6342...
6340		6342
6341	`SkScalar alpha = 1.0 / 255.0 * oo;`	6343	`SkScalar alpha = 1.0 / 255.0 * oo;`
6342	`MSG_DEBUG("Calculated alpha value: " << alpha);`	6344	`MSG_DEBUG("Calculated alpha value: " << alpha);`
6343	`SkPaint paint;`	6345	`SkPaint paint;`
6344	`paint.setAlphaf(alpha);`	6346	`paint.setAlphaf(alpha);`
6345	`paint.setImageFilter(SkImageFilters::AlphaThreshold(region, 0.0, alpha, nullptr));`	6347	`// paint.setImageFilter(SkImageFilters::AlphaThreshold(region, 0.0, alpha, nullptr));`
6346	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(imgButton);`	6348	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgButton);`
6347	`canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`	6349	`canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`
6348	`imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});`	6350	`imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});`
6349	`imgButton = ooButton;`	6351	`imgButton = ooButton;`
6350	`}`	6352	`}`
6351		6353
Line 6526...	Line 6528...
6526		6528
6527	`SkScalar alpha = 1.0 / 255.0 * oo;`	6529	`SkScalar alpha = 1.0 / 255.0 * oo;`
6528	`MSG_DEBUG("Calculated alpha value: " << alpha);`	6530	`MSG_DEBUG("Calculated alpha value: " << alpha);`
6529	`SkPaint paint;`	6531	`SkPaint paint;`
6530	`paint.setAlphaf(alpha);`	6532	`paint.setAlphaf(alpha);`
6531	`paint.setImageFilter(SkImageFilters::AlphaThreshold(region, 0.0, alpha, nullptr));`	6533	`// paint.setImageFilter(SkImageFilters::AlphaThreshold(region, 0.0, alpha, nullptr));`
6532	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(imgButton);`	6534	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(imgButton);`
6533	`canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`	6535	`canvas.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`
6534	`imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});`	6536	`imgButton.erase(SK_ColorTRANSPARENT, {0, 0, w, h});`
6535	`imgButton = ooButton;`	6537	`imgButton = ooButton;`
6536	`}`	6538	`}`
6537		6539
Line 7018...	Line 7020...
7018	`}`	7020	`}`
7019		7021
7020	`SkPaint paint;`	7022	`SkPaint paint;`
7021	`paint.setBlendMode(SkBlendMode::kSrcOver);`	7023	`paint.setBlendMode(SkBlendMode::kSrcOver);`
7022	`SkCanvas can(Bm);`	7024	`SkCanvas can(Bm);`
7023	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(base);`	7025	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(base);`
7024	`can.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`	7026	`can.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`
7025	`return Bm;`	7027	`return Bm;`
7026	`}`	7028	`}`
7027		7029
7028	`/**`	7030	`/**`
Line 7115...	Line 7117...
7115	`if (!alpha.empty())`	7117	`if (!alpha.empty())`
7116	`{`	7118	`{`
7117	`SkPaint paint;`	7119	`SkPaint paint;`
7118	`paint.setBlendMode(SkBlendMode::kSrcOver);`	7120	`paint.setBlendMode(SkBlendMode::kSrcOver);`
7119	`SkCanvas can(maskBm);`	7121	`SkCanvas can(maskBm);`
7120	`sk_sp<SkImage> _image = SkImage::MakeFromBitmap(base);`	7122	`sk_sp<SkImage> _image = SkImages::RasterFromBitmap(base);`
7121	`can.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`	7123	`can.drawImage(_image, 0, 0, SkSamplingOptions(), &paint);`
7122	`}`	7124	`}`
7123		7125
7124	`return maskBm;`	7126	`return maskBm;`
7125	`}`	7127	`}`
Line 7583...	Line 7585...
7583	`SkImageInfo info = bm->info();`	7585	`SkImageInfo info = bm->info();`
7584	`int width = std::max(1, (int)((double)info.width() * scaleWidth));`	7586	`int width = std::max(1, (int)((double)info.width() * scaleWidth));`
7585	`int height = std::max(1, (int)((double)info.height() * scaleHeight));`	7587	`int height = std::max(1, (int)((double)info.height() * scaleHeight));`
7586	`MSG_DEBUG("Scaling image to size " << width << " x " << height);`	7588	`MSG_DEBUG("Scaling image to size " << width << " x " << height);`
7587	`// Create a canvas and draw new image`	7589	`// Create a canvas and draw new image`
7588	`sk_sp<SkImage> im = SkImage::MakeFromBitmap(*bm);`	7590	`sk_sp<SkImage> im = SkImages::RasterFromBitmap(*bm);`
7589		7591
7590	`if (!allocPixels(width, height, bm))`	7592	`if (!allocPixels(width, height, bm))`
7591	`return false;`	7593	`return false;`
7592		7594
7593	`bm->eraseColor(SK_ColorTRANSPARENT);`	7595	`bm->eraseColor(SK_ColorTRANSPARENT);`
Line 7608...	Line 7610...
7608	`SkPaint paint;`	7610	`SkPaint paint;`
7609	`paint.setBlendMode(SkBlendMode::kSrc);`	7611	`paint.setBlendMode(SkBlendMode::kSrc);`
7610	`// paint.setFilterQuality(kHigh_SkFilterQuality);`	7612	`// paint.setFilterQuality(kHigh_SkFilterQuality);`
7611		7613
7612	`SkImageInfo info = bm->info();`	7614	`SkImageInfo info = bm->info();`
7613	`sk_sp<SkImage> im = SkImage::MakeFromBitmap(*bm);`	7615	`sk_sp<SkImage> im = SkImages::RasterFromBitmap(*bm);`
7614		7616
7615	`if (width <= 0)`	7617	`if (width <= 0)`
7616	`rwidth = info.width() + width;`	7618	`rwidth = info.width() + width;`
7617		7619
7618	`if (rwidth <= 0)`	7620	`if (rwidth <= 0)`
Line 7648...	Line 7650...
7648	`rheight = info.height() + height;`	7650	`rheight = info.height() + height;`
7649		7651
7650	`if (rheight <= 0)`	7652	`if (rheight <= 0)`
7651	`rheight = 1;`	7653	`rheight = 1;`
7652		7654
7653	`sk_sp<SkImage> im = SkImage::MakeFromBitmap(*bm);`	7655	`sk_sp<SkImage> im = SkImages::RasterFromBitmap(*bm);`
7654	`MSG_DEBUG("Width: " << info.width() << ", Height: " << rheight);`	7656	`MSG_DEBUG("Width: " << info.width() << ", Height: " << rheight);`
7655		7657
7656	`if (!allocPixels(info.width(), rheight, bm))`	7658	`if (!allocPixels(info.width(), rheight, bm))`
7657	`return false;`	7659	`return false;`
7658		7660
Line 7688...	Line 7690...
7688	`rheight = 1;`	7690	`rheight = 1;`
7689		7691
7690	`if (rwidth <= 0)`	7692	`if (rwidth <= 0)`
7691	`rwidth = 1;`	7693	`rwidth = 1;`
7692		7694
7693	`sk_sp<SkImage> im = SkImage::MakeFromBitmap(*bm);`	7695	`sk_sp<SkImage> im = SkImages::RasterFromBitmap(*bm);`
7694	`MSG_DEBUG("Width: " << rwidth << ", Height: " << rheight);`	7696	`MSG_DEBUG("Width: " << rwidth << ", Height: " << rheight);`
7695		7697
7696	`if (!allocPixels(rwidth, rheight, bm))`	7698	`if (!allocPixels(rwidth, rheight, bm))`
7697	`return false;`	7699	`return false;`
7698		7700

Subversion Repositories tpanel

(root)/trunk/tbutton.cpp @ 368 – Rev 361 → 365