blob: a75aa73d1bc71dfdf01378c13e92a6d00a35a1fa [file] [log] [blame]
/*
* 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;
}