void AnimationChannel::removeDuplicates()
{
LOG(3, " Removing duplicates for channel with target attribute: %u.\n", _targetAttrib);
int startCount = _keytimes.size();
size_t propSize = Transform::getPropertySize(_targetAttrib);
if (propSize > 1 && !_interpolations.empty() && _interpolations[0] == LINEAR)
{
size_t prevIndex = 0;
std::vector<float>::iterator prevStart = _keyValues.begin();
std::vector<float>::iterator prevEnd = prevStart + propSize - 1;
size_t i = 1;
for (i = 1; i < _keytimes.size(); ++i)
{
std::vector<float>::iterator start = _keyValues.begin() + i * propSize;
std::vector<float>::iterator end = start + propSize - 1;
if (!equal(prevStart, prevEnd, start) || i == _keytimes.size() - 1)
{
if (i - prevIndex > 2)
{
deleteRange(prevIndex+1, i, propSize);
i = prevIndex;
prevStart = _keyValues.begin() + i * propSize;
prevEnd = prevStart + propSize - 1;
}
else
{
prevStart = start;
prevEnd = end;
prevIndex = i;
}
}
}
if (i - 1 - prevIndex >= 2)
{
deleteRange(prevIndex+1, i, propSize);
}
}
LOG(3, " Removed %d duplicate keyframes from channel.\n", startCount- _keytimes.size());
}
void EditableTextComponent::keyTyped(const KeyEventUnrecPtr e)
{
if(getEnabled() && getEditable() && !(e->getModifiers() &( KeyEvent::KEY_MODIFIER_ALT | KeyEvent::KEY_MODIFIER_CONTROL | KeyEvent::KEY_MODIFIER_META )))
{
if(e->getKeyChar()>31 && e->getKeyChar() < 127)
{
if(hasSelection())
{
deleteSelectedText();
setCaretPosition(_TextSelectionStart);
}
insert(std::string( 1,e->getKeyChar() ), _TextSelectionStart);
_TextSelectionStart = getCaretPosition();
_TextSelectionEnd = _TextSelectionStart;
}
if(e->getKey()== e->KEY_BACK_SPACE)
{
if(hasSelection())
{
deleteSelectedText();
}
else
{
//erase at the current caret position
Int32 DeleteIndex(getCaretPosition());
if(DeleteIndex != 0)
{
moveCaret(-1);
deleteRange(DeleteIndex-1, DeleteIndex);
}
}
}
if(e->getKey()== e->KEY_DELETE)
{
if(hasSelection())
{
deleteSelectedText();
}
else if(getText().size()>0)
{
//erase at the current caret position
deleteRange(getCaretPosition(), getCaretPosition()+1);
_TextSelectionStart = getCaretPosition();
_TextSelectionEnd = _TextSelectionStart;
}
}
}
switch(e->getKey())
{
case KeyEvent::KEY_RIGHT:
case KeyEvent::KEY_KEYPAD_RIGHT:
moveCaret(1);
break;
case KeyEvent::KEY_LEFT:
case KeyEvent::KEY_KEYPAD_LEFT:
moveCaret(-1);
break;
case KeyEvent::KEY_V:
if(e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
{
paste();
}
break;
case KeyEvent::KEY_C:
if(e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
{
copy();
}
break;
case KeyEvent::KEY_X:
if(e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
{
cut();
}
break;
case KeyEvent::KEY_A:
if(e->getModifiers() & KeyEvent::KEY_MODIFIER_COMMAND)
{
selectAll();
}
break;
}
Inherited::keyTyped(e);
}
bool RangeDeleter::deleteNow(OperationContext* txn,
const RangeDeleterOptions& options,
string* errMsg) {
if (stopRequested()) {
*errMsg = "deleter is already stopped.";
return false;
}
string dummy;
if (errMsg == NULL) errMsg = &dummy;
const string& ns(options.range.ns);
const BSONObj& min(options.range.minKey);
const BSONObj& max(options.range.maxKey);
NSMinMax deleteRange(ns, min, max);
{
boost::lock_guard<boost::mutex> sl(_queueMutex);
if (!canEnqueue_inlock(ns, min, max, errMsg)) {
return false;
}
_deleteSet.insert(&deleteRange);
// Note: count for pending deletes is an integral part of the shutdown story.
// Therefore, to simplify things, there is no "pending" state for deletes in
// deleteNow, the state transition is simply inProgress -> done.
_deletesInProgress++;
}
set<CursorId> cursorsToWait;
if (options.waitForOpenCursors) {
_env->getCursorIds(txn, ns, &cursorsToWait);
}
long long checkIntervalMillis = 5;
RangeDeleteEntry taskDetails(options);
taskDetails.stats.queueStartTS = jsTime();
for (; !cursorsToWait.empty(); sleepmillis(checkIntervalMillis)) {
logCursorsWaiting(&taskDetails);
set<CursorId> cursorsNow;
_env->getCursorIds(txn, ns, &cursorsNow);
set<CursorId> cursorsLeft;
std::set_intersection(cursorsToWait.begin(),
cursorsToWait.end(),
cursorsNow.begin(),
cursorsNow.end(),
std::inserter(cursorsLeft, cursorsLeft.end()));
cursorsToWait.swap(cursorsLeft);
if (stopRequested()) {
*errMsg = "deleter was stopped.";
boost::lock_guard<boost::mutex> sl(_queueMutex);
_deleteSet.erase(&deleteRange);
_deletesInProgress--;
if (_deletesInProgress == 0) {
_nothingInProgressCV.notify_one();
}
return false;
}
if (checkIntervalMillis < kMaxCursorCheckIntervalMillis) {
checkIntervalMillis *= 2;
}
}
taskDetails.stats.queueEndTS = jsTime();
taskDetails.stats.deleteStartTS = jsTime();
bool result = _env->deleteRange(txn,
taskDetails,
&taskDetails.stats.deletedDocCount,
errMsg);
taskDetails.stats.deleteEndTS = jsTime();
if (result) {
taskDetails.stats.waitForReplStartTS = jsTime();
result = _waitForMajority(txn, errMsg);
taskDetails.stats.waitForReplEndTS = jsTime();
}
{
boost::lock_guard<boost::mutex> sl(_queueMutex);
_deleteSet.erase(&deleteRange);
_deletesInProgress--;
if (_deletesInProgress == 0) {
_nothingInProgressCV.notify_one();
}
}
recordDelStats(new DeleteJobStats(taskDetails.stats));
return result;
}
bool RangeDeleter::deleteNow(const std::string& ns,
const BSONObj& min,
const BSONObj& max,
const BSONObj& shardKeyPattern,
bool secondaryThrottle,
string* errMsg) {
if (stopRequested()) {
*errMsg = "deleter is already stopped.";
return false;
}
string dummy;
if (errMsg == NULL) errMsg = &dummy;
NSMinMax deleteRange(ns, min, max);
{
scoped_lock sl(_queueMutex);
if (!canEnqueue_inlock(ns, min, max, errMsg)) {
return false;
}
_deleteSet.insert(&deleteRange);
_stats->incTotalDeletes_inlock();
// Note: count for pending deletes is an integral part of the shutdown story.
// Therefore, to simplify things, there is no "pending" state for deletes in
// deleteNow, the state transition is simply inProgress -> done.
_stats->incInProgressDeletes_inlock();
}
set<CursorId> cursorsToWait;
_env->getCursorIds(ns, &cursorsToWait);
long long checkIntervalMillis = 5;
if (!cursorsToWait.empty()) {
log() << "rangeDeleter waiting for " << cursorsToWait.size()
<< " cursors in " << ns << " to finish" << endl;
}
while (!cursorsToWait.empty()) {
set<CursorId> cursorsNow;
_env->getCursorIds(ns, &cursorsNow);
set<CursorId> cursorsLeft;
std::set_intersection(cursorsToWait.begin(),
cursorsToWait.end(),
cursorsNow.begin(),
cursorsNow.end(),
std::inserter(cursorsLeft, cursorsLeft.end()));
cursorsToWait.swap(cursorsLeft);
if (stopRequested()) {
*errMsg = "deleter was stopped.";
scoped_lock sl(_queueMutex);
_deleteSet.erase(&deleteRange);
_stats->decInProgressDeletes_inlock();
_stats->decTotalDeletes_inlock();
if (!_stats->hasInProgress_inlock()) {
_nothingInProgressCV.notify_one();
}
return false;
}
if (checkIntervalMillis < MaxCurorCheckIntervalMillis) {
checkIntervalMillis *= 2;
}
sleepmillis(checkIntervalMillis);
}
bool result = _env->deleteRange(ns, min, max, shardKeyPattern,
secondaryThrottle, errMsg);
{
scoped_lock sl(_queueMutex);
_deleteSet.erase(&deleteRange);
_stats->decInProgressDeletes_inlock();
_stats->decTotalDeletes_inlock();
if (!_stats->hasInProgress_inlock()) {
_nothingInProgressCV.notify_one();
}
}
return result;
}
void TEditor::handleEvent( TEvent& event )
{
TView::handleEvent( event );
convertEvent( event );
Boolean centerCursor = Boolean(!cursorVisible());
uchar selectMode = 0;
if( selecting == True || (getShiftState() & 0x03) != 0 )
selectMode = smExtend;
switch( event.what )
{
case evMouseDown:
if( event.mouse.doubleClick == True )
selectMode |= smDouble;
do {
lock();
if( event.what == evMouseAuto )
{
TPoint mouse = makeLocal( event.mouse.where );
TPoint d = delta;
if( mouse.x < 0 )
d.x--;
if( mouse.x >= size.x )
d.x++;
if( mouse.y < 0 )
d.y--;
if( mouse.y >= size.y )
d.y++;
scrollTo(d.x, d.y);
}
setCurPtr(getMousePtr(event.mouse.where), selectMode);
selectMode |= smExtend;
unlock();
} while( mouseEvent(event, evMouseMove + evMouseAuto) );
break;
case evKeyDown:
if( event.keyDown.charScan.charCode == 9 ||
( event.keyDown.charScan.charCode >= 32 && event.keyDown.charScan.charCode < 255 ) )
{
lock();
if( overwrite == True && hasSelection() == False )
if( curPtr != lineEnd(curPtr) )
selEnd = nextChar(curPtr);
insertText( &event.keyDown.charScan.charCode, 1, False);
trackCursor(centerCursor);
unlock();
}
else
return;
break;
case evCommand:
switch( event.message.command )
{
case cmFind:
find();
break;
case cmReplace:
replace();
break;
case cmSearchAgain:
doSearchReplace();
break;
default:
lock();
switch( event.message.command )
{
case cmCut:
clipCut();
break;
case cmCopy:
clipCopy();
// hideSelect(); // JS 12.4.94
break;
case cmPaste:
clipPaste();
break;
case cmUndo:
undo();
break;
case cmClear:
deleteSelect();
break;
case cmCharLeft:
setCurPtr(prevChar(curPtr), selectMode);
break;
case cmCharRight:
setCurPtr(nextChar(curPtr), selectMode);
break;
case cmWordLeft:
setCurPtr(prevWord(curPtr), selectMode);
break;
case cmWordRight:
setCurPtr(nextWord(curPtr), selectMode);
break;
case cmLineStart:
setCurPtr(lineStart(curPtr), selectMode);
break;
case cmLineEnd:
setCurPtr(lineEnd(curPtr), selectMode);
break;
case cmLineUp:
setCurPtr(lineMove(curPtr, -1), selectMode);
break;
case cmLineDown:
setCurPtr(lineMove(curPtr, 1), selectMode);
break;
case cmPageUp:
setCurPtr(lineMove(curPtr, -(size.y-1)), selectMode);
break;
case cmPageDown:
setCurPtr(lineMove(curPtr, size.y-1), selectMode);
break;
case cmTextStart:
setCurPtr(0, selectMode);
break;
case cmTextEnd:
setCurPtr(bufLen, selectMode);
break;
case cmNewLine:
newLine();
break;
case cmBackSpace:
deleteRange(prevChar(curPtr), curPtr, True);
break;
case cmDelChar:
deleteRange(curPtr, nextChar(curPtr), True);
break;
case cmDelWord:
deleteRange(curPtr, nextWord(curPtr), False);
break;
case cmDelStart:
deleteRange(lineStart(curPtr), curPtr, False);
break;
case cmDelEnd:
deleteRange(curPtr, lineEnd(curPtr), False);
break;
case cmDelLine:
deleteRange(lineStart(curPtr), nextLine(curPtr), False);
break;
case cmInsMode:
toggleInsMode();
break;
case cmStartSelect:
startSelect();
break;
case cmHideSelect:
hideSelect();
break;
case cmIndentMode:
autoIndent = Boolean(!autoIndent);
break;
default:
unlock();
return;
}
trackCursor(centerCursor);
unlock();
break;
}
case evBroadcast:
switch( event.message.command )
{
case cmScrollBarChanged:
checkScrollBar( event, hScrollBar, delta.x );
checkScrollBar( event, vScrollBar, delta.y );
break;
default:
return;
}
}
clearEvent(event);
}
void deleteAndClear(Container& c) {
deleteRange(c.begin(), c.end());
c.clear();
}
void deleteRange(Container const& c) {
deleteRange(c.begin(), c.end());
}
int rfx_remove_range(time_t fromTime, uvast fromNode, uvast toNode)
{
Sdr sdr = getIonsdr();
PsmPartition ionwm = getIonwm();
IonVdb *vdb = getIonVdb();
IonRXref arg;
PsmAddress rxelt;
PsmAddress nextElt;
PsmAddress rxaddr;
IonRXref *rxref;
/* Note: when the fromTime passed to ionadmin is '*'
* a fromTime of zero is passed to rfx_remove_range,
* where it is interpreted as "all ranges between
* these two nodes". */
memset((char *) &arg, 0, sizeof(IonRXref));
arg.fromNode = fromNode;
arg.toNode = toNode;
CHKERR(sdr_begin_xn(sdr));
if (fromTime) /* Not a wild-card deletion. */
{
arg.fromTime = fromTime;
rxelt = sm_rbt_search(ionwm, vdb->rangeIndex, rfx_order_ranges,
&arg, &nextElt);
if (rxelt) /* Found it. */
{
rxaddr = sm_rbt_data(ionwm, rxelt);
deleteRange(rxaddr, 0);
}
}
else /* Wild-card deletion, start at time zero. */
{
while (1)
{
/* Get first remaining range for this
* to/from node pair. */
oK(sm_rbt_search(ionwm, vdb->rangeIndex,
rfx_order_ranges, &arg, &rxelt));
if (rxelt == 0)
{
break; /* No more ranges. */
}
rxaddr = sm_rbt_data(ionwm, rxelt);
rxref = (IonRXref *) psp(ionwm, rxaddr);
if (rxref->fromNode > arg.fromNode
|| rxref->toNode > arg.toNode)
{
break; /* No more matches. */
}
deleteRange(rxaddr, 0);
}
}
if (fromNode > toNode)
{
/* This is either an imputed range or else
* a non-canonical range assertion,
* indicating an override of the normal
* symmetry in the owlt between nodes. The
* reverse range assertion does *not* hold. */
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Can't remove range(s).", NULL);
return -1;
}
return 0;
}
/* Canonical range assertion(s); delete corresponding
* imputed range(s) as well. */
arg.fromNode = toNode; /* Reverse direction. */
arg.toNode = fromNode; /* Reverse direction. */
if (fromTime) /* Not a wild-card deletion. */
{
arg.fromTime = fromTime;
rxelt = sm_rbt_search(ionwm, vdb->rangeIndex, rfx_order_ranges,
&arg, &nextElt);
if (rxelt) /* Found it. */
{
rxaddr = sm_rbt_data(ionwm, rxelt);
deleteRange(rxaddr, 1);
}
}
else /* Wild-card deletion, start at time zero. */
{
while (1)
{
/* Get first remaining range for this
* to/from node pair. */
oK(sm_rbt_search(ionwm, vdb->rangeIndex,
rfx_order_ranges, &arg, &rxelt));
if (rxelt == 0)
{
break; /* No more ranges. */
}
rxaddr = sm_rbt_data(ionwm, rxelt);
rxref = (IonRXref *) psp(ionwm, rxaddr);
if (rxref->fromNode > arg.fromNode
|| rxref->toNode > arg.toNode)
{
break; /* No more matches. */
}
deleteRange(rxaddr, 1);
}
}
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Can't remove range(s).", NULL);
return -1;
}
return 0;
}
bool RangeDeleter::deleteNow(OperationContext* txn,
const std::string& ns,
const BSONObj& min,
const BSONObj& max,
const BSONObj& shardKeyPattern,
bool secondaryThrottle,
string* errMsg) {
if (stopRequested()) {
*errMsg = "deleter is already stopped.";
return false;
}
string dummy;
if (errMsg == NULL) errMsg = &dummy;
NSMinMax deleteRange(ns, min, max);
{
scoped_lock sl(_queueMutex);
if (!canEnqueue_inlock(ns, min, max, errMsg)) {
return false;
}
_deleteSet.insert(&deleteRange);
// Note: count for pending deletes is an integral part of the shutdown story.
// Therefore, to simplify things, there is no "pending" state for deletes in
// deleteNow, the state transition is simply inProgress -> done.
_deletesInProgress++;
}
set<CursorId> cursorsToWait;
_env->getCursorIds(txn, ns, &cursorsToWait);
long long checkIntervalMillis = 5;
if (!cursorsToWait.empty()) {
log() << "rangeDeleter waiting for " << cursorsToWait.size()
<< " cursors in " << ns << " to finish" << endl;
}
RangeDeleteEntry taskDetails(ns, min, max, shardKeyPattern, secondaryThrottle);
taskDetails.stats.queueStartTS = jsTime();
Date_t timeSinceLastLog;
for (; !cursorsToWait.empty(); sleepmillis(checkIntervalMillis)) {
const unsigned long long timeNow = curTimeMillis64();
const unsigned long long elapsedTimeMillis =
timeNow - taskDetails.stats.queueStartTS.millis;
const unsigned long long lastLogMillis = timeNow - timeSinceLastLog.millis;
if (elapsedTimeMillis > LogCursorsThresholdMillis &&
lastLogMillis > LogCursorsIntervalMillis) {
timeSinceLastLog = jsTime();
logCursorsWaiting(ns, min, max, elapsedTimeMillis, cursorsToWait);
}
set<CursorId> cursorsNow;
_env->getCursorIds(txn, ns, &cursorsNow);
set<CursorId> cursorsLeft;
std::set_intersection(cursorsToWait.begin(),
cursorsToWait.end(),
cursorsNow.begin(),
cursorsNow.end(),
std::inserter(cursorsLeft, cursorsLeft.end()));
cursorsToWait.swap(cursorsLeft);
if (stopRequested()) {
*errMsg = "deleter was stopped.";
scoped_lock sl(_queueMutex);
_deleteSet.erase(&deleteRange);
_deletesInProgress--;
if (_deletesInProgress == 0) {
_nothingInProgressCV.notify_one();
}
return false;
}
if (checkIntervalMillis < MaxCurorCheckIntervalMillis) {
checkIntervalMillis *= 2;
}
}
taskDetails.stats.queueEndTS = jsTime();
ReplTime lastOp;
taskDetails.stats.deleteStartTS = jsTime();
bool result = _env->deleteRange(txn,
taskDetails,
&taskDetails.stats.deletedDocCount,
&lastOp,
errMsg);
taskDetails.stats.deleteEndTS = jsTime();
if (result) {
taskDetails.stats.waitForReplStartTS = jsTime();
result = _env->waitForReplication(lastOp,
DelWriteConcern,
WaitForReplTimeoutSecs,
errMsg);
taskDetails.stats.waitForReplEndTS = jsTime();
}
{
scoped_lock sl(_queueMutex);
_deleteSet.erase(&deleteRange);
_deletesInProgress--;
if (_deletesInProgress == 0) {
_nothingInProgressCV.notify_one();
}
}
recordDelStats(new DeleteJobStats(taskDetails.stats));
return result;
}
