Check if area if used.

@param mover The object moving on map.
@param ctx The horizontal tile index.
@param cty The vertical tile index.
@param ignoreObjectId The object ID to ignore.
@return <code>true</code> if area is used, <code>false</code> else.
777063
private boolean isTileNotAvailable(Pathfindable mover, int ctx, int cty, Integer ignoreObjectId)
    {
        final Collection<Integer> ids = getObjectsId(ctx, cty);
        final Tile tile = map.getTile(ctx, cty);
        if (tile != null)
        {
            final TilePath tilePath = tile.getFeature(TilePath.class);
            if (mover.isBlocking(tilePath.getCategory())
                || ignoreObjectId != null && !ids.isEmpty() && !ids.contains(ignoreObjectId))
            {
                return true;
            }
        }
        return false;
    }
1283639
private void checkBeginSelection(Cursor cursor, SelectorModel model)
    {
        final boolean canClick = !model.getClickableArea().contains(cursor.getScreenX(), cursor.getScreenY());
        if (!model.isSelecting() && !canClick)
        {
            model.setSelecting(true);
            startX = cursor.getX();
            startY = cursor.getY();

            for (final SelectorListener listener : listeners)
            {
                listener.notifySelectionStarted(Geom.createArea(startX, startY, 0, 0));
            }
        }
    }
866014
private boolean checkLargeMotion( int width , int height ) {
		if( first ) {
			getImageCorners(width,height,corners);
			previousArea = computeArea(corners);
			first = false;
		} else {
			getImageCorners(width,height,corners);

			double area = computeArea(corners);

			double change = Math.max(area/previousArea,previousArea/area)-1;
			if( change > maxJumpFraction ) {
				return true;
			}
			previousArea = area;
		}

		return false;

	}
573916
boolean moveCursor(final INodeReadTrx paramRtx, final ERevision paramRevision) throws TTIOException {
        assert paramRtx != null;

        boolean moved = false;

        final ITreeStructData node = ((ITreeStructData)paramRtx.getNode());
        if (node.hasFirstChild()) {
            if (node.getKind() != ROOT && mDiffKind == EDiffOptimized.HASHED && mHashKind != HashKind.None
                && (mDiff == EDiff.SAMEHASH || mDiff == EDiff.DELETED)) {
                moved = paramRtx.moveTo(((ITreeStructData)paramRtx.getNode()).getRightSiblingKey());

                if (!moved) {
                    moved = moveToFollowingNode(paramRtx, paramRevision);
                }
            } else {
                moved = paramRtx.moveTo(((ITreeStructData)paramRtx.getNode()).getFirstChildKey());
                if (moved) {
                    switch (paramRevision) {
                    case NEW:
                        mDepth.incrementNewDepth();
                        break;
                    case OLD:
                        mDepth.incrementOldDepth();
                        break;
                    }
                }
            }
        } else if (node.hasRightSibling()) {
            if (paramRtx.getNode().getDataKey() == mRootKey) {
                paramRtx.moveTo(ROOT_NODE);
            } else {
                moved = paramRtx.moveTo(((ITreeStructData)paramRtx.getNode()).getRightSiblingKey());
            }
        } else {
            moved = moveToFollowingNode(paramRtx, paramRevision);
        }

        return moved;
    }
238106
public void containerASCompleted(Object asKey) {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled(); // d532639.2

        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "containerASCompleted : " + asKey);

        containerASMap.remove(asKey);

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "containerASCompleted");
    }
539038
boolean checkSelectForSwipe(int action, MotionEvent motionEvent, int pointerIndex) {
        if (mSelected != null || action != MotionEvent.ACTION_MOVE
                || mActionState == ACTION_STATE_DRAG || !mCallback.isItemViewSwipeEnabled()) {
            return false;
        }
        if (mRecyclerView.getScrollState() == RecyclerView.SCROLL_STATE_DRAGGING) {
            return false;
        }
        final ViewHolder vh = findSwipedView(motionEvent);
        if (vh == null) {
            return false;
        }
        final int movementFlags = mCallback.getAbsoluteMovementFlags(mRecyclerView, vh);
        final int swipeFlags = (movementFlags & ACTION_MODE_SWIPE_MASK)
                >> (DIRECTION_FLAG_COUNT * ACTION_STATE_SWIPE);
        if (swipeFlags == 0) {
            return false;
        }
        // mDx and mDy are only set in allowed directions. We use custom x/y here instead of
        // updateDxDy to avoid swiping if user moves more in the other direction
        final float x = motionEvent.getX(pointerIndex);
        final float y = motionEvent.getY(pointerIndex);
        // Calculate the distance moved
        final float dx = x - mInitialTouchX;
        final float dy = y - mInitialTouchY;
        // swipe target is chose w/o applying flags so it does not really check if swiping in that
        // direction is allowed. This why here, we use mDx mDy to check slope value again.
        final float absDx = Math.abs(dx);
        final float absDy = Math.abs(dy);
        if (absDx < mSlop && absDy < mSlop) {
            return false;
        }
        if (absDx > absDy) {
            if (dx < 0 && (swipeFlags & LEFT) == 0) {
                return false;
            }
            if (dx > 0 && (swipeFlags & RIGHT) == 0) {
                return false;
            }
        } else {
            if (dy < 0 && (swipeFlags & UP) == 0) {
                return false;
            }
            if (dy > 0 && (swipeFlags & DOWN) == 0) {
                return false;
            }
        }
        mDx = mDy = 0f;
        mActivePointerId = motionEvent.getPointerId(0);
        select(vh, ACTION_STATE_SWIPE);
        return true;
    }
482435
function() {
            if (!this.parent) {
                Kinetic.Util.warn('Node has no parent. moveUp function is ignored.');
                return;
            }
            var index = this.index,
                len = this.parent.getChildren().length;
            if(index < len - 1) {
                this.parent.children.splice(index, 1);
                this.parent.children.splice(index + 1, 0, this);
                this.parent._setChildrenIndices();
                return true;
            }
            return false;
        }
390992
boolean checkUpdate(final INodeReadTrx paramNewRtx, final INodeReadTrx paramOldRtx) throws TTIOException {
        assert paramNewRtx != null;
        assert paramOldRtx != null;
        boolean updated = false;
        final long newKey = paramNewRtx.getNode().getDataKey();
        boolean movedNewRtx = paramNewRtx.moveTo(((ITreeStructData)paramNewRtx.getNode()).getRightSiblingKey());
        final long oldKey = paramOldRtx.getNode().getDataKey();
        boolean movedOldRtx = paramOldRtx.moveTo(((ITreeStructData)paramOldRtx.getNode()).getRightSiblingKey());
        if (movedNewRtx && movedOldRtx && checkNodes(paramNewRtx, paramOldRtx)) {
            updated = true;
        } else if (!movedNewRtx && !movedOldRtx) {
            movedNewRtx = paramNewRtx.moveTo(paramNewRtx.getNode().getParentKey());
            movedOldRtx = paramOldRtx.moveTo(paramOldRtx.getNode().getParentKey());

            if (movedNewRtx && movedOldRtx && checkNodes(paramNewRtx, paramOldRtx)) {
                updated = true;
            }
        }
        paramNewRtx.moveTo(newKey);
        paramOldRtx.moveTo(oldKey);
        if (!updated) {
            updated = paramNewRtx.getNode().getDataKey() == paramOldRtx.getNode().getDataKey();
        }
        return updated;
    }
106637
@Override
    protected boolean isAfter(int x, int y, Rectangle innerAlloc)
    {
        // System.err.println("isAfter: " + innerAlloc + " my bounds " +
        // box.getAbsoluteBounds());
        // System.err.println("XY: " + x + " : " + y);
        innerAlloc.setBounds(box.getAbsoluteBounds());
        if (majorAxis == View.X_AXIS)
        {
            return (x > (innerAlloc.width + innerAlloc.x));
        }
        else
        {
            return (y > (innerAlloc.height + innerAlloc.y));
        }
    }
1072408
public boolean isVisible(Tiled tiled)
    {
        final int tx = tiled.getInTileX();
        final int ty = tiled.getInTileY();
        final int tw = tiled.getInTileWidth() - 1;
        final int th = tiled.getInTileHeight() - 1;

        for (int ctx = tx; ctx <= tx + tw; ctx++)
        {
            for (int cty = ty; cty <= ty + th; cty++)
            {
                if (isFogged(ctx, cty) || !isVisited(ctx, cty))
                {
                    return false;
                }
            }
        }
        return true;
    }
560291
private boolean isTileBlocked(Pathfindable mover, int tx, int ty)
    {
        final Tile tile = map.getTile(tx, ty);
        if (tile != null)
        {
            final TilePath tilePath = tile.getFeature(TilePath.class);
            return mover.isBlocking(tilePath.getCategory());
        }
        return false;
    }
1009596
public boolean isIgnored(String controlKey, Object controlValue, Object receivedJson, Set<String> ignoreExpressions, ReadContext readContext) {
        if (controlValue != null && controlValue.toString().trim().equals(Citrus.IGNORE_PLACEHOLDER)) {
            if (log.isDebugEnabled()) {
                log.debug("JSON entry: '" + controlKey + "' is ignored by placeholder '" +
                        Citrus.IGNORE_PLACEHOLDER + "'");
            }
            return true;
        }

        for (String jsonPathExpression : ignoreExpressions) {
            Object foundEntry = readContext.read(jsonPathExpression);

            if (foundEntry instanceof JSONArray && ((JSONArray) foundEntry).contains(receivedJson)) {
                if (log.isDebugEnabled()) {
                    log.debug("JSON entry: '" + controlKey + "' is ignored - skip value validation");
                }
                return true;
            }

            if (foundEntry != null && foundEntry.equals(receivedJson)) {
                if (log.isDebugEnabled()) {
                    log.debug("JSON entry: '" + controlKey + "' is ignored - skip value validation");
                }
                return true;
            }
        }

        return false;
    }
105370
public boolean isInClipArea(final long pX, final long pY) {
        return pX > mXMin && pX < mXMax && pY > mYMin && pY < mYMax;
    }
25615
private boolean isIgnoreIssue(final Throwable e) {
        final StackTraceElement[] stackTrace = e.getStackTrace();
        /**
         * <pre>
         * java.lang.NullPointerException
         *   at java.awt.geom.RectangularShape.setFrameFromDiagonal(RectangularShape.java:271)
         *   at edu.uci.ics.jung.visualization.control.PickingGraphMousePlugin.mouseDragged(PickingGraphMousePlugin.java:295)
         * </pre>
         */
        if (e instanceof NullPointerException && stackTrace != null && stackTrace.length > 1) {
            final StackTraceElement stack1 = stackTrace[0];
            if ("java.awt.geom.RectangularShape".equals(stack1.getClassName()) && "setFrameFromDiagonal"
                    .equals(stack1.getMethodName())) {
                final StackTraceElement stack2 = stackTrace[1];
                if ("edu.uci.ics.jung.visualization.control.PickingGraphMousePlugin".equals(stack2.getClassName())
                        && "mouseDragged".equals(stack2.getMethodName())) {
                    return true;
                }
            }
        }
        return false;
    }
562052
public static int getSelectableBackground(Context ctx) {
        // If we're running on Honeycomb or newer, then we can use the Theme's
        // selectableItemBackground to ensure that the View has a pressed state
        TypedValue outValue = new TypedValue();
        //it is important here to not use the android.R because this wouldn't add the latest drawable
        ctx.getTheme().resolveAttribute(R.attr.selectableItemBackground, outValue, true);
        return outValue.resourceId;
    }
999978
public boolean clear(TileBasedMap map, Space space) {
		if (tileBased) {
			return true;
		}
		
		float x = 0;
		boolean donex = false;
		
		while (x < space.getWidth()) {
			float y = 0;
			boolean doney = false;
			
			while (y < space.getHeight()) {
				sx = (int) (space.getX()+x);
				sy = (int) (space.getY()+y);
				
				if (map.blocked(this, sx, sy)) {
					return false;
				}
				
				y += 0.1f;
				if ((y > space.getHeight()) && (!doney)) {
					y = space.getHeight();
					doney = true;
				}
			}
			
			
			x += 0.1f;
			if ((x > space.getWidth()) && (!donex)) {
				x = space.getWidth();
				donex = true;
			}
		}
		
		return true;
	}
191633
private boolean areaAreaPredicates_(int half_edge, int id_a, int id_b) {
		boolean bRelationKnown = true;

		if (m_perform_predicates[MatrixPredicate.InteriorInterior]) {
			interiorAreaInteriorArea_(half_edge, id_a, id_b);
			bRelationKnown &= isPredicateKnown_(
					MatrixPredicate.InteriorInterior);
		}

		if (m_perform_predicates[MatrixPredicate.InteriorBoundary]) {
			interiorAreaBoundaryArea_(half_edge, id_a,
					MatrixPredicate.InteriorBoundary);
			bRelationKnown &= isPredicateKnown_(
					MatrixPredicate.InteriorBoundary);
		}

		if (m_perform_predicates[MatrixPredicate.InteriorExterior]) {
			interiorAreaExteriorArea_(half_edge, id_a, id_b,
					MatrixPredicate.InteriorExterior);
			bRelationKnown &= isPredicateKnown_(
					MatrixPredicate.InteriorExterior);
		}

		if (m_perform_predicates[MatrixPredicate.BoundaryInterior]) {
			interiorAreaBoundaryArea_(half_edge, id_b,
					MatrixPredicate.BoundaryInterior);
			bRelationKnown &= isPredicateKnown_(
					MatrixPredicate.BoundaryInterior);
		}

		if (m_perform_predicates[MatrixPredicate.BoundaryBoundary]) {
			boundaryAreaBoundaryArea_(half_edge, id_a, id_b);
			bRelationKnown &= isPredicateKnown_(
					MatrixPredicate.BoundaryBoundary);
		}

		if (m_perform_predicates[MatrixPredicate.BoundaryExterior]) {
			boundaryAreaExteriorArea_(half_edge, id_a, id_b,
					MatrixPredicate.BoundaryExterior);
			bRelationKnown &= isPredicateKnown_(
					MatrixPredicate.BoundaryExterior);
		}

		if (m_perform_predicates[MatrixPredicate.ExteriorInterior]) {
			interiorAreaExteriorArea_(half_edge, id_b, id_a,
					MatrixPredicate.ExteriorInterior);
			bRelationKnown &= isPredicateKnown_(
					MatrixPredicate.ExteriorInterior);
		}

		if (m_perform_predicates[MatrixPredicate.ExteriorBoundary]) {
			boundaryAreaExteriorArea_(half_edge, id_b, id_a,
					MatrixPredicate.ExteriorBoundary);
			bRelationKnown &= isPredicateKnown_(
					MatrixPredicate.ExteriorBoundary);
		}

		return bRelationKnown;
	}