The Tor Browser / file revision

gfx/skia/trunk/src/views/SkOSMenu.cpp@129ffea94266

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

Sat, 03 Jan 2015 20:18:00 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Sat, 03 Jan 2015 20:18:00 +0100
branch
TOR_BUG_3246
changeset 7
129ffea94266
permissions
-rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

     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