void DownloadSession::addPart(const PartFile& partFile) { if (partFile.m_values == ReturnValues::good)// && partFile.m_partHash == calculatePartHash(partFile)) { if (!flushPart(partFile)) { setEnd(StatusValue::notSave); return; } } else if (partFile.m_values == ReturnValues::noPart) { unsetPart(); } else if (partFile.m_values == ReturnValues::noDistribution) { setEnd(StatusValue::notDistribution); return; } if (getPart()) { write(); } }
static Ref<Range> expandToParagraphBoundary(PassRefPtr<Range> range) { Ref<Range> paragraphRange = range->cloneRange(); setStart(paragraphRange.ptr(), startOfParagraph(range->startPosition())); setEnd(paragraphRange.ptr(), endOfParagraph(range->endPosition())); return paragraphRange; }
void SpellChecker::chunkAndMarkAllMisspellingsAndBadGrammar(TextCheckingTypeMask textCheckingOptions, const TextCheckingParagraph& fullParagraphToCheck, bool asynchronous) { if (fullParagraphToCheck.isRangeEmpty() || fullParagraphToCheck.isEmpty()) return; // Since the text may be quite big chunk it up and adjust to the sentence boundary. const int kChunkSize = 16 * 1024; int start = fullParagraphToCheck.checkingStart(); int end = fullParagraphToCheck.checkingEnd(); start = std::min(start, end); end = std::max(start, end); const int kNumChunksToCheck = asynchronous ? (end - start + kChunkSize - 1) / (kChunkSize) : 1; int currentChunkStart = start; RefPtr<Range> checkRange = fullParagraphToCheck.checkingRange(); if (kNumChunksToCheck == 1 && asynchronous) { markAllMisspellingsAndBadGrammarInRanges(textCheckingOptions, checkRange.get(), checkRange.get(), asynchronous, 0); return; } for (int iter = 0; iter < kNumChunksToCheck; ++iter) { checkRange = fullParagraphToCheck.subrange(currentChunkStart, kChunkSize); setStart(checkRange.get(), startOfSentence(VisiblePosition(checkRange->startPosition()))); setEnd(checkRange.get(), endOfSentence(VisiblePosition(checkRange->endPosition()))); int checkingLength = 0; markAllMisspellingsAndBadGrammarInRanges(textCheckingOptions, checkRange.get(), checkRange.get(), asynchronous, iter, &checkingLength); currentChunkStart += checkingLength; } }
static PassRefPtrWillBeRawPtr<Range> expandToParagraphBoundary(PassRefPtrWillBeRawPtr<Range> range) { RefPtrWillBeRawPtr<Range> paragraphRange = range->cloneRange(); setStart(paragraphRange.get(), startOfParagraph(VisiblePosition(range->startPosition()))); setEnd(paragraphRange.get(), endOfParagraph(VisiblePosition(range->endPosition()))); return paragraphRange; }
static PassRefPtr<Range> expandToParagraphBoundary(PassRefPtr<Range> range) { RefPtr<Range> paragraphRange = range->cloneRange(IGNORE_EXCEPTION); setStart(paragraphRange.get(), startOfParagraph(range->startPosition())); setEnd(paragraphRange.get(), endOfParagraph(range->endPosition())); return paragraphRange; }
Edge::Edge(Vertex *start, Vertex *end) : LineGraphicsItem(start, end) { setStart(start); setEnd(end); veigth = GlobalSettings::getEdgeVeight(); }
IntervalAnchor::IntervalAnchor(string id, double begin, double end) : ContentAnchor(id) { typeSet.insert("IntervalAnchor"); this->begin = 0; setEnd(end); setBegin(begin); }
int Timer::timeDiff() { setEnd(); int time_used = ((m_end.tv_sec - m_begin.tv_sec) * 1000000 \ +(m_end.tv_usec - m_begin.tv_usec)); setBegin(); return time_used; }
static PassRefPtr<Range> expandToParagraphBoundary(PassRefPtr<Range> range) { ExceptionCode ec = 0; RefPtr<Range> paragraphRange = range->cloneRange(ec); setStart(paragraphRange.get(), startOfParagraph(range->startPosition())); setEnd(paragraphRange.get(), endOfParagraph(range->endPosition())); return paragraphRange; }
/** * Construct an IF instructon instance. * * @param _condition The condition expression to evaluate. * @param thenToken The token for the terminating THEN keyword. * This is where we mark the end of the * instruction. */ RexxInstructionIf::RexxInstructionIf(RexxInternalObject *_condition, RexxToken *thenToken) { condition = _condition; //get the location from the THEN token and use its location to set // the end of the instruction. Note that the THEN is traced on its // own, but using the start of the THEN gives a fuller picture of things. SourceLocation location = thenToken->getLocation(); setEnd(location.getLineNumber(), location.getOffset()); }
TransformInterpolator::TransformInterpolator(const MATRIX &start, const MATRIX &end, unsigned int totalSteps) : d(new TransformInterpolatorPrivate) { d->totalSteps = totalSteps; d->currentStep = 0; d->startTransform = start; MatrixToQuaternion(d->startRotation, start); setEnd(end); }
CurveSegmentModel*LinearCurveSegmentModel::clone( const id_type<CurveSegmentModel>& id, QObject *parent) const { auto cs = new LinearCurveSegmentModel{id, parent}; cs->setStart(this->start()); cs->setEnd(this->end()); // Previous and following shall be set afterwards by the cloner. return cs; }
void DownloadSession::connectSeeder(const boost::system::error_code &err) { if (err) { setEnd(StatusValue::notConnect); return; } m_file.open(m_fileLocation, std::ios::out | std::ios::binary); if (!m_file) { display(std::to_string(GetLastError())); setEnd(StatusValue::notOpen); return; } m_receiveBuffer = (char*)& m_receivedPart; m_sendBuffer = (char*)& m_partNumber; write(); }
SegmentModel*GammaSegment::clone( const Id<SegmentModel>& id, QObject* parent) const { auto cs = new GammaSegment{id, parent}; cs->setStart(this->start()); cs->setEnd(this->end()); cs->gamma = gamma; // Previous and following shall be set afterwards by the cloner. return cs; }
SGMScanInfo& SGMScanInfo::operator =(const SGMScanInfo &other){ if(this != &other){ AMDbObject::operator=(other); setScanName(other.scanName()); setHasEdge(other.hasEdge()); setEdge(other.edge()); setEnergy(other.energy()); setStart(other.start()); setMiddle(other.middle()); setEnd(other.end()); } return *this; }
void Ramp::configure(const std::string& parameters) { if (parameters.empty()) return; std::vector<std::string> values = Op::split(parameters, " "); std::size_t required = 2; if (values.size() < required) { std::ostringstream ex; ex << "[configuration error] term <" << className() << ">" << " requires <" << required << "> parameters"; throw fl::Exception(ex.str(), FL_AT); } setStart(Op::toScalar(values.at(0))); setEnd(Op::toScalar(values.at(1))); }
static void onRsnSetInfo( HWND hwnd, const RS_INFO *pInfo ) { setLower ( hwnd, pInfo->_lower ); setUpper ( hwnd, pInfo->_upper ); setSaveStart2 ( hwnd, pInfo->_lower ); setSaveEnd2 ( hwnd, pInfo->_upper ); setStart ( hwnd, pInfo->_start ); setEnd ( hwnd, pInfo->_end ); setMinRange ( hwnd, pInfo->_minRange ); setGranularity( hwnd, pInfo->_granularity ); invalidateRect( hwnd ); invalidateCursor(); }
SGMScanInfo::SGMScanInfo(const QString &scanName, QPair<QString, double> edgeAndEnergy, SGMEnergyPosition start, SGMEnergyPosition middle, SGMEnergyPosition end, QObject *parent) : AMDbObject(parent) { setName(scanName); setScanName(scanName); if(!edgeAndEnergy.first.isEmpty() && edgeAndEnergy.second > 0) hasEdge_ = true; else hasEdge_ = false; edge_ = edgeAndEnergy.first; energy_ = edgeAndEnergy.second; setStart(start); setMiddle(middle); setEnd(end); }
void DownloadSession::writeHandler(const boost::system::error_code &err, std::size_t bytes) { if (!err) { std::fill(m_receivedPart.m_part, m_receivedPart.m_part + PARTSIZE, 0); m_receivedPart.m_partSize = 0; m_receivedPart.m_partHash = 0; m_receivedPart.m_partNumber = 0; read(); } else { setEnd(StatusValue::notWrite); return; } }
int SampleChannel::loadByPatch(const char *f, int i) { int res = load(f); volume = G_Patch.getVol(i); key = G_Patch.getKey(i); index = G_Patch.getIndex(i); mode = G_Patch.getMode(i); mute = G_Patch.getMute(i); mute_s = G_Patch.getMute_s(i); solo = G_Patch.getSolo(i); boost = G_Patch.getBoost(i); panLeft = G_Patch.getPanLeft(i); panRight = G_Patch.getPanRight(i); readActions = G_Patch.getRecActive(i); recStatus = readActions ? REC_READING : REC_STOPPED; readPatchMidiIn(i); midiInReadActions = G_Patch.getMidiValue(i, "InReadActions"); midiInPitch = G_Patch.getMidiValue(i, "InPitch"); readPatchMidiOut(i); if (res == SAMPLE_LOADED_OK) { setBegin(G_Patch.getBegin(i)); setEnd (G_Patch.getEnd(i, wave->size)); setPitch(G_Patch.getPitch(i)); } else { // volume = DEFAULT_VOL; // mode = DEFAULT_CHANMODE; // status = STATUS_WRONG; // key = 0; if (res == SAMPLE_LEFT_EMPTY) status = STATUS_EMPTY; else if (res == SAMPLE_READ_ERROR) status = STATUS_MISSING; sendMidiLplay(); } return res; }
ImplicitList::ImplicitList(InternalType* _poStart, InternalType* _poStep, InternalType* _poEnd) { m_iSize = -1; m_eOutType = ScilabGeneric; m_bComputed = false; m_poStart = NULL; m_poStep = NULL; m_poEnd = NULL; m_pDblStart = NULL; m_pDblStep = NULL; m_pDblEnd = NULL; setStart(_poStart); setStep(_poStep); setEnd(_poEnd); compute(); #ifndef NDEBUG Inspector::addItem(this); #endif }
void SymbolicList::evalDollar(GVN & gvn, const GVN::Value * dollarVal) { if (GVN::Value * const dollar = gvn.getExistingValue(symbol::Symbol(L"$"))) { if (GVN::Value * v = evalDollar(gvn, getStart(), dollar, dollarVal)) { setStart(v); } if (GVN::Value * v = evalDollar(gvn, getStep(), dollar, dollarVal)) { setStep(v); } if (GVN::Value * v = evalDollar(gvn, getEnd(), dollar, dollarVal)) { setEnd(v); } } }
std::vector<sk_sp<sksg::GeometryNode>> AttachTrimGeometryEffect( const Json::Value& jtrim, AttachContext* ctx, std::vector<sk_sp<sksg::GeometryNode>>&& geos) { enum class Mode { kMerged, // "m": 1 kSeparate, // "m": 2 } gModes[] = { Mode::kMerged, Mode::kSeparate }; const auto mode = gModes[SkTPin<int>(ParseDefault(jtrim["m"], 1) - 1, 0, SK_ARRAY_COUNT(gModes) - 1)]; std::vector<sk_sp<sksg::GeometryNode>> inputs; if (mode == Mode::kMerged) { inputs.push_back(sksg::Merge::Make(std::move(geos), sksg::Merge::Mode::kMerge)); } else { inputs = std::move(geos); } std::vector<sk_sp<sksg::GeometryNode>> trimmed; trimmed.reserve(inputs.size()); for (const auto& i : inputs) { const auto trimEffect = sksg::TrimEffect::Make(i); trimmed.push_back(trimEffect); const auto adapter = sk_make_sp<TrimEffectAdapter>(std::move(trimEffect)); BindProperty<ScalarValue>(jtrim["s"], &ctx->fAnimators, [adapter](const ScalarValue& s) { adapter->setStart(s); }); BindProperty<ScalarValue>(jtrim["e"], &ctx->fAnimators, [adapter](const ScalarValue& e) { adapter->setEnd(e); }); BindProperty<ScalarValue>(jtrim["o"], &ctx->fAnimators, [adapter](const ScalarValue& o) { adapter->setOffset(o); }); } return trimmed; }
ProcessModel::ProcessModel( const TimeValue& duration, const Id<Process::ProcessModel>& id, QObject* parent) : Curve::CurveProcessModel {duration, id, Metadata<ObjectKey_k, ProcessModel>::get(), parent} { pluginModelList = new iscore::ElementPluginModelList{iscore::IDocument::documentContext(*parent), this}; setUseParentDuration(true); // Named shall be enough ? setCurve(new Curve::Model{Id<Curve::Model>(45345), this}); auto s1 = new Curve::DefaultCurveSegmentModel(Id<Curve::SegmentModel>(1), m_curve); s1->setStart({0., 0.0}); s1->setEnd({1., 1.}); m_curve->addSegment(s1); connect(m_curve, &Curve::Model::changed, this, &ProcessModel::curveChanged); metadata.setName(QString("Mapping.%1").arg(*this->id().val())); }
void Line3DOverlay::setProperties(const QVariantMap& properties) { Base3DOverlay::setProperties(properties); auto start = properties["start"]; // if "start" property was not there, check to see if they included aliases: startPoint if (!start.isValid()) { start = properties["startPoint"]; } if (start.isValid()) { setStart(vec3FromVariant(start)); } auto end = properties["end"]; // if "end" property was not there, check to see if they included aliases: endPoint if (!end.isValid()) { end = properties["endPoint"]; } if (end.isValid()) { setEnd(vec3FromVariant(end)); } }
void DownloadSession::readHandler(const boost::system::error_code &err, std::size_t bytes) { if (!err) { //------------------------------------------- //std::string str("RECEIVE: "); //str += std::to_string(m_receivedPart.m_partSize) + " " + std::to_string(m_receivedPart.m_partHash) + " " + std::to_string(m_receivedPart.m_partNumber); //display(str); display(std::to_string(m_receivedPart.m_partNumber)); //------------------------------------------- addPart(m_receivedPart); } else { std::string str("RECEIVE FALSE: "); str += std::to_string(m_receivedPart.m_partSize) + " " + std::to_string(m_receivedPart.m_partHash) + " " + std::to_string(m_receivedPart.m_partNumber); display(str); setEnd(StatusValue::notRead); return; } }
void Line3DOverlay::setProperties(const QScriptValue& properties) { Base3DOverlay::setProperties(properties); QScriptValue start = properties.property("start"); // if "start" property was not there, check to see if they included aliases: startPoint if (!start.isValid()) { start = properties.property("startPoint"); } if (start.isValid()) { QScriptValue x = start.property("x"); QScriptValue y = start.property("y"); QScriptValue z = start.property("z"); if (x.isValid() && y.isValid() && z.isValid()) { glm::vec3 newStart; newStart.x = x.toVariant().toFloat(); newStart.y = y.toVariant().toFloat(); newStart.z = z.toVariant().toFloat(); setStart(newStart); } } QScriptValue end = properties.property("end"); // if "end" property was not there, check to see if they included aliases: endPoint if (!end.isValid()) { end = properties.property("endPoint"); } if (end.isValid()) { QScriptValue x = end.property("x"); QScriptValue y = end.property("y"); QScriptValue z = end.property("z"); if (x.isValid() && y.isValid() && z.isValid()) { glm::vec3 newEnd; newEnd.x = x.toVariant().toFloat(); newEnd.y = y.toVariant().toFloat(); newEnd.z = z.toVariant().toFloat(); setEnd(newEnd); } } }
static void scroll( HWND hwnd, int direction, int timeOut ) { LONG page_size = getEnd( hwnd ) - getStart( hwnd ); if ( page_size <= getGranularity( hwnd ) ) { page_size = getGranularity( hwnd ); } if ( page_size <= 0 ) { page_size = 1; } LONG delta = 0; if ( -1 == direction ) { delta = -page_size; if ( getStart( hwnd ) + delta < getLower( hwnd ) ) { delta = getLower( hwnd ) - getStart( hwnd ); } } else { delta = page_size; if ( getUpper( hwnd ) < getEnd( hwnd ) + delta ) { delta = getUpper( hwnd ) - getEnd( hwnd ); } } int start = adjust( hwnd, getStart( hwnd ) + delta ); int end = adjust( hwnd, getEnd ( hwnd ) + delta ); if ( start != getStart( hwnd ) || end != getEnd( hwnd ) ) { setStart( hwnd, start ); setEnd ( hwnd, end ); invalidateRect( hwnd ); invalidateCursor(); notifyParent( hwnd ); } // TODO: discuss SPI_GETKEYBOARDDELAY if ( 0 < timeOut ) { SetTimer( hwnd, 1, timeOut, 0 ); } }
void CurvePresenter::updateSegmentsType(const QString& segmentName) { // They keep their start / end and previous / following but change type. // TODO maybe it would be better to encapsulate this ? auto factory = SingletonCurveSegmentList::instance().get(segmentName); QVector<QByteArray> newSegments; newSegments.resize(m_model->segments().size()); int i = 0; for(CurveSegmentModel* segment : m_model->segments()) { CurveSegmentModel* current; if(segment->selection.get()) { auto ns = factory->make(segment->id(), nullptr); ns->setStart(segment->start()); ns->setEnd(segment->end()); ns->setPrevious(segment->previous()); ns->setFollowing(segment->following()); current = ns; } else { current = segment; } Serializer<DataStream> s{&newSegments[i++]}; s.readFrom(*current); } m_commandDispatcher.submitCommand( new UpdateCurve{ iscore::IDocument::path(m_model), std::move(newSegments) }); }
static void onKey( HWND hwnd, UINT vk, BOOL fDown, int cRepeat, UINT flags ) { long start = getStart( hwnd ); long end = getEnd( hwnd ); const BOOL controlKey = GetAsyncKeyState( VK_CONTROL ) < 0; if ( VK_ESCAPE == vk ) { if ( htNone != getHTCode( hwnd ) ) { setHTCode( hwnd, htNone ); const LONG oldStart = getSaveStart( hwnd ); const LONG oldEnd = getSaveEnd ( hwnd ); setStart( hwnd, oldStart ); setEnd ( hwnd, oldEnd ); invalidateRect( hwnd ); //onLButtonUp( hwnd, 0, 0, 0 ); // TODO retain capture anyway? // TODO notify parent return; //** FUNCTION EXIT POINT } } const UINT left_key = isVertical( hwnd ) ? VK_UP : VK_LEFT ; const UINT right_key = isVertical( hwnd ) ? VK_DOWN : VK_RIGHT; long granularity = getGranularity( hwnd ); if ( granularity <= 0 ) { granularity = 1; } if ( left_key == vk ) { if ( controlKey ) { if ( getMinRange( hwnd ) < end - start ) { end -= granularity; } } else if ( getLower( hwnd ) < start ) { start -= granularity; end -= granularity; } } else if ( right_key == vk ) { if ( end < getUpper( hwnd ) ) { end += granularity; if ( !controlKey ) { start += granularity; } } } else if ( VK_PRIOR == vk ) { scroll( hwnd, -1, 0 ); return; //*** FUNCTION EXIT POINT } else if ( VK_NEXT == vk ) { scroll( hwnd, 1, 0 ); return; //*** FUNCTION EXIT POINT } else if ( VK_HOME == vk ) { const long range = abs( getLower( hwnd ) - start ); start -= range; end -= range; } else if ( VK_END == vk ) { const long range = abs( getUpper( hwnd ) - end ); start += range; end += range; } start = adjust( hwnd, start ); end = adjust( hwnd, end ); if ( start != getStart( hwnd ) || end != getEnd( hwnd ) ) { setStart( hwnd, start ); setEnd ( hwnd, end ); invalidateRect( hwnd ); invalidateCursor(); notifyParent( hwnd ); } }