void
Config::addCacheParam(const std::string &name, const std::string &value) const {
if (stop_collect_cache_) {
return;
}
Range name_r = trim(createRange(name));
static Range prefix = createRange("/xscript/");
if (!startsWith(name_r, prefix)) {
return;
}
for(std::set<std::string>::iterator it = forbidden_keys_.begin();
it != forbidden_keys_.end();
++it) {
if ('/' == *it->rbegin()) {
if (0 == strncmp(name_r.begin(), it->c_str(), it->size())) {
return;
}
}
else if (name_r == trim(createRange(*it))) {
return;
}
}
std::string key(name_r.begin() + prefix.size(), name_r.end());
cache_params_[key] = value;
}
// static
PassRefPtrWillBeRawPtr<SpellCheckRequest> SpellCheckRequest::create(TextCheckingTypeMask textCheckingOptions, TextCheckingProcessType processType, const EphemeralRange& checkingRange, const EphemeralRange& paragraphRange, int requestNumber)
{
if (checkingRange.isNull())
return nullptr;
if (!checkingRange.startPosition().computeContainerNode()->rootEditableElement())
return nullptr;
String text = plainText(checkingRange, TextIteratorEmitsObjectReplacementCharacter);
if (text.isEmpty())
return nullptr;
RefPtrWillBeRawPtr<Range> checkingRangeObject = createRange(checkingRange);
RefPtrWillBeRawPtr<Range> paragraphRangeObject = nullptr;
// Share identical Range objects.
if (checkingRange == paragraphRange)
paragraphRangeObject = checkingRangeObject;
else
paragraphRangeObject = createRange(paragraphRange);
const DocumentMarkerVector& markers = checkingRangeObject->ownerDocument().markers().markersInRange(checkingRange, DocumentMarker::SpellCheckClientMarkers());
Vector<uint32_t> hashes(markers.size());
Vector<unsigned> offsets(markers.size());
for (size_t i = 0; i < markers.size(); ++i) {
hashes[i] = markers[i]->hash();
offsets[i] = markers[i]->startOffset();
}
return adoptRefWillBeNoop(new SpellCheckRequest(checkingRangeObject, paragraphRangeObject, text, textCheckingOptions, processType, hashes, offsets, requestNumber));
}
void DOMSelection::deleteFromDocument() {
if (!isAvailable())
return;
FrameSelection& selection = frame()->selection();
if (selection.isNone())
return;
// TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
// needs to be audited. See http://crbug.com/590369 for more details.
// |VisibleSelection::toNormalizedEphemeralRange| requires clean layout.
frame()->document()->updateStyleAndLayoutIgnorePendingStylesheets();
Range* selectedRange =
createRange(selection.selection().toNormalizedEphemeralRange());
if (!selectedRange)
return;
selectedRange->deleteContents(ASSERT_NO_EXCEPTION);
setBaseAndExtent(selectedRange->startContainer(),
selectedRange->startOffset(),
selectedRange->startContainer(),
selectedRange->startOffset(), ASSERT_NO_EXCEPTION);
}
void
Config::addForbiddenKey(const std::string &key) const {
if (stop_collect_cache_) {
return;
}
Range key_r = trim(createRange(key));
if (key_r.empty()) {
return;
}
static Range mask = createRange("/*");
if (endsWith(key_r, mask)) {
forbidden_keys_.insert(std::string(key_r.begin(), key_r.end() - 1));
}
else {
forbidden_keys_.insert(std::string(key_r.begin(), key_r.end()));
}
}
Token* TokenFactory::getGraphemePattern() {
if (fGrapheme == 0) {
Token* base_char = createRange(); // [{ASSIGNED}]-[{M},{C}]
base_char->mergeRanges(getRange(fgUniAssigned));
base_char->subtractRanges(getRange(fgUniMark));
base_char->subtractRanges(getRange(fgUniControl));
Token* virama = createRange();
virama->addRange(0x094D, 0x094D);
virama->addRange(0x09CD, 0x09CD);
virama->addRange(0x0A4D, 0x0A4D);
virama->addRange(0x0ACD, 0x0ACD);
virama->addRange(0x0B4D, 0x0B4D);
virama->addRange(0x0BCD, 0x0BCD);
virama->addRange(0x0C4D, 0x0C4D);
virama->addRange(0x0CCD, 0x0CCD);
virama->addRange(0x0D4D, 0x0D4D);
virama->addRange(0x0E3A, 0x0E3A);
virama->addRange(0x0F84, 0x0F84);
Token* combiner_wo_virama = createRange();
combiner_wo_virama->mergeRanges(getRange(fgUniMark));
combiner_wo_virama->addRange(0x1160, 0x11FF); // hangul_medial and hangul_final
combiner_wo_virama->addRange(0xFF9F, 0xFF9F); // extras
Token* left = TokenFactory::createUnion(); // base_char?
left->addChild(base_char, this);
left->addChild(createToken(Token::T_EMPTY), this);
Token* foo = createUnion();
foo->addChild(TokenFactory::createConcat(virama,getRange(fgUniLetter)), this);
foo->addChild(combiner_wo_virama, this);
foo = createClosure(foo);
foo = createConcat(left, foo);
fGrapheme = foo;
}
return fGrapheme;
}
Range
MetaBlock::getLuaCode(Block *lua) const {
const char* code = XmlUtils::cdataValue(lua->node());
if (NULL == code) {
code = XmlUtils::value(lua->node());
if (NULL != code) {
return trim(createRange(code));
}
}
return Range((const char*)NULL, (const char*)NULL);
}
TEST_F(EventHandlerTest, dragSelectionAfterScroll)
{
setHtmlInnerHTML("<style> body { margin: 0px; } .upper { width: 300px; height: 400px; }"
".lower { margin: 0px; width: 300px; height: 400px; } .line { display: block; width: 300px; height: 30px; } </style>"
"<div class='upper'></div>"
"<div class='lower'>"
"<span class='line'>Line 1</span><span class='line'>Line 2</span><span class='line'>Line 3</span><span class='line'>Line 4</span><span class='line'>Line 5</span>"
"<span class='line'>Line 6</span><span class='line'>Line 7</span><span class='line'>Line 8</span><span class='line'>Line 9</span><span class='line'>Line 10</span>"
"</div>");
FrameView* frameView = document().view();
frameView->scrollTo(DoublePoint(0, 400));
PlatformMouseEvent mouseDownEvent(
IntPoint(0, 0),
IntPoint(100, 200),
LeftButton,
PlatformEvent::MousePressed,
1,
static_cast<PlatformEvent::Modifiers>(0),
WTF::currentTime());
document().frame()->eventHandler().handleMousePressEvent(mouseDownEvent);
PlatformMouseEvent mouseMoveEvent(
IntPoint(100, 50),
IntPoint(200, 250),
LeftButton,
PlatformEvent::MouseMoved,
1,
static_cast<PlatformEvent::Modifiers>(0),
WTF::currentTime());
document().frame()->eventHandler().handleMouseMoveEvent(mouseMoveEvent);
page().autoscrollController().animate(WTF::currentTime());
page().animator().serviceScriptedAnimations(WTF::currentTime());
PlatformMouseEvent mouseUpEvent(
IntPoint(100, 50),
IntPoint(200, 250),
LeftButton,
PlatformEvent::MouseReleased,
1,
static_cast<PlatformEvent::Modifiers>(0),
WTF::currentTime());
document().frame()->eventHandler().handleMouseReleaseEvent(mouseUpEvent);
FrameSelection& selection = document().frame()->selection();
ASSERT_TRUE(selection.isRange());
RefPtrWillBeRawPtr<Range> range = createRange(selection.selection().toNormalizedEphemeralRange());
ASSERT_TRUE(range.get());
EXPECT_EQ("Line 1\nLine 2", range->text());
}
vector<string> summaryRanges(vector<int>& nums) {
vector<string> ans;
if (nums.empty())
return ans;
int lo = nums[0];
int i;
for (i = 1; i < nums.size(); i++) {
if (nums[i] == nums[i-1] + 1)
continue;
else {
string range = createRange(lo, nums[i-1]);
lo = nums[i];
ans.push_back(range);
}
}
string range = createRange(lo, nums[i-1]);
lo = nums[i];
ans.push_back(range);
return ans;
}
TEST_F(EventHandlerTest, dragSelectionAfterScroll) {
setHtmlInnerHTML(
"<style> body { margin: 0px; } .upper { width: 300px; height: 400px; }"
".lower { margin: 0px; width: 300px; height: 400px; } .line { display: "
"block; width: 300px; height: 30px; } </style>"
"<div class='upper'></div>"
"<div class='lower'>"
"<span class='line'>Line 1</span><span class='line'>Line 2</span><span "
"class='line'>Line 3</span><span class='line'>Line 4</span><span "
"class='line'>Line 5</span>"
"<span class='line'>Line 6</span><span class='line'>Line 7</span><span "
"class='line'>Line 8</span><span class='line'>Line 9</span><span "
"class='line'>Line 10</span>"
"</div>");
FrameView* frameView = document().view();
frameView->layoutViewportScrollableArea()->setScrollOffset(
ScrollOffset(0, 400), ProgrammaticScroll);
PlatformMouseEvent mouseDownEvent(
IntPoint(0, 0), IntPoint(100, 200), WebPointerProperties::Button::Left,
PlatformEvent::MousePressed, 1, PlatformEvent::Modifiers::LeftButtonDown,
WTF::monotonicallyIncreasingTime());
document().frame()->eventHandler().handleMousePressEvent(mouseDownEvent);
PlatformMouseEvent mouseMoveEvent(
IntPoint(100, 50), IntPoint(200, 250), WebPointerProperties::Button::Left,
PlatformEvent::MouseMoved, 1, PlatformEvent::Modifiers::LeftButtonDown,
WTF::monotonicallyIncreasingTime());
document().frame()->eventHandler().handleMouseMoveEvent(
mouseMoveEvent, Vector<PlatformMouseEvent>());
page().autoscrollController().animate(WTF::monotonicallyIncreasingTime());
page().animator().serviceScriptedAnimations(
WTF::monotonicallyIncreasingTime());
PlatformMouseEvent mouseUpEvent(
IntPoint(100, 50), IntPoint(200, 250), WebPointerProperties::Button::Left,
PlatformEvent::MouseReleased, 1, static_cast<PlatformEvent::Modifiers>(0),
WTF::monotonicallyIncreasingTime());
document().frame()->eventHandler().handleMouseReleaseEvent(mouseUpEvent);
FrameSelection& selection = document().frame()->selection();
ASSERT_TRUE(selection.isRange());
Range* range =
createRange(selection.selection().toNormalizedEphemeralRange());
ASSERT_TRUE(range);
EXPECT_EQ("Line 1\nLine 2", range->text());
}
void WebSurroundingText::initializeFromCurrentSelection(WebLocalFrame* frame,
size_t maxLength) {
LocalFrame* webFrame = toWebLocalFrameImpl(frame)->frame();
// TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
// needs to be audited. See http://crbug.com/590369 for more details.
webFrame->document()->updateStyleAndLayoutIgnorePendingStylesheets();
if (Range* range = createRange(
webFrame->selection().selection().toNormalizedEphemeralRange())) {
// TODO(xiaochengh): The followinng SurroundingText can hold a null Range,
// in which case we should prevent it from being stored in |m_private|.
m_private.reset(new SurroundingText(*range, maxLength));
}
}
void DOMSelection::deleteFromDocument()
{
if (!m_frame)
return;
FrameSelection& selection = m_frame->selection();
if (selection.isNone())
return;
RefPtrWillBeRawPtr<Range> selectedRange = createRange(selection.selection().toNormalizedEphemeralRange());
if (!selectedRange)
return;
selectedRange->deleteContents(ASSERT_NO_EXCEPTION);
setBaseAndExtent(selectedRange->startContainer(), selectedRange->startOffset(), selectedRange->startContainer(), selectedRange->startOffset(), ASSERT_NO_EXCEPTION);
}
void AsciiComponentClass::add(unichar c) {
DEBUG_PRINTF("adding \\x%02x\n", c);
if (c > 0xff) { // too big!
throw LocatedParseError("Hexadecimal value is greater than \\xFF");
}
if (in_cand_range) {
createRange(c);
return;
}
CharReach ncr(c, c);
if (mode.caseless) {
make_caseless(&ncr);
}
cr |= ncr;
range_start = c;
}
bool SelectionEditor::setSelectedRange(const EphemeralRange& range, TextAffinity affinity, SelectionDirectionalMode directional, FrameSelection::SetSelectionOptions options)
{
if (range.isNull())
return false;
// Non-collapsed ranges are not allowed to start at the end of a line that is wrapped,
// they start at the beginning of the next line instead
m_logicalRange = nullptr;
stopObservingVisibleSelectionChangeIfNecessary();
// Since |FrameSeleciton::setSelection()| dispatches events and DOM tree
// can be modified by event handlers, we should create |Range| object before
// calling it.
m_logicalRange = createRange(range);
VisibleSelection newSelection(range.startPosition(), range.endPosition(), affinity, directional == SelectionDirectionalMode::Directional);
m_frameSelection->setSelection(newSelection, options);
startObservingVisibleSelectionChange();
return true;
}
std::string
HttpUtils::normalizeOutputHeaderName(const std::string &name) {
std::string res;
Range range = trim(createRange(name)), head, tail;
res.reserve(range.size());
while (!range.empty()) {
split(range, '-', head, tail);
if (!head.empty()) {
res.append(1, toupper(*head.begin()));
}
if (head.size() > 1) {
res.append(head.begin() + 1, head.end());
}
range = trim(tail);
if (!range.empty()) {
res.append(1, '-');
}
}
return res;
}
namespace xscript {
static const std::string ELAPSED_TIME_META_KEY = "elapsed-time";
static const std::string EXPIRE_TIME_META_KEY = "expire-time";
static const std::string LAST_MODIFIED_META_KEY = "last-modified";
struct MetaCore::MetaCoreData {
MetaCoreData() : elapsed_time_(MetaCore::undefinedElapsedTime())
{}
~MetaCoreData()
{}
void reset() {
data_.clear();
elapsed_time_ = MetaCore::undefinedElapsedTime();
}
TypedMap data_;
int elapsed_time_;
};
MetaCore::MetaCore() : core_data_(new MetaCoreData())
{}
MetaCore::~MetaCore()
{}
void
MetaCore::reset() {
core_data_->reset();
}
static const Range ELAPSED_TIME_RANGE = createRange("Elapsed-time:");
bool
MetaCore::parse(const char *buf, boost::uint32_t size) {
try {
reset();
Range data(buf, buf + size);
if (startsWith(data, ELAPSED_TIME_RANGE)) {
Range chunk;
split(data, Parser::RN_RANGE, chunk, data);
Range prefix, key;
split(chunk, ':', prefix, key);
if (key.empty()) {
log()->error("incorrect elapsed time format in block cache data");
return false;
}
core_data_->elapsed_time_ = static_cast<int>(*((boost::int32_t*)key.begin()));
}
const char* buf_tmp = data.begin();
const char* buf_end = data.end();
while (buf_tmp < buf_end) {
if (buf_end - buf_tmp < (boost::int32_t)sizeof(boost::uint32_t)) {
throw std::runtime_error("Incorrect meta format");
}
boost::uint32_t var = *((boost::uint32_t*)buf_tmp);
buf_tmp += sizeof(boost::uint32_t);
if (buf_end - buf_tmp < (boost::int64_t)var) {
throw std::runtime_error("Incorrect meta format");
}
Range key(buf_tmp, buf_tmp + var);
buf_tmp += var;
if (buf_end - buf_tmp < (boost::int32_t)sizeof(boost::uint32_t)) {
throw std::runtime_error("Incorrect meta format");
}
boost::uint32_t size = *((boost::uint32_t*)buf_tmp);
if (buf_tmp + size > buf_end) {
throw std::runtime_error("Incorrect meta format");
}
TypedValue value(Range(buf_tmp, buf_tmp + size));
core_data_->data_.insert(std::string(key.begin(), key.end()), value);
buf_tmp += size;
}
}
catch (const std::exception &e) {
log()->error("exception caught while parsing block cache data: %s", e.what());
return false;
}
return true;
}
void
MetaCore::serialize(std::string &buf) const {
if (undefinedElapsedTime() != core_data_->elapsed_time_) {
buf.append("Elapsed-time:");
boost::int32_t var = core_data_->elapsed_time_;
buf.append((char*)&var, sizeof(var));
buf.append("\r\n");
}
const std::map<std::string, TypedValue>& values = core_data_->data_.values();
for (std::map<std::string, TypedValue>::const_iterator it = values.begin();
it != values.end();
++it) {
boost::uint32_t var = it->first.size();
buf.append((char*)&var, sizeof(var));
buf.append(it->first);
it->second.serialize(buf);
}
}
int
MetaCore::undefinedElapsedTime() {
return -1;
}
const TypedValue&
MetaCore::find(const std::string &name) const {
return core_data_->data_.findNoThrow(name);
}
void
MetaCore::insert(const std::string &name, const TypedValue &value) {
core_data_->data_.insert(name, value);
}
bool
MetaCore::has(const std::string &name) const {
return core_data_->data_.has(name);
}
time_t
MetaCore::getElapsedTime() const {
return core_data_->elapsed_time_;
}
void
MetaCore::setElapsedTime(time_t time) {
core_data_->elapsed_time_ = time;
}
const std::map<std::string, TypedValue>&
MetaCore::values() const {
return core_data_->data_.values();
}
struct Meta::MetaData {
MetaData() : expire_time_(Meta::undefinedExpireTime()),
last_modified_(Meta::undefinedLastModified()),
cache_params_writable_(false), core_writable_(true)
{}
~MetaData()
{}
void reset() {
core_.reset();
child_.clear();
cache_params_writable_ = false;
core_writable_ = true;
expire_time_ = Meta::undefinedExpireTime();
last_modified_ = Meta::undefinedLastModified();
}
void initCore() {
if (NULL == core_.get()) {
core_ = boost::shared_ptr<MetaCore>(new MetaCore);
}
}
boost::shared_ptr<MetaCore> core_;
TypedMap child_;
time_t expire_time_;
time_t last_modified_;
bool cache_params_writable_;
bool core_writable_;
};
Meta::Meta() : meta_data_(new MetaData())
{}
Meta::~Meta()
{}
void
Meta::reset() {
meta_data_->reset();
}
time_t
Meta::undefinedExpireTime() {
return -1;
}
time_t
Meta::undefinedLastModified() {
return -1;
}
void
Meta::initCore() {
meta_data_->initCore();
}
void
Meta::setCore(const boost::shared_ptr<MetaCore> &core) {
meta_data_->core_ = core;
}
boost::shared_ptr<MetaCore>
Meta::getCore() const {
return meta_data_->core_;
}
const std::string&
Meta::get(const std::string &name, const std::string &default_value) const {
const TypedValue& value = meta_data_->child_.findNoThrow(name);
if (!value.nil()) {
return value.asString();
}
if (meta_data_->core_.get()) {
const TypedValue& value = meta_data_->core_->find(name);
if (!value.nil()) {
return value.asString();
}
}
return default_value;
}
const TypedValue&
Meta::getTypedValue(const std::string &name) const {
const TypedValue& value = meta_data_->child_.findNoThrow(name);
if (!value.nil()) {
return value;
}
return meta_data_->core_.get() ? meta_data_->core_->find(name) : value;
}
void
Meta::setTypedValue(const std::string &name, const TypedValue &value) {
if (!allowKey(name)) {
throw std::runtime_error(name + " key is not allowed");
}
if (meta_data_->core_writable_) {
initCore();
meta_data_->core_->insert(name, value);
}
else {
meta_data_->child_.insert(name, value);
}
}
void
Meta::setBool(const std::string &name, bool value) {
setTypedValue(name, TypedValue(value));
}
void
Meta::setLong(const std::string &name, boost::int32_t value) {
setTypedValue(name, TypedValue(value));
}
void
Meta::setULong(const std::string &name, boost::uint32_t value) {
setTypedValue(name, TypedValue(value));
}
void
Meta::setLongLong(const std::string &name, boost::int64_t value) {
setTypedValue(name, TypedValue(value));
}
void
Meta::setULongLong(const std::string &name, boost::uint64_t value) {
setTypedValue(name, TypedValue(value));
}
void
Meta::setDouble(const std::string &name, double value) {
setTypedValue(name, TypedValue(value));
}
void
Meta::setString(const std::string &name, const std::string &value) {
setTypedValue(name, TypedValue(value));
}
void
Meta::setArray(const std::string &name, const std::vector<std::string> &value) {
TypedValue val = TypedValue::createArrayValue();
for (std::vector<std::string>::const_iterator it = value.begin();
it != value.end();
++it) {
val.add(StringUtils::EMPTY_STRING, TypedValue(*it));
}
setTypedValue(name, val);
}
void
Meta::setMap(const std::string &name, const std::vector<StringUtils::NamedValue> &value) {
TypedValue val = TypedValue::createMapValue();
for (std::vector<StringUtils::NamedValue>::const_iterator it = value.begin();
it != value.end();
++it) {
val.add(it->first, TypedValue(it->second));
}
setTypedValue(name, val);
}
bool
Meta::has(const std::string &name) const {
if (meta_data_->child_.has(name)) {
return true;
}
if (meta_data_->core_.get() && meta_data_->core_->has(name)) {
return true;
}
return false;
}
void
Meta::setElapsedTime(int time) {
if (time < 0) {
throw std::runtime_error("Incorrect elapsed time value");
}
initCore();
meta_data_->core_->setElapsedTime(time);
}
int
Meta::getElapsedTime() const {
return meta_data_->core_.get() ?
meta_data_->core_->getElapsedTime() :
MetaCore::undefinedElapsedTime();
}
time_t
Meta::getExpireTime() const {
return meta_data_->expire_time_;
}
void
Meta::setExpireTime(time_t time) {
if (meta_data_->cache_params_writable_) {
meta_data_->expire_time_ = time;
}
}
time_t
Meta::getLastModified() const {
return meta_data_->last_modified_;
}
void
Meta::setLastModified(time_t time) {
if (meta_data_->cache_params_writable_) {
meta_data_->last_modified_ = time;
}
}
void
Meta::setCacheParams(time_t expire, time_t last_modified) {
meta_data_->expire_time_ = expire;
meta_data_->last_modified_ = last_modified;
}
bool
Meta::allowKey(const std::string &key) const {
if (ELAPSED_TIME_META_KEY == key ||
EXPIRE_TIME_META_KEY == key ||
LAST_MODIFIED_META_KEY == key) {
return false;
}
return true;
}
static void
processNewMetaNode(const std::string &name, const TypedValue &value,
XmlNodeHelper &result, xmlNodePtr &last_node) {
XmlTypedVisitor visitor;
value.visit(&visitor);
XmlNodeHelper res = visitor.result();
xmlNewProp(res.get(), (const xmlChar*)"name", (const xmlChar*)name.c_str());
if (result.get()) {
last_node = xmlAddNextSibling(last_node, res.release());
}
else {
result = res;
last_node = result.get();
}
}
XmlNodeHelper
Meta::getXml() const {
XmlNodeHelper result;
xmlNodePtr last_insert_node = NULL;
if (MetaCore::undefinedElapsedTime() != getElapsedTime()) {
TypedValue value((boost::int64_t)getElapsedTime());
processNewMetaNode(ELAPSED_TIME_META_KEY, value, result, last_insert_node);
}
if (undefinedExpireTime() != meta_data_->expire_time_) {
TypedValue value((boost::int64_t)meta_data_->expire_time_);
processNewMetaNode(EXPIRE_TIME_META_KEY, value, result, last_insert_node);
}
if (undefinedExpireTime() != meta_data_->last_modified_) {
TypedValue value((boost::int64_t)meta_data_->last_modified_);
processNewMetaNode(LAST_MODIFIED_META_KEY, value, result, last_insert_node);
}
const std::map<std::string, TypedValue> &values = meta_data_->child_.values();
for(std::map<std::string, TypedValue>::const_iterator it = values.begin();
it != values.end();
++it) {
if (!allowKey(it->first)) {
continue;
}
processNewMetaNode(it->first, it->second, result, last_insert_node);
}
if (NULL == meta_data_->core_.get()) {
return result;
}
const std::map<std::string, TypedValue> &core_values = meta_data_->core_->values();
for(std::map<std::string, TypedValue>::const_iterator it = core_values.begin();
it != core_values.end();
++it) {
if (meta_data_->child_.has(it->first)) {
continue;
}
processNewMetaNode(it->first, it->second, result, last_insert_node);
}
return result;
}
void
Meta::cacheParamsWritable(bool flag) {
meta_data_->cache_params_writable_ = flag;
}
void
Meta::coreWritable(bool flag) {
meta_data_->core_writable_ = flag;
}
} // namespace xscript
void MgClKernel::run()
{
if(!environment())
return;
if(!localRange())
return;
if(!d_ptr->arguments.size())
return;
if(!valid())
return;
Q_EMIT runStarted();
cl::KernelFunctor functor = d_ptr->kernel.bind(
d_ptr->environment->d_ptr->commandQueue,
createRange(offsetRange()),
createRange(localRange()),
createRange(globalRange())
);
switch (d_ptr->arguments.size()) {
case 1:
functor();
break;
case 2:
functor();
break;
case 3:
functor();
break;
case 4:
functor();
break;
case 5:
functor();
break;
case 6:
functor();
break;
case 7:
functor();
break;
case 8:
functor();
break;
case 9:
functor();
break;
case 10:
functor();
break;
case 11:
functor();
break;
case 12:
functor();
break;
case 13:
functor();
break;
case 14:
functor();
break;
case 15:
functor();
break;
default:
break;
}
Q_EMIT runFinished();
}
