window_ptr WindowFactory::Create(const std::string& type, const std::string& name)
{
try
{
if(type.empty())
return window_ptr();
typedef CreatorsMap::iterator CreatorsIt;
CreatorsIt it = m_creators.find(type);
if (it == m_creators.end())
{
m_system.logEvent(log::warning, std::string("Factory: couldn't create window ") + type);
return window_ptr();
}
return (it->second)->Create(name);
}
catch (...)
{
m_system.logEvent(log::warning, std::string("Factory: exception occerud while creating window ") + type);
return window_ptr();
}
}
void ScrollPane::setTarget(WindowBase* target)
{
m_target = target;
if(target && m_scroll)
{
add(window_ptr(target));
bringToBack(target);
layoutTarget();
subscribe<events::SizedEvent, ScrollPane> (&ScrollPane::onTargetSized, m_target);
}
else if(!target)
{
unsubscribe<events::SizedEvent>();
}
invalidate();
}
void base_window::addChildWindow(base_window* wnd)
{
if(wnd) add(window_ptr(wnd));
}
//-------------------------------------------------------------------------
CSeqMasker::TMaskList *
CSeqMasker::DoMask(
const CSeqVector& data, TSeqPos begin, TSeqPos stop ) const
{
ustat->total_ = 0;
auto_ptr<TMaskList> mask(new TMaskList);
if( window_size > data.size() )
{
ERR_POST( Warning
<< "length of data is shorter than the window size" );
}
Uint4 cutoff_score = ustat->get_threshold();
Uint4 textend = ustat->get_textend();
Uint1 nbits = discontig ? CSeqMaskerUtil::BitCount( pattern ) : 0;
Uint4 unit_size = ustat->UnitSize() + nbits;
auto_ptr<CSeqMaskerWindow> window_ptr
(discontig ? new CSeqMaskerWindowPattern( data, unit_size,
window_size, window_step,
pattern, unit_step )
: new CSeqMaskerWindow( data, unit_size,
window_size, window_step,
unit_step, begin, stop ));
CSeqMaskerWindow & window = *window_ptr;
score->SetWindow( window );
if( trigger == eTrigger_Min ) trigger_score->SetWindow( window );
Uint4 start = 0, end = 0, cend = 0;
Uint4 limit = textend;
const CSeqMaskerIstat::optimization_data * od
= ustat->get_optimization_data();
CSeqMaskerCacheBoost booster( window, od );
while( window )
{
Uint4 ts = (*trigger_score)();
Uint4 s = (*score)();
Uint4 adv = window_step;
if( s < limit )
{
if( end > start )
{
if( window.Start() > cend )
{
mask->push_back( TMaskedInterval( start, end ) );
start = end = cend = 0;
}
}
if( od != 0 && od->cba_ != 0 )
{
adv = window.Start();
if( !booster.Check() )
break;
adv = window_step*( 1 + window.Start() - adv );
}
}
else if( ts < cutoff_score )
{
if( end > start )
{
if( window.Start() > cend + 1 )
{
mask->push_back( TMaskedInterval( start, end ) );
start = end = cend = 0;
}
else cend = window.End();
}
}
else
{
if( end > start )
{
if( window.Start() > cend + 1 )
{
mask->push_back( TMaskedInterval( start, end ) );
start = window.Start();
}
}
else start = window.Start();
cend = end = window.End();
}
if( adv == window_step )
++window;
score->PostAdvance( adv );
}
if( end > start )
mask->push_back( TMaskedInterval( start, end ) );
window_ptr.reset();
if( merge_pass )
{
Uint1 nbits = discontig ? CSeqMaskerUtil::BitCount( pattern ) : 0;
Uint4 unit_size = ustat->UnitSize() + nbits;
if( mask->size() < 2 ) return mask.release();
TMList masked, unmasked;
TMaskList::iterator jtmp = mask->end();
{{
for( TMaskList::iterator i = mask->begin(), j = --jtmp;
i != j; )
{
masked.push_back( mitem( i->first, i->second, unit_size,
data, *this ) );
Uint4 nstart = (i++)->second - unit_size + 2;
unmasked.push_back( mitem( nstart, i->first + unit_size - 2,
unit_size, data, *this ) );
}
masked.push_back( mitem( (mask->rbegin())->first,
(mask->rbegin())->second,
unit_size, data, *this ) );
}}
Int4 count = 0;
TMList::iterator ii = masked.begin();
TMList::iterator j = unmasked.begin();
TMList::iterator k = ii, l = ii;
--k; ++l;
for( ; ii != masked.end(); k = l = ii, --k, ++l )
{
Uint4 ldist = (ii != masked.begin())
? ii->start - k->end - 1 : 0;
TMList::iterator tmpend = masked.end();
--tmpend;
Uint4 rdist = (ii != tmpend)
? l->start - ii->end - 1 : 0;
double lavg = 0.0, ravg = 0.0;
bool can_go_left = count && ldist
&& ldist <= mean_merge_cutoff_dist;
bool can_go_right = rdist
&& rdist <= mean_merge_cutoff_dist;
if( can_go_left )
{
TMList::iterator tmp = j; --tmp;
lavg = MergeAvg( k, tmp, unit_size );
can_go_left = can_go_left && (lavg >= merge_cutoff_score);
}
if( can_go_right )
{
ravg = MergeAvg( ii, j, unit_size );
can_go_right = can_go_right && (ravg >= merge_cutoff_score);
}
if( can_go_right )
{
if( can_go_left )
{
if( ravg >= lavg )
{
++count;
++ii;
++j;
}
else // count must be greater than 0.
{
--count;
k->avg = MergeAvg( k, --j, unit_size );
_TRACE( "Merging "
<< k->start << " - " << k->end
<< " and "
<< ii->start << " - " << ii->end );
Merge( masked, k, unmasked, j );
if( count )
{
ii = --k;
--j;
--count;
}
else ii = k;
}
}
else
{
++count;
++ii;
++j;
}
}
else if( can_go_left )
{
--count;
k->avg = MergeAvg( k, --j, unit_size );
_TRACE( "Merging "
<< k->start << " - " << k->end
<< " and "
<< ii->start << " - " << ii->end );
Merge( masked, k, unmasked, j );
if( count )
{
ii = --k;
--j;
--count;
}
else ii = k;
}
else
{
++ii;
++j;
count = 0;
}
}
for( ii = masked.begin(), j = unmasked.begin(), k = ii++;
ii != masked.end(); (k = ii++), j++ )
{
if( k->end + abs_merge_cutoff_dist >= ii->start )
{
_TRACE( "Unconditionally merging "
<< k->start << " - " << k->end
<< " and "
<< ii->start << " - " << ii->end );
k->avg = MergeAvg( k, j, unit_size );
Merge( masked, k, unmasked, j );
ii = k;
if( ++ii == masked.end() ) break;
}
}
mask->clear();
for( TMList::const_iterator iii = masked.begin(); iii != masked.end(); ++iii )
mask->push_back( TMaskedInterval( iii->start, iii->end ) );
}
return mask.release();
}
