The Tor Browser / file revision

 /*

  * Copyright 2011 Google Inc.

  *

  * Use of this source code is governed by a BSD-style license that can be

  * found in the LICENSE file.

  */

 #include "SkImageView.h"

 #include "SkAnimator.h"

 #include "SkBitmap.h"

 #include "SkCanvas.h"

 #include "SkImageDecoder.h"

 #include "SkMatrix.h"

 #include "SkSystemEventTypes.h"

 #include "SkTime.h"

 SkImageView::SkImageView()

 {

     fMatrix        = NULL;

     fScaleType    = kMatrix_ScaleType;

     fData.fAnim    = NULL;        // handles initializing the other union values

     fDataIsAnim    = true;

     fUriIsValid    = false;    // an empty string is not valid

 }

 SkImageView::~SkImageView()

 {

     if (fMatrix)

         sk_free(fMatrix);

     this->freeData();

 }

 void SkImageView::getUri(SkString* uri) const

 {

     if (uri)

         *uri = fUri;

 }

 void SkImageView::setUri(const char uri[])

 {

     if (!fUri.equals(uri))

     {

         fUri.set(uri);

         this->onUriChange();

     }

 }

 void SkImageView::setUri(const SkString& uri)

 {

     if (fUri != uri)

     {

         fUri = uri;

         this->onUriChange();

     }

 }

 void SkImageView::setScaleType(ScaleType st)

 {

     SkASSERT((unsigned)st <= kFitEnd_ScaleType);

     if ((ScaleType)fScaleType != st)

     {

         fScaleType = SkToU8(st);

         if (fUriIsValid)

             this->inval(NULL);

     }

 }

 bool SkImageView::getImageMatrix(SkMatrix* matrix) const

 {

     if (fMatrix)

     {

         SkASSERT(!fMatrix->isIdentity());

         if (matrix)

             *matrix = *fMatrix;

         return true;

     }

     else

     {

         if (matrix)

             matrix->reset();

         return false;

     }

 }

 void SkImageView::setImageMatrix(const SkMatrix* matrix)

 {

     bool changed = false;

     if (matrix && !matrix->isIdentity())

     {

         if (fMatrix == NULL)

             fMatrix = (SkMatrix*)sk_malloc_throw(sizeof(SkMatrix));

         *fMatrix = *matrix;

         changed = true;

     }

     else    // set us to identity

     {

         if (fMatrix)

         {

             SkASSERT(!fMatrix->isIdentity());

             sk_free(fMatrix);

             fMatrix = NULL;

             changed = true;

         }

     }

     // only redraw if we changed our matrix and we're not in scaleToFit mode

     if (changed && this->getScaleType() == kMatrix_ScaleType && fUriIsValid)

         this->inval(NULL);

 }

 ///////////////////////////////////////////////////////////////////////////////////////////////

 bool SkImageView::onEvent(const SkEvent& evt)

 {

     if (evt.isType(SK_EventType_Inval))

     {

         if (fUriIsValid)

             this->inval(NULL);

         return true;

     }

     return this->INHERITED::onEvent(evt);

 }

 static inline SkMatrix::ScaleToFit scaleTypeToScaleToFit(SkImageView::ScaleType st)

 {

     SkASSERT(st != SkImageView::kMatrix_ScaleType);

     SkASSERT((unsigned)st <= SkImageView::kFitEnd_ScaleType);

     SkASSERT(SkImageView::kFitXY_ScaleType - 1 == SkMatrix::kFill_ScaleToFit);

     SkASSERT(SkImageView::kFitStart_ScaleType - 1 == SkMatrix::kStart_ScaleToFit);

     SkASSERT(SkImageView::kFitCenter_ScaleType - 1 == SkMatrix::kCenter_ScaleToFit);

     SkASSERT(SkImageView::kFitEnd_ScaleType - 1 == SkMatrix::kEnd_ScaleToFit);

     return (SkMatrix::ScaleToFit)(st - 1);

 }

 void SkImageView::onDraw(SkCanvas* canvas)

 {

     SkRect    src;

     if (!this->getDataBounds(&src))

     {

         SkDEBUGCODE(canvas->drawColor(SK_ColorRED);)

         return;        // nothing to draw

     }

     SkAutoCanvasRestore    restore(canvas, true);

     SkMatrix            matrix;

     if (this->getScaleType() == kMatrix_ScaleType)

         (void)this->getImageMatrix(&matrix);

     else

     {

         SkRect    dst;

         dst.set(0, 0, this->width(), this->height());

         matrix.setRectToRect(src, dst, scaleTypeToScaleToFit(this->getScaleType()));

     }

     canvas->concat(matrix);

     SkPaint    paint;

     paint.setAntiAlias(true);

     if (fDataIsAnim)

     {

         SkMSec    now = SkTime::GetMSecs();

         SkAnimator::DifferenceType diff = fData.fAnim->draw(canvas, &paint, now);

 SkDEBUGF(("SkImageView : now = %X[%12.3f], diff = %d\n", now, now/1000., diff));

         if (diff == SkAnimator::kDifferent)

             this->inval(NULL);

         else if (diff == SkAnimator::kPartiallyDifferent)

         {

             SkRect    bounds;

             fData.fAnim->getInvalBounds(&bounds);

             matrix.mapRect(&bounds);    // get the bounds into view coordinates

             this->inval(&bounds);

         }

     }

     else

         canvas->drawBitmap(*fData.fBitmap, 0, 0, &paint);

 }

 void SkImageView::onInflate(const SkDOM& dom, const SkDOMNode* node)

 {

     this->INHERITED::onInflate(dom, node);

     const char* src = dom.findAttr(node, "src");

     if (src)

         this->setUri(src);

     int    index = dom.findList(node, "scaleType", "matrix,fitXY,fitStart,fitCenter,fitEnd");

     if (index >= 0)

         this->setScaleType((ScaleType)index);

     // need inflate syntax/reader for matrix

 }

 /////////////////////////////////////////////////////////////////////////////////////

 void SkImageView::onUriChange()

 {

     if (this->freeData())

         this->inval(NULL);

     fUriIsValid = true;        // give ensureUriIsLoaded() a shot at the new uri

 }

 bool SkImageView::freeData()

 {

     if (fData.fAnim)    // test is valid for all union values

     {

         if (fDataIsAnim)

             delete fData.fAnim;

         else

             delete fData.fBitmap;

         fData.fAnim = NULL;    // valid for all union values

         return true;

     }

     return false;

 }

 bool SkImageView::getDataBounds(SkRect* bounds)

 {

     SkASSERT(bounds);

     if (this->ensureUriIsLoaded())

     {

         SkScalar width, height;

         if (fDataIsAnim)

         {

             if (SkScalarIsNaN(width = fData.fAnim->getScalar("dimensions", "x")) ||

                 SkScalarIsNaN(height = fData.fAnim->getScalar("dimensions", "y")))

             {

                 // cons up fake bounds

                 width = this->width();

                 height = this->height();

             }

         }

         else

         {

             width = SkIntToScalar(fData.fBitmap->width());

             height = SkIntToScalar(fData.fBitmap->height());

         }

         bounds->set(0, 0, width, height);

         return true;

     }

     return false;

 }

 bool SkImageView::ensureUriIsLoaded()

 {

     if (fData.fAnim)    // test is valid for all union values

     {

         SkASSERT(fUriIsValid);

         return true;

     }

     if (!fUriIsValid)

         return false;

     // try to load the url

     if (fUri.endsWith(".xml"))    // assume it is screenplay

     {

         SkAnimator* anim = new SkAnimator;

         if (!anim->decodeURI(fUri.c_str()))

         {

             delete anim;

             fUriIsValid = false;

             return false;

         }

         anim->setHostEventSink(this);

         fData.fAnim = anim;

         fDataIsAnim = true;

     }

     else    // assume it is an image format

     {

     #if 0

         SkBitmap* bitmap = new SkBitmap;

         if (!SkImageDecoder::DecodeURL(fUri.c_str(), bitmap))

         {

             delete bitmap;

             fUriIsValid = false;

             return false;

         }

         fData.fBitmap = bitmap;

         fDataIsAnim = false;

     #else

         return false;

     #endif

     }

     return true;

 }