bool WaveTrack::Copy(double t0, double t1, Track **dest)
{
if (t1 < t0)
return false;
sampleCount s0, s1;
TimeToSamplesClip(t0, &s0);
TimeToSamplesClip(t1, &s1);
WaveTrack *newTrack = new WaveTrack(mDirManager);
newTrack->Init(*this);
delete newTrack->mSequence;
newTrack->mSequence = NULL;
if (!mSequence->Copy(s0, s1, &newTrack->mSequence)) {
// Error
*dest = NULL;
delete newTrack;
return false;
}
newTrack->GetEnvelope()->CopyFrom(GetEnvelope(), t0, t1);
*dest = newTrack;
MarkChanged();
return true;
}
bool WaveTrack::Cut(double t0, double t1, Track **dest)
{
bool success;
sampleCount s0, s1;
WaveTrack *newTrack;
if (t1 < t0)
return false;
TimeToSamplesClip(t0, &s0);
TimeToSamplesClip(t1, &s1);
newTrack = new WaveTrack(mDirManager);
delete newTrack->mSequence;
newTrack->mSequence = NULL;
success = mSequence->Copy(s0, s1, &newTrack->mSequence);
if (success)
success = mSequence->Delete(s0, s1-s0);
if (!success) {
*dest = NULL;
delete newTrack;
return false;
}
newTrack->GetEnvelope()->CopyFrom(GetEnvelope(), t0, t1);
mEnvelope->CollapseRegion(t0, t1);
*dest = newTrack;
MarkChanged();
return true;
}
void TimeTrack::Draw(wxDC & dc, const wxRect & r, double h, double pps)
{
double tstep = 1.0 / pps; // Seconds per point
double t0 = h;
double t1 = h + (r.width * tstep);
//Make sure t1 (the right bound) is greater than 0
if (t1 < 0.0)
t1 = 0.0;
//make sure t1 is greater than t0
if (t0 > t1)
t0 = t1;
dc.SetBrush(blankBrush);
dc.SetPen(blankPen);
dc.DrawRectangle(r);
//copy this rectangle away for future use.
wxRect mid = r;
// Draw the Ruler
mRuler->SetBounds(r.x, r.y, r.x + r.width - 1, r.y + r.height - 1);
double min = t0;
double max = min + r.width / pps;
mRuler->SetRange(min, max);
mRuler->SetFlip(false); // If we don't do this, the Ruler doesn't redraw itself when the envelope is modified.
// I have no idea why!
//
// LL: It's because the ruler only Invalidate()s when the new value is different
// than the current value.
mRuler->SetFlip(GetHeight() > 75 ? true : true);
mRuler->Draw(dc, this);
int *heights = new int[mid.width];
double *envValues = new double[mid.width];
GetEnvelope()->GetValues(envValues, mid.width, t0, tstep);
double t = t0;
int x;
for (x = 0; x < mid.width; x++)
{
heights[x] = (int)(mid.height * (1 - envValues[x]));
t += tstep;
}
dc.SetPen(AColor::envelopePen);
for (x = 0; x < mid.width; x++)
{
int thisy = r.y + heights[x];
AColor::Line(dc, mid.x + x, thisy, mid.x + x, thisy+3);
}
if (heights)
delete[]heights;
if (envValues)
delete[]envValues;
}
// Our envelope represents the playback speed, which is the rate of change of
// playback position. We want to find the playback position at time t, so
// we have to integrate the playback speed.
double TimeTrack::warp( double t )
{
double result = GetEnvelope()->Integral( 0.0, t,
GetRangeLower()/100.0,
GetRangeUpper()/100.0 );
//printf( "Warping %.2f to %.2f\n", t, result );
return result;
}
bool WaveClip::Clear(double t0, double t1)
{
sampleCount s0, s1;
TimeToSamplesClip(t0, &s0);
TimeToSamplesClip(t1, &s1);
if (GetSequence()->Delete(s0, s1-s0))
{
// msmeyer
//
// Delete all cutlines that are within the given area, if any.
//
// Note that when cutlines are active, two functions are used:
// Clear() and ClearAndAddCutLine(). ClearAndAddCutLine() is called
// whenever the user directly calls a command that removes some audio, e.g.
// "Cut" or "Clear" from the menu. This command takes care about recursive
// preserving of cutlines within clips. Clear() is called when internal
// operations want to remove audio. In the latter case, it is the right
// thing to just remove all cutlines within the area.
//
double clip_t0 = t0;
double clip_t1 = t1;
if (clip_t0 < GetStartTime())
clip_t0 = GetStartTime();
if (clip_t1 > GetEndTime())
clip_t1 = GetEndTime();
WaveClipList::compatibility_iterator nextIt;
for (WaveClipList::compatibility_iterator it = mCutLines.GetFirst(); it; it=nextIt)
{
nextIt = it->GetNext();
WaveClip* clip = it->GetData();
double cutlinePosition = mOffset + clip->GetOffset();
if (cutlinePosition >= t0 && cutlinePosition <= t1)
{
// This cutline is within the area, delete it
delete clip;
mCutLines.DeleteNode(it);
} else
if (cutlinePosition >= t1)
{
clip->Offset(clip_t0-clip_t1);
}
}
// Collapse envelope
GetEnvelope()->CollapseRegion(t0, t1);
if (t0 < GetStartTime())
Offset(-(GetStartTime() - t0));
MarkChanged();
return true;
}
return false;
}
void TimeTrack::testMe()
{
GetEnvelope()->Flatten(0.0);
GetEnvelope()->Insert( 0.0, 0.2 );
GetEnvelope()->Insert( 5.0 - 0.001, 0.2 );
GetEnvelope()->Insert( 5.0 + 0.001, 1.3 );
GetEnvelope()->Insert( 10.0, 1.3 );
double value1 = GetEnvelope()->Integral(2.0, 13.0);
double expected1 = (5.0 - 2.0) * 0.2 + (13.0 - 5.0) * 1.3;
double value2 = GetEnvelope()->IntegralOfInverse(2.0, 13.0);
double expected2 = (5.0 - 2.0) / 0.2 + (13.0 - 5.0) / 1.3;
if( fabs(value1 - expected1) > 0.01 )
{
printf( "TimeTrack: Integral failed! expected %f got %f\n", expected1, value1);
}
if( fabs(value2 - expected2) > 0.01 )
{
printf( "TimeTrack: IntegralOfInverse failed! expected %f got %f\n", expected2, value2);
}
/*double reqt0 = 10.0 - .1;
double reqt1 = 10.0 + .1;
double t0 = warp( reqt0 );
double t1 = warp( reqt1 );
if( t0 > t1 )
{
printf( "TimeTrack: Warping reverses an interval! [%.2f,%.2f] -> [%.2f,%.2f]\n",
reqt0, reqt1,
t0, t1 );
}*/
}
void TimeTrack::testMe()
{
GetEnvelope()->SetDefaultValue(0.5);
GetEnvelope()->Flatten(0.0);
GetEnvelope()->Insert( 0.0, 0.0 );
GetEnvelope()->Insert( 5.0, 1.0 );
GetEnvelope()->Insert( 10.0, 0.0 );
double reqt0 = 10.0 - .1;
double reqt1 = 10.0 + .1;
double t0 = warp( reqt0 );
double t1 = warp( reqt1 );
if( t0 > t1 )
{
printf( "TimeTrack: Warping reverses an interval! [%.2f,%.2f] -> [%.2f,%.2f]\n",
reqt0, reqt1,
t0, t1 );
}
}
//Compute the integral warp factor between two non-warped time points
double TimeTrack::ComputeWarpFactor(double t0, double t1)
{
double factor;
factor = GetEnvelope()->Average(t0, t1);
factor = (GetRangeLower() *
(1 - factor) +
factor *
GetRangeUpper()) /
100.0;
return factor;
}
void TimeTrack::Draw(wxDC & dc, const wxRect & r, const ZoomInfo &zoomInfo) const
{
double min = zoomInfo.PositionToTime(0);
double max = zoomInfo.PositionToTime(r.width);
if (min > max)
{
wxASSERT(false);
min = max;
}
dc.SetBrush(blankBrush);
dc.SetPen(blankPen);
dc.DrawRectangle(r);
//copy this rectangle away for future use.
wxRect mid = r;
// Draw the Ruler
mRuler->SetBounds(r.x, r.y, r.x + r.width - 1, r.y + r.height - 1);
mRuler->SetRange(min, max);
mRuler->SetFlip(false); // If we don't do this, the Ruler doesn't redraw itself when the envelope is modified.
// I have no idea why!
//
// LL: It's because the ruler only Invalidate()s when the NEW value is different
// than the current value.
mRuler->SetFlip(GetHeight() > 75 ? true : true); // MB: so why don't we just call Invalidate()? :)
mRuler->Draw(dc, this);
double *envValues = new double[mid.width];
GetEnvelope()->GetValues(envValues, mid.width, 0, zoomInfo);
dc.SetPen(AColor::envelopePen);
double logLower = log(std::max(1.0e-7, mRangeLower)), logUpper = log(std::max(1.0e-7, mRangeUpper));
for (int x = 0; x < mid.width; x++)
{
double y;
if(mDisplayLog)
y = (double)mid.height * (logUpper - log(envValues[x])) / (logUpper - logLower);
else
y = (double)mid.height * (mRangeUpper - envValues[x]) / (mRangeUpper - mRangeLower);
int thisy = r.y + (int)y;
AColor::Line(dc, mid.x + x, thisy - 1, mid.x + x, thisy+2);
}
if (envValues)
delete[]envValues;
}
void ProsodyDisplay::DrawEnv(wxDC& dc, int x1, int y1, int width, PHONEME_LIST *ph)
{//==============================================================================
int pitchr;
int pitch;
int p1;
int ix;
int x,y;
int y2=0;
unsigned char *env;
PHONEME_DATA phdata_tone;
if(width <= 0) return;
if((pitchr = ph->pitch2 - ph->pitch1) < 0)
{
pitchr = -pitchr;
p1 = ph->pitch2;
}
else
{
p1 = ph->pitch1;
}
if(p1 == 255) return;
dc.SetPen(PEN_PITCHENV);
env = envelope_data[ph->env];
if((ph->type == phVOWEL) && (ph->tone_ph != 0))
{
// the envelope is given by a Tone phoneme acting on this vowel
InterpretPhoneme2(ph->tone_ph, &phdata_tone);
env = GetEnvelope(phdata_tone.pitch_env);
}
if(env == NULL)
return;
for(ix=0; ix<=width; ix+=4)
{
x = int((ix * 127.9)/width);
pitch = p1 + (pitchr * env[x])/256;
y = y1-int(pitch * scaley);
if(ix > 0)
dc.DrawLine(x1+ix-4,y2,x1+ix,y);
y2 = y;
}
} // end of DrawEnv
bool WaveClip::InsertSilence(double t, double len)
{
sampleCount s0;
TimeToSamplesClip(t, &s0);
sampleCount slen = (sampleCount)floor(len * mRate + 0.5);
if (!GetSequence()->InsertSilence(s0, slen))
{
wxASSERT(false);
return false;
}
OffsetCutLines(t, len);
GetEnvelope()->InsertSpace(t, len);
MarkChanged();
return true;
}
CSimpleMarkerElement::CSimpleMarkerElement(const GEOMETRY::geom::Geometry& geometry)
:IMarkerElement(geometry)
{
m_enumElementType = ET_SIMPLE_POINT_ELEMENT;
Display::CSimpleMarkerSymbol* pMarkerSymbol = new Display::CSimpleMarkerSymbol;
//
//init symbol
pMarkerSymbol->SetOutLineColor(RGB(0,0,0));
pMarkerSymbol->SetMarkerColor(RGB(0,0,0));
pMarkerSymbol->SetMarkerType(SIMPLE_MARKER_CIRCLE);
pMarkerSymbol->SetMarkerSize(8);
//
m_pSymbol.reset(pMarkerSymbol);
m_pSelectionHandle.reset(new CEnvelopeTracker(GetEnvelope(), HT_FOUR));
m_bCanSetWHRMode = FALSE;
}
void CalcLengths(Translator *tr)
{//==============================
int ix;
int ix2;
PHONEME_LIST *prev;
PHONEME_LIST *next;
PHONEME_LIST *next2;
PHONEME_LIST *next3;
PHONEME_LIST *p;
PHONEME_LIST *p2;
int stress;
int type;
static int more_syllables=0;
int pre_sonorant=0;
int pre_voiced=0;
int last_pitch = 0;
int pitch_start;
int length_mod;
int len;
int env2;
int end_of_clause;
int embedded_ix = 0;
int min_drop;
int pitch1;
int emphasized;
int tone_mod;
unsigned char *pitch_env=NULL;
PHONEME_DATA phdata_tone;
for(ix=1; ix<n_phoneme_list; ix++)
{
prev = &phoneme_list[ix-1];
p = &phoneme_list[ix];
stress = p->stresslevel & 0x7;
emphasized = p->stresslevel & 0x8;
next = &phoneme_list[ix+1];
if(p->synthflags & SFLAG_EMBEDDED)
{
DoEmbedded2(&embedded_ix);
}
type = p->type;
if(p->synthflags & SFLAG_SYLLABLE)
type = phVOWEL;
switch(type)
{
case phPAUSE:
last_pitch = 0;
break;
case phSTOP:
last_pitch = 0;
if(prev->type == phFRICATIVE)
p->prepause = 25;
else
if((more_syllables > 0) || (stress < 4))
p->prepause = 48;
else
p->prepause = 60;
if(prev->type == phSTOP)
p->prepause = 60;
if((tr->langopts.word_gap & 0x10) && (p->newword))
p->prepause = 60;
if(p->ph->phflags & phLENGTHENSTOP)
p->prepause += 30;
if(p->synthflags & SFLAG_LENGTHEN)
p->prepause += tr->langopts.long_stop;
break;
case phVFRICATIVE:
case phFRICATIVE:
if(p->newword)
{
if((prev->type == phVOWEL) && (p->ph->phflags & phNOPAUSE))
{
}
else
{
p->prepause = 15;
}
}
if(next->type==phPAUSE && prev->type==phNASAL && !(p->ph->phflags&phFORTIS))
p->prepause = 25;
if(prev->ph->phflags & phBRKAFTER)
p->prepause = 30;
if((tr->langopts.word_gap & 0x10) && (p->newword))
p->prepause = 30;
if((p->ph->phflags & phSIBILANT) && next->type==phSTOP && !next->newword)
{
if(prev->type == phVOWEL)
p->length = 200; // ?? should do this if it's from a prefix
else
p->length = 150;
}
else
p->length = 256;
if(type == phVFRICATIVE)
{
if(next->type==phVOWEL)
{
pre_voiced = 1;
}
if((prev->type==phVOWEL) || (prev->type == phLIQUID))
{
p->length = (255 + prev->length)/2;
}
}
break;
case phVSTOP:
if(prev->type==phVFRICATIVE || prev->type==phFRICATIVE || (prev->ph->phflags & phSIBILANT) || (prev->type == phLIQUID))
p->prepause = 30;
if(next->type==phVOWEL || next->type==phLIQUID)
{
if((next->type==phVOWEL) || !next->newword)
pre_voiced = 1;
p->prepause = 40;
if((prev->type == phPAUSE) || (prev->type == phVOWEL)) // || (prev->ph->mnemonic == ('/'*256+'r')))
p->prepause = 0;
else
if(p->newword==0)
{
if(prev->type==phLIQUID)
p->prepause = 20;
if(prev->type==phNASAL)
p->prepause = 12;
if(prev->type==phSTOP && !(prev->ph->phflags & phFORTIS))
p->prepause = 0;
}
}
if((tr->langopts.word_gap & 0x10) && (p->newword) && (p->prepause < 20))
p->prepause = 20;
break;
case phLIQUID:
case phNASAL:
p->amp = tr->stress_amps[0]; // unless changed later
p->length = 256; // TEMPORARY
min_drop = 0;
if(p->newword)
{
if(prev->type==phLIQUID)
p->prepause = 25;
if(prev->type==phVOWEL)
{
if(!(p->ph->phflags & phNOPAUSE))
p->prepause = 12;
}
}
if(next->type==phVOWEL)
{
pre_sonorant = 1;
}
else
{
p->pitch2 = last_pitch;
if((prev->type==phVOWEL) || (prev->type == phLIQUID))
{
p->length = prev->length;
if(p->type == phLIQUID)
{
p->length = speed1;
}
if(next->type == phVSTOP)
{
p->length = (p->length * 160)/100;
}
if(next->type == phVFRICATIVE)
{
p->length = (p->length * 120)/100;
}
}
else
{
for(ix2=ix; ix2<n_phoneme_list; ix2++)
{
if(phoneme_list[ix2].type == phVOWEL)
{
p->pitch2 = phoneme_list[ix2].pitch2;
break;
}
}
}
p->pitch1 = p->pitch2-16;
if(p->pitch2 < 16)
{
p->pitch1 = 0;
}
p->env = PITCHfall;
pre_voiced = 0;
}
break;
case phVOWEL:
min_drop = 0;
next2 = &phoneme_list[ix+2];
next3 = &phoneme_list[ix+3];
if(stress > 7) stress = 7;
if(stress <= 1)
{
stress = stress ^ 1; // swap diminished and unstressed (until we swap stress_amps,stress_lengths in tr_languages)
}
if(pre_sonorant)
p->amp = tr->stress_amps[stress]-1;
else
p->amp = tr->stress_amps[stress];
if(emphasized)
p->amp = 25;
if(ix >= (n_phoneme_list-3))
{
// last phoneme of a clause, limit its amplitude
if(p->amp > tr->langopts.param[LOPT_MAXAMP_EOC])
p->amp = tr->langopts.param[LOPT_MAXAMP_EOC];
}
// is the last syllable of a word ?
more_syllables=0;
end_of_clause = 0;
for(p2 = p+1; p2->newword== 0; p2++)
{
if((p2->type == phVOWEL) && !(p2->ph->phflags & phNONSYLLABIC))
more_syllables++;
if(p2->ph->code == phonPAUSE_CLAUSE)
end_of_clause = 2;
}
if(p2->ph->code == phonPAUSE_CLAUSE)
end_of_clause = 2;
if((p2->newword & 2) && (more_syllables==0))
{
end_of_clause = 2;
}
// calc length modifier
if((next->ph->code == phonPAUSE_VSHORT) && (next2->type == phPAUSE))
{
// if PAUSE_VSHORT is followed by a pause, then use that
next = next2;
next2 = next3;
next3 = &phoneme_list[ix+4];
}
if(more_syllables==0)
{
len = tr->langopts.length_mods0[next2->ph->length_mod *10+ next->ph->length_mod];
if((next->newword) && (tr->langopts.word_gap & 0x20))
{
// consider as a pause + first phoneme of the next word
length_mod = (len + tr->langopts.length_mods0[next->ph->length_mod *10+ 1])/2;
}
else
length_mod = len;
}
else
{
length_mod = tr->langopts.length_mods[next2->ph->length_mod *10+ next->ph->length_mod];
if((next->type == phNASAL) && (next2->type == phSTOP || next2->type == phVSTOP) && (next3->ph->phflags & phFORTIS))
length_mod -= 15;
}
if(more_syllables==0)
length_mod *= speed1;
else
if(more_syllables==1)
length_mod *= speed2;
else
length_mod *= speed3;
length_mod = length_mod / 128;
if(length_mod < 8)
length_mod = 8; // restrict how much lengths can be reduced
if(stress >= 7)
{
// tonic syllable, include a constant component so it doesn't decrease directly with speed
length_mod += tr->langopts.lengthen_tonic;
if(emphasized)
length_mod += (tr->langopts.lengthen_tonic/2);
}
else
if(emphasized)
{
length_mod += tr->langopts.lengthen_tonic;
}
if((len = tr->stress_lengths[stress]) == 0)
len = tr->stress_lengths[6];
length_mod = length_mod * len;
if(p->tone_ph != 0)
{
if((tone_mod = phoneme_tab[p->tone_ph]->std_length) > 0)
{
// a tone phoneme specifies a percentage change to the length
length_mod = (length_mod * tone_mod) / 100;
}
}
if((end_of_clause == 2) && !(tr->langopts.stress_flags & S_NO_EOC_LENGTHEN))
{
// this is the last syllable in the clause, lengthen it - more for short vowels
len = (p->ph->std_length * 2);
if(tr->langopts.stress_flags & 0x40000)
len=200; // don't lengthen short vowels more than long vowels at end-of-clause
length_mod = length_mod * (256 + (280 - len)/3)/256;
}
if(length_mod > tr->langopts.max_lengthmod*speed1)
{
//limit the vowel length adjustment for some languages
length_mod = (tr->langopts.max_lengthmod*speed1);
}
length_mod = length_mod / 128;
if(p->type != phVOWEL)
{
length_mod = 256; // syllabic consonant
min_drop = 16;
}
p->length = length_mod;
if(p->env >= (N_ENVELOPE_DATA-1))
{
fprintf(stderr,"espeak: Bad intonation data\n");
p->env = 0;
}
// pre-vocalic part
// set last-pitch
env2 = p->env + 1; // version for use with preceding semi-vowel
if(p->tone_ph != 0)
{
InterpretPhoneme2(p->tone_ph, &phdata_tone);
pitch_env = GetEnvelope(phdata_tone.pitch_env);
}
else
{
pitch_env = envelope_data[env2];
}
pitch_start = p->pitch1 + ((p->pitch2-p->pitch1)*pitch_env[0])/256;
if(pre_sonorant || pre_voiced)
{
// set pitch for pre-vocalic part
if(pitch_start == 255)
last_pitch = pitch_start; // pitch is not set
if(pitch_start - last_pitch > 16)
last_pitch = pitch_start - 16;
prev->pitch1 = last_pitch;
prev->pitch2 = pitch_start;
if(last_pitch < pitch_start)
{
prev->env = PITCHrise;
p->env = env2;
}
else
{
prev->env = PITCHfall;
}
prev->length = length_mod;
prev->amp = p->amp;
if((prev->type != phLIQUID) && (prev->amp > 18))
prev->amp = 18;
}
// vowel & post-vocalic part
next->synthflags &= ~SFLAG_SEQCONTINUE;
if(next->type == phNASAL && next2->type != phVOWEL)
next->synthflags |= SFLAG_SEQCONTINUE;
if(next->type == phLIQUID)
{
next->synthflags |= SFLAG_SEQCONTINUE;
if(next2->type == phVOWEL)
{
next->synthflags &= ~SFLAG_SEQCONTINUE;
}
if(next2->type != phVOWEL)
{
if(next->ph->mnemonic == ('/'*256+'r'))
{
next->synthflags &= ~SFLAG_SEQCONTINUE;
// min_drop = 15;
}
}
}
if((min_drop > 0) && ((p->pitch2 - p->pitch1) < min_drop))
{
pitch1 = p->pitch2 - min_drop;
if(pitch1 < 0)
pitch1 = 0;
p->pitch1 = pitch1;
}
last_pitch = p->pitch1 + ((p->pitch2-p->pitch1)*envelope_data[p->env][127])/256;
pre_sonorant = 0;
pre_voiced = 0;
break;
}
}
} // end of CalcLengths
double TimeTrack::SolveWarpedLength(double t0, double length) const
{
return GetEnvelope()->SolveIntegralOfInverse(t0, length);
}
NS_IMETHODIMP
nsSOAPMessage::Encode(PRUint16 aVersion, const nsAString & aMethodName,
const nsAString & aTargetObjectURI,
PRUint32 aHeaderBlockCount,
nsISOAPHeaderBlock ** aHeaderBlocks,
PRUint32 aParameterCount,
nsISOAPParameter ** aParameters)
{
static NS_NAMED_LITERAL_STRING(realEmptySOAPDocStr1,
"<env:Envelope xmlns:env=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:enc=\"http://schemas.xmlsoap.org/soap/encoding/\"><env:Header/><env:Body/></env:Envelope>");
static NS_NAMED_LITERAL_STRING(realEmptySOAPDocStr2,
"<env:Envelope xmlns:env=\"http://www.w3.org/2001/09/soap-envelope\" xmlns:enc=\"http://www.w3.org/2001/09/soap-encoding\"><env:Header/><env:Body/></env:Envelope>");
static const nsAString *kEmptySOAPDocStr[] = {
&realEmptySOAPDocStr1, &realEmptySOAPDocStr2
};
if (aVersion != nsISOAPMessage::VERSION_1_1
&& aVersion != nsISOAPMessage::VERSION_1_2)
return SOAP_EXCEPTION(NS_ERROR_ILLEGAL_VALUE,"SOAP_BAD_VALUE","Cannot encode message blocks without a valid SOAP version specified.");
// Construct the message skeleton
nsresult rv;
nsCOMPtr<nsIDOMNode> ignored;
nsCOMPtr<nsIDOMParser> parser = do_CreateInstance(kDOMParserCID, &rv);
if (NS_FAILED(rv))
return rv;
rv = parser->ParseFromString(nsPromiseFlatString(*kEmptySOAPDocStr[aVersion]).get(),
"application/xml", getter_AddRefs(mMessage));
if (NS_FAILED(rv))
return rv;
// Declare the default encoding. This should always be non-null, but may be empty string.
nsCOMPtr<nsISOAPEncoding> encoding;
rv = GetEncoding(getter_AddRefs(encoding));
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsIDOMElement> envelope;
rv = GetEnvelope(getter_AddRefs(envelope));
if (NS_FAILED(rv))
return rv;
if (envelope) {
nsAutoString enc;
rv = mEncoding->GetStyleURI(enc);
if (NS_FAILED(rv))
return rv;
if (!enc.IsEmpty()) {
rv = envelope->SetAttributeNS(*gSOAPStrings->kSOAPEnvURI[aVersion],
gSOAPStrings->kEncodingStyleAttribute, enc);
if (NS_FAILED(rv))
return rv;
}
}
// Declare the schema namespaces, taking into account any mappings that are present.
nsAutoString temp;
nsAutoString temp2;
temp.Assign(gSOAPStrings->kXMLNamespacePrefix);
temp.Append(gSOAPStrings->kXSPrefix);
rv = encoding->GetExternalSchemaURI(gSOAPStrings->kXSURI, temp2);
if (NS_FAILED(rv))
return rv;
rv = envelope->SetAttributeNS(gSOAPStrings->kXMLNamespaceNamespaceURI, temp, temp2);
if (NS_FAILED(rv))
return rv;
temp.Assign(gSOAPStrings->kXMLNamespacePrefix);
temp.Append(gSOAPStrings->kXSIPrefix);
rv = encoding->GetExternalSchemaURI(gSOAPStrings->kXSIURI, temp2);
if (NS_FAILED(rv))
return rv;
rv = envelope->SetAttributeNS(gSOAPStrings->kXMLNamespaceNamespaceURI, temp, temp2);
if (NS_FAILED(rv))
return rv;
// Encode and add headers, if any were specified
if (aHeaderBlockCount) {
nsCOMPtr<nsIDOMElement> parent;
rv = GetHeader(getter_AddRefs(parent));
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsISOAPHeaderBlock> header;
nsCOMPtr<nsIDOMElement> element;
nsAutoString name;
nsAutoString namespaceURI;
PRUint32 i;
for (i = 0; i < aHeaderBlockCount; i++) {
header = aHeaderBlocks[i];
if (!header)
return SOAP_EXCEPTION(NS_ERROR_ILLEGAL_VALUE,"SOAP_NULL_HEADER","Cannot encode null in header array.");
rv = header->GetElement(getter_AddRefs(element));
if (element) {
nsCOMPtr<nsIDOMNode> node1;
node1 = element;
nsCOMPtr<nsIDOMNode> node2;
rv = mMessage->ImportNode(node1, PR_TRUE, getter_AddRefs(node1));
if (NS_FAILED(rv))
return rv;
rv = parent->AppendChild(node2, getter_AddRefs(node1));
if (NS_FAILED(rv))
return rv;
element = do_QueryInterface(node1);
} else {
rv = header->GetNamespaceURI(namespaceURI);
if (NS_FAILED(rv))
return rv;
rv = header->GetName(name);
if (NS_FAILED(rv))
return rv;
nsAutoString actorURI;
rv = header->GetActorURI(actorURI);
if (NS_FAILED(rv))
return rv;
PRBool mustUnderstand;
rv = header->GetMustUnderstand(&mustUnderstand);
if (NS_FAILED(rv))
return rv;
rv = header->GetEncoding(getter_AddRefs(encoding));
if (NS_FAILED(rv))
return rv;
if (!encoding) {
rv = GetEncoding(getter_AddRefs(encoding));
if (NS_FAILED(rv))
return rv;
}
nsCOMPtr<nsISchemaType> schemaType;
rv = header->GetSchemaType(getter_AddRefs(schemaType));
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsIVariant> value;
rv = header->GetValue(getter_AddRefs(value));
if (NS_FAILED(rv))
return rv;
rv = encoding->Encode(value, namespaceURI, name,
schemaType, nsnull, parent,
getter_AddRefs(element));
if (NS_FAILED(rv))
return rv;
if (!actorURI.IsEmpty()) {
element->SetAttributeNS(gSOAPStrings->kSOAPEnvPrefix,
gSOAPStrings->kActorAttribute, actorURI);
if (NS_FAILED(rv))
return rv;
}
if (mustUnderstand) {
element->SetAttributeNS(gSOAPStrings->kSOAPEnvPrefix,
gSOAPStrings->kMustUnderstandAttribute,
gSOAPStrings->kTrueA);
if (NS_FAILED(rv))
return rv;
}
if (mEncoding != encoding) {
nsAutoString enc;
encoding->GetStyleURI(enc);
element->
SetAttributeNS(*gSOAPStrings->kSOAPEnvURI[aVersion],
gSOAPStrings->kEncodingStyleAttribute, enc);
}
}
}
}
nsCOMPtr<nsIDOMElement> body;
rv = GetBody(getter_AddRefs(body));
if (NS_FAILED(rv))
return rv;
// Only produce a call element if mMethodName was non-empty
if (!aMethodName.IsEmpty()) {
nsAutoString temp;
rv = encoding->GetExternalSchemaURI(aTargetObjectURI, temp);
nsCOMPtr<nsIDOMElement> call;
rv = mMessage->CreateElementNS(temp, aMethodName,
getter_AddRefs(call));
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsIDOMNode> ignored;
rv = body->AppendChild(call, getter_AddRefs(ignored));
if (NS_FAILED(rv))
return rv;
body = call;
}
// Encode and add all of the parameters into the body
nsCOMPtr<nsISOAPParameter> param;
nsCOMPtr<nsIDOMElement> element;
nsCOMPtr<nsISOAPEncoding> newencoding;
nsAutoString name;
nsAutoString namespaceURI;
PRUint32 i;
for (i = 0; i < aParameterCount; i++) {
param = aParameters[i];
if (!param)
return SOAP_EXCEPTION(NS_ERROR_ILLEGAL_VALUE,"SOAP_NULL_PARAMETER","Cannot encode null in parameter array.");
rv = param->GetElement(getter_AddRefs(element));
if (element) {
nsCOMPtr<nsIDOMNode> node1;
node1 = element;
nsCOMPtr<nsIDOMNode> node2;
rv = mMessage->ImportNode(node1, PR_TRUE, getter_AddRefs(node2));
if (NS_FAILED(rv))
return rv;
rv = body->AppendChild(node2, getter_AddRefs(node1));
if (NS_FAILED(rv))
return rv;
element = do_QueryInterface(node1);
} else {
rv = param->GetNamespaceURI(namespaceURI);
if (NS_FAILED(rv))
return rv;
rv = param->GetName(name);
if (NS_FAILED(rv))
return rv;
rv = param->GetEncoding(getter_AddRefs(newencoding));
if (NS_FAILED(rv))
return rv;
if (!newencoding) {
newencoding = encoding;
}
nsCOMPtr<nsISchemaType> schemaType;
rv = param->GetSchemaType(getter_AddRefs(schemaType));
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsIVariant> value;
rv = param->GetValue(getter_AddRefs(value));
if (NS_FAILED(rv))
return rv;
rv = newencoding->Encode(value, namespaceURI, name,
schemaType, nsnull, body,
getter_AddRefs(element));
if (NS_FAILED(rv))
return rv;
if (encoding != newencoding) {
nsAutoString enc;
newencoding->GetStyleURI(enc);
element->SetAttributeNS(*gSOAPStrings->kSOAPEnvURI[aVersion],
gSOAPStrings->kEncodingStyleAttribute, enc);
}
}
}
return NS_OK;
}
bool WaveClip::ClearAndAddCutLine(double t0, double t1)
{
if (t0 > GetEndTime() || t1 < GetStartTime())
return true; // time out of bounds
WaveClip *newClip = new WaveClip(mSequence->GetDirManager(),
mSequence->GetSampleFormat(),
mRate);
double clip_t0 = t0;
double clip_t1 = t1;
if (clip_t0 < GetStartTime())
clip_t0 = GetStartTime();
if (clip_t1 > GetEndTime())
clip_t1 = GetEndTime();
if (!newClip->CreateFromCopy(clip_t0, clip_t1, this))
return false;
newClip->SetOffset(clip_t0-mOffset);
// Sort out cutlines that belong to the new cutline
WaveClipList::compatibility_iterator nextIt;
for (WaveClipList::compatibility_iterator it = mCutLines.GetFirst(); it; it=nextIt)
{
nextIt = it->GetNext();
WaveClip* clip = it->GetData();
double cutlinePosition = mOffset + clip->GetOffset();
if (cutlinePosition >= t0 && cutlinePosition <= t1)
{
clip->SetOffset(cutlinePosition - newClip->GetOffset() - mOffset);
newClip->mCutLines.Append(clip);
mCutLines.DeleteNode(it);
} else
if (cutlinePosition >= t1)
{
clip->Offset(clip_t0-clip_t1);
}
}
// Clear actual audio data
sampleCount s0, s1;
TimeToSamplesClip(t0, &s0);
TimeToSamplesClip(t1, &s1);
if (GetSequence()->Delete(s0, s1-s0))
{
// Collapse envelope
GetEnvelope()->CollapseRegion(t0, t1);
if (t0 < GetStartTime())
Offset(-(GetStartTime() - t0));
MarkChanged();
mCutLines.Append(newClip);
return true;
} else
{
delete newClip;
return false;
}
}
//Compute the (average) warp factor between two non-warped time points
double TimeTrack::ComputeWarpFactor(double t0, double t1) const
{
return GetEnvelope()->AverageOfInverse(t0, t1);
}
void CSimpleMarkerElement::DrawNormal(Display::IDisplayPtr pDisplay)
{
Display::IMarkerSymbol* pMarkerSymbol = dynamic_cast<Display::IMarkerSymbol*>(m_pSymbol.get());
if(m_bGeometryChanged)
{
DIS_RECT *pHandleDisBound = pDisplay->GetDisplayTransformation().TransformToDisplay(&GetEnvelope());
long width = pHandleDisBound->Width()*Display::CDC::GetCreateDCsRateOfPixelAndMillimeter();
long height = pHandleDisBound->Height()*Display::CDC::GetCreateDCsRateOfPixelAndMillimeter();
long symbolSizeMM = width < height ? width : height;
float symbolSize = SYSTEM::UnitConverter::ConvertUnits(symbolSizeMM, SYSTEM::SYS_UNIT_MILLIMETER, pMarkerSymbol->GetUnit());
if(pDisplay->GetDisplayTransformation().GetReferenceScale() != 0)
{
float fScale = pDisplay->GetDisplayTransformation().GetReferenceScale()/pDisplay->GetDisplayTransformation().GetMapScale();
if (fScale != 1.000000)
{
symbolSize /= fScale;
}
}
pMarkerSymbol->SetMarkerSize(symbolSize);
m_bGeometryChanged = FALSE;
}
else
{
//¸üÐÂselectionhandle
double dblSize = pMarkerSymbol->GetMarkerSize();
if(pDisplay->GetDisplayTransformation().GetReferenceScale() != 0)
{
float fScale = pDisplay->GetDisplayTransformation().GetReferenceScale()/pDisplay->GetDisplayTransformation().GetMapScale();
if (fScale != 1.000000)
{
dblSize *= fScale;
}
}
double dbSizeMM = SYSTEM::UnitConverter::ConvertUnits(dblSize, pMarkerSymbol->GetUnit(), SYSTEM::SYS_UNIT_MILLIMETER);
long markerSizePixel = dbSizeMM/Display::CDC::GetCreateDCsRateOfPixelAndMillimeter();
double markerSizeGeo;
pDisplay->GetDisplayTransformation().ConvertDisplayToGeo(markerSizePixel, markerSizeGeo);
GEOMETRY::geom::Envelope env(*m_pGeometry->getCoordinate());
env.expandBy(abs(markerSizeGeo)/2);
GEOMETRY::geom::Geometry* pGeo = GEOMETRY::geom::GeometryFactory::getDefaultInstance()->toGeometry(&env);
m_pSelectionHandle->SetGeometry(*pGeo);
GEOMETRY::geom::GeometryFactory::getDefaultInstance()->destroyGeometry(pGeo);
}
//»æÖÆ
pDisplay->SetSymbol( m_pSymbol.get() );
pDisplay->Begin();
pDisplay->Draw( m_pGeometry );
pDisplay->End();
}
double TimeTrack::ComputeWarpedLength(double t0, double t1) const
{
return GetEnvelope()->IntegralOfInverse(t0, t1);
}