QCString dispositionNotificationBodyContent( const QString & r,
const QCString & o,
const QCString & omid,
DispositionType d,
ActionMode a,
SendingMode s,
const QValueList<DispositionModifier> & m,
const QString & special )
{
// in Perl: chomp(special)
QString spec;
if ( special.endsWith("\n") )
spec = special.left( special.length() - 1 );
else
spec = special;
// std headers:
QCString result = reportingUAField();
result += orginalRecipient( o );
result += finalRecipient( r );
result += originalMessageID( omid );
result += dispositionField( d, a, s, m );
// headers that are only present for certain disposition {types,modifiers}:
if ( d == Failed )
result += "Failure: " + encodeRFC2047String( spec, "utf-8" ) + "\n";
else if ( m.contains( Error ) )
result += "Error: " + encodeRFC2047String( spec, "utf-8" ) + "\n";
else if ( m.contains( Warning ) )
result += "Warning: " + encodeRFC2047String( spec, "utf-8" ) + "\n";
return result;
}
void StoneHandler::checkNeighbourLiberty(int x, int y, QValueList<int> &libCounted, int &liberties, Matrix *m) //SL added eb 8
{
if (!x || !y)
return;
Stone *s;
// CHECK_PTR(m); // SL added eb 8
if (m==NULL) //added eb 8 -> we don't have a matrix passed here, so we check on the board
{
if (x <= boardHandler->board->getBoardSize() && y <= boardHandler->board->getBoardSize() && x >= 0 && y >= 0 &&
!libCounted.contains(100*x + y) &&
((s = stones->find(Matrix::coordsToKey(x, y))) == NULL ||
!s->visible()))
{
libCounted.append(100*x + y);
liberties ++;
}
}
else
{
if (x <= boardHandler->board->getBoardSize() && y <= boardHandler->board->getBoardSize() && x >= 0 && y >= 0 &&
!libCounted.contains(100*x + y) &&
(m->at(x - 1, y - 1) == stoneNone )) // ?? check stoneErase ?
{
libCounted.append(100*x + y);
liberties ++;
} // end add eb 8
}
}
void KoZoomAction::setZoom( const QString& text )
{
bool ok = false;
QString t = text;
int zoom = t.remove( '%' ).toInt( &ok );
// where we'll store sorted new zoom values
QValueList<int> list;
if( zoom > 10 ) list.append( zoom );
// "Captured" non-empty sequence of digits
QRegExp regexp("(\\d+)");
const QStringList itemsList( items() );
for( QStringList::ConstIterator it = itemsList.begin(); it != itemsList.end(); ++it )
{
regexp.search( *it );
const int val=regexp.cap(1).toInt( &ok );
//zoom : limit inferior=10
if( ok && val>9 && list.contains( val )==0 )
list.append( val );
}
qHeapSort( list );
// update items with new sorted zoom values
QStringList values;
for (QValueList<int>::Iterator it = list.begin(); it != list.end(); ++it )
values.append( i18n("%1%").arg(*it) );
setItems( values );
QString zoomStr = i18n("%1%").arg( zoom );
setCurrentItem( values.findIndex( zoomStr ) );
}
void
CollectionScanner::scanFiles( const QStringList& entries )
{
DEBUG_BLOCK
typedef QPair<QString, QString> CoverBundle;
QStringList validImages; validImages << "jpg" << "png" << "gif" << "jpeg";
QStringList validPlaylists; validPlaylists << "m3u" << "pls";
QValueList<CoverBundle> covers;
QStringList images;
foreachType( QStringList, entries ) {
const QString path = *it;
const QString ext = extension( path );
const QString dir = directory( path );
// Write path to logfile
if( !m_logfile.isEmpty() ) {
QFile log( m_logfile );
if( log.open( IO_WriteOnly ) )
log.writeBlock( path.local8Bit(), path.length() );
}
if( validImages.contains( ext ) )
images += path;
else if( m_importPlaylists && validPlaylists.contains( ext ) ) {
AttributeMap attributes;
attributes["path"] = path;
writeElement( "playlist", attributes );
}
else {
MetaBundle::EmbeddedImageList images;
MetaBundle mb( KURL::fromPathOrURL( path ), true, TagLib::AudioProperties::Fast, &images );
const AttributeMap attributes = readTags( mb );
if( !attributes.empty() ) {
writeElement( "tags", attributes );
CoverBundle cover( attributes["artist"], attributes["album"] );
if( !covers.contains( cover ) )
covers += cover;
foreachType( MetaBundle::EmbeddedImageList, images ) {
AttributeMap attributes;
attributes["path"] = path;
attributes["hash"] = (*it).hash();
attributes["description"] = (*it).description();
writeElement( "embed", attributes );
}
}
}
WORD SSIManager::findFreeId( const QValueList<WORD>& idList, WORD fromId ) const
{
for ( WORD id = fromId; id < 0x8000; id++ )
{
if ( idList.contains( id ) == 0 )
return id;
}
return 0xFFFF;
}
void TableEditor::slotRemoveRow()
{
if (m_row == -1)
m_row = m_dataTable->numRows() - 1;
int i = 0;
int j = 0;
for (QValueList<QValueList<TableNode> >::Iterator it = m_tableTags->begin(); it != m_tableTags->end(); ++it) {
j = 0;
for (QValueList<TableNode>::Iterator it2 = (*it).begin(); it2 != (*it).end(); ++it2) {
if ((*it2).merged && (*it2).mergedRow == m_row) {
(*it2).merged = false;
setCellText(m_dataTable, i, j, tagContent((*it2).node));
m_dataTable->item(i, j)->setEnabled(true);
(*it2).node->tag->deleteAttribute("colspan");
(*it2).node->tag->deleteAttribute("rowspan");
}
j++;
}
i++;
}
QValueList<TableNode*> updatedMainNodes;
QValueList<QValueList<TableNode> >::Iterator it2 = m_tableTags->at(m_row);
for (QValueList<TableNode>::Iterator it3 = (*it2).begin(); it3 != (*it2).end(); ++it3) {
if ((*it3).merged)
{
TableNode *mainTableNode = &((*m_tableTags)[(*it3).mergedRow][(*it3).mergedCol]);
if (mainTableNode->node && !updatedMainNodes.contains(mainTableNode))
{
int rowspan = mainTableNode->node->tag->attributeValue("rowspan", true).toInt();
rowspan--;
if (rowspan > 1)
mainTableNode->node->tag->editAttribute("rowspan", QString("%1").arg(rowspan));
else
mainTableNode->node->tag->deleteAttribute("rowspan");
updatedMainNodes.append(mainTableNode);
}
}
Node::deleteNode((*it3).node);
(*it3).node = 0L;
newNum--;
}
m_tableTags->erase(it2);
m_dataTable->removeRow(m_row);
QValueList<TableNode>::Iterator it = m_tableRows->at(m_row);
Node::deleteNode((*it).node);
newNum--;
m_tableRows->erase(it);
m_rowSpin->setValue(m_dataTable->numRows());
}
void StoneHandler::checkNeighbourLibertyOnMatrix(int x, int y, QValueList<int> &libCounted, int &liberties, Matrix *m)
{
if (!x || !y)
return;
// Stone *s;
if (x <= boardHandler->board->getBoardSize() && y <= boardHandler->board->getBoardSize() && x >= 0 && y >= 0 &&
!libCounted.contains(100*x + y) &&
(m->at(x - 1, y - 1) == MARK_TERRITORY_DONE_BLACK ||
m->at(x - 1, y - 1) == MARK_TERRITORY_DONE_WHITE))
{
libCounted.append(100*x + y);
liberties ++;
}
}
void FavoriteFolderView::initializeFavorites()
{
QValueList<int> seenInboxes = GlobalSettings::self()->favoriteFolderViewSeenInboxes();
KMFolderTree *ft = mainWidget()->folderTree();
assert( ft );
for ( QListViewItemIterator it( ft ); it.current(); ++it ) {
KMFolderTreeItem *fti = static_cast<KMFolderTreeItem*>( it.current() );
if ( fti->type() == KFolderTreeItem::Inbox && fti->folder() && !seenInboxes.contains( fti->folder()->id() ) ) {
seenInboxes.append( fti->folder()->id() );
if ( fti->folder() == kmkernel->inboxFolder() && hideLocalInbox() )
continue;
if ( kmkernel->iCalIface().hideResourceFolder( fti->folder() ) )
continue;
addFolder( fti->folder(), prettyName( fti ) );
}
}
GlobalSettings::self()->setFavoriteFolderViewSeenInboxes( seenInboxes );
}
bool Ts2Rtp::addChannels( QPtrList<ChannelDesc> *channels )
{
int i, j, k, pmtpid=8191;
ChannelDesc *desc, *d;
QValueList<int> pids;
if ( !rtpSocket && !makeSocket() )
return false;
sendList = "";
for ( i=0; i<(int)channels->count(); i++ ) {
desc = channels->at( i );
sendList = sendList+desc->name+"|"+QString().setNum(desc->vpid)+"|"+QString().setNum(desc->apid[0].pid)+"|";
if ( desc->apid[0].ac3 ) sendList+= "y|";
else sendList+= "n|";
sendList+= QString().setNum(desc->subpid[0].pid);
sendList+= "|";
sendList+= QString().setNum(desc->subpid[0].page);
sendList+= "|";
sendList+= QString().setNum(desc->subpid[0].id);
sendList+= "|";
sendList+= QString().setNum(desc->subpid[0].type);
sendList+= "|";
sendList+= desc->subpid[0].lang+"|";
for ( j=i; j<(int)channels->count(); j++ ) {
pids.clear();
d = channels->at( j );
if ( d->vpid )
pids.append( d->vpid );
for ( k=0; k<d->napid && k<MAX_AUDIO; k++ )
pids.append( d->apid[k].pid );
for ( k=0; k<d->nsubpid && k<MAX_DVBSUB; k++ )
pids.append( d->subpid[k].pid );
while ( pmtpid==17 || pids.contains( pmtpid ) )
--pmtpid;
}
desc->pmtpid = pmtpid--;
}
sendList+="\n";
psiTables( channels );
writePsi = true;
psiTimer.start( 500 );
return true;
}
QStringList Rad::kanjiByRad(const QStringList &list)
{
//kdDebug() << "kanjiByRad (list version)\n";
QStringList ret;
QValueList<QStringList> lists;
for (QStringList::ConstIterator it = list.begin(); it != list.end(); ++it)
{
//kdDebug() << "loading radical " << *it << endl;
lists.append(kanjiByRad(*it));
}
QStringList first = lists.first();
lists.pop_front();
for (QStringList::Iterator kit = first.begin(); kit != first.end(); ++kit)
{
//kdDebug() << "kit is " << *kit << endl;
QValueList<bool> outcomes;
for (QValueList<QStringList>::Iterator it = lists.begin(); it != lists.end(); ++it)
{
//kdDebug() << "looping through lists\n";
outcomes.append((*it).contains(*kit) > 0);
}
const bool containsBool = false;
if ((outcomes.contains(containsBool) < 1))
{
//kdDebug() << "appending " << *kit << endl;
ret.append(*kit);
}
else
{
//kdDebug() << "not appending " << *kit << endl;
}
}
return ret;
}
bool cMulti::canPlace( const Coord& pos, unsigned short multiid, QPtrList<cUObject>& moveOut, unsigned short yard )
{
MultiDefinition *multi = MultiCache::instance()->getMulti( multiid );
if ( !multi )
{
return false;
}
moveOut.setAutoDelete( false );
// Get the boundaries and build a list sorted by x,y
int left = multi->getLeft();
int right = multi->getRight();
int bottom = multi->getBottom();
int top = multi->getTop();
int height = multi->getHeight();
int width = multi->getWidth();
Q_UNUSED( bottom );
QValueList<Coord> borderList; // a list of points around the foundation that need to be clear of impassables
QValueList<Coord> yardList; // a list of points in the yard (front/back of the house that needs to be clear)
for ( int x = 0; x < width; ++x )
{
for ( int y = 0; y < height; ++y )
{
Coord point = pos + Coord( x + left, y + top );
bool hasBase = false; // Has this multi tile a base below the floor?
// See if there are any tiles at that position
const QValueVector<multiItem_st> &multiItems = multi->itemsAt( x + left, y + top );
if ( multiItems.size() == 0 )
{
continue; // Skip this tile since there are no items here
}
cTerritory *region = Territories::instance()->region( point );
if ( region && region->isNoHousing() )
{
return false; // No housing is allowed in this region
}
// Collect data for the intersect checks
StaticsIterator statics = Maps::instance()->staticsIterator( point );
MapItemsIterator items = MapObjects::instance()->listItemsAtCoord( point );
int top, bottom;
unsigned short landId;
Maps::instance()->mapTileSpan( point, landId, bottom, top );
// Check every tile of the multi at the current position
// The following algorithm is more or less a ripoff of RunUOs idea.
for ( unsigned int i = 0; i < multiItems.size(); ++i )
{
multiItem_st multiItem = multiItems[i];
tile_st tile = TileCache::instance()->getTile( multiItem.tile );
// Calculcate the spawn of the tile
int itemBottom = point.z + multiItem.z;
// if the tile is a surface, someone has to be able to stand on it.
int itemTop = itemBottom + tile.height + ( ( ( tile.flag2 & 0x02 ) != 0 ) ? 16 : 0 );
// There is special handling for floor tiles
bool baseTile = multiItem.z == 0 && ( tile.flag1 & 0x10 ) != 0;
bool isHovering = true; // This tile has not yet something to "stand" on
Q_UNUSED( isHovering );
if ( baseTile )
hasBase = true;
// Does the multi item intersect a land-tile?
if ( ( itemTop < top && itemTop >= bottom ) || ( itemBottom < top && itemBottom >= bottom ) )
{
return false;
}
// Since houses can only be built on land and not on items, it's enough to check for
// a solid foundation here
if ( pos.z != bottom || pos.z != top )
{
return false;
}
// Check if the multi item is interfering with a static tile at the same position
statics.reset();
while ( !statics.atEnd() )
{
const staticrecord &staticTile = ( statics++ ).data();
tile_st staticInfo = TileCache::instance()->getTile( staticTile.itemid );
int staticBottom = staticTile.zoff;
int staticTop = staticBottom + staticInfo.height;
// The tile intersects a static tile
if ( ( itemTop < staticTop && itemTop >= staticBottom ) || ( itemBottom < staticTop && itemBottom >= staticBottom ) )
{
bool impassable = ( staticInfo.flag1 & 0x40 ) != 0;
bool background = ( staticInfo.flag1 & 0x01 ) != 0;
bool surface = ( staticInfo.flag2 & 0x02 ) != 0;
// A normally blocking tile is intersecting our multi
if ( impassable || ( !background && surface ) )
{
return false;
}
}
}
// Do the same check (as above) with movable items, but make sure that movable items
// are moved out of the house
for ( P_ITEM pItem = items.first(); pItem; pItem = items.next() )
{
tile_st itemInfo = TileCache::instance()->getTile( pItem->id() );
int dynamicBottom = pItem->pos().z;
int dynamicTop = dynamicBottom + itemInfo.height;
// Only handle the tile if it is intersecting the multi
if ( ( itemTop < dynamicTop && itemTop >= dynamicBottom ) || ( itemBottom < dynamicTop && itemBottom >= dynamicBottom ) )
{
// Move the item out of the multi space if possible
if ( ( pItem->movable() == 0 && itemInfo.weight != 255 ) || pItem->movable() == 1 )
{
moveOut.append( pItem );
}
else
{
bool impassable = ( itemInfo.flag1 & 0x40 ) != 0;
bool background = ( itemInfo.flag1 & 0x01 ) != 0;
bool surface = ( itemInfo.flag2 & 0x02 ) != 0;
// A normally blocking tile is intersecting our multi
if ( impassable || ( !background && surface ) )
{
return false;
}
}
}
}
// Moves mobiles inside the multi out to the ban location
MapCharsIterator chars = MapObjects::instance()->listCharsAtCoord( point );
for ( P_CHAR pChar = chars.first(); pChar; pChar = chars.next() )
{
// Move them ALWAYS out, they could be trapped by the castle
// otherwise (or other strange multi forms)
moveOut.append( pChar );
}
// To keep roads house free, here's a specialized check for roads
if ( ( landId >= 0x71 && landId <= 0x8c ) || ( landId >= 0x14c && landId <= 0x14f ) || ( landId >= 0x161 && landId <= 0x174 ) || ( landId >= 0x1f0 && landId <= 0x1f3 ) || ( landId >= 0x26e && landId <= 0x279 ) || ( landId >= 0x27e && landId <= 0x281 ) || ( landId >= 0x324 && landId <= 0x3ac ) || ( landId >= 0x597 && landId <= 0x5a6 ) || ( landId >= 0x637 && landId <= 0x63a ) || ( landId >= 0x67d && landId <= 0x6a0 ) || ( landId >= 0x7ae && landId <= 0x7b1 ) || ( landId >= 0x442 && landId <= 0x479 ) || ( landId >= 0x501 && landId <= 0x510 ) || ( landId >= 0x009 && landId <= 0x015 ) || ( landId >= 0x150 && landId <= 0x15c ) )
{
return false; // Road Blocked
}
// For houses (they have a base you know...)
// we collect another list of points around the house that need to be checked
if ( hasBase )
{
int xOffset, yOffset;
// We have to do two loops since the yard size does play a role here
// but not for the border
for ( xOffset = -1; xOffset <= 1; ++xOffset )
{
for ( yOffset = -yard; yOffset <= yard; ++yOffset )
{
Coord pos = point + Coord( xOffset, yOffset );
if ( !yardList.contains( pos ) )
{
yardList.push_back( pos ); // Put this point into the yard checklist if it's not there
}
}
}
for ( xOffset = -1; xOffset <= 1; ++xOffset )
{
for ( yOffset = -1; yOffset <= 1; ++yOffset )
{
Coord pos = point + Coord( xOffset, yOffset );
// Only do the following if the current tiles position differs from the
// check position.
if ( xOffset != 0 || yOffset != 0 )
{
// The border list should not contain tiles that are actually below the multis
// floor and hence not visible and covered by a walkable multi tile.
// So what we do here is check if within 8 z units of the multis floor there is a
// walkable tile above the border tile
int multiX = x + xOffset; // Offset to the upper left corner of the multi
int multiY = y + yOffset; // Offset to the upper left corner of the multi
bool found = false; // Assume there is no such tile
// Only do this check if the to-be-checked tile is really within the multi
// boundaries
if ( multiX >= 0 && multiY >= 0 && multiX < width && multiY < height )
{
// Get the multi tiles at the to-check position
const QValueVector<multiItem_st> &tiles = multi->itemsAt( multiX + left, multiY + right );
QValueVector<multiItem_st>::const_iterator it;
for ( it = tiles.begin(); it != tiles.end(); ++it )
{
if ( it->z > 8 )
{
continue; // Skip the tile if its above the base (2nd floor etc.)
}
// Get the tiledata info for this tile if it's below z8
tile_st tileInfo = TileCache::instance()->getTile( it->tile );
bool surface = ( tileInfo.flag2 & 0x02 ) != 0;
if ( tileInfo.height == 0 && surface )
{
found = true;
break;
}
}
// We found a tile that we could stand on. So it's not neccesary to check
// that the house stands on something walkable here.
if ( found )
{
continue;
}
}
// Add the tile to the list of border tiles.
if ( !borderList.contains( pos ) )
{
borderList.append( pos );
}
}
}
}
}
}
}
}
QValueList<Coord>::const_iterator it;
// Now check all the accumulated border tiles
for ( it = borderList.begin(); it != borderList.end(); ++it )
{
map_st mapTile = Maps::instance()->seekMap( *it );
land_st mapTileInfo = TileCache::instance()->getLand( mapTile.id );
// Impassable map tiles are not allowed nearby
bool impassable = ( mapTileInfo.flag1 & 0x40 ) != 0;
if ( impassable )
{
return false;
}
// Get Static Tiles
StaticsIterator statics = Maps::instance()->staticsIterator( *it );
while ( !statics.atEnd() )
{
const staticrecord &staticItem = statics.data();
tile_st staticInfo = TileCache::instance()->getTile( staticItem.itemid );
bool impassable = ( staticInfo.flag1 & 0x40 ) != 0;
bool background = ( staticInfo.flag1 & 0x01 ) != 0;
bool surface = ( staticInfo.flag2 & 0x02 ) != 0;
// The tile is only of importance if it's not below the multi
if ( ( staticItem.zoff > ( ( *it ).z + 2 ) ) && ( impassable || ( !background && surface ) ) )
{
return false; // A normally blocking tile is intersecting our multi border
}
statics++;
}
// Do the same check (as above) with dynamic items
MapItemsIterator items = MapObjects::instance()->listItemsAtCoord( *it );
for ( P_ITEM pItem = items.first(); pItem; pItem = items.next() )
{
tile_st itemInfo = TileCache::instance()->getTile( pItem->id() );
// Move the item out of the multi space if possible
if ( ( pItem->movable() == 0 && itemInfo.weight != 255 ) || pItem->movable() == 1 )
continue;
if ( pItem->pos().z <= ( ( *it ).z + 2 ) )
continue; // Does not interfere with the border
bool impassable = ( itemInfo.flag1 & 0x40 ) != 0;
bool background = ( itemInfo.flag1 & 0x01 ) != 0;
bool surface = ( itemInfo.flag2 & 0x02 ) != 0;
// A normally blocking tile is intersecting our multi
if ( impassable || ( !background && surface ) )
return false;
}
}
// The yard has to be free of any multis at that position
for ( it = yardList.begin(); it != yardList.end(); ++it )
{
// Search for multis in the region
MapMultisIterator multis = MapObjects::instance()->listMultisInCircle( *it, 18 );
for ( cMulti*multi = multis.first(); multi; multi = multis.next() )
{
if ( multi->inMulti( *it ) )
{
// This is a simplified check but it should be sufficient.
return false;
}
}
}
return true;
}
