blob: 746780df1c305d0d28e6bb57eb23fdaf801383ae [file] [log] [blame]
/*
* Copyright 2006 The Android Open Source Project
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkDisplayEvent.h"
#include "SkAnimateMaker.h"
#include "SkDisplayApply.h"
#include "SkDisplayInput.h"
#include "SkDisplayList.h"
#ifdef SK_DEBUG
#include "SkDump.h"
#endif
#include "SkEvent.h"
#include "SkDisplayInput.h"
#include "SkKey.h"
#include "SkMetaData.h"
#include "SkScript.h"
#include "SkUtils.h"
enum SkDisplayEvent_Properties {
SK_PROPERTY(key),
SK_PROPERTY(keys)
};
#if SK_USE_CONDENSED_INFO == 0
const SkMemberInfo SkDisplayEvent::fInfo[] = {
SK_MEMBER(code, EventCode),
SK_MEMBER(disable, Boolean),
SK_MEMBER_PROPERTY(key, String), // a single key (also last key pressed)
SK_MEMBER_PROPERTY(keys, String), // a single key or dash-delimited range of keys
SK_MEMBER(kind, EventKind),
SK_MEMBER(target, String),
SK_MEMBER(x, Float),
SK_MEMBER(y, Float)
};
#endif
DEFINE_GET_MEMBER(SkDisplayEvent);
SkDisplayEvent::SkDisplayEvent() : code((SkKey) -1), disable(false),
kind(kUser), x(0), y(0), fLastCode((SkKey) -1), fMax((SkKey) -1), fTarget(nullptr) {
}
SkDisplayEvent::~SkDisplayEvent() {
deleteMembers();
}
bool SkDisplayEvent::addChild(SkAnimateMaker& , SkDisplayable* child) {
*fChildren.append() = child;
return true;
}
bool SkDisplayEvent::contains(SkDisplayable* match) {
for (int index = 0; index < fChildren.count(); index++) {
if (fChildren[index] == match || fChildren[index]->contains(match))
return true;
}
return false;
}
SkDisplayable* SkDisplayEvent::contains(const SkString& match) {
for (int index = 0; index < fChildren.count(); index++) {
SkDisplayable* child = fChildren[index];
if (child->contains(match))
return child;
}
return nullptr;
}
void SkDisplayEvent::deleteMembers() {
for (int index = 0; index < fChildren.count(); index++) {
SkDisplayable* evt = fChildren[index];
delete evt;
}
}
#ifdef SK_DUMP_ENABLED
void SkDisplayEvent::dumpEvent(SkAnimateMaker* maker) {
dumpBase(maker);
SkString str;
SkDump::GetEnumString(SkType_EventKind, kind, &str);
SkDebugf("kind=\"%s\" ", str.c_str());
if (kind == SkDisplayEvent::kKeyPress || kind == SkDisplayEvent::kKeyPressUp) {
if (code >= 0)
SkDump::GetEnumString(SkType_EventCode, code, &str);
else
str.set("none");
SkDebugf("code=\"%s\" ", str.c_str());
}
if (kind == SkDisplayEvent::kKeyChar) {
if (fMax != (SkKey) -1 && fMax != code)
SkDebugf("keys=\"%c - %c\" ", code, fMax);
else
SkDebugf("key=\"%c\" ", code);
}
if (fTarget != nullptr) {
SkDebugf("target=\"%s\" ", fTarget->id);
}
if (kind >= SkDisplayEvent::kMouseDown && kind <= SkDisplayEvent::kMouseUp) {
SkDebugf("x=\"%g\" y=\"%g\" ", SkScalarToFloat(x), SkScalarToFloat(y));
}
if (disable)
SkDebugf("disable=\"true\" ");
SkDebugf("/>\n");
}
#endif
bool SkDisplayEvent::enableEvent(SkAnimateMaker& maker)
{
maker.fActiveEvent = this;
if (fChildren.count() == 0)
return false;
if (disable)
return false;
#ifdef SK_DUMP_ENABLED
if (maker.fDumpEvents) {
SkDebugf("enable: ");
dumpEvent(&maker);
}
#endif
SkDisplayList& displayList = maker.fDisplayList;
for (int index = 0; index < fChildren.count(); index++) {
SkDisplayable* displayable = fChildren[index];
if (displayable->isGroup()) {
SkTDDrawableArray* parentList = displayList.getDrawList();
*parentList->append() = (SkADrawable*) displayable; // make it findable before children are enabled
}
if (displayable->enable(maker))
continue;
if (maker.hasError())
return true;
if (displayable->isDrawable() == false)
return true; // error
SkADrawable* drawable = (SkADrawable*) displayable;
SkTDDrawableArray* parentList = displayList.getDrawList();
*parentList->append() = drawable;
}
return false;
}
bool SkDisplayEvent::getProperty(int index, SkScriptValue* value) const {
switch (index) {
case SK_PROPERTY(key):
case SK_PROPERTY(keys): {
value->fType = SkType_String;
char scratch[8];
SkKey convert = index == SK_PROPERTY(keys) ? code : fLastCode;
size_t size = convert > 0 ? SkUTF8_FromUnichar(convert, scratch) : 0;
fKeyString.set(scratch, size);
value->fOperand.fString = &fKeyString;
if (index != SK_PROPERTY(keys) || fMax == (SkKey) -1 || fMax == code)
break;
value->fOperand.fString->append("-");
size = SkUTF8_FromUnichar(fMax, scratch);
value->fOperand.fString->append(scratch, size);
} break;
default:
SkASSERT(0);
return false;
}
return true;
}
void SkDisplayEvent::onEndElement(SkAnimateMaker& maker)
{
if (kind == kUser)
return;
maker.fEvents.addEvent(this);
if (kind == kOnEnd) {
SkDEBUGCODE(bool found = ) maker.find(target.c_str(), &fTarget);
SkASSERT(found);
SkASSERT(fTarget && fTarget->isAnimate());
SkAnimateBase* animate = (SkAnimateBase*) fTarget;
animate->setHasEndEvent();
}
}
void SkDisplayEvent::populateInput(SkAnimateMaker& maker, const SkEvent& fEvent) {
const SkMetaData& meta = fEvent.getMetaData();
SkMetaData::Iter iter(meta);
SkMetaData::Type type;
int number;
const char* name;
while ((name = iter.next(&type, &number)) != nullptr) {
if (name[0] == '\0')
continue;
SkDisplayable* displayable;
SkInput* input;
for (int index = 0; index < fChildren.count(); index++) {
displayable = fChildren[index];
if (displayable->getType() != SkType_Input)
continue;
input = (SkInput*) displayable;
if (input->name.equals(name))
goto found;
}
if (!maker.find(name, &displayable) || displayable->getType() != SkType_Input)
continue;
input = (SkInput*) displayable;
found:
switch (type) {
case SkMetaData::kS32_Type:
meta.findS32(name, &input->fInt);
break;
case SkMetaData::kScalar_Type:
meta.findScalar(name, &input->fFloat);
break;
case SkMetaData::kPtr_Type:
SkASSERT(0);
break; // !!! not handled for now
case SkMetaData::kString_Type:
input->string.set(meta.findString(name));
break;
default:
SkASSERT(0);
}
}
// re-evaluate all animators that may have built their values from input strings
for (SkDisplayable** childPtr = fChildren.begin(); childPtr < fChildren.end(); childPtr++) {
SkDisplayable* displayable = *childPtr;
if (displayable->isApply() == false)
continue;
SkApply* apply = (SkApply*) displayable;
apply->refresh(maker);
}
}
bool SkDisplayEvent::setProperty(int index, SkScriptValue& value) {
SkASSERT(index == SK_PROPERTY(key) || index == SK_PROPERTY(keys));
SkASSERT(value.fType == SkType_String);
SkString* string = value.fOperand.fString;
const char* chars = string->c_str();
int count = SkUTF8_CountUnichars(chars);
SkASSERT(count >= 1);
code = (SkKey) SkUTF8_NextUnichar(&chars);
fMax = code;
SkASSERT(count == 1 || index == SK_PROPERTY(keys));
if (--count > 0) {
SkASSERT(*chars == '-');
chars++;
fMax = (SkKey) SkUTF8_NextUnichar(&chars);
SkASSERT(fMax >= code);
}
return true;
}