void CalendarDiffAlgo::diffList( const QString &id,
const QValueList<L> &left, const QValueList<L> &right )
{
for ( uint i = 0; i < left.count(); ++i ) {
if ( right.find( left[ i ] ) == right.end() )
additionalLeftField( id, toString( left[ i ] ) );
}
for ( uint i = 0; i < right.count(); ++i ) {
if ( left.find( right[ i ] ) == left.end() )
additionalRightField( id, toString( right[ i ] ) );
}
}
void
QueueManager::addItems( QListViewItem *after )
{
/*
HACK!!!!! We can know which items where dragged since they should still be selected
I do this, because:
- Dragging items from the playlist provides urls
- Providing urls, requires iterating through the entire list in order to find which
item was selected. Possibly a very expensive task - worst case: O(n)
- After a drag, those items are still selected in the playlist, so we can find out
which PlaylistItems were dragged by selectedItems();
*/
if( !after )
after = m_listview->lastChild();
QPtrList<QListViewItem> list = Playlist::instance()->selectedItems();
for( QListViewItem *item = list.first(); item; item = list.next() )
{
#define item static_cast<PlaylistItem*>(item)
QValueList<PlaylistItem*> current = m_map.values();
if( current.find( item ) == current.end() ) //avoid duplication
{
QString title = i18n("%1 - %2").arg( item->artist(), item->title() );
after = new QueueItem( m_listview, after, title );
m_map[ after ] = item;
}
#undef item
}
}
void OKeyFilterPrivate::addHandler(QWSServer::KeyboardFilter*aF)
{
if (!aF) return;
if (filterList.find(aF)!=filterList.end()) {
return;
}
odebug << "adding a keyboard filter handler"<<oendl;
filterList.append(aF);
}
void OKeyFilterPrivate::addPreHandler(QWSServer::KeyboardFilter*aF)
{
if (!aF) return;
if (preFilterList.find(aF)!=preFilterList.end()) {
return;
}
odebug << "adding a preferred keyboard filter handler"<<oendl;
preFilterList.append(aF);
}
void OKeyFilterPrivate::remHandler(QWSServer::KeyboardFilter*aF)
{
if (!aF) return;
QValueList<QWSServer::KeyboardFilter*>::Iterator iter;
if ( (iter=filterList.find(aF))==filterList.end() ) {
return;
}
odebug << "removing a keyboard filter handler"<<oendl;
filterList.remove(iter);
}
QStringList KUser::groupNames() const {
QStringList result;
QValueList<KUserGroup> allGroups = KUserGroup::allGroups();
QValueList<KUserGroup>::const_iterator it;
for ( it = allGroups.begin(); it != allGroups.end(); ++it ) {
QValueList<KUser> users = (*it).users();
if ( users.find( *this ) != users.end()) {
result.append((*it).name());
}
}
return result;
}
void
QueueManager::addQueuedItem( PlaylistItem *item )
{
Playlist *pl = Playlist::instance();
if( !pl ) return; //should never happen
const int index = pl->m_nextTracks.findRef( item );
QListViewItem *after;
if( !index ) after = 0;
else
{
int find = m_listview->childCount();
if( index - 1 <= find )
find = index - 1;
after = m_listview->itemAtIndex( find );
}
QValueList<PlaylistItem*> current = m_map.values();
QValueListIterator<PlaylistItem*> newItem = current.find( item );
QString title = i18n("%1 - %2").arg( item->artist(), item->title() );
if( newItem == current.end() ) //avoid duplication
{
after = new QueueItem( m_listview, after, title );
m_map[ after ] = item;
}
else //track is in the queue, remove it.
{
QListViewItem *removableItem = m_listview->findItem( title, 0 );
if( removableItem )
{
//Remove the key from the map, so we can re-queue the item
QMapIterator<QListViewItem*, PlaylistItem*> end( m_map.end() );
for( QMapIterator<QListViewItem*, PlaylistItem*> it = m_map.begin(); it != end; ++it )
{
if( it.data() == item )
{
m_map.remove( it );
//Remove the item from the queuelist
m_listview->takeItem( removableItem );
delete removableItem;
return;
}
}
}
}
}
/******************************************************************************
* Check if any alarms are pending for a specified calendar, and display the
* pending alarms.
*/
void AlarmDaemon::checkAlarms(ADCalendar *cal)
{
kdDebug(5901) << "AlarmDaemons::checkAlarms(" << cal->urlString() << ")" << endl;
if(!cal->loaded() || !cal->enabled())
return;
QDateTime now = QDateTime::currentDateTime();
kdDebug(5901) << " To: " << now.toString() << endl;
QValueList<KCal::Alarm *> alarms = cal->alarmsTo(now);
if(!alarms.count())
return;
QValueList<KCal::Event *> eventsDone;
for(QValueList<KCal::Alarm *>::ConstIterator it = alarms.begin(); it != alarms.end(); ++it)
{
KCal::Event *event = dynamic_cast<KCal::Event *>((*it)->parent());
if(!event || eventsDone.find(event) != eventsDone.end())
continue; // either not an event, or the event has already been processed
eventsDone += event;
const QString &eventID = event->uid();
kdDebug(5901) << "AlarmDaemon::checkAlarms(): event " << eventID << endl;
// Check which of the alarms for this event are due.
// The times in 'alarmtimes' corresponding to due alarms are set.
// The times for non-due alarms are set invalid in 'alarmtimes'.
bool recurs = event->doesRecur();
const QStringList cats = event->categories();
bool floats = (cats.find(QString::fromLatin1("DATE")) != cats.end());
QDateTime nextDateTime = event->dtStart();
if(recurs)
{
QString prop = event->customProperty("KALARM", "NEXTRECUR");
if(prop.length() >= 8)
{
// The next due recurrence time is specified
QDate d(prop.left(4).toInt(), prop.mid(4, 2).toInt(), prop.mid(6, 2).toInt());
if(d.isValid())
{
if(floats && prop.length() == 8)
nextDateTime = d;
else if(!floats && prop.length() == 15 && prop[8] == QChar('T'))
{
QTime t(prop.mid(9, 2).toInt(), prop.mid(11, 2).toInt(), prop.mid(13, 2).toInt());
if(t.isValid())
nextDateTime = QDateTime(d, t);
}
}
}
}
if(floats)
nextDateTime.setTime(mStartOfDay);
QValueList<QDateTime> alarmtimes;
KCal::Alarm::List alarms = event->alarms();
for(KCal::Alarm::List::ConstIterator al = alarms.begin(); al != alarms.end(); ++al)
{
KCal::Alarm *alarm = *al;
QDateTime dt;
if(alarm->enabled())
{
QDateTime dt1;
if(!alarm->hasTime())
{
// Find the latest recurrence for the alarm.
// Need to do this for alarms with offsets in order to detect
// reminders due for recurrences.
int offset = alarm->hasStartOffset() ? alarm->startOffset().asSeconds()
: alarm->endOffset().asSeconds() + event->dtStart().secsTo(event->dtEnd());
if(offset)
{
dt1 = nextDateTime.addSecs(floats ? (offset / SECS_PER_DAY) * SECS_PER_DAY : offset);
if(dt1 > now)
dt1 = QDateTime();
}
}
// Get latest due repetition, or the recurrence time if none
dt = nextDateTime;
if(nextDateTime <= now && alarm->repeatCount() > 0)
{
int snoozeSecs = alarm->snoozeTime() * 60;
int offset = alarm->repeatCount() * snoozeSecs;
QDateTime lastRepetition = nextDateTime.addSecs(floats ? (offset / SECS_PER_DAY) * SECS_PER_DAY : offset);
if(lastRepetition <= now)
dt = lastRepetition;
else
{
int repetition = nextDateTime.secsTo(now) / snoozeSecs;
int offset = repetition * snoozeSecs;
dt = nextDateTime.addSecs(floats ? (offset / SECS_PER_DAY) * SECS_PER_DAY : offset);
}
}
if(!dt.isValid() || dt > now
|| dt1.isValid() && dt1 > dt) // already tested dt1 <= now
dt = dt1;
}
alarmtimes.append(dt);
}
if(!cal->eventHandled(event, alarmtimes))
{
if(notifyEvent(cal, eventID))
cal->setEventPending(event, alarmtimes);
}
}
}
/**
Paints the actual data area.
\param painter the QPainter onto which the chart should be painted
\param data the data that will be displayed as a chart
\param paint2nd specifies whether the main chart or the additional chart is to be drawn now
\param regions a pointer to a list of regions that will be filled
with regions representing the data segments, if not null
*/
void KDChartPiePainter::paintData( QPainter* painter,
KDChartTableDataBase* data,
bool paint2nd,
KDChartDataRegionList* regions )
{
//bHelp=true;
uint chart = paint2nd ? 1 : 0;
QRect ourClipRect( _dataRect );
ourClipRect.addCoords( -1,-1,1,1 );
const QWMatrix & world = painter->worldMatrix();
ourClipRect =
#if COMPAT_QT_VERSION >= 0x030000
world.mapRect( ourClipRect );
#else
world.map( ourClipRect );
#endif
painter->setClipRect( ourClipRect );
// find which dataset to paint
uint dataset;
if ( !params()->findDataset( KDChartParams::DataEntry
,
dataset, dataset ) ) {
return ; // nothing to draw
}
if ( dataset == KDCHART_ALL_DATASETS )
// setChartSourceMode() has not been used (or all datasets have been
// configured to be used); use the first dataset by
// default
dataset = 0;
// Number of values: If -1, use all values, otherwise use the
// specified number of values.
if ( params()->numValues() != -1 )
_numValues = params()->numValues();
else
_numValues = data->usedCols();
_startAngles.resize( _numValues );
_angleLens.resize( _numValues );
// compute position
_size = QMIN( _dataRect.width(), _dataRect.height() ); // initial size
// if the pies explode, we need to give them additional space =>
// make the basic size smaller
if ( params()->explode() ) {
double doubleSize = ( double ) _size;
doubleSize /= ( 1.0 + params()->explodeFactor() * 2 );
_size = ( int ) doubleSize;
}
int sizeFor3DEffect = 0;
if ( !params()->threeDPies() ) {
int x = ( _dataRect.width() == _size ) ? 0 : ( ( _dataRect.width() - _size ) / 2 );
int y = ( _dataRect.height() == _size ) ? 0 : ( ( _dataRect.height() - _size ) / 2 );
_position = QRect( x, y, _size, _size );
_position.moveBy( _dataRect.left(), _dataRect.top() );
} else {
// threeD: width is the maximum possible width; height is 1/2 of that
int x = ( _dataRect.width() == _size ) ? 0 : ( ( _dataRect.width() - _size ) / 2 );
int height = _size;
// make sure that the height plus the threeDheight is not more than the
// available size
if ( params()->threeDPieHeight() >= 0 ) {
// positive pie height: absolute value
sizeFor3DEffect = params()->threeDPieHeight();
height = _size - sizeFor3DEffect;
} else {
// negative pie height: relative value
sizeFor3DEffect = -( int ) ( ( ( double ) params()->threeDPieHeight() / 100.0 ) * ( double ) height );
height = _size - sizeFor3DEffect;
}
int y = ( _dataRect.height() == height ) ? 0 : ( ( _dataRect.height() - height - sizeFor3DEffect ) / 2 );
_position = QRect( _dataRect.left() + x, _dataRect.top() + y,
_size, height );
// _position.moveBy( _dataRect.left(), _dataRect.top() );
}
double sum = data->rowAbsSum( dataset );
if( sum==0 ) //nothing to draw
return;
double sectorsPerValue = 5760.0 / sum; // 5760 == 16*360, number of sections in Qt circle
int currentValue = params()->pieStart() * 16;
bool atLeastOneValue = false; // guard against completely empty tables
QVariant vValY;
for ( int value = 0; value < _numValues; value++ ) {
// is there anything at all at this value
/* see above for meaning of 16 */
if( data->cellCoord( dataset, value, vValY, 1 ) &&
QVariant::Double == vValY.type() ){
_startAngles[ value ] = currentValue;
const double cellValue = fabs( vValY.toDouble() );
_angleLens[ value ] = ( int ) floor( cellValue * sectorsPerValue + 0.5 );
atLeastOneValue = true;
} else { // mark as non-existent
_angleLens[ value ] = 0;
if ( value > 0 )
_startAngles[ value ] = _startAngles[ value - 1 ];
else
_startAngles[ value ] = currentValue;
}
currentValue = _startAngles[ value ] + _angleLens[ value ];
}
// If there was no value at all, bail out, to avoid endless loops
// later on (e.g. in findPieAt()).
if( !atLeastOneValue )
return;
// Find the backmost pie which is at +90° and needs to be drawn
// first
int backmostpie = findPieAt( 90 * 16 );
// Find the frontmost pie (at -90°/+270°) that should be drawn last
int frontmostpie = findPieAt( 270 * 16 );
// and put the backmost pie on the TODO stack to initialize it,
// but only if it is not the frontmostpie
QValueStack < int > todostack;
if ( backmostpie != frontmostpie )
todostack.push( backmostpie );
else {
// Otherwise, try to find something else
int leftOfCurrent = findLeftPie( backmostpie );
if ( leftOfCurrent != frontmostpie ) {
todostack.push( leftOfCurrent );
} else {
int rightOfCurrent = findRightPie( backmostpie );
if ( rightOfCurrent != frontmostpie ) {
todostack.push( rightOfCurrent );
}
}
// If we get here, there was nothing else, and we will bail
// out of the while loop below.
}
// The list with pies that have already been drawn
QValueList < int > donelist;
// Draw pies until the todostack is empty or only the frontmost
// pie is there
while ( !todostack.isEmpty() &&
!( ( todostack.count() == 1 ) &&
( ( todostack.top() == frontmostpie ) ) ) ) {
// The while loop cannot be cancelled if frontmostpie is on
// top of the stack, but this is also backmostpie (can happen
// when one of the pies covers more than 1/2 of the circle. In
// this case, we need to find something else to put on the
// stack to get things going.
// take one pie from the stack
int currentpie = todostack.pop();
// if this pie was already drawn, ignore it
if ( donelist.find( currentpie ) != donelist.end() )
continue;
// If this pie is the frontmost pie, put it back, but at the
// second position (otherwise, there would be an endless
// loop). If this pie is the frontmost pie, there must be at
// least one other pie, otherwise the loop would already have
// been terminated by the loop condition.
if ( currentpie == frontmostpie ) {
Q_ASSERT( !todostack.isEmpty() );
// QValueStack::exchange() would be nice here...
int secondpie = todostack.pop();
if ( currentpie == secondpie )
// no need to have the second pie twice on the stack,
// forget about one instance and take the third
// instead
if ( todostack.isEmpty() )
break; // done anyway
else
secondpie = todostack.pop();
todostack.push( currentpie );
todostack.push( secondpie );
continue;
}
// When we get here, we can just draw the pie and proceed.
drawOnePie( painter, data, dataset, currentpie, chart,
sizeFor3DEffect,
regions );
// Mark the pie just drawn as done.
donelist.append( currentpie );
// Now take the pie to the left and to the right, check
// whether these have not been painted already, and put them
// on the stack.
int leftOfCurrent = findLeftPie( currentpie );
if ( donelist.find( leftOfCurrent ) == donelist.end() )
todostack.push( leftOfCurrent );
int rightOfCurrent = findRightPie( currentpie );
if ( donelist.find( rightOfCurrent ) == donelist.end() )
todostack.push( rightOfCurrent );
}
// now only the frontmost pie is left to draw
drawOnePie( painter, data, dataset, frontmostpie, chart,
sizeFor3DEffect,
regions );
}
/**
Internal method that draws one of the pies in a pie chart.
\param painter the QPainter to draw in
\param dataset the dataset to draw the pie for
\param pie the pie to draw
\param the chart to draw the pie in
\param regions a pointer to a list of regions that will be filled
with regions representing the data segments, if not null
*/
void KDChartPiePainter::drawOnePie( QPainter* painter,
KDChartTableDataBase* /*data*/,
uint dataset, uint pie, uint chart,
uint threeDPieHeight,
KDChartDataRegionList* regions )
{
// Is there anything to draw at all?
int angleLen = _angleLens[ ( int ) pie ];
if ( angleLen ) {
int startAngle = _startAngles[ ( int ) pie ];
KDChartDataRegion* datReg = 0;
QRegion* region = 0;
bool mustDeleteRegion = false;
if ( regions ){
region = new QRegion();
mustDeleteRegion = true;
}
QRect drawPosition = _position;
if ( params()->explode() ) {
// need to compute a new position for each or some of the pie
QValueList<int> explodeList = params()->explodeValues();
if( explodeList.count() == 0 || // nothing on list, explode all
explodeList.find( pie ) != explodeList.end() ) {
double explodeAngle = ( startAngle + angleLen / 2 ) / 16;
double explodeAngleRad = DEGTORAD( explodeAngle );
double cosAngle = cos( explodeAngleRad );
double sinAngle = -sin( explodeAngleRad );
// find the explode factor for this particular pie
double explodeFactor = 0.0;
QMap<int,double> explodeFactors = params()->explodeFactors();
if( !explodeFactors.contains( pie ) ) // not on factors list, use default
explodeFactor = params()->explodeFactor();
else // on factors list, use segment-specific value
explodeFactor = explodeFactors[pie];
double explodeX = explodeFactor * _size * cosAngle;
double explodeY = explodeFactor * _size * sinAngle;
drawPosition.moveBy( static_cast<int>( explodeX ), static_cast<int>( explodeY ) );
} else
drawPosition = _position;
} else
drawPosition = _position;
// The 3D effect needs to be drawn first because it could
// otherwise partly hide the pie itself.
if ( params()->threeDPies() ) {
draw3DEffect( painter, drawPosition, dataset, pie, chart,
threeDPieHeight,
params()->explode(), region );
}
painter->setBrush( params()->dataColor( pie ) );
if ( angleLen == 5760 ) {
// full circle, avoid nasty line in the middle
painter->drawEllipse( drawPosition );
if ( regions ) {
QPointArray hitregion;
hitregion.makeEllipse( drawPosition.x(), drawPosition.y(),
drawPosition.width(),
drawPosition.height() );
datReg = new KDChartDataRegion( region->unite( QRegion( hitregion ) ),
dataset,
pie,
chart );
datReg->points[ KDChartEnums::PosCenter ]
= drawPosition.center();
datReg->points[ KDChartEnums::PosCenterRight ]
= pointOnCircle( drawPosition, 0 );
datReg->points[ KDChartEnums::PosTopRight ]
= pointOnCircle( drawPosition, 720 );
datReg->points[ KDChartEnums::PosTopCenter ]
= pointOnCircle( drawPosition, 1440 );
datReg->points[ KDChartEnums::PosTopLeft ]
= pointOnCircle( drawPosition, 2160 );
datReg->points[ KDChartEnums::PosCenterLeft ]
= pointOnCircle( drawPosition, 2880 );
datReg->points[ KDChartEnums::PosBottomLeft ]
= pointOnCircle( drawPosition, 3600 );
datReg->points[ KDChartEnums::PosBottomCenter ]
= pointOnCircle( drawPosition, 4320 );
datReg->points[ KDChartEnums::PosBottomRight ]
= pointOnCircle( drawPosition, 5040 );
datReg->startAngle = 2880;
datReg->angleLen = 5760;
regions->append( datReg );
}
} else {
// draw the top of this piece
// Start with getting the points for the arc.
const int arcPoints = angleLen;
QPointArray collect(arcPoints+2);
int i=0;
for ( ; i<=angleLen; ++i){
collect.setPoint(i, pointOnCircle( drawPosition, startAngle+i ));
}
// Adding the center point of the piece.
collect.setPoint(i, drawPosition.center() );
painter->drawPolygon( collect );
//if( bHelp ){
// painter->drawPolyline( collect );
//bHelp=false;
//}
if ( regions ) {
QPointArray hitregion;
hitregion.makeArc( drawPosition.x(), drawPosition.y(),
drawPosition.width(),
drawPosition.height(),
( int ) startAngle, ( int ) angleLen );
hitregion.resize( hitregion.size() + 1 );
hitregion.setPoint( hitregion.size() - 1,
drawPosition.center() );
datReg = new KDChartDataRegion( region->unite( QRegion( hitregion ) ),
dataset,
pie,
chart );
datReg->points[ KDChartEnums::PosTopLeft ]
= pointOnCircle( drawPosition, startAngle + angleLen );
datReg->points[ KDChartEnums::PosTopCenter ]
= pointOnCircle( drawPosition, startAngle + angleLen / 2 );
datReg->points[ KDChartEnums::PosTopRight ]
= pointOnCircle( drawPosition, startAngle );
datReg->points[ KDChartEnums::PosBottomLeft ] = drawPosition.center();
datReg->points[ KDChartEnums::PosBottomCenter ]
= datReg->points[ KDChartEnums::PosBottomLeft ];
datReg->points[ KDChartEnums::PosBottomRight ]
= datReg->points[ KDChartEnums::PosBottomLeft ];
datReg->points[ KDChartEnums::PosCenterLeft ]
= QPoint( ( datReg->points[ KDChartEnums::PosTopLeft ].x()
+ datReg->points[ KDChartEnums::PosBottomLeft ].x() ) / 2,
( datReg->points[ KDChartEnums::PosTopLeft ].y()
+ datReg->points[ KDChartEnums::PosBottomLeft ].y() ) / 2 );
datReg->points[ KDChartEnums::PosCenter ]
= QPoint( ( datReg->points[ KDChartEnums::PosTopCenter ].x()
+ datReg->points[ KDChartEnums::PosBottomCenter ].x() ) / 2,
( datReg->points[ KDChartEnums::PosTopCenter ].y()
+ datReg->points[ KDChartEnums::PosBottomCenter ].y() ) / 2 );
datReg->points[ KDChartEnums::PosCenterRight ]
= QPoint( ( datReg->points[ KDChartEnums::PosTopRight ].x()
+ datReg->points[ KDChartEnums::PosBottomRight ].x() ) / 2,
( datReg->points[ KDChartEnums::PosTopRight ].y()
+ datReg->points[ KDChartEnums::PosBottomRight ].y() ) / 2 );
datReg->startAngle = startAngle;
datReg->angleLen = angleLen;
regions->append( datReg );
}
}
if( mustDeleteRegion )
delete region;
}
}
bool CppEditorCompletion::doObjectCompletion( const QString &objName )
{
if ( !ths )
return FALSE;
QString object( objName );
int i = -1;
if ( ( i = object.findRev( "->" ) ) != -1 )
object = object.mid( i + 2 );
if ( ( i = object.findRev( "." ) ) != -1 )
object = object.mid( i + 1 );
object = object.simplifyWhiteSpace();
QObject *obj = 0;
if ( ths->name() == object || object == "this" ) {
obj = ths;
} else {
obj = ths->child( object );
}
if ( !obj )
return FALSE;
QValueList<CompletionEntry> lst;
if ( obj->children() ) {
for ( QObjectListIt cit( *obj->children() ); cit.current(); ++cit ) {
QString s( cit.current()->name() );
if ( s.find( " " ) == -1 && s.find( "qt_" ) == -1 && s.find( "unnamed" ) == -1 ) {
CompletionEntry c;
c.type = "variable";
c.text = s;
c.prefix = "";
lst << c;
}
}
}
QStrList props = obj->metaObject()->propertyNames( TRUE );
for ( QPtrListIterator<char> pit( props ); pit.current(); ++pit ) {
QString f( pit.current() );
QChar c = f[ 0 ];
f.remove( (uint)0, 1 );
f.prepend( c.upper() );
f.prepend( "set" );
CompletionEntry ce;
ce.type = "property";
ce.text = f;
ce.postfix = "()";
if ( lst.find( ce ) == lst.end() )
lst << ce;
}
QStrList slts = obj->metaObject()->slotNames( TRUE );
for ( QPtrListIterator<char> sit( slts ); sit.current(); ++sit ) {
QString f( sit.current() );
f = f.left( f.find( "(" ) );
CompletionEntry c;
c.type = "slot";
c.text = f;
c.postfix = "()";
if ( lst.find( c ) == lst.end() )
lst << c;
}
if ( lst.isEmpty() )
return FALSE;
showCompletion( lst );
return TRUE;
}
