blob: ad0c73f80dc5fec95daefd1848bec593d1561d4e [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 <stdarg.h>
#include "SkOSMenu.h"
#include "SkThread.h"
static int gOSMenuCmd = 7000;
SkOSMenu::SkOSMenu(const char title[]) {
fTitle.set(title);
}
SkOSMenu::~SkOSMenu() {
this->reset();
}
void SkOSMenu::reset() {
fItems.deleteAll();
fTitle.reset();
}
const SkOSMenu::Item* SkOSMenu::getItemByID(int itemID) const {
for (int i = 0; i < fItems.count(); ++i) {
if (itemID == fItems[i]->getID())
return fItems[i];
}
return NULL;
}
void SkOSMenu::getItems(const SkOSMenu::Item* items[]) const {
if (items) {
for (int i = 0; i < fItems.count(); ++i) {
items[i] = fItems[i];
}
}
}
void SkOSMenu::assignKeyEquivalentToItem(int itemID, SkUnichar key) {
for (int i = 0; i < fItems.count(); ++i) {
if (itemID == fItems[i]->getID())
fItems[i]->setKeyEquivalent(key);
}
}
bool SkOSMenu::handleKeyEquivalent(SkUnichar key) {
int value = 0, size = 0;
bool state;
SkOSMenu::TriState tristate;
for (int i = 0; i < fItems.count(); ++i) {
Item* item = fItems[i];
if (item->getKeyEquivalent()== key) {
SkString list;
switch (item->getType()) {
case kList_Type:
SkOSMenu::FindListItemCount(*item->getEvent(), &size);
SkOSMenu::FindListIndex(*item->getEvent(), item->getSlotName(), &value);
value = (value + 1) % size;
item->setInt(value);
break;
case kSwitch_Type:
SkOSMenu::FindSwitchState(*item->getEvent(), item->getSlotName(), &state);
item->setBool(!state);
break;
case kTriState_Type:
SkOSMenu::FindTriState(*item->getEvent(), item->getSlotName(), &tristate);
if (kOnState == tristate)
tristate = kMixedState;
else
tristate = (SkOSMenu::TriState)((int)tristate + 1);
item->setTriState(tristate);
break;
case kAction_Type:
case kCustom_Type:
case kSlider_Type:
case kTextField_Type:
default:
break;
}
item->postEvent();
return true;
}
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
SkOSMenu::Item::Item(const char label[], SkOSMenu::Type type,
const char slotName[], SkEvent* evt) {
fLabel.set(label);
fSlotName.set(slotName);
fType = type;
fEvent = evt;
fKey = 0;
fID = sk_atomic_inc(&gOSMenuCmd);
}
void SkOSMenu::Item::setBool(bool value) const {
SkASSERT(SkOSMenu::kSwitch_Type == fType);
fEvent->setBool(fSlotName.c_str(), value);
}
void SkOSMenu::Item::setScalar(SkScalar value) const {
SkASSERT(SkOSMenu::kSlider_Type == fType);
fEvent->setScalar(fSlotName.c_str(), value);
}
void SkOSMenu::Item::setInt(int value) const {
SkASSERT(SkOSMenu::kList_Type == fType);
fEvent->setS32(fSlotName.c_str(), value);
}
void SkOSMenu::Item::setTriState(TriState value) const {
SkASSERT(SkOSMenu::kTriState_Type == fType);
fEvent->setS32(fSlotName.c_str(), value);
}
void SkOSMenu::Item::setString(const char value[]) const {
SkASSERT(SkOSMenu::kTextField_Type == fType);
fEvent->setString(fSlotName.c_str(), value);
}
////////////////////////////////////////////////////////////////////////////////
static const char* gMenuEventType = "SkOSMenuEventType";
static const char* gSlider_Min_Scalar = "SkOSMenuSlider_Min";
static const char* gSlider_Max_Scalar = "SkOSMenuSlider_Max";
static const char* gDelimiter = "|";
static const char* gList_Items_Str = "SkOSMenuList_Items";
static const char* gList_ItemCount_S32 = "SkOSMenuList_ItemCount";
int SkOSMenu::appendItem(const char label[], Type type, const char slotName[],
SkEvent* evt) {
SkOSMenu::Item* item = new Item(label, type, slotName, evt);
fItems.append(1, &item);
return item->getID();
}
int SkOSMenu::appendAction(const char label[], SkEventSinkID target) {
SkEvent* evt = new SkEvent(gMenuEventType, target);
//Store label in event so it can be used to identify the action later
evt->setString(label, label);
return appendItem(label, SkOSMenu::kAction_Type, "", evt);
}
int SkOSMenu::appendList(const char label[], const char slotName[],
SkEventSinkID target, int index, const char option[], ...) {
SkEvent* evt = new SkEvent(gMenuEventType, target);
va_list args;
if (option) {
SkString str(option);
va_start(args, option);
int count = 1;
for (const char* arg = va_arg(args, const char*); arg != NULL; arg = va_arg(args, const char*)) {
str += gDelimiter;
str += arg;
++count;
}
va_end(args);
evt->setString(gList_Items_Str, str);
evt->setS32(gList_ItemCount_S32, count);
evt->setS32(slotName, index);
}
return appendItem(label, SkOSMenu::kList_Type, slotName, evt);
}
int SkOSMenu::appendSlider(const char label[], const char slotName[],
SkEventSinkID target, SkScalar min, SkScalar max,
SkScalar defaultValue) {
SkEvent* evt = new SkEvent(gMenuEventType, target);
evt->setScalar(gSlider_Min_Scalar, min);
evt->setScalar(gSlider_Max_Scalar, max);
evt->setScalar(slotName, defaultValue);
return appendItem(label, SkOSMenu::kSlider_Type, slotName, evt);
}
int SkOSMenu::appendSwitch(const char label[], const char slotName[],
SkEventSinkID target, bool defaultState) {
SkEvent* evt = new SkEvent(gMenuEventType, target);
evt->setBool(slotName, defaultState);
return appendItem(label, SkOSMenu::kSwitch_Type, slotName, evt);
}
int SkOSMenu::appendTriState(const char label[], const char slotName[],
SkEventSinkID target, SkOSMenu::TriState defaultState) {
SkEvent* evt = new SkEvent(gMenuEventType, target);
evt->setS32(slotName, defaultState);
return appendItem(label, SkOSMenu::kTriState_Type, slotName, evt);
}
int SkOSMenu::appendTextField(const char label[], const char slotName[],
SkEventSinkID target, const char placeholder[]) {
SkEvent* evt = new SkEvent(gMenuEventType, target);
evt->setString(slotName, placeholder);
return appendItem(label, SkOSMenu::kTextField_Type, slotName, evt);
}
bool SkOSMenu::FindListItemCount(const SkEvent& evt, int* count) {
return evt.isType(gMenuEventType) && evt.findS32(gList_ItemCount_S32, count);
}
bool SkOSMenu::FindListItems(const SkEvent& evt, SkString items[]) {
if (evt.isType(gMenuEventType) && items) {
const char* text = evt.findString(gList_Items_Str);
if (text != NULL) {
SkString temp(text);
char* token = strtok((char*)temp.c_str(), gDelimiter);
int index = 0;
while (token != NULL) {
items[index].set(token, strlen(token));
token = strtok (NULL, gDelimiter);
++index;
}
}
return true;
}
return false;
}
bool SkOSMenu::FindSliderMin(const SkEvent& evt, SkScalar* min) {
return evt.isType(gMenuEventType) && evt.findScalar(gSlider_Min_Scalar, min);
}
bool SkOSMenu::FindSliderMax(const SkEvent& evt, SkScalar* max) {
return evt.isType(gMenuEventType) && evt.findScalar(gSlider_Max_Scalar, max);
}
bool SkOSMenu::FindAction(const SkEvent& evt, const char label[]) {
return evt.isType(gMenuEventType) && evt.findString(label);
}
bool SkOSMenu::FindListIndex(const SkEvent& evt, const char slotName[], int* value) {
return evt.isType(gMenuEventType) && evt.findS32(slotName, value);
}
bool SkOSMenu::FindSliderValue(const SkEvent& evt, const char slotName[], SkScalar* value) {
return evt.isType(gMenuEventType) && evt.findScalar(slotName, value);
}
bool SkOSMenu::FindSwitchState(const SkEvent& evt, const char slotName[], bool* value) {
return evt.isType(gMenuEventType) && evt.findBool(slotName, value);
}
bool SkOSMenu::FindTriState(const SkEvent& evt, const char slotName[], SkOSMenu::TriState* value) {
return evt.isType(gMenuEventType) && evt.findS32(slotName, (int*)value);
}
bool SkOSMenu::FindText(const SkEvent& evt, const char slotName[], SkString* value) {
if (evt.isType(gMenuEventType)) {
const char* text = evt.findString(slotName);
if (!text || !*text)
return false;
else {
value->set(text);
return true;
}
}
return false;
}