void RenderGeometryMap::pushMappingsToAncestor(const RenderLayer* layer, const RenderLayer* ancestorLayer, bool respectTransforms)
{
MapCoordinatesFlags newFlags = respectTransforms ? m_mapCoordinatesFlags : m_mapCoordinatesFlags & ~UseTransforms;
SetForScope<MapCoordinatesFlags> flagsChange(m_mapCoordinatesFlags, newFlags);
const RenderLayerModelObject& renderer = layer->renderer();
// We have to visit all the renderers to detect flipped blocks. This might defeat the gains
// from mapping via layers.
bool canConvertInLayerTree = ancestorLayer ? canMapBetweenRenderersViaLayers(layer->renderer(), ancestorLayer->renderer()) : false;
if (canConvertInLayerTree) {
LayoutSize layerOffset = layer->offsetFromAncestor(ancestorLayer);
// The RenderView must be pushed first.
if (!m_mapping.size()) {
ASSERT(ancestorLayer->renderer().isRenderView());
pushMappingsToAncestor(&ancestorLayer->renderer(), nullptr);
}
SetForScope<size_t> positionChange(m_insertionPosition, m_mapping.size());
push(&renderer, layerOffset, /*accumulatingTransform*/ true, /*isNonUniform*/ false, /*isFixedPosition*/ false, /*hasTransform*/ false);
return;
}
const RenderLayerModelObject* ancestorRenderer = ancestorLayer ? &ancestorLayer->renderer() : nullptr;
pushMappingsToAncestor(&renderer, ancestorRenderer);
}
void LayoutGeometryMap::pushMappingsToAncestor(const PaintLayer* layer, const PaintLayer* ancestorLayer)
{
const LayoutObject* layoutObject = layer->layoutObject();
bool crossDocument = ancestorLayer && layer->layoutObject()->frame() != ancestorLayer->layoutObject()->frame();
ASSERT(!crossDocument || m_mapCoordinatesFlags & TraverseDocumentBoundaries);
// We have to visit all the layoutObjects to detect flipped blocks. This might defeat the gains
// from mapping via layers.
bool canConvertInLayerTree = (ancestorLayer && !crossDocument) ? canMapBetweenLayoutObjects(layer->layoutObject(), ancestorLayer->layoutObject()) : false;
LAYOUT_GEOMETRY_MAP_LOG("LayoutGeometryMap::pushMappingsToAncestor from layer %p to layer %p, canConvertInLayerTree=%d\n", layer, ancestorLayer, canConvertInLayerTree);
if (canConvertInLayerTree) {
LayoutPoint layerOffset;
layer->convertToLayerCoords(ancestorLayer, layerOffset);
// The LayoutView must be pushed first.
if (!m_mapping.size()) {
ASSERT(ancestorLayer->layoutObject()->isLayoutView());
pushMappingsToAncestor(ancestorLayer->layoutObject(), 0);
}
TemporaryChange<size_t> positionChange(m_insertionPosition, m_mapping.size());
bool accumulatingTransform = layer->layoutObject()->style()->preserves3D() || ancestorLayer->layoutObject()->style()->preserves3D();
push(layoutObject, toLayoutSize(layerOffset), accumulatingTransform ? AccumulatingTransform : 0);
return;
}
const LayoutBoxModelObject* ancestorLayoutObject = ancestorLayer ? ancestorLayer->layoutObject() : 0;
pushMappingsToAncestor(layoutObject, ancestorLayoutObject);
}
/**
* Opens a dialog box with all available mixers and let the user choose one.
* If the user selects a mixer, "_mixer" will be set and positionChange() is called.
*/
void KMixApplet::selectMixer()
{
QStringList lst;
int n=1;
for (Mixer *mixer=Mixer::mixers().first(); mixer!=0; mixer=Mixer::mixers().next())
{
QString s;
s.sprintf("%i. %s", n, mixer->mixerName().ascii());
lst << s;
n++;
}
bool ok = FALSE;
QString res = KInputDialog::getItem( i18n("Mixers"),
i18n("Available mixers:"),
lst, 1, FALSE, &ok, this );
if ( ok )
{
Mixer *mixer = Mixer::mixers().at( lst.findIndex( res ) );
if (!mixer)
KMessageBox::sorry( this, i18n("Invalid mixer entered.") );
else
{
delete m_errorLabel;
m_errorLabel = 0;
_mixer = mixer;
// Create the ViewApplet by calling positionChange() ... :)
// To take over reversedDir and (more important) to create the mixer widget
// if necessary!
positionChange(position());
}
}
}
void RenderGeometryMap::pushMappingsToAncestor(const RenderLayer* layer, const RenderLayer* ancestorLayer)
{
const RenderObject& renderer = layer->renderer();
// We have to visit all the renderers to detect flipped blocks. This might defeat the gains
// from mapping via layers.
bool canConvertInLayerTree = ancestorLayer ? canMapBetweenRenderers(layer->renderer(), ancestorLayer->renderer()) : false;
// fprintf(stderr, "RenderGeometryMap::pushMappingsToAncestor from layer %p to layer %p, canConvertInLayerTree=%d\n", layer, ancestorLayer, canConvertInLayerTree);
if (canConvertInLayerTree) {
LayoutPoint layerOffset;
layer->convertToLayerCoords(ancestorLayer, layerOffset);
// The RenderView must be pushed first.
if (!m_mapping.size()) {
ASSERT(ancestorLayer->renderer().isRenderView());
pushMappingsToAncestor(&ancestorLayer->renderer(), 0);
}
TemporaryChange<size_t> positionChange(m_insertionPosition, m_mapping.size());
push(&renderer, toLayoutSize(layerOffset), /*accumulatingTransform*/ true, /*isNonUniform*/ false, /*isFixedPosition*/ false, /*hasTransform*/ false);
return;
}
const RenderLayerModelObject* ancestorRenderer = ancestorLayer ? &ancestorLayer->renderer() : 0;
pushMappingsToAncestor(&renderer, ancestorRenderer);
}
TaskBarExtension::TaskBarExtension(const QString& configFile, Type type,
int actions, QWidget *parent, const char *name)
: KPanelExtension(configFile, type, actions, parent, name),
m_bgImage(0),
m_bgFilename(0),
m_rootPixmap(0)
{
QHBoxLayout *layout = new QHBoxLayout(this);
m_container = new TaskBarContainer(false, this);
m_container->setBackgroundOrigin(AncestorOrigin);
positionChange(position());
layout->addWidget(m_container);
connect(m_container, SIGNAL(containerCountChanged()),
SIGNAL(updateLayout()));
kapp->dcopClient()->setNotifications(true);
connectDCOPSignal("kicker", "kicker", "configurationChanged()",
"configure()", false);
connect(kapp, SIGNAL(kdisplayPaletteChanged()),
SLOT(setBackgroundTheme()));
QTimer::singleShot(0, this, SLOT(setBackgroundTheme()));
}
void TMGraphView::zoomToOverview()
{
view_address = 0;
view_time = 0;
address_zoom_factor = width()/(double)total_bytes;
time_zoom_factor = height()/(double)total_time;
emit positionChange(displayAddressToRealAddress(view_address), view_time);
update();
}
void LayoutGeometryMap::pushMappingsToAncestor(const LayoutObject* layoutObject, const LayoutBoxModelObject* ancestorLayoutObject)
{
// We need to push mappings in reverse order here, so do insertions rather than appends.
TemporaryChange<size_t> positionChange(m_insertionPosition, m_mapping.size());
do {
layoutObject = layoutObject->pushMappingToContainer(ancestorLayoutObject, *this);
} while (layoutObject && layoutObject != ancestorLayoutObject);
ASSERT(m_mapping.isEmpty() || isTopmostLayoutView(m_mapping[0].m_layoutObject));
}
void RenderGeometryMap::pushMappingsToAncestor(const RenderObject* renderer, const RenderLayerModelObject* ancestorRenderer)
{
// We need to push mappings in reverse order here, so do insertions rather than appends.
SetForScope<size_t> positionChange(m_insertionPosition, m_mapping.size());
do {
renderer = renderer->pushMappingToContainer(ancestorRenderer, *this);
} while (renderer && renderer != ancestorRenderer);
ASSERT(m_mapping.isEmpty() || m_mapping[0].m_renderer->isRenderView());
}
void TMGraphView::addressMove(long long da)
{
if(da < 0 && -da > view_address)
view_address = 0;
else if(da > 0 && da > 0xFFFFFFFFFFFFFFFF - view_address)
view_address = 0xFFFFFFFFFFFFFFFF;
else
view_address += da;
emit positionChange(displayAddressToRealAddress(view_address), view_time);
}
void TMGraphView::timeMove(long long dt)
{
if(dt < 0 && -dt > view_time)
view_time = 0;
else if(dt > 0 && dt > 0xFFFFFFFFFFFFFFFF - view_time)
view_time = 0xFFFFFFFFFFFFFFFF;
else
view_time += dt;
emit positionChange(displayAddressToRealAddress(view_address), view_time);
}
void TMGraphView::zoomToOverview()
{
view_address = 0;
view_time = 0;
updateZoomFactors();
emit positionChange(displayAddressToRealAddress(view_address), view_time);
update();
}
void TMGraphView::onWindowResize()
{
// Special behaviour if overview: fit to new window size
if (view_address == 0 && view_time == 0)
{
updateZoomFactors();
}
// Otherwise, repaint at the same zoom level, thus showing more stuff if you increase window size, less stuff if you decrease it
emit positionChange(displayAddressToRealAddress(view_address), view_time);
update();
}
void RenderGeometryMap::pushMappingsToAncestor(
const RenderObject* renderer,
const RenderBox* ancestorRenderer) {
// We need to push mappings in reverse order here, so do insertions rather
// than appends.
TemporaryChange<size_t> positionChange(m_insertionPosition, m_mapping.size());
do {
renderer = renderer->pushMappingToContainer(ancestorRenderer, *this);
} while (renderer && renderer != ancestorRenderer);
ASSERT(m_mapping.isEmpty() || isTopmostRenderView(m_mapping[0].m_renderer));
}
void bubbleSort(List *list) {
int swap, i, j;
int size = getListSize(list);
swap = 1;
while (swap) {
swap = 0;
for (j = 0; j < size - 1; j++) {
if (getNumber(list, j) > getNumber(list, (j + 1))) {
positionChange(list, (j + 1), (j));
swap = 1;
}
}
if (swap)
show(list);
}
}
void selectionSort(List *list) {
int menor, i, j, aux, mudou = 0;
int size = getListSize(list);
for (i = 0; i < size - 1; i++) {
menor = i;
for (j = i + 1; j < size; j++) {
if (getNumber(list, menor) > getNumber(list, j)) {
menor = j;
mudou = 1;
}
}
positionChange(list, menor, i);
if (mudou) {
show(list);
mudou = 0;
}
}
}
void RenderGeometryMap::pushMappingsToAncestor(const RenderLayer* layer, const RenderLayer* ancestorLayer)
{
const RenderObject* renderer = layer->renderer();
// The simple case can be handled fast in the layer tree.
bool canConvertInLayerTree = ancestorLayer ? canMapViaLayer(ancestorLayer) : false;
for (const RenderLayer* current = layer; current != ancestorLayer && canConvertInLayerTree; current = current->parent())
canConvertInLayerTree = canMapViaLayer(current);
if (canConvertInLayerTree) {
TemporaryChange<size_t> positionChange(m_insertionPosition, m_mapping.size());
LayoutPoint layerOffset;
layer->convertToLayerCoords(ancestorLayer, layerOffset);
push(renderer, toLayoutSize(layerOffset), /*accumulatingTransform*/ true, /*isNonUniform*/ false, /*isFixedPosition*/ false, /*hasTransform*/ false);
return;
}
const RenderBoxModelObject* ancestorRenderer = ancestorLayer ? ancestorLayer->renderer() : 0;
pushMappingsToAncestor(renderer, ancestorRenderer);
}
void RenderGeometryMap::pushMappingsToAncestor(
const RenderLayer* layer,
const RenderLayer* ancestorLayer) {
const RenderObject* renderer = layer->renderer();
bool crossDocument = false;
ASSERT(!crossDocument || m_mapCoordinatesFlags & TraverseDocumentBoundaries);
// We have to visit all the renderers to detect flipped blocks. This might
// defeat the gains from mapping via layers.
bool canConvertInLayerTree =
(ancestorLayer && !crossDocument)
? canMapBetweenRenderers(layer->renderer(), ancestorLayer->renderer())
: false;
// fprintf(stderr, "RenderGeometryMap::pushMappingsToAncestor from layer %p
// to layer %p, canConvertInLayerTree=%d\n", layer, ancestorLayer,
// canConvertInLayerTree);
if (canConvertInLayerTree) {
LayoutPoint layerOffset;
layer->convertToLayerCoords(ancestorLayer, layerOffset);
// The RenderView must be pushed first.
if (!m_mapping.size()) {
ASSERT(ancestorLayer->renderer()->isRenderView());
pushMappingsToAncestor(ancestorLayer->renderer(), 0);
}
TemporaryChange<size_t> positionChange(m_insertionPosition,
m_mapping.size());
bool accumulatingTransform =
layer->renderer()->style()->preserves3D() ||
ancestorLayer->renderer()->style()->preserves3D();
push(renderer, toLayoutSize(layerOffset), accumulatingTransform,
/*isNonUniform*/ false, /*hasTransform*/ false);
return;
}
const RenderBox* ancestorRenderer =
ancestorLayer ? ancestorLayer->renderer() : 0;
pushMappingsToAncestor(renderer, ancestorRenderer);
}
void insertionSort(List *list) {
printf("size: %d \n", getListSize(list));
int key, i, j, mudou = 0;
int size = getListSize(list);
for (j = 1; j < size; j++) {
key = getNumber(list, j);
i = j - 1;
while (i >= 0 && getNumber(list, i) > key) {
positionChange(list, (i + 1), i);
i = i - 1;
mudou = 1;
}
get(list, i + 1)->number = key;
if (mudou) {
mudou = 0;
show(list);
}
}
}
void Scrollbar::setScrollPosition(int position)
{
if (position > length - visibleLength) {
position = length - visibleLength;
}
if (position < 0) {
position = 0;
}
int oldPosition = scrollPosition;
scrollPosition = position;
if (position != oldPosition) {
ChangeEvent<int> positionChange(shared_from_this(), "scrollPosition", oldPosition, scrollPosition);
onScrollPositionChange(positionChange);
}
repaint();
}
void shellSort(List *list) {
int size = getListSize(list);
int i = size / 2;
int chave, k, mudou;
while (i != 0) {
do {
chave = 1;
mudou = 0;
for (k = 0; k < size - i; k++) {
if (getNumber(list, k) > getNumber(list, (k + 1))) {
positionChange(list, k, (k + 1));
chave = 0;
mudou = 1;
}
}
if (mudou)
show(list);
} while (chave == 0);
i = i / 2;
}
}
ReturnValue Tile::__queryAdd(int32_t index, const Thing* thing, uint32_t count,
uint32_t flags, Creature* actor/* = NULL*/) const
{
const CreatureVector* creatures = getCreatures();
const TileItemVector* items = getItemList();
if (const Creature* creature = thing->getCreature()) {
if (hasBitSet(FLAG_NOLIMIT, flags)) {
return RET_NOERROR;
}
if (hasBitSet(FLAG_PATHFINDING, flags)) {
if (floorChange() || positionChange()) {
return RET_NOTPOSSIBLE;
}
}
if (ground == NULL) {
return RET_NOTPOSSIBLE;
}
if (const Monster* monster = creature->getMonster()) {
if (hasFlag(TILESTATE_PROTECTIONZONE)) {
return RET_NOTPOSSIBLE;
}
if (floorChange() || positionChange()) {
return RET_NOTPOSSIBLE;
}
if (monster->canPushCreatures() && !monster->isSummon()) {
if (creatures) {
Creature* creature;
for (uint32_t i = 0; i < creatures->size(); ++i) {
creature = creatures->at(i);
if (creature->getPlayer() && creature->getPlayer()->isInGhostMode()) {
continue;
}
const Monster* creatureMonster = creature->getMonster();
if (!creatureMonster || !creature->isPushable() ||
(creatureMonster->isSummon() && creatureMonster->getMaster()->getPlayer())) {
return RET_NOTPOSSIBLE;
}
}
}
} else if (creatures && !creatures->empty()) {
for (CreatureVector::const_iterator cit = creatures->begin(); cit != creatures->end(); ++cit) {
if (!(*cit)->isInGhostMode()) {
return RET_NOTENOUGHROOM;
}
}
}
if (hasFlag(TILESTATE_IMMOVABLEBLOCKSOLID)) {
return RET_NOTPOSSIBLE;
}
if (hasBitSet(FLAG_PATHFINDING, flags) && hasFlag(TILESTATE_IMMOVABLENOFIELDBLOCKPATH)) {
return RET_NOTPOSSIBLE;
}
if (hasFlag(TILESTATE_BLOCKSOLID) || (hasBitSet(FLAG_PATHFINDING, flags) && hasFlag(TILESTATE_NOFIELDBLOCKPATH))) {
if (!(monster->canPushItems() || hasBitSet(FLAG_IGNOREBLOCKITEM, flags))) {
return RET_NOTPOSSIBLE;
}
}
MagicField* field = getFieldItem();
if (field && !field->isBlocking()) {
CombatType_t combatType = field->getCombatType();
//There is 3 options for a monster to enter a magic field
//1) Monster is immune
if (!monster->isImmune(combatType)) {
//1) Monster is "strong" enough to handle the damage
//2) Monster is already afflicated by this type of condition
if (hasBitSet(FLAG_IGNOREFIELDDAMAGE, flags)) {
if (!(monster->canPushItems() || monster->hasCondition(Combat::DamageToConditionType(combatType)))) {
return RET_NOTPOSSIBLE;
}
} else {
return RET_NOTPOSSIBLE;
}
}
}
return RET_NOERROR;
} else if (const Player* player = creature->getPlayer()) {
if (creatures && !creatures->empty() && !hasBitSet(FLAG_IGNOREBLOCKCREATURE, flags) && !player->isAccessPlayer()) {
for (CreatureVector::const_iterator cit = creatures->begin(); cit != creatures->end(); ++cit) {
if (!player->canWalkthrough(*cit)) {
return RET_NOTPOSSIBLE;
}
}
}
if (player->getParent() == NULL && hasFlag(TILESTATE_NOLOGOUT)) {
//player is trying to login to a "no logout" tile
return RET_NOTPOSSIBLE;
}
if (player->getTile() && player->isPzLocked()) {
if (!player->getTile()->hasFlag(TILESTATE_PVPZONE)) {
//player is trying to enter a pvp zone while being pz-locked
if (hasFlag(TILESTATE_PVPZONE)) {
return RET_PLAYERISPZLOCKEDENTERPVPZONE;
}
} else if (!hasFlag(TILESTATE_PVPZONE)) { //player is trying to leave a pvp zone while being pz-locked
return RET_PLAYERISPZLOCKEDLEAVEPVPZONE;
}
}
if ((hasFlag(TILESTATE_NOPVPZONE) || hasFlag(TILESTATE_PROTECTIONZONE)) && player->isPzLocked()) {
return RET_PLAYERISPZLOCKED;
}
} else if (creatures && !creatures->empty() && !hasBitSet(FLAG_IGNOREBLOCKCREATURE, flags)) {
for (CreatureVector::const_iterator cit = creatures->begin(); cit != creatures->end(); ++cit) {
if (!(*cit)->isInGhostMode()) {
return RET_NOTENOUGHROOM;
}
}
}
if (items) {
if (!hasBitSet(FLAG_IGNOREBLOCKITEM, flags)) {
//If the FLAG_IGNOREBLOCKITEM bit isn't set we dont have to iterate every single item
if (hasFlag(TILESTATE_BLOCKSOLID)) {
return RET_NOTENOUGHROOM;
}
} else {
//FLAG_IGNOREBLOCKITEM is set
if (ground) {
const ItemType& iiType = Item::items[ground->getID()];
if (iiType.blockSolid && (!iiType.moveable || ground->getUniqueId() != 0)) {
return RET_NOTPOSSIBLE;
}
}
if (const TileItemVector* items = getItemList()) {
Item* iitem;
for (ItemVector::const_iterator it = items->begin(); it != items->end(); ++it) {
iitem = (*it);
const ItemType& iiType = Item::items[iitem->getID()];
if (iiType.blockSolid && (!iiType.moveable || iitem->getUniqueId() != 0)) {
return RET_NOTPOSSIBLE;
}
}
}
}
}
} else if (const Item* item = thing->getItem()) {
if (items && items->size() >= 0xFFFF) {
return RET_NOTPOSSIBLE;
}
if (hasBitSet(FLAG_NOLIMIT, flags)) {
return RET_NOERROR;
}
bool itemIsHangable = item->isHangable();
if (ground == NULL && !itemIsHangable) {
return RET_NOTPOSSIBLE;
}
if (creatures && !creatures->empty() && item->isBlocking() && !hasBitSet(FLAG_IGNOREBLOCKCREATURE, flags)) {
for (CreatureVector::const_iterator cit = creatures->begin(); cit != creatures->end(); ++cit) {
if (!(*cit)->isInGhostMode()) {
return RET_NOTENOUGHROOM;
}
}
}
if (itemIsHangable && hasFlag(TILESTATE_SUPPORTS_HANGABLE)) {
if (items) {
for (ItemVector::const_iterator it = items->begin(), end = items->end(); it != end; ++it) {
if ((*it)->isHangable()) {
return RET_NEEDEXCHANGE;
}
}
}
} else {
if (ground) {
const ItemType& iiType = Item::items[ground->getID()];
if (iiType.blockSolid) {
if (!iiType.allowPickupable || item->isMagicField() || item->isBlocking()) {
if (!item->isPickupable()) {
return RET_NOTENOUGHROOM;
}
if (!iiType.hasHeight || iiType.pickupable || iiType.isBed()) {
return RET_NOTENOUGHROOM;
}
}
}
}
if (items) {
for (ItemVector::const_iterator it = items->begin(), end = items->end(); it != end; ++it) {
const ItemType& iiType = Item::items[(*it)->getID()];
if (!iiType.blockSolid) {
continue;
}
if (iiType.allowPickupable && !item->isMagicField() && !item->isBlocking()) {
continue;
}
if (!item->isPickupable()) {
return RET_NOTENOUGHROOM;
}
if (!iiType.hasHeight || iiType.pickupable || iiType.isBed()) {
return RET_NOTENOUGHROOM;
}
}
}
}
}
return RET_NOERROR;
}
ReturnValue Tile::__queryAdd(int32_t index, const Thing* thing, uint32_t count,
uint32_t flags) const
{
const CreatureVector* creatures = getCreatures();
const TileItemVector* items = getItemList();
if(const Creature* creature = thing->getCreature())
{
if(ground)
{
if(const Monster* monster = creature->getMonster())
{
const ItemType& iType = Item::items[ground->getID()];
if(ground->getID() == 11756)
return RET_NOTPOSSIBLE;
if(ground->getID() == 4821)
return RET_NOTPOSSIBLE;
if(ground->getID() == 4822)
return RET_NOTPOSSIBLE;
if(ground->getID() == 4823)
return RET_NOTPOSSIBLE;
if(ground->getID() == 4824)
return RET_NOTPOSSIBLE;
if(ground->getID() == 4825)
return RET_NOTPOSSIBLE;
}
}
if(hasBitSet(FLAG_NOLIMIT, flags))
return RET_NOERROR;
if(hasBitSet(FLAG_PATHFINDING, flags))
{
if(floorChange() || positionChange())
return RET_NOTPOSSIBLE;
}
if(!ground)
return RET_NOTPOSSIBLE;
if(const Monster* monster = creature->getMonster())
{
if((hasFlag(TILESTATE_PROTECTIONZONE)) && monster->isSummon())
return RET_NOERROR;
if(floorChange() || positionChange())
return RET_NOTPOSSIBLE;
if(monster->canPushCreatures() && !monster->isSummon())
{
if(creatures)
{
Creature* tmp = NULL;
for(uint32_t i = 0; i < creatures->size(); ++i)
{
tmp = creatures->at(i);
if(creature->canWalkthrough(tmp))
continue;
if(!tmp->getMonster() || !tmp->isPushable() ||
(tmp->getMonster()->isSummon() &&
tmp->getMonster()->isPlayerSummon()))
return RET_NOTPOSSIBLE;
}
}
}
else if(creatures && !creatures->empty())
{
for(CreatureVector::const_iterator cit = creatures->begin(); cit != creatures->end(); ++cit)
{
if(!creature->canWalkthrough(*cit))
return RET_NOTENOUGHROOM;
}
}
if(hasFlag(TILESTATE_IMMOVABLEBLOCKSOLID))
return RET_NOTPOSSIBLE;
if(hasBitSet(FLAG_PATHFINDING, flags) && hasFlag(TILESTATE_IMMOVABLENOFIELDBLOCKPATH))
return RET_NOTPOSSIBLE;
if((hasFlag(TILESTATE_BLOCKSOLID) || (hasBitSet(FLAG_PATHFINDING, flags) && hasFlag(TILESTATE_NOFIELDBLOCKPATH)))
&& (!(monster->canPushItems() || hasBitSet(FLAG_IGNOREBLOCKITEM, flags))))
return RET_NOTPOSSIBLE;
MagicField* field = getFieldItem();
if(field && !field->isBlocking(monster))
{
CombatType_t combatType = field->getCombatType();
//There is 3 options for a monster to enter a magic field
//1) Monster is immune
if(!monster->isImmune(combatType))
{
//1) Monster is "strong" enough to handle the damage
//2) Monster is already afflicated by this type of condition
if(!hasBitSet(FLAG_IGNOREFIELDDAMAGE, flags))
return RET_NOTPOSSIBLE;
if(!monster->canPushItems() && !monster->hasCondition(
Combat::DamageToConditionType(combatType), false))
return RET_NOTPOSSIBLE;
}
}
return RET_NOERROR;
}
else if(const Player* player = creature->getPlayer())
{
if(creatures && !creatures->empty() && !hasBitSet(FLAG_IGNOREBLOCKCREATURE, flags))
{
for(CreatureVector::const_iterator cit = creatures->begin(); cit != creatures->end(); ++cit)
{
if(!creature->canWalkthrough(*cit))
return RET_NOTENOUGHROOM; //RET_NOTPOSSIBLE
}
}
if(!player->getParent() && hasFlag(TILESTATE_NOLOGOUT)) //player is trying to login to a "no logout" tile
return RET_NOTPOSSIBLE;
if(player->isPzLocked() && !player->getTile()->hasFlag(TILESTATE_PVPZONE) && hasFlag(TILESTATE_PVPZONE)) //player is trying to enter a pvp zone while being pz-locked
return RET_PLAYERISPZLOCKEDENTERPVPZONE;
if(player->isPzLocked() && player->getTile()->hasFlag(TILESTATE_PVPZONE) && !hasFlag(TILESTATE_PVPZONE)) //player is trying to leave a pvp zone while being pz-locked
return RET_PLAYERISPZLOCKEDLEAVEPVPZONE;
if(hasFlag(TILESTATE_NOPVPZONE) && player->isPzLocked())
return RET_PLAYERISPZLOCKED;
if(hasFlag(TILESTATE_PROTECTIONZONE) && player->isPzLocked())
return RET_PLAYERISPZLOCKED;
}
else if(creatures && !creatures->empty() && !hasBitSet(FLAG_IGNOREBLOCKCREATURE, flags))
{
for(CreatureVector::const_iterator cit = creatures->begin(); cit != creatures->end(); ++cit)
{
if(!creature->canWalkthrough(*cit))
return RET_NOTENOUGHROOM;
}
}
if(items)
{
MagicField* field = getFieldItem();
if(field && field->isBlocking(creature))
return RET_NOTPOSSIBLE;
if(!hasBitSet(FLAG_IGNOREBLOCKITEM, flags))
{
//If the FLAG_IGNOREBLOCKITEM bit isn't set we dont have to iterate every single item
if(hasFlag(TILESTATE_BLOCKSOLID))
return RET_NOTENOUGHROOM;
}
else
{
//FLAG_IGNOREBLOCKITEM is set
if(ground)
{
const ItemType& iType = Item::items[ground->getID()];
if(ground->isBlocking(creature) && (!iType.moveable || (ground->isLoadedFromMap() &&
(ground->getUniqueId() || (ground->getActionId()
&& ground->getContainer())))))
return RET_NOTPOSSIBLE;
}
if(const TileItemVector* items = getItemList())
{
Item* iItem = NULL;
for(ItemVector::const_iterator it = items->begin(); it != items->end(); ++it)
{
iItem = (*it);
const ItemType& iType = Item::items[iItem->getID()];
if(iItem->isBlocking(creature) && (!iType.moveable || (iItem->isLoadedFromMap() &&
(iItem->getUniqueId() || (iItem->getActionId()
&& iItem->getContainer())))))
return RET_NOTPOSSIBLE;
}
}
}
}
}
else if(const Item* item = thing->getItem())
{
#ifdef __DEBUG__
if(thing->getParent() == NULL && !hasBitSet(FLAG_NOLIMIT, flags))
std::cout << "[Notice - Tile::__queryAdd] thing->getParent() == NULL" << std::endl;
#endif
if(items && items->size() >= 0xFFFF)
return RET_NOTPOSSIBLE;
if(hasBitSet(FLAG_NOLIMIT, flags))
return RET_NOERROR;
bool itemIsHangable = item->isHangable();
if(!ground && !itemIsHangable)
return RET_NOTPOSSIBLE;
if(creatures && !creatures->empty() && !hasBitSet(FLAG_IGNOREBLOCKCREATURE, flags))
{
for(CreatureVector::const_iterator cit = creatures->begin(); cit != creatures->end(); ++cit)
{
if(!(*cit)->isGhost() && item->isBlocking(*cit))
return RET_NOTENOUGHROOM;
}
}
if(hasFlag(TILESTATE_PROTECTIONZONE))
{
const uint32_t itemLimit = g_config.getNumber(ConfigManager::ITEMLIMIT_PROTECTIONZONE);
if(itemLimit && getThingCount() > itemLimit)
return RET_TILEISFULL;
}
bool hasHangable = false, supportHangable = false;
if(items)
{
Thing* iThing = NULL;
for(uint32_t i = 0; i < getThingCount(); ++i)
{
iThing = __getThing(i);
if(const Item* iItem = iThing->getItem())
{
const ItemType& iType = Item::items[iItem->getID()];
if(iType.isHangable)
hasHangable = true;
if(iType.isHorizontal || iType.isVertical)
supportHangable = true;
if(itemIsHangable && (iType.isHorizontal || iType.isVertical))
continue;
else if(iType.blockSolid)
{
if(!item->isPickupable())
return RET_NOTENOUGHROOM;
if(iType.allowPickupable)
continue;
if(!iType.hasHeight || iType.pickupable || iType.isBed())
return RET_NOTENOUGHROOM;
}
}
}
}
if(itemIsHangable && hasHangable && supportHangable)
return RET_NEEDEXCHANGE;
}
return RET_NOERROR;
}
void TMGraphView::setAddress(unsigned long long address)
{
view_address = realAddressToDisplayAddress(address);
emit positionChange(address, view_time);
update();
}
void TMGraphView::setTime(unsigned long long time)
{
view_time = time;
emit positionChange(displayAddressToRealAddress(view_address), view_time);
update();
}
KMixApplet::KMixApplet( const QString& configFile, Type t,
QWidget *parent, const char *name )
: KPanelApplet( configFile, t, KPanelApplet::Preferences | KPanelApplet::ReportBug | KPanelApplet::About, parent, name ),
m_mixerWidget(0), m_errorLabel(0), m_pref(0),
m_aboutData( "kmix", I18N_NOOP("KMix Panel Applet"),
APP_VERSION, "Mini Sound Mixer Applet", KAboutData::License_GPL,
I18N_NOOP( "(c) 1996-2000 Christian Esken\n(c) 2000-2003 Christian Esken, Stefan Schimanski") )
{
setBackgroundOrigin(AncestorOrigin);
kdDebug(67100) << "KMixApplet::KMixApplet instancing Applet. Old s_instCount="<< s_instCount << " configfile=" << configFile << endl;
//kdDebug(67100) << "KMixApplet::KMixApplet()" << endl;
_layout = new QHBoxLayout(this); // it will always only be one item in it, so we don't care whether it is HBox or VBox
// init static vars
if ( s_instCount == 0) {
Mixer::mixers().setAutoDelete( TRUE );
QString dummyStringHwinfo;
MixerToolBox::initMixer(Mixer::mixers(), false, dummyStringHwinfo);
}
s_instCount++;
kdDebug(67100) << "KMixApplet::KMixApplet instancing Applet, s_instCount="<< s_instCount << endl;
KGlobal::dirs()->addResourceType( "appicon", KStandardDirs::kde_default("data") + "kmix/pics" );
loadConfig();
/********** find out to use which mixer ****************************************/
_mixer = 0;
for (_mixer= Mixer::mixers().first(); _mixer!=0; _mixer=Mixer::mixers().next())
{
if ( _mixer->id() == _mixerId ) break;
}
if ( _mixer == 0 ) {
/* Until KMix V3.4-0 the mixerNumber (int) was stored. This was too complicated to handle, so we use an
* unique ID (_mixer->mixerId(). But in case when the user changes soundcards (or when upgrading from
* KMix 3.4-0 to a 3.4-1 or newer), we scan also for the soundcard name */
for (_mixer= Mixer::mixers().first(); _mixer!=0; _mixer=Mixer::mixers().next())
{
if ( _mixer->mixerName() == _mixerName ) break;
}
}
// don't prompt for a mixer if there is just one available
if ( !_mixer && Mixer::mixers().count() == 1 ) {
_mixer = Mixer::mixers().first();
}
if ( _mixer == 0 )
{
// No mixer set by user (kmixappletrc_*) and more than one to choose
// We do NOT know which mixer to use => ask the User
m_errorLabel = new QPushButton( i18n("Select Mixer"), this );
m_errorLabel->setGeometry(0, 0, m_errorLabel->sizeHint().width(), m_errorLabel->sizeHint().height() );
resize( m_errorLabel->sizeHint() );
connect( m_errorLabel, SIGNAL(clicked()), this, SLOT(selectMixer()) );
}
else {
// We know which mixer to use: Call positionChange(), which does all the creating
positionChange(position());
}
m_aboutData.addCredit( I18N_NOOP( "For detailed credits, please refer to the About information of the KMix program" ) );
}
ReturnValue Tile::__queryAdd(int32_t index, const Thing* thing, uint32_t count,
uint32_t flags) const
{
const CreatureVector* creatures = getCreatures();
const TileItemVector* items = getItemList();
if (const Creature* creature = thing->getCreature())
{
if (hasBitSet(FLAG_NOLIMIT, flags))
{
return RET_NOERROR;
}
if (hasBitSet(FLAG_PATHFINDING, flags))
{
if (floorChange() || positionChange())
{
return RET_NOTPOSSIBLE;
}
}
if (!ground)
{
return RET_NOTPOSSIBLE;
}
if (const Monster* monster = creature->getMonster())
{
if (hasFlag(TILESTATE_PROTECTIONZONE))
{
return RET_NOTPOSSIBLE;
}
if (floorChange() || positionChange())
{
return RET_NOTPOSSIBLE;
}
if (monster->canPushCreatures() && !monster->isSummon())
{
if (creatures)
{
Creature* creature;
for (uint32_t i = 0; i < creatures->size(); ++i)
{
creature = creatures->at(i);
if (monster->canWalkthrough(creature))
{
continue;
}
if (!creature->getMonster() ||
!creature->isPushable() ||
(creature->getMonster()->isPlayerSummon()))
{
return RET_NOTPOSSIBLE;
}
}
}
}
else if (creatures && !creatures->empty())
{
for (CreatureVector::const_iterator cit = creatures->begin(); cit != creatures->end(); ++cit)
{
if (!monster->canWalkthrough(*cit))
{
return RET_NOTENOUGHROOM;
}
}
}
if (hasFlag(TILESTATE_IMMOVABLEBLOCKSOLID))
{
return RET_NOTPOSSIBLE;
}
if (hasBitSet(FLAG_PATHFINDING, flags) && hasFlag(TILESTATE_IMMOVABLENOFIELDBLOCKPATH))
{
return RET_NOTPOSSIBLE;
}
if (hasFlag(TILESTATE_BLOCKSOLID) || (hasBitSet(FLAG_PATHFINDING, flags) && hasFlag(TILESTATE_NOFIELDBLOCKPATH)))
{
if (!(monster->canPushItems() || hasBitSet(FLAG_IGNOREBLOCKITEM, flags)))
{
return RET_NOTPOSSIBLE;
}
}
MagicField* field = getFieldItem();
if (field && !field->isBlocking(monster))
{
CombatType_t combatType = field->getCombatType();
//There are 3 options for a monster to enter a magic field
//1) Monster is immune
if (!monster->isImmune(combatType))
{
//2) Monster is "strong" enough to handle the damage and was attacked
//3) Monster is already afflicated by this type of condition
if (hasBitSet(FLAG_IGNOREFIELDDAMAGE, flags))
{
if (!monster->hasCondition(Combat::DamageToConditionType(combatType), false))
{
if (!monster->canPushItems() || !monster->hadRecentBattle())
{
return RET_NOTPOSSIBLE;
}
}
}
else
{
return RET_NOTPOSSIBLE;
}
}
}
}
else if (const Player* player = creature->getPlayer())
{
if (creatures && !creatures->empty() && !hasBitSet(FLAG_IGNOREBLOCKCREATURE, flags))
{
for (CreatureVector::const_iterator cit = creatures->begin(); cit != creatures->end(); ++cit)
{
if (!player->canWalkthrough(*cit))
{
return RET_NOTENOUGHROOM; //RET_NOTPOSSIBLE
}
}
}
if (!player->getParent() && hasFlag(TILESTATE_NOLOGOUT))
{
//player is trying to login to a "no logout" tile
return RET_NOTPOSSIBLE;
}
if (player->getTile())
{
if (player->isPzLocked() && !player->getTile()->hasFlag(TILESTATE_PVPZONE) && hasFlag(TILESTATE_PVPZONE))
{
//player is trying to enter a pvp zone while being pz-locked
return RET_PLAYERISPZLOCKEDENTERPVPZONE;
}
if (player->isPzLocked() && player->getTile()->hasFlag(TILESTATE_PVPZONE) && !hasFlag(TILESTATE_PVPZONE))
{
//player is trying to leave a pvp zone while being pz-locked
return RET_PLAYERISPZLOCKEDLEAVEPVPZONE;
}
}
if (hasFlag(TILESTATE_NOPVPZONE) && player->isPzLocked())
{
return RET_PLAYERISPZLOCKED;
}
if (hasFlag(TILESTATE_PROTECTIONZONE) && player->isPzLocked())
{
return RET_PLAYERISPZLOCKED;
}
}
else
{
if (creatures && !creatures->empty() && !hasBitSet(FLAG_IGNOREBLOCKCREATURE, flags))
{
for (CreatureVector::const_iterator cit = creatures->begin(); cit != creatures->end(); ++cit)
{
if (!creature->canWalkthrough(*cit))
{
return RET_NOTENOUGHROOM;
}
}
}
}
if (items)
{
MagicField* field = getFieldItem();
if (field && field->isBlocking(creature))
{
return RET_NOTPOSSIBLE;
}
if (!hasBitSet(FLAG_IGNOREBLOCKITEM, flags))
{
//If the FLAG_IGNOREBLOCKITEM bit isn't set we dont have to iterate every single item
if (hasFlag(TILESTATE_BLOCKSOLID))
{
return RET_NOTENOUGHROOM;
}
}
else
{
//FLAG_IGNOREBLOCKITEM is set
if (ground)
{
const ItemType& iiType = Item::items[ground->getID()];
if (ground->isBlocking(creature) && (!iiType.moveable || ground->getUniqueId() != 0))
{
return RET_NOTPOSSIBLE;
}
}
if (const TileItemVector* items = getItemList())
{
Item* iitem;
for (ItemVector::const_iterator it = items->begin(); it != items->end(); ++it)
{
iitem = (*it);
const ItemType& iiType = Item::items[iitem->getID()];
if (iitem->isBlocking(creature) && (!iiType.moveable || iitem->getUniqueId() != 0))
{
return RET_NOTPOSSIBLE;
}
}
}
}
}
}
else if (const Item* item = thing->getItem())
{
#ifdef __DEBUG__
if (!thing->getParent() && !hasBitSet(FLAG_NOLIMIT, flags))
{
std::cout << "Notice: Tile::__queryAdd() - thing->getParent() == NULL" << std::endl;
}
#endif
if (items)
{
int64_t c = g_config.getNumber(ConfigManager::MAX_STACK_SIZE);
//acceptable stack sizes should be higher than 100 and <= than 65535
uint16_t max_stack_size = uint16_t(std::max(std::min(c, int64_t(0xFFFF)), int64_t(100)));
if (items->size() >= max_stack_size)
{
return RET_NOTPOSSIBLE;
}
}
if (hasBitSet(FLAG_NOLIMIT, flags))
{
return RET_NOERROR;
}
bool itemIsHangable = item->isHangable();
if (!ground && !itemIsHangable)
{
return RET_NOTPOSSIBLE;
}
if (creatures && !creatures->empty() && !hasBitSet(FLAG_IGNOREBLOCKCREATURE, flags))
{
for (CreatureVector::const_iterator cit = creatures->begin(); cit != creatures->end(); ++cit)
{
if ((!(*cit)->getPlayer() || !(*cit)->getPlayer()->hasSomeInvisibilityFlag()) && item->isBlocking(*cit))
{
return RET_NOTENOUGHROOM;
}
}
}
const uint32_t itemLimit = g_config.getNumber(hasFlag(TILESTATE_PROTECTIONZONE) ? ConfigManager::PROTECTION_TILE_LIMIT : ConfigManager::TILE_LIMIT);
if (itemLimit && getThingCount() > itemLimit)
{
return RET_TILEISFULL;
}
bool hasHangable = false;
bool supportHangable = false;
if (items)
{
Thing* iithing = NULL;
for (uint32_t i = 0; i < getThingCount(); ++i)
{
iithing = __getThing(i);
if (const Item* iitem = iithing->getItem())
{
const ItemType& iiType = Item::items[iitem->getID()];
if (iiType.isHangable)
{
hasHangable = true;
}
if (iiType.isHorizontal || iiType.isVertical)
{
supportHangable = true;
}
if (itemIsHangable && (iiType.isHorizontal || iiType.isVertical))
{
//
}
else if (iiType.blockSolid || iiType.isSolidForItems())
{
if (item->isPickupable())
{
if (iiType.allowPickupable)
{
continue;
}
if (!iiType.hasHeight || iiType.pickupable || iiType.isBed())
{
return RET_NOTENOUGHROOM;
}
}
else
{
return RET_NOTENOUGHROOM;
}
}
}
}
}
if (itemIsHangable && hasHangable && supportHangable)
{
return RET_NEEDEXCHANGE;
}
}
return RET_NOERROR;
}
ReturnValue Tile::queryAdd(int32_t, const Thing& thing, uint32_t, uint32_t flags, Creature*) const
{
if (const Creature* creature = thing.getCreature()) {
if (hasBitSet(FLAG_NOLIMIT, flags)) {
return RETURNVALUE_NOERROR;
}
if (hasBitSet(FLAG_PATHFINDING, flags)) {
if (floorChange() || positionChange()) {
return RETURNVALUE_NOTPOSSIBLE;
}
}
if (ground == nullptr) {
return RETURNVALUE_NOTPOSSIBLE;
}
if (const Monster* monster = creature->getMonster()) {
if (hasFlag(TILESTATE_PROTECTIONZONE)) {
return RETURNVALUE_NOTPOSSIBLE;
}
if (floorChange() || positionChange()) {
return RETURNVALUE_NOTPOSSIBLE;
}
const CreatureVector* creatures = getCreatures();
if (monster->canPushCreatures() && !monster->isSummon()) {
if (creatures) {
for (Creature* tileCreature : *creatures) {
if (tileCreature->getPlayer() && tileCreature->getPlayer()->isInGhostMode()) {
continue;
}
const Monster* creatureMonster = tileCreature->getMonster();
if (!creatureMonster || !tileCreature->isPushable() ||
(creatureMonster->isSummon() && creatureMonster->getMaster()->getPlayer())) {
return RETURNVALUE_NOTPOSSIBLE;
}
}
}
} else if (creatures && !creatures->empty()) {
for (const Creature* tileCreature : *creatures) {
if (!tileCreature->isInGhostMode()) {
return RETURNVALUE_NOTENOUGHROOM;
}
}
}
if (hasFlag(TILESTATE_IMMOVABLEBLOCKSOLID)) {
return RETURNVALUE_NOTPOSSIBLE;
}
if (hasBitSet(FLAG_PATHFINDING, flags) && hasFlag(TILESTATE_IMMOVABLENOFIELDBLOCKPATH)) {
return RETURNVALUE_NOTPOSSIBLE;
}
if (hasFlag(TILESTATE_BLOCKSOLID) || (hasBitSet(FLAG_PATHFINDING, flags) && hasFlag(TILESTATE_NOFIELDBLOCKPATH))) {
if (!(monster->canPushItems() || hasBitSet(FLAG_IGNOREBLOCKITEM, flags))) {
return RETURNVALUE_NOTPOSSIBLE;
}
}
MagicField* field = getFieldItem();
if (field && !field->isBlocking()) {
CombatType_t combatType = field->getCombatType();
//There is 3 options for a monster to enter a magic field
//1) Monster is immune
if (!monster->isImmune(combatType)) {
//1) Monster is "strong" enough to handle the damage
//2) Monster is already afflicated by this type of condition
if (hasBitSet(FLAG_IGNOREFIELDDAMAGE, flags)) {
if (!(monster->canPushItems() || monster->hasCondition(Combat::DamageToConditionType(combatType)))) {
return RETURNVALUE_NOTPOSSIBLE;
}
} else {
return RETURNVALUE_NOTPOSSIBLE;
}
}
}
return RETURNVALUE_NOERROR;
}
const CreatureVector* creatures = getCreatures();
if (const Player* player = creature->getPlayer()) {
if (creatures && !creatures->empty() && !hasBitSet(FLAG_IGNOREBLOCKCREATURE, flags) && !player->isAccessPlayer()) {
for (const Creature* tileCreature : *creatures) {
if (!player->canWalkthrough(tileCreature)) {
return RETURNVALUE_NOTPOSSIBLE;
}
}
}
if (player->getParent() == nullptr && hasFlag(TILESTATE_NOLOGOUT)) {
//player is trying to login to a "no logout" tile
return RETURNVALUE_NOTPOSSIBLE;
}
const Tile* playerTile = player->getTile();
if (playerTile && player->isPzLocked()) {
if (!playerTile->hasFlag(TILESTATE_PVPZONE)) {
//player is trying to enter a pvp zone while being pz-locked
if (hasFlag(TILESTATE_PVPZONE)) {
return RETURNVALUE_PLAYERISPZLOCKEDENTERPVPZONE;
}
} else if (!hasFlag(TILESTATE_PVPZONE)) {
// player is trying to leave a pvp zone while being pz-locked
return RETURNVALUE_PLAYERISPZLOCKEDLEAVEPVPZONE;
}
if ((!playerTile->hasFlag(TILESTATE_NOPVPZONE) && hasFlag(TILESTATE_NOPVPZONE)) ||
(!playerTile->hasFlag(TILESTATE_PROTECTIONZONE) && hasFlag(TILESTATE_PROTECTIONZONE))) {
// player is trying to enter a non-pvp/protection zone while being pz-locked
return RETURNVALUE_PLAYERISPZLOCKED;
}
}
} else if (creatures && !creatures->empty() && !hasBitSet(FLAG_IGNOREBLOCKCREATURE, flags)) {
for (const Creature* tileCreature : *creatures) {
if (!tileCreature->isInGhostMode()) {
return RETURNVALUE_NOTENOUGHROOM;
}
}
}
const TileItemVector* items = getItemList();
if (items) {
if (!hasBitSet(FLAG_IGNOREBLOCKITEM, flags)) {
//If the FLAG_IGNOREBLOCKITEM bit isn't set we dont have to iterate every single item
if (hasFlag(TILESTATE_BLOCKSOLID)) {
return RETURNVALUE_NOTENOUGHROOM;
}
} else {
//FLAG_IGNOREBLOCKITEM is set
if (ground) {
const ItemType& iiType = Item::items[ground->getID()];
if (iiType.blockSolid && (!iiType.moveable || ground->hasAttribute(ITEM_ATTRIBUTE_UNIQUEID))) {
return RETURNVALUE_NOTPOSSIBLE;
}
}
for (const Item* item : *items) {
const ItemType& iiType = Item::items[item->getID()];
if (iiType.blockSolid && (!iiType.moveable || item->hasAttribute(ITEM_ATTRIBUTE_UNIQUEID))) {
return RETURNVALUE_NOTPOSSIBLE;
}
}
}
}
} else if (const Item* item = thing.getItem()) {
const TileItemVector* items = getItemList();
if (items && items->size() >= 0xFFFF) {
return RETURNVALUE_NOTPOSSIBLE;
}
if (hasBitSet(FLAG_NOLIMIT, flags)) {
return RETURNVALUE_NOERROR;
}
bool itemIsHangable = item->isHangable();
if (ground == nullptr && !itemIsHangable) {
return RETURNVALUE_NOTPOSSIBLE;
}
const CreatureVector* creatures = getCreatures();
if (creatures && !creatures->empty() && item->isBlocking() && !hasBitSet(FLAG_IGNOREBLOCKCREATURE, flags)) {
for (const Creature* tileCreature : *creatures) {
if (!tileCreature->isInGhostMode()) {
return RETURNVALUE_NOTENOUGHROOM;
}
}
}
if (itemIsHangable && hasFlag(TILESTATE_SUPPORTS_HANGABLE)) {
if (items) {
for (const Item* tileItem : *items) {
if (tileItem->isHangable()) {
return RETURNVALUE_NEEDEXCHANGE;
}
}
}
} else {
if (ground) {
const ItemType& iiType = Item::items[ground->getID()];
if (iiType.blockSolid) {
if (!iiType.allowPickupable || item->isMagicField() || item->isBlocking()) {
if (!item->isPickupable()) {
return RETURNVALUE_NOTENOUGHROOM;
}
if (!iiType.hasHeight || iiType.pickupable || iiType.isBed()) {
return RETURNVALUE_NOTENOUGHROOM;
}
}
}
}
if (items) {
for (const Item* tileItem : *items) {
const ItemType& iiType = Item::items[tileItem->getID()];
if (!iiType.blockSolid) {
continue;
}
if (iiType.allowPickupable && !item->isMagicField() && !item->isBlocking()) {
continue;
}
if (!item->isPickupable()) {
return RETURNVALUE_NOTENOUGHROOM;
}
if (!iiType.hasHeight || iiType.pickupable || iiType.isBed()) {
return RETURNVALUE_NOTENOUGHROOM;
}
}
}
}
}
return RETURNVALUE_NOERROR;
}
void KPanelExtension::setPosition( Position p )
{
if( _position == p ) return;
_position = p;
positionChange( p );
}