/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SampleCode_DEFINED
#define SampleCode_DEFINED
#include "Registry.h"
#include "SkColor.h"
#include "SkMacros.h"
#include "SkMetaData.h"
#include "SkPoint.h"
#include "SkRefCnt.h"
#include "SkString.h"
class SkAnimTimer;
class SkCanvas;
class Sample;
using SampleFactory = Sample* (*)();
using SampleRegistry = sk_tools::Registry<SampleFactory>;
#define DEF_SAMPLE(code) \
static Sample* SK_MACRO_APPEND_LINE(F_)() { code } \
static SampleRegistry SK_MACRO_APPEND_LINE(R_)(SK_MACRO_APPEND_LINE(F_));
///////////////////////////////////////////////////////////////////////////////
class Sample : public SkRefCnt {
public:
Sample()
: fBGColor(SK_ColorWHITE)
, fWidth(0), fHeight(0)
, fHaveCalledOnceBeforeDraw(false)
{}
SkScalar width() const { return fWidth; }
SkScalar height() const { return fHeight; }
void setSize(SkScalar width, SkScalar height);
void setSize(const SkPoint& size) { this->setSize(size.fX, size.fY); }
void setWidth(SkScalar width) { this->setSize(width, fHeight); }
void setHeight(SkScalar height) { this->setSize(fWidth, height); }
/** Call this to have the view draw into the specified canvas. */
virtual void draw(SkCanvas* canvas);
// Click handling
class Click {
public:
Click(Sample* target);
virtual ~Click();
enum State {
kDown_State,
kMoved_State,
kUp_State
};
enum ModifierKeys {
kShift_ModifierKey = 1 << 0,
kControl_ModifierKey = 1 << 1,
kOption_ModifierKey = 1 << 2, // same as ALT
kCommand_ModifierKey = 1 << 3,
};
SkPoint fOrig, fPrev, fCurr;
SkIPoint fIOrig, fIPrev, fICurr;
State fState;
unsigned fModifierKeys;
SkMetaData fMeta;
private:
sk_sp<Sample> fTarget;
friend class Sample;
};
Click* findClickHandler(SkScalar x, SkScalar y, unsigned modifierKeys);
static void DoClickDown(Click*, int x, int y, unsigned modi);
static void DoClickMoved(Click*, int x, int y, unsigned modi);
static void DoClickUp(Click*, int x, int y, unsigned modi);
void setBGColor(SkColor color) { fBGColor = color; }
bool animate(const SkAnimTimer& timer) { return this->onAnimate(timer); }
class Event {
public:
Event();
explicit Event(const char type[]);
Event(const Event& src);
~Event();
/** Returns true if the event's type matches exactly the specified type (case sensitive) */
bool isType(const char type[]) const;
/** Return the event's unnamed 32bit field. Default value is 0 */
uint32_t getFast32() const { return f32; }
/** Set the event's unnamed 32bit field. */
void setFast32(uint32_t x) { f32 = x; }
/** Return true if the event contains the named 32bit field, and return the field
in value (if value is non-null). If there is no matching named field, return false
and ignore the value parameter.
*/
bool findS32(const char name[], int32_t* value = nullptr) const {
return fMeta.findS32(name, value);
}
/** Return true if the event contains the named SkScalar field, and return the field
in value (if value is non-null). If there is no matching named field, return false
and ignore the value parameter.
*/
bool findScalar(const char name[], SkScalar* value = nullptr) const {
return fMeta.findScalar(name, value);
}
/** Return true if the event contains the named SkScalar field, and return the fields
in value[] (if value is non-null), and return the number of SkScalars in count
(if count is non-null). If there is no matching named field, return false
and ignore the value and count parameters.
*/
const SkScalar* findScalars(const char name[], int* count, SkScalar values[]=nullptr) const{
return fMeta.findScalars(name, count, values);
}
/** Return the value of the named string field, or nullptr. */
const char* findString(const char name[]) const { return fMeta.findString(name); }
/** Return true if the event contains the named pointer field, and return the field
in value (if value is non-null). If there is no matching named field, return false
and ignore the value parameter.
*/
bool findPtr(const char name[], void** value) const { return fMeta.findPtr(name, value); }
bool findBool(const char name[], bool* value) const { return fMeta.findBool(name, value); }
const void* findData(const char name[], size_t* byteCount = nullptr) const {
return fMeta.findData(name, byteCount);
}
/** Returns true if ethe event contains the named 32bit field, and if it equals the specified value */
bool hasS32(const char name[], int32_t value) const { return fMeta.hasS32(name, value); }
/** Returns true if ethe event contains the named SkScalar field, and if it equals the specified value */
bool hasScalar(const char name[], SkScalar value) const { return fMeta.hasScalar(name, value); }
/** Returns true if ethe event contains the named string field, and if it equals (using strcmp) the specified value */
bool hasString(const char name[], const char value[]) const { return fMeta.hasString(name, value); }
/** Returns true if ethe event contains the named pointer field, and if it equals the specified value */
bool hasPtr(const char name[], void* value) const { return fMeta.hasPtr(name, value); }
bool hasBool(const char name[], bool value) const { return fMeta.hasBool(name, value); }
bool hasData(const char name[], const void* data, size_t byteCount) const {
return fMeta.hasData(name, data, byteCount);
}
/** Add/replace the named 32bit field to the event. */
void setS32(const char name[], int32_t value) { fMeta.setS32(name, value); }
/** Add/replace the named SkScalar field to the event. */
void setScalar(const char name[], SkScalar value) { fMeta.setScalar(name, value); }
/** Add/replace the named SkScalar[] field to the event. */
SkScalar* setScalars(const char name[], int count, const SkScalar values[] = nullptr) {
return fMeta.setScalars(name, count, values);
}
/** Add/replace the named string field to the event. */
void setString(const char name[], const char value[]) { fMeta.setString(name, value); }
/** Add/replace the named pointer field to the event. */
void setPtr(const char name[], void* value) { fMeta.setPtr(name, value); }
void setBool(const char name[], bool value) { fMeta.setBool(name, value); }
void setData(const char name[], const void* data, size_t byteCount) {
fMeta.setData(name, data, byteCount);
}
/** Return the underlying metadata object */
SkMetaData& getMetaData() { return fMeta; }
/** Return the underlying metadata object */
const SkMetaData& getMetaData() const { return fMeta; }
///////////////////////////////////////////////////////////////////////////
private:
SkMetaData fMeta;
SkString fType;
uint32_t f32;
};
/** Pass an event to this object for processing. Returns true if the event was handled. */
bool doEvent(const Event&);
/** Returns true if the sink (or one of its subclasses) understands the event as a query.
If so, the sink may modify the event to communicate its "answer".
*/
bool doQuery(Event* query);
static const char* kCharEvtName;
static const char* kTitleEvtName;
static bool CharQ(const Event&, SkUnichar* outUni);
static bool TitleQ(const Event&);
static void TitleR(Event*, const char title[]);
static bool RequestTitle(Sample* view, SkString* title);
protected:
/** Override to handle events in your subclass.
* Overriders must call the super class for unhandled events.
*/
virtual bool onEvent(const Event&);
virtual bool onQuery(Event*);
/** Override to be notified of size changes. Overriders must call the super class. */
virtual void onSizeChange();
/** Override this if you might handle the click */
virtual Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned modi);
/** Override to track clicks. Return true as long as you want to track the pen/mouse. */
virtual bool onClick(Click*);
virtual void onDrawBackground(SkCanvas*);
virtual void onDrawContent(SkCanvas*) = 0;
virtual bool onAnimate(const SkAnimTimer&) { return false; }
virtual void onOnceBeforeDraw() {}
private:
SkColor fBGColor;
SkScalar fWidth, fHeight;
bool fHaveCalledOnceBeforeDraw;
};
#endif