The Tor Browser / file comparison

comparison: gfx/skia/trunk/src/views/SkOSMenu.cpp

gfx/skia/trunk/src/views/SkOSMenu.cpp

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:b7105594a83b
1 /*
2 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7 #include <stdarg.h>
8 #include "SkOSMenu.h"
9 #include "SkThread.h"
10
11 static int gOSMenuCmd = 7000;
12
13 SkOSMenu::SkOSMenu(const char title[]) {
14 fTitle.set(title);
15 }
16
17 SkOSMenu::~SkOSMenu() {
18 this->reset();
19 }
20
21 void SkOSMenu::reset() {
22 fItems.deleteAll();
23 fTitle.reset();
24 }
25
26 const SkOSMenu::Item* SkOSMenu::getItemByID(int itemID) const {
27 for (int i = 0; i < fItems.count(); ++i) {
28 if (itemID == fItems[i]->getID())
29 return fItems[i];
30 }
31 return NULL;
32 }
33
34 void SkOSMenu::getItems(const SkOSMenu::Item* items[]) const {
35 if (NULL != items) {
36 for (int i = 0; i < fItems.count(); ++i) {
37 items[i] = fItems[i];
38 }
39 }
40 }
41
42 void SkOSMenu::assignKeyEquivalentToItem(int itemID, SkUnichar key) {
43 for (int i = 0; i < fItems.count(); ++i) {
44 if (itemID == fItems[i]->getID())
45 fItems[i]->setKeyEquivalent(key);
46 }
47 }
48
49 bool SkOSMenu::handleKeyEquivalent(SkUnichar key) {
50 int value = 0, size = 0;
51 bool state;
52 SkOSMenu::TriState tristate;
53 for (int i = 0; i < fItems.count(); ++i) {
54 Item* item = fItems[i];
55 if (item->getKeyEquivalent()== key) {
56 SkString list;
57 switch (item->getType()) {
58 case kList_Type:
59 SkOSMenu::FindListItemCount(*item->getEvent(), &size);
60 SkOSMenu::FindListIndex(*item->getEvent(), item->getSlotName(), &value);
61 value = (value + 1) % size;
62 item->setInt(value);
63 break;
64 case kSwitch_Type:
65 SkOSMenu::FindSwitchState(*item->getEvent(), item->getSlotName(), &state);
66 item->setBool(!state);
67 break;
68 case kTriState_Type:
69 SkOSMenu::FindTriState(*item->getEvent(), item->getSlotName(), &tristate);
70 if (kOnState == tristate)
71 tristate = kMixedState;
72 else
73 tristate = (SkOSMenu::TriState)((int)tristate + 1);
74 item->setTriState(tristate);
75 break;
76 case kAction_Type:
77 case kCustom_Type:
78 case kSlider_Type:
79 case kTextField_Type:
80 default:
81 break;
82 }
83 item->postEvent();
84 return true;
85 }
86 }
87 return false;
88 }
89
90 ////////////////////////////////////////////////////////////////////////////////
91
92 SkOSMenu::Item::Item(const char label[], SkOSMenu::Type type,
93 const char slotName[], SkEvent* evt) {
94 fLabel.set(label);
95 fSlotName.set(slotName);
96 fType = type;
97 fEvent = evt;
98 fKey = 0;
99 fID = sk_atomic_inc(&gOSMenuCmd);
100 }
101
102 void SkOSMenu::Item::setBool(bool value) const {
103 SkASSERT(SkOSMenu::kSwitch_Type == fType);
104 fEvent->setBool(fSlotName.c_str(), value);
105 }
106
107 void SkOSMenu::Item::setScalar(SkScalar value) const {
108 SkASSERT(SkOSMenu::kSlider_Type == fType);
109 fEvent->setScalar(fSlotName.c_str(), value);
110 }
111
112 void SkOSMenu::Item::setInt(int value) const {
113 SkASSERT(SkOSMenu::kList_Type == fType);
114 fEvent->setS32(fSlotName.c_str(), value);
115 }
116
117 void SkOSMenu::Item::setTriState(TriState value) const {
118 SkASSERT(SkOSMenu::kTriState_Type == fType);
119 fEvent->setS32(fSlotName.c_str(), value);
120 }
121
122 void SkOSMenu::Item::setString(const char value[]) const {
123 SkASSERT(SkOSMenu::kTextField_Type == fType);
124 fEvent->setString(fSlotName.c_str(), value);
125 }
126
127 ////////////////////////////////////////////////////////////////////////////////
128
129 static const char* gMenuEventType = "SkOSMenuEventType";
130 static const char* gSlider_Min_Scalar = "SkOSMenuSlider_Min";
131 static const char* gSlider_Max_Scalar = "SkOSMenuSlider_Max";
132 static const char* gDelimiter = "|";
133 static const char* gList_Items_Str = "SkOSMenuList_Items";
134 static const char* gList_ItemCount_S32 = "SkOSMenuList_ItemCount";
135
136 int SkOSMenu::appendItem(const char label[], Type type, const char slotName[],
137 SkEvent* evt) {
138 SkOSMenu::Item* item = new Item(label, type, slotName, evt);
139 fItems.append(1, &item);
140 return item->getID();
141 }
142
143 int SkOSMenu::appendAction(const char label[], SkEventSinkID target) {
144 SkEvent* evt = new SkEvent(gMenuEventType, target);
145 //Store label in event so it can be used to identify the action later
146 evt->setString(label, label);
147 return appendItem(label, SkOSMenu::kAction_Type, "", evt);
148 }
149
150 int SkOSMenu::appendList(const char label[], const char slotName[],
151 SkEventSinkID target, int index, const char option[], ...) {
152 SkEvent* evt = new SkEvent(gMenuEventType, target);
153 va_list args;
154 if (option) {
155 SkString str(option);
156 va_start(args, option);
157 int count = 1;
158 for (const char* arg = va_arg(args, const char*); arg != NULL; arg = va_arg(args, const char*)) {
159 str += gDelimiter;
160 str += arg;
161 ++count;
162 }
163 va_end(args);
164 evt->setString(gList_Items_Str, str);
165 evt->setS32(gList_ItemCount_S32, count);
166 evt->setS32(slotName, index);
167 }
168 return appendItem(label, SkOSMenu::kList_Type, slotName, evt);
169 }
170
171 int SkOSMenu::appendSlider(const char label[], const char slotName[],
172 SkEventSinkID target, SkScalar min, SkScalar max,
173 SkScalar defaultValue) {
174 SkEvent* evt = new SkEvent(gMenuEventType, target);
175 evt->setScalar(gSlider_Min_Scalar, min);
176 evt->setScalar(gSlider_Max_Scalar, max);
177 evt->setScalar(slotName, defaultValue);
178 return appendItem(label, SkOSMenu::kSlider_Type, slotName, evt);
179 }
180
181 int SkOSMenu::appendSwitch(const char label[], const char slotName[],
182 SkEventSinkID target, bool defaultState) {
183 SkEvent* evt = new SkEvent(gMenuEventType, target);
184 evt->setBool(slotName, defaultState);
185 return appendItem(label, SkOSMenu::kSwitch_Type, slotName, evt);
186 }
187
188 int SkOSMenu::appendTriState(const char label[], const char slotName[],
189 SkEventSinkID target, SkOSMenu::TriState defaultState) {
190 SkEvent* evt = new SkEvent(gMenuEventType, target);
191 evt->setS32(slotName, defaultState);
192 return appendItem(label, SkOSMenu::kTriState_Type, slotName, evt);
193 }
194
195 int SkOSMenu::appendTextField(const char label[], const char slotName[],
196 SkEventSinkID target, const char placeholder[]) {
197 SkEvent* evt = new SkEvent(gMenuEventType, target);
198 evt->setString(slotName, placeholder);
199 return appendItem(label, SkOSMenu::kTextField_Type, slotName, evt);
200 }
201
202 bool SkOSMenu::FindListItemCount(const SkEvent& evt, int* count) {
203 return evt.isType(gMenuEventType) && evt.findS32(gList_ItemCount_S32, count);
204 }
205
206 bool SkOSMenu::FindListItems(const SkEvent& evt, SkString items[]) {
207 if (evt.isType(gMenuEventType) && NULL != items) {
208 const char* text = evt.findString(gList_Items_Str);
209 if (text != NULL) {
210 SkString temp(text);
211 char* token = strtok((char*)temp.c_str(), gDelimiter);
212 int index = 0;
213 while (token != NULL) {
214 items[index].set(token, strlen(token));
215 token = strtok (NULL, gDelimiter);
216 ++index;
217 }
218 }
219 return true;
220 }
221 return false;
222 }
223
224 bool SkOSMenu::FindSliderMin(const SkEvent& evt, SkScalar* min) {
225 return evt.isType(gMenuEventType) && evt.findScalar(gSlider_Min_Scalar, min);
226 }
227
228 bool SkOSMenu::FindSliderMax(const SkEvent& evt, SkScalar* max) {
229 return evt.isType(gMenuEventType) && evt.findScalar(gSlider_Max_Scalar, max);
230 }
231
232 bool SkOSMenu::FindAction(const SkEvent& evt, const char label[]) {
233 return evt.isType(gMenuEventType) && evt.findString(label);
234 }
235
236 bool SkOSMenu::FindListIndex(const SkEvent& evt, const char slotName[], int* value) {
237 return evt.isType(gMenuEventType) && evt.findS32(slotName, value);
238 }
239
240 bool SkOSMenu::FindSliderValue(const SkEvent& evt, const char slotName[], SkScalar* value) {
241 return evt.isType(gMenuEventType) && evt.findScalar(slotName, value);
242 }
243
244 bool SkOSMenu::FindSwitchState(const SkEvent& evt, const char slotName[], bool* value) {
245 return evt.isType(gMenuEventType) && evt.findBool(slotName, value);
246 }
247
248 bool SkOSMenu::FindTriState(const SkEvent& evt, const char slotName[], SkOSMenu::TriState* value) {
249 return evt.isType(gMenuEventType) && evt.findS32(slotName, (int*)value);
250 }
251
252 bool SkOSMenu::FindText(const SkEvent& evt, const char slotName[], SkString* value) {
253 if (evt.isType(gMenuEventType)) {
254 const char* text = evt.findString(slotName);
255 if (!text || !*text)
256 return false;
257 else {
258 value->set(text);
259 return true;
260 }
261 }
262 return false;
263 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial