Real CartesianTrackingObjective::IncrementalCost(Real t,const ParabolicRamp::ParabolicRampND& ramp)
{
if(times.empty()) return 0.0;
if(t>=times.back()) return ramp.endTime*endTimeWeight;
if(t+ramp.endTime<times.front()) return 0.0;
assert(times.front() == 0.0);
Real sum=0.0;
int sindex = FindSegment(t);
int eindex = FindSegment(t+ramp.endTime);
Real tindex=t;
int index=sindex;
if(sindex < 0) {
//start in middle of ramp
tindex=times.front();
index = 0;
}
while(index < eindex && index+1 < (int)times.size()) {
Real tnext = times[index+1];
sum += IntegrateSegment(index,tindex,tnext,t,ramp);
tindex = tnext;
index++;
}
if(index == eindex && eindex < (int)times.size())
sum += IntegrateSegment(eindex,tindex,t+ramp.endTime,t,ramp);
else
sum += (t+ramp.endTime - times.back())*endTimeWeight;
return sum;
}
const float Spline::GetYFromMonotonicX(float x) const
{
int segmentIndex=0;
float yValue = 0.0f;
if(FindSegment(x, segmentIndex))
{
float s = ApproximateCubicBezierParameter (x, mKnots[segmentIndex].x,
mOutTangents[segmentIndex].x,
mInTangents[segmentIndex+1].x,
mKnots[segmentIndex+1].x);
yValue = GetY(segmentIndex, s);
}
else
{
if(mKnots.size() > 0)
{
Vector3 lastPoint = mKnots[mKnots.size()-1];
if(fabsf(lastPoint.x - x) < GetRangedEpsilon(lastPoint.x, x))
{
yValue = lastPoint.y;
}
}
}
return yValue;
}
BOOL BIniFile::AddKey(const char *const cpcSegName,
char *const cpcKeyName,
const char *const cpcValue)
{
BZ_CHECK_RETURN_BOOL(NULL != cpcSegName);
BZ_CHECK_RETURN_BOOL(NULL != cpcKeyName);
BZ_CHECK_RETURN_BOOL(NULL != cpcValue);
int nIdx = 0;
BKeyNode key;
key.m_bssKey = BSimpleString(cpcKeyName);
key.m_bssValue = BSimpleString(cpcValue);
if (-1 != (nIdx = FindSegment(cpcSegName)))
{
m_segArray[nIdx].m_keyArray.push_back(key);
return TRUE;
}
BSegmentNode seg;
seg.m_bssSeg = BSimpleString(cpcSegName);
seg.m_keyArray.push_back(key);
m_segArray.push_back(seg);
return TRUE;
}
BOOL BIniFile::GetIntValue(const char *const cpcSegName,
const char *const cpcKeyName,
OUT int &pValue) const
{
BZ_CHECK_RETURN_BOOL(NULL != cpcSegName);
BZ_CHECK_RETURN_BOOL(NULL != cpcKeyName);
int nIdx = FindSegment(cpcSegName);
if (-1 == nIdx)
{
return FALSE;
}
for (int i = m_segArray[nIdx].m_keyArray.size() - 1; i != -1; --i)
{
if (cpcKeyName == m_segArray[nIdx].m_keyArray[i].m_bssKey)
{
char cpTmp[TEMP_BUFFER_LEN];
::strcpy(cpTmp, m_segArray[nIdx].m_keyArray[i].m_bssValue.m_cpStr);
pValue = atoi(cpTmp);
return TRUE;
}
}
return FALSE;
}
BOOL BIniFile::GetValue(const char *const cpcSegName,
const char *const cpcKeyName,
OUT char * pValue) const
{
BZ_CHECK_RETURN_BOOL(NULL != cpcSegName);
BZ_CHECK_RETURN_BOOL(NULL != cpcKeyName);
BZ_CHECK_RETURN_BOOL(NULL != pValue);
int nIdx = FindSegment(cpcSegName);
if (-1 == nIdx)
{
return FALSE;
}
for (int i = m_segArray[nIdx].m_keyArray.size() - 1; i != -1; --i)
{
if (cpcKeyName == m_segArray[nIdx].m_keyArray[i].m_bssKey)
{
::strcpy(pValue, m_segArray[nIdx].m_keyArray[i].m_bssValue.m_cpStr);
return TRUE;
}
}
return FALSE;
}
bool CopyToUser(void* userdst_ptr, const void* ksrc_ptr, size_t count)
{
uintptr_t userdst = (uintptr_t) userdst_ptr;
uintptr_t ksrc = (uintptr_t) ksrc_ptr;
bool result = true;
Process* process = CurrentProcess();
assert(IsInProcessAddressSpace(process));
kthread_mutex_lock(&process->segment_lock);
while ( count )
{
struct segment* segment = FindSegment(process, userdst);
if ( !segment || !(segment->prot & PROT_WRITE) )
{
errno = EFAULT;
result = false;
break;
}
size_t amount = count;
size_t segment_available = segment->addr + segment->size - userdst;
if ( segment_available < amount )
amount = segment_available;
memcpy((void*) userdst, (const void*) ksrc, amount);
userdst += amount;
ksrc += amount;
count -= amount;
}
kthread_mutex_unlock(&process->segment_lock);
return result;
}
Real CartesianTrackingObjective::DifferentialCost(Real t,const Vector& q,const Vector& dq)
{
if(times.empty()) return 0.0;
//penalize exceeding end time
if(t >= times.back()) return endTimeWeight;
int index=FindSegment(t);
return DifferentialCost(t,q,index);
}
Vector3 CartesianTrackingObjective::GetDesiredPosition(Real t) const
{
if(t>=times.back()) return positions.back();
if(t<=times.front()) return positions.front();
int index = FindSegment(t);
Real u=(t-times[index])/(times[index+1]-times[index]);
return positions[index]+u*(positions[index+1]-positions[index]);
}
Segment* HexDoc::GetSegment(uint64 nIndex, uint64 *pSegmentStart)
{
int n = FindSegment(nIndex);
if (n < 0)
return NULL;
if (pSegmentStart)
*pSegmentStart = bases[n];
return segments[n];
}
// NOTE: No overflow can happen here because the user can't make an infinitely
// long string spanning the entire address space because the user can't
// control the entire address space.
char* GetStringFromUser(const char* usersrc_str)
{
uintptr_t usersrc = (uintptr_t) usersrc_str;
size_t result_length = 0;
Process* process = CurrentProcess();
assert(IsInProcessAddressSpace(process));
kthread_mutex_lock(&process->segment_lock);
bool done = false;
while ( !done )
{
uintptr_t current_at = usersrc + result_length;
struct segment* segment = FindSegment(process, current_at);
if ( !segment || !(segment->prot & PROT_READ) )
{
kthread_mutex_unlock(&process->segment_lock);
return errno = EFAULT, (char*) NULL;
}
size_t segment_available = segment->addr + segment->size - current_at;
volatile const char* str = (volatile const char*) current_at;
size_t length = 0;
for ( ; length < segment_available; length++ )
{
char c = str[length];
if ( c == '\0' )
{
done = true;
break;
}
}
result_length += length;
}
char* result = new char[result_length + 1];
if ( !result )
{
kthread_mutex_unlock(&process->segment_lock);
return (char*) NULL;
}
memcpy(result, (const char*) usersrc, result_length);
result[result_length] = '\0';
// We have transferred a bunch of bytes from user-space and appended a zero
// byte. This is a string. If no concurrent threads were modifying the
// memory, this is the intended string. If the memory was modified, we got
// potential garbage followed by a NUL byte. This is a string, but probably
// not what was intended. If the garbage itself had a premature unexpected
// NUL byte, that's okay, the garbage string just got truncated.
kthread_mutex_unlock(&process->segment_lock);
return result;
}
BOOL BIniFile::GetSegment(const char *cpSegName, OUT BSegmentNode &segVal) const
{
int nPos = FindSegment(cpSegName);
if (-1 == nPos)
{
return FALSE;
}
segVal = m_segArray[nPos];
return TRUE;
}
static void HistoClickProc (PaneL pn, PoinT pt)
{
VieweR v;
Uint2 segID, primID, primCt;
SegmenT s;
PrimitivE p;
GraphViewFormPtr gvp;
SeqIntPtr sint;
PntInfo pnt;
segID = 0;
primID = 0;
primCt = 0;
v = (VieweR) pn;
s = FindSegment (v, pt, &segID, &primID, &primCt);
gvp = GetObjectExtra (v);
if (primID < 1)
{
WatchCursor ();
ExploreSegment (s, v, UnHLSeg);
ObjMgrDeSelectAll ();
ArrowCursor ();
}
else
{
WatchCursor ();
ExploreSegment (s, v, UnHLSeg);
ObjMgrDeSelectAll ();
ArrowCursor ();
p = GetPrimitive (s, primCt);
HighlightPrimitive (v, s, p, FRAME_PRIMITIVE);
gvp->slp = (SeqLocPtr) ValNodeNew (NULL);
sint = SeqIntNew ();
sint->id = SeqIdDup (gvp->bsp->id);
if (primID == 1)
sint->strand = Seq_strand_plus;
else
sint->strand = Seq_strand_minus;
MapViewerToWorld (v, pt, &pnt);
gvp->start = pnt.x * gvp->zoom;
gvp->stop = gvp->start+gvp->window;
sint->from = gvp->start;
sint->to = gvp->stop;
gvp->slp->choice = SEQLOC_INT;
gvp->slp->data.ptrvalue = (Pointer) sint;
ObjMgrSelect (gvp->entityID, gvp->itemID, OBJ_BIOSEQ, OM_REGION_SEQLOC,
gvp->slp);
}
return;
}
//******************************************************************************
void MEMORY_POOL::FreeBlock(void* ptr)
{
SEGMENT* Segment = FindSegment( ptr );
// TODO: check for cyclic lists more completely?
if(ptr == Segment->FreeBlock) {
return;
}
BLOCK* PrevBlock = Segment->FreeBlock;
Segment->FreeBlock = (BLOCK*)ptr;
Segment->FreeBlock->Next = PrevBlock;
AddToFreeList(Segment);
NumBlocks--;
}
void CartesianTrackingObjective::GetDifferentialCostFunction(Real t,Matrix3& A,Vector3& b) const
{
if(t < times.front() || t >= times.back()) {
A.setZero();
b.setZero();
return;
}
int index=FindSegment(t);
Real u=(t-times[index])/(times[index+1]-times[index]);
Vector3 pu = positions[index]+u*(positions[index+1]-positions[index]);
b = pu;
if(matWeights.empty()) {
A.setIdentity();
if (!weights.empty()) A *= weights[index];
}
else A = matWeights[index];
}
//int_{0 to 1} d(p,a+u(b-a)) du
//d(p,a+u(b-a)) = (a-p + u(b-a)).A(a-p + u(b-a))
// = (a-p).A(a-p) + 2 u (b-a).A(a-p) + u^2 (b-a).A(b-a)
//int_{0 to 1} d(p,a+u(b-a)) du
// = int_{0 to 1} (a-p).A(a-p) + 2 u (b-a).A(a-p) + u^2 (b-a).A(b-a)
// = (a-p).A(a-p) + (b-a).A(a-p) + 1/3 (b-a).A(b-a)
// = ((a+b)/2-p).A((a+b)/2-p) + 1/12 (b-a).A(b-a)
Real CartesianTrackingObjective::TerminalCost(Real tend,const Vector& qend,const Vector& dqend)
{
assert(positions.size()==times.size());
if(positions.empty()) return 0.0;
//printf("TerminalCost\n");
//compute workspace position at terminal config
robot->UpdateConfig(qend);
Vector3 p = robot->links[link].T_World*localPosition;
Real sum=0.0;
if(tend < times.back()) {
//need to integrate the remainder of the trajectory
int index=FindSegment(tend);
if(index >= 0) {
//first segment: integrate from tend to the next segment portion
Real dt = times[index+1]-tend;
Real u = (tend-times[index])/(times[index+1]-times[index]);
Vector3 pu = positions[index]+u*(positions[index+1]-positions[index]);
Vector3 p1 = positions[index+1];
Vector3 pmid = (p1 + pu)*0.5;
Real w = (weights.empty() ? 1.0 : weights[index]);
Real err = (matWeights.empty() ?
w*(p.distanceSquared(pmid) + p1.distanceSquared(pu)/12.0)
: (p-pmid).dot(matWeights[index]*(p-pmid)) + (p1-pu).dot(matWeights[index]*(p1-pu))/12.0);
sum += err*dt;
}
else assert(index == -1);
//remaining segments
for(size_t i=(size_t)index+1;i+1<times.size();i++) {
Real dt = times[i+1]-times[i];
Vector3 p0 = positions[i];
Vector3 p1 = positions[i+1];
Vector3 pmid = (p1 + p0)*0.5;
Real w = (weights.empty() ? 1.0 : weights[i]);
Real err = (matWeights.empty() ?
w*(p.distanceSquared(pmid) + p1.distanceSquared(p0)/12.0)
: (p-pmid).dot(matWeights[i]*(p-pmid)) + (p1-p0).dot(matWeights[i]*(p1-p0))/12.0);
sum += err*dt;
}
}
sum += endPosWeight*p.distanceSquared(positions.back());
sum += (p-positions.back()).dot(endPosMatWeight*(p-positions.back()));
return sum;
}
bool HexDoc::InsertSegment(THSIZE nAddress, Segment *newSegment)
{
if (nAddress == size)
{
InsertSegment2(segments.size(), nAddress, newSegment);
// ... and we're done. That was easy.
goto end;
}
int n = FindSegment(nAddress);
if (n == -1)
return false; // I don't know how this would happen... maybe nAddress > size?
THSIZE base = bases[n];
Segment *ts = segments[n];
if (nAddress != base) // insert new segment inside existing segment
{
n++;
Segment* ts2 = ts->Split(nAddress - base);
//ts2->next = SegmentAt(n);
//ts->next = newSegment;
//newSegment->next = ts2;
//segments.insert(segments.begin() + n, ts2);
//bases.insert(bases.begin() + n, nAddress); // second part of old segment now starts at nAddress
InsertSegment2(n, nAddress, ts2);
}
//else: insert new segment at beginning of other segment. n is already correct.
InsertSegment2(n, nAddress, newSegment);
//! todo: recover from failed allocation and don't leave data list broken
// Adjust bases after index n to include newly inserted segment.
while (++n < (int)bases.size())
bases[n] += newSegment->size;
//UpdateSegmentPointers();
end:
this->m_curSeg = NULL;
this->size += newSegment->size;
return true;
}
int BIniFile::FindKey(const char *const cpcSegName,
const char *const cpcKeyName) const
{
BZ_CHECK_RETURN_BOOL(NULL != cpcSegName);
BZ_CHECK_RETURN_BOOL(NULL != cpcKeyName);
int nIdx;
if (-1 == (nIdx = FindSegment(cpcSegName)))
{
return false;
}
for (int j = m_segArray[nIdx].m_keyArray.size() - 1; j != -1; --j)
{
if (cpcKeyName == m_segArray[nIdx].m_keyArray[j].m_bssKey)
{
return j;
}
}
return -1;
}
BNDS* BNDP_CreateBndS (HEAP *Heap, BNDP **theBndP, INT n)
{
BS *bs = (BS *) GetFreelistMemory(Heap,sizeof(BS));
BP **bp = (BP **) theBndP;
INT j,k;
ASSERT(bs != NULL);
bs->n = n;
bs->id = 0;
bs->segment = 0;
bs->segment = FindSegment(n,bp);
if (Prop == NULL)
bs->property = 0;
else
bs->property = Prop(bs->segment);
for (j=0; j<n; j++)
for (k=0; k<DIM; k++)
bs->x[j][k] = bp[j]->x[k];
return((BNDS *)bs);
}
static Int2 LIBCALLBACK MatrixMsgFunc (OMMsgStructPtr ommsp)
{
OMUserDataPtr omudp;
GraphViewFormPtr gvp;
SeqGraphPtr sgp;
VieweR v;
PoinT pt;
PntInfo pw;
Uint2 segID, primID, primCt;
SegmenT s;
PrimitivE p;
Int4 pos;
FloatHi maxVal;
if ((omudp = (OMUserDataPtr) (ommsp->omuserdata)) == NULL)
return OM_MSG_RET_ERROR;
if ((gvp = (GraphViewFormPtr) (omudp->userdata.ptrvalue)) == NULL)
return OM_MSG_RET_ERROR;
switch (ommsp->message)
{
case OM_MSG_SELECT:
if (ommsp->itemtype == OBJ_BIOSEQ)
{
if (ommsp->regiontype == OM_REGION_SEQLOC)
{
if ((sgp = gvp->sgp) == NULL)
return OM_MSG_RET_ERROR;
switch (sgp->flags[2])
{
default:
case 1:
maxVal = sgp->max.realvalue;
break;
case 2:
case 3:
maxVal = (FloatHi) sgp->max.intvalue;
break;
}
if (gvp->slp != NULL)
{
v = gvp->viewer;
pt.x = 0;
pt.y = 0;
s = FindSegment (v, pt, &segID, &primID, &primCt);
ExploreSegment (s, v, UnHLSeg);
/*
ObjMgrDeSelectAll ();
gvp->slp = NULL;
*/
}
pos = SeqLocStart ((SeqLocPtr) ommsp->region);
pos += SeqLocStop ((SeqLocPtr) ommsp->region);
pos /= 2;
pos /= gvp->zoom;
pw.x = (Int2) pos;
if (SeqLocStrand ((SeqLocPtr) ommsp->region) == Seq_strand_plus)
{
pw.y = (Int2) (gvp->margin + ((Int4) (1.0 +
(maxVal/2)) * sgp->a) +
(Int4) sgp->b);
}
else
{
pw.y = (Int2) (gvp->margin + ((Int4) (maxVal - 1.0 -
(maxVal/2)) * sgp->a) +
(Int4) sgp->b);
}
v = gvp->viewer;
primID = 0;
MapWorldToViewer (v, pw, &pt);
s = FindSegment (v, pt, &segID, &primID, &primCt);
if (primID < 1 || s == NULL)
return OM_MSG_RET_ERROR;
p = GetPrimitive (s, primCt);
WatchCursor ();
ExploreSegment (s, v, UnHLSeg);
ArrowCursor ();
HighlightPrimitive (v, s, p, FRAME_PRIMITIVE);
/* DUP/memcp and delta id
gvp->slp = (Pointer) (ommsp->region);
*/
/*
ObjMgrSelect (gvp->entityID, gvp->itemID, OBJ_BIOSEQ, OM_REGION_SEQLOC,
gvp->slp);
*/
}
}
break;
case OM_MSG_DESELECT:
if (ommsp->itemtype == OBJ_BIOSEQ)
{
if (ommsp->regiontype == OM_REGION_SEQLOC)
{
if (gvp->slp != NULL)
{
/*
v = gvp->viewer;
pt.x = 0;
pt.y = 0;
s = FindSegment (v, pt, &segID, &primID, &primCt);
ExploreSegment (s, v, UnHLSeg);
ObjMgrDeSelectAll ();
gvp->slp = NULL;
*/
}
}
}
break;
case OM_MSG_DEL:
case OM_MSG_CREATE:
case OM_MSG_UPDATE:
case OM_MSG_CACHED:
case OM_MSG_UNCACHED:
case OM_MSG_TO_CLIPBOARD:
break;
default:
break;
}
return OM_MSG_RET_OK;
}
static Int2 LIBCALLBACK FilterMsgFunc (OMMsgStructPtr ommsp)
{
OMUserDataPtr omudp;
GraphViewFormPtr gvp;
SeqGraphPtr sgp;
VieweR v;
PoinT pt;
PntInfo pw;
Uint2 segID, primID, primCt, start, end, i;
SegmenT s;
PrimitivE p;
FloatHi fval;
Int4 pos;
FloatHi maxVal, minVal;
if ((omudp = (OMUserDataPtr) (ommsp->omuserdata)) == NULL)
return OM_MSG_RET_ERROR;
if ((gvp = (GraphViewFormPtr) (omudp->userdata.ptrvalue)) == NULL)
return OM_MSG_RET_ERROR;
switch (ommsp->message)
{
case OM_MSG_SELECT:
if (ommsp->itemtype == OBJ_BIOSEQ)
{
if (ommsp->regiontype == OM_REGION_SEQLOC)
{
if ((sgp = gvp->sgp) == NULL)
return OM_MSG_RET_ERROR;
switch (sgp->flags[2])
{
default:
case 1:
maxVal = sgp->max.realvalue;
minVal = sgp->min.realvalue;
break;
case 2:
case 3:
maxVal = (FloatHi) sgp->max.intvalue;
minVal = (FloatHi) sgp->min.intvalue;
break;
}
if (gvp->slp != NULL)
{
v = gvp->viewer;
pt.x = 0;
pt.y = 0;
s = FindSegment (v, pt, &segID, &primID, &primCt);
ExploreSegment (s, v, UnHLSeg);
/*
ObjMgrDeSelectAll ();
gvp->slp = NULL;
*/
}
pos = SeqLocStart ((SeqLocPtr) ommsp->region);
pos /= gvp->zoom;
pw.x = (Int2) pos;
v = gvp->viewer;
primID = 0;
fval = minVal - 1;
while (primID < 1 && fval < maxVal)
{
fval++;
pw.y = (Int2) (gvp->margin + ((Int4) (fval * sgp->a)) +
(Int4) sgp->b);
MapWorldToViewer (v, pw, &pt);
s = FindSegment (v, pt, &segID, &primID, &primCt);
}
if (primCt == 0 && fval == maxVal)
return OM_MSG_RET_ERROR;
if (s == NULL)
return OM_MSG_RET_ERROR;
start = primCt;
pos = SeqLocStop ((SeqLocPtr) ommsp->region);
pos /= gvp->zoom;
pw.x = (Int2) pos;
primID = 0;
fval = minVal - 1;
while (primID < 1 && fval < maxVal)
{
fval++;
pw.y = (Int2) (gvp->margin + ((Int4) (fval * sgp->a)) +
(Int4) sgp->b);
MapWorldToViewer (v, pw, &pt);
s = FindSegment (v, pt, &segID, &primID, &primCt);
}
if (primCt == 0 || fval == maxVal)
return OM_MSG_RET_ERROR;
if (s == NULL)
return OM_MSG_RET_ERROR;
end = primCt;
if (start > end)
return OM_MSG_RET_ERROR;
WatchCursor ();
ExploreSegment (s, v, UnHLSeg);
ArrowCursor ();
for (i = start; i < end; i++)
{
p = GetPrimitive (s, i);
HighlightPrimitive (v, s, p, FRAME_PRIMITIVE);
}
/* DUP/memcp and delta id
gvp->slp = (Pointer) (ommsp->region);
*/
/*
ObjMgrSelect (gvp->entityID, gvp->itemID, OBJ_BIOSEQ, OM_REGION_SEQLOC,
gvp->slp);
*/
}
}
break;
case OM_MSG_DESELECT:
if (ommsp->itemtype == OBJ_BIOSEQ)
{
if (ommsp->regiontype == OM_REGION_SEQLOC)
{
if (gvp->slp != NULL)
{
/*
v = gvp->viewer;
pt.x = 0;
pt.y = 0;
s = FindSegment (v, pt, &segID, &primID, &primCt);
ExploreSegment (s, v, UnHLSeg);
ObjMgrDeSelectAll ();
gvp->slp = NULL;
*/
}
}
}
break;
case OM_MSG_DEL:
case OM_MSG_CREATE:
case OM_MSG_UPDATE:
case OM_MSG_CACHED:
case OM_MSG_UNCACHED:
case OM_MSG_TO_CLIPBOARD:
break;
default:
break;
}
return OM_MSG_RET_OK;
}
//------------------------------------------------------------------------------
void Sketcher_CommandTrim::TrimCurve()
{
mySObject = Handle(Sketcher_Object)::DownCast(data->Value(NearestCurveIndex));
newTrimmedObj = mySObject->GetAIS_Object();
switch (TypeofObject) {
case PointSketcherObject:
break;
case LineSketcherObject:
if (mySeqOfPntU.Length() <= 2) DelTrimmedObject();
else {
FindSegment();
if (FirstU == mySeqOfPntU.First())
EditLine(SecondU,mySeqOfPntU.Last());
else if (SecondU == mySeqOfPntU.Last())
EditLine(mySeqOfPntU.First(),FirstU);
else
AddNewLine(SecondU,mySeqOfPntU.Last());
}
break;
case CircleSketcherObject:
if (mySeqOfPntU.Length() <= 1) DelTrimmedObject();
else {
if ((mySeqOfPntU.First() + 2*M_PI) != mySeqOfPntU.Last())
mySeqOfPntU.Append(mySeqOfPntU.First() + 2*M_PI);
if (mySeqOfPntU(1) > NearestPntU) {
FirstU = mySeqOfPntU(mySeqOfPntU.Length()-1);
SecondU = mySeqOfPntU.Last();
}
else FindSegment();
EditCircle();
}
break;
case ArcSketcherObject:
if (mySeqOfPntU.Length() <= 2) DelTrimmedObject();
else {
if (NearestPntU < FirstU) NearestPntU += 2*M_PI;
FindSegment();
if (FirstU == mySeqOfPntU.First())
EditArc(SecondU,mySeqOfPntU.Last());
else if (SecondU == mySeqOfPntU.Last())
EditArc(mySeqOfPntU.First(),FirstU);
else
AddNewArc(SecondU,mySeqOfPntU.Last());
}
break;
default:
break;
}
}
bool HexDoc::RemoveAt(uint64 nIndex, uint64 nSize, int flags /*= 0*/)
{
if (!(flags & SUPPRESS_UPDATE) && !CanReplaceAt(nIndex, nSize, 0))
return false;
m_curSeg = NULL;
if (nIndex == this->size)
return nSize == 0;
int n = FindSegment(nIndex), firstAffected = -1;
THSIZE base = bases[n];
const THSIZE removeSize = nSize; // nSize gets modified
while (nSize)
{
Segment* ts = segments[n];
if (ts->contains(nIndex - 1, base) && ts->contains(nIndex + nSize, base))
{ //---xxx---
n++;
Segment* ts2 = ts->RemoveMid(nIndex - base, nSize);
InsertSegment2(n, nIndex, ts2);
firstAffected = n + 1; // skip updating the newly inserted segment
break;
}
else if (ts->contains(nIndex - 1, base))
{ // ---xxx
nSize -= ts->size - (nIndex - base);
ts->RemoveRight(nIndex - base);
base += ts->size;
firstAffected = n;
n++;
}
else if (ts->contains(nIndex + nSize, base))
{ // xxx---
ts->RemoveLeft(nSize);
if (firstAffected == -1)
firstAffected = n + 1;
break;
}
else
{ // xxx
nSize -= ts->size;
delete ts;
RemoveSegment(n);
if (firstAffected == -1)
firstAffected = n;
}
}
m_iChangeIndex++;
if (hw && !(flags & SUPPRESS_UPDATE))
hw->OnDataChange(nIndex, removeSize, 0);
if (firstAffected == -1)
firstAffected = 0;
for (n = firstAffected; n < (int)bases.size(); n++)
bases[n] -= removeSize; //! this belongs somewhere else, or at least inside SUPPRESS_UPDATE check.
this->size -= removeSize;
return true;
}
static void GraphClickProc (PaneL pn, PoinT pt)
{
VieweR v;
Uint2 segID, primID, primCt, start, end, i;
SegmenT s;
PrimitivE p;
GraphViewFormPtr gvp;
SeqIntPtr sint;
PntInfo pnt;
segID = 0;
primID = 0;
primCt = 0;
v = (VieweR) pn;
s = FindSegment (v, pt, &segID, &primID, &primCt);
p = GetPrimitive (s, primCt);
if (primID == 0)
return;
gvp = GetObjectExtra (v);
if (gvp->flagNewClick)
{
WatchCursor ();
ExploreSegment (s, v, UnHLSeg);
ArrowCursor ();
HighlightPrimitive (v, s, p, FRAME_PRIMITIVE);
gvp->flagNewClick = FALSE;
gvp->HLRange = primCt;
MapViewerToWorld (v, pt, &pnt);
gvp->start = pnt.x * gvp->zoom;
}
else
{
start = gvp->HLRange;
if (start < primCt)
end = (Uint2) (primCt + 1);
else
{
start = primCt;
end = (Uint2) (gvp->HLRange + 1);
}
for (i = start; i < end; i++)
{
p = GetPrimitive (s, i);
HighlightPrimitive (v, s, p, FRAME_PRIMITIVE);
}
if (gvp->slp != NULL)
{
ObjMgrDeSelect (gvp->entityID, gvp->itemID, OBJ_BIOSEQ, OM_REGION_SEQLOC,
gvp->slp);
/* gvp->slp = SeqLocFree (gvp->slp); */
gvp->slp = NULL;
}
gvp->slp = (SeqLocPtr) ValNodeNew (NULL);
sint = SeqIntNew ();
sint->id = SeqIdDup (gvp->bsp->id);
sint->strand = Seq_strand_plus;
MapViewerToWorld (v, pt, &pnt);
gvp->stop = pnt.x * gvp->zoom;
if (gvp->start < gvp->stop)
{
sint->from = gvp->start;
sint->to = gvp->stop;
}
else
{
sint->from = gvp->stop;
sint->to = gvp->start;
}
gvp->slp->choice = SEQLOC_INT;
gvp->slp->data.ptrvalue = (Pointer) sint;
ObjMgrSelect (gvp->entityID, gvp->itemID, OBJ_BIOSEQ, OM_REGION_SEQLOC,
gvp->slp);
/* ObjMgrAlsoSelect for loop thru slp's */
/* have to clone each slp added to chain and pass clone to OM */
gvp->flagNewClick = TRUE;
}
return;
}
