@Override
public Rect[] getOperatorBoundingBoxes() {
// Get the sizes
final Rect childRect = getChild(0).getBoundingBox();
final int parentheseWidth = (int) (childRect.height() * PARENTHESES_RATIO);
Rect textBounding = sizeAddPadding(getSize(findTextSize()));
// Make sure everything is aligned nicely
final int childCenterY = getChild(0).getCenter().y;
final int childTop = Math.max(textBounding.centerY() - childCenterY, 0);
textBounding.offsetTo(0, Math.max(childCenterY - textBounding.centerY(), 0));
// Return the bounding boxes
return new Rect[] {
textBounding,
new Rect(
textBounding.width(),
childTop,
textBounding.width() + parentheseWidth,
childTop + childRect.height()),
new Rect(
textBounding.width() + parentheseWidth + childRect.width(),
childTop,
textBounding.width() + childRect.width() + 2 * parentheseWidth,
childTop + childRect.height())
};
}
private void doSelectionHandleTestUrlLaunched(TestPageType pageType) throws Throwable {
clickNodeToShowSelectionHandles(pageType.nodeId);
assertWaitForSelectionEditableEquals(pageType.selectionShouldBeEditable);
HandleView startHandle = getStartHandle();
HandleView endHandle = getEndHandle();
Rect nodeWindowBounds = getNodeBoundsPix(pageType.nodeId);
int leftX = (nodeWindowBounds.left + nodeWindowBounds.centerX()) / 2;
int centerX = nodeWindowBounds.centerX();
int rightX = (nodeWindowBounds.right + nodeWindowBounds.centerX()) / 2;
int topY = (nodeWindowBounds.top + nodeWindowBounds.centerY()) / 2;
int centerY = nodeWindowBounds.centerY();
int bottomY = (nodeWindowBounds.bottom + nodeWindowBounds.centerY()) / 2;
// Drag start handle up and to the left. The selection start should decrease.
dragHandleAndCheckSelectionChange(startHandle, leftX, topY, -1, 0);
// Drag end handle down and to the right. The selection end should increase.
dragHandleAndCheckSelectionChange(endHandle, rightX, bottomY, 0, 1);
// Drag start handle back to the middle. The selection start should increase.
dragHandleAndCheckSelectionChange(startHandle, centerX, centerY, 1, 0);
// Drag end handle up and to the left past the start handle. Both selection start and end
// should decrease.
dragHandleAndCheckSelectionChange(endHandle, leftX, topY, -1, -1);
// Drag start handle down and to the right past the end handle. Both selection start and end
// should increase.
dragHandleAndCheckSelectionChange(startHandle, rightX, bottomY, 1, 1);
clickToDismissHandles();
}
protected void onDrawCell(Canvas canvas, Cell cell) {
if (cell.text == null && cell.bgColor == null && cell.rtDrawable == null)
return; // 如果无内容，且无背景色不进行绘制
Rect rect = this.getCellRectInView(cell);
if (cell.bgColor != null) {
canvas.drawColor(cell.bgColor);
}
if (cell.ballColor != null) {
painter.setColor(cell.ballColor);
canvas.drawCircle(rect.centerX(), rect.centerY(), rect.height() / 2 - 1 * dp, painter);
}
if (cell.textColor != null) painter.setColor(cell.textColor);
if (cell.text != null) {
if (cell.textSize > 0) painter.setTextSize(cell.textSize);
else painter.setTextSize(this.textSize);
painter.setTextAlign(cell.aligin);
int cx = rect.centerX();
if (cell.aligin == Align.LEFT) cx = rect.left;
else if (cell.aligin == Align.RIGHT) cx = rect.right;
int cy = rect.centerY() + (int) (painter.getTextSize() * 2 / 5 + 0.5f);
if (cell.fixedTextX) cx -= offX;
if (cell.fixedTextY) cy -= offY;
canvas.drawText(cell.text, cx, cy, painter);
}
if (cell.rtDrawable != null) {
int minWidth = cell.rtDrawable.getMinimumWidth();
if (minWidth > rect.width() / 2) minWidth = rect.width() / 2;
cell.rtDrawable.setBounds(
new Rect(rect.right - minWidth, rect.top, rect.right, rect.top + minWidth));
cell.rtDrawable.draw(canvas);
}
}
@Override
public void draw(Canvas canvas) {
Rect bounds = getBounds();
final boolean isRtl = isLayoutRtl();
// Interpolated widths of arrow bars
final float arrowSize = lerp(mBarSize, mTopBottomArrowSize, mProgress);
final float middleBarSize = lerp(mBarSize, mMiddleArrowSize, mProgress);
// Interpolated size of middle bar
final float middleBarCut = lerp(0, mBarThickness / 2, mProgress);
// The rotation of the top and bottom bars (that make the arrow head)
final float rotation = lerp(0, ARROW_HEAD_ANGLE, mProgress);
// The whole canvas rotates as the transition happens
final float canvasRotate = lerp(isRtl ? 180 : 0, isRtl ? 0 : 180, mProgress);
final float topBottomBarOffset = lerp(mBarGap + mBarThickness, 0, mProgress);
mPath.rewind();
final float arrowEdge = -middleBarSize / 2;
// draw middle bar
mPath.moveTo(arrowEdge + middleBarCut, 0);
mPath.rLineTo(middleBarSize - middleBarCut, 0);
final float arrowWidth = Math.round(arrowSize * Math.cos(rotation));
final float arrowHeight = Math.round(arrowSize * Math.sin(rotation));
// top bar
mPath.moveTo(arrowEdge, topBottomBarOffset);
mPath.rLineTo(arrowWidth, arrowHeight);
// bottom bar
mPath.moveTo(arrowEdge, -topBottomBarOffset);
mPath.rLineTo(arrowWidth, -arrowHeight);
mPath.moveTo(0, 0);
mPath.close();
canvas.save();
// Rotate the whole canvas if spinning, if not, rotate it 180 to get
// the arrow pointing the other way for RTL.
if (mSpin) {
canvas.rotate(
canvasRotate * ((mVerticalMirror ^ isRtl) ? -1 : 1), bounds.centerX(), bounds.centerY());
} else if (isRtl) {
canvas.rotate(-180, bounds.centerX(), bounds.centerY());
}
canvas.translate(bounds.centerX(), bounds.centerY());
canvas.drawPath(mPath, mPaint);
canvas.restore();
}
public static void scaleRectAboutCenter(Rect r, float scale) {
int cx = r.centerX();
int cy = r.centerY();
r.offset(-cx, -cy);
Utilities.scaleRect(r, scale);
r.offset(cx, cy);
}
public void onDrawRectText(Canvas canvas, Rect rect) {
Rect textBounds = new Rect();
paint = new Paint();
paint.setStrokeWidth(textSize);
paint.setTextSize(textSize);
paint.setColor(textColor);
paint.setTextAlign(Paint.Align.CENTER);
paint.getTextBounds(text, 0, text.length(), textBounds);
canvas.drawText(text, rect.centerX(), rect.centerY() - textBounds.exactCenterY(), paint);
this.rect = rect;
this.x = rect.centerX();
this.y = rect.centerY() - textBounds.exactCenterY();
}
// Determines which edges are hit by touching at (x, y).
public int getHit(float x, float y) {
Rect r = computeLayout();
final float hysteresis = 20F;
int retval = GROW_NONE;
if (mCircle) {
float distX = x - r.centerX();
float distY = y - r.centerY();
int distanceFromCenter = (int) Math.sqrt(distX * distX + distY * distY);
int radius = mDrawRect.width() / 2;
int delta = distanceFromCenter - radius;
if (Math.abs(delta) <= hysteresis) {
if (Math.abs(distY) > Math.abs(distX)) {
if (distY < 0) {
retval = GROW_TOP_EDGE;
} else {
retval = GROW_BOTTOM_EDGE;
}
} else {
if (distX < 0) {
retval = GROW_LEFT_EDGE;
} else {
retval = GROW_RIGHT_EDGE;
}
}
} else if (distanceFromCenter < radius) {
retval = MOVE;
} else {
retval = GROW_NONE;
}
} else {
// verticalCheck makes sure the position is between the top and
// the bottom edge (with some tolerance). Similar for horizCheck.
boolean verticalCheck = (y >= r.top - hysteresis) && (y < r.bottom + hysteresis);
boolean horizCheck = (x >= r.left - hysteresis) && (x < r.right + hysteresis);
// Check whether the position is near some edge(s).
if ((Math.abs(r.left - x) < hysteresis) && verticalCheck) {
retval |= GROW_LEFT_EDGE;
}
if ((Math.abs(r.right - x) < hysteresis) && verticalCheck) {
retval |= GROW_RIGHT_EDGE;
}
if ((Math.abs(r.top - y) < hysteresis) && horizCheck) {
retval |= GROW_TOP_EDGE;
}
if ((Math.abs(r.bottom - y) < hysteresis) && horizCheck) {
retval |= GROW_BOTTOM_EDGE;
}
// Not near any edge but inside the rectangle: move.
if (retval == GROW_NONE && r.contains((int) x, (int) y)) {
retval = MOVE;
}
}
return retval;
}
private void drawMovRect(Canvas canvas) {
canvas.drawRect(movRect, dragging);
canvas.drawText(
selNum + "",
movRect.centerX(),
movRect.centerY() + textOffsetY - cellLength / 2,
number_fixed);
}
private void drawGradient(Canvas canvas) {
float xSectionWidth = 1f / mSectionsCount;
int currentIndexColor = mColorsIndex;
mLinearGradientPositions[0] = 0f;
mLinearGradientPositions[mLinearGradientPositions.length - 1] = 1f;
int firstColorIndex = currentIndexColor - 1;
if (firstColorIndex < 0) firstColorIndex += mColors.length;
mLinearGradientColors[0] = mColors[firstColorIndex];
for (int i = 0; i < mSectionsCount; ++i) {
float position = mInterpolator.getInterpolation(i * xSectionWidth + mCurrentOffset);
mLinearGradientPositions[i + 1] = position;
mLinearGradientColors[i + 1] = mColors[currentIndexColor];
currentIndexColor = (currentIndexColor + 1) % mColors.length;
}
mLinearGradientColors[mLinearGradientColors.length - 1] = mColors[currentIndexColor];
float left =
mReversed
? (mMirrorMode ? Math.abs(mBounds.left - mBounds.right) / 2 : mBounds.left)
: mBounds.left;
float right =
mMirrorMode
? (mReversed ? mBounds.left : Math.abs(mBounds.left - mBounds.right) / 2)
: mBounds.right;
float top = mBounds.centerY() - mStrokeWidth / 2;
float bottom = mBounds.centerY() + mStrokeWidth / 2;
LinearGradient linearGradient =
new LinearGradient(
left,
top,
right,
bottom,
mLinearGradientColors,
mLinearGradientPositions,
mMirrorMode ? Shader.TileMode.MIRROR : Shader.TileMode.CLAMP);
mPaint.setShader(linearGradient);
}
@Override
protected synchronized void onDraw(Canvas canvas) {
// First draw the regular progress bar, then custom draw our text
super.onDraw(canvas);
Rect bounds = new Rect();
textPaint.getTextBounds(text, 0, text.length(), bounds);
int x = getWidth() / 2 - bounds.centerX();
int y = getHeight() / 2 - bounds.centerY();
canvas.drawText(text, x, y, textPaint);
}
private void initializePaddles() {
// Order from top to bottom; Red, Green, Orange, Cyan, Yellow, Blue
Rect redTouch = new Rect(0, 0, getWidth(), getHeight() / 8);
Rect blueTouch = new Rect(0, 7 * getHeight() / 8, getWidth(), getHeight());
Rect greenTouch = new Rect(0, 4 * getHeight() / 16, getWidth(), (getHeight() / 16) * 5);
Rect orangeTouch = new Rect(0, 6 * getHeight() / 16, getWidth(), (getHeight() / 16) * 7);
Rect yellowTouch = new Rect(0, 11 * getHeight() / 16, getWidth(), (getHeight() / 4) * 3);
Rect cyanTouch = new Rect(0, 9 * getHeight() / 16, getWidth(), (getHeight() / 16) * 10);
mRed = new Paddle(Color.RED, redTouch.bottom + PADDING);
mBlue = new Paddle(Color.BLUE, blueTouch.top - PADDING - Paddle.PADDLE_THICKNESS);
mGreen = new Paddle(Color.GREEN, greenTouch.centerY() + PADDING);
mYellow = new Paddle(Color.YELLOW, yellowTouch.centerY() + PADDING);
mOrange = new Paddle(Color.rgb(255, 128, 0), orangeTouch.centerY() + PADDING);
mCyan = new Paddle(Color.rgb(0, 255, 255), cyanTouch.centerY() + PADDING);
mRed.setTouchbox(redTouch);
mBlue.setTouchbox(blueTouch);
mGreen.setTouchbox(greenTouch);
mYellow.setTouchbox(yellowTouch);
mOrange.setTouchbox(orangeTouch);
mCyan.setTouchbox(cyanTouch);
mRed.setHandicap(mCpuHandicap);
mBlue.setHandicap(mCpuHandicap);
mGreen.setHandicap(mCpuHandicap);
mYellow.setHandicap(mCpuHandicap);
mOrange.setHandicap(mCpuHandicap);
mCyan.setHandicap(mCpuHandicap);
mRed.player = mRedPlayer;
mBlue.player = mBluePlayer;
mRed.setSlave(mOrange);
mBlue.setSlave(mCyan);
mOrange.setSlave(mYellow);
mCyan.setSlave(mGreen);
mRed.setLives(STARTING_LIVES + mLivesModifier);
mBlue.setLives(STARTING_LIVES + mLivesModifier);
}
/**
* @param command The {@link AndroidCommand}
* @return {@link AndroidCommandResult}
* @throws JSONException
* @see
* io.appium.android.bootstrap.CommandHandler#execute(io.appium.android.bootstrap.AndroidCommand)
*/
@Override
public AndroidCommandResult execute(final AndroidCommand command) throws JSONException {
initalize();
try {
params = command.params();
// isElementCommand doesn't check to see if we actually have an element
// so getElement is used instead.
try {
if (command.getElement() != null) {
isElement = true;
}
} catch (final Exception e) {
isElement = false;
}
if (isElement) {
// extract x and y from the element.
el = command.getElement();
final Rect bounds = el.getVisibleBounds();
clickX = bounds.centerX();
clickY = bounds.centerY();
} else { // no element so extract x and y from params
final Object paramX = params.get("x");
final Object paramY = params.get("y");
double targetX = 0.5;
double targetY = 0.5;
if (paramX != null) {
targetX = Double.parseDouble(paramX.toString());
}
if (paramY != null) {
targetY = Double.parseDouble(paramY.toString());
}
final ArrayList<Integer> posVals = absPosFromCoords(new Double[] {targetX, targetY});
clickX = posVals.get(0);
clickY = posVals.get(1);
}
if (executeTouchEvent()) {
return getSuccessResult(true);
}
} catch (final UiObjectNotFoundException e) {
return new AndroidCommandResult(WDStatus.NO_SUCH_ELEMENT, e.getMessage());
} catch (final ElementNotInHashException e) {
return new AndroidCommandResult(WDStatus.NO_SUCH_ELEMENT, e.getMessage());
} catch (final Exception e) {
return getErrorResult(e.getMessage());
}
return getErrorResult("Failed to execute touch event");
}
public int addBand(Rect rect) {
mBands.add(0, mCurrentBand = new Band(rect.centerX(), rect.centerY()));
mCurrentBand.mask = false;
int x = (mCurrentBand.xPos1 + mCurrentBand.xPos2) / 2;
int y = (mCurrentBand.yPos1 + mCurrentBand.yPos2) / 2;
double addDelta = ADD_MIN_DIST * Math.max(rect.width(), rect.height());
boolean moved = true;
int count = 0;
int toMove = mBands.indexOf(mCurrentBand);
while (moved) {
moved = false;
count++;
if (count > 14) {
break;
}
for (Band point : mBands) {
if (point.mask) {
break;
}
}
for (Band point : mBands) {
if (point.mask) {
break;
}
int index = mBands.indexOf(point);
if (toMove != index) {
double dist = Math.hypot(point.xPos1 - x, point.yPos1 - y);
if (dist < addDelta) {
moved = true;
mCurrentBand.xPos1 += addDelta;
mCurrentBand.yPos1 += addDelta;
mCurrentBand.xPos2 += addDelta;
mCurrentBand.yPos2 += addDelta;
x = (mCurrentBand.xPos1 + mCurrentBand.xPos2) / 2;
y = (mCurrentBand.yPos1 + mCurrentBand.yPos2) / 2;
if (mCurrentBand.yPos1 > rect.bottom) {
mCurrentBand.yPos1 = (int) (rect.top + addDelta);
}
if (mCurrentBand.xPos1 > rect.right) {
mCurrentBand.xPos1 = (int) (rect.left + addDelta);
}
}
}
}
}
trimVector();
return 0;
}
@Override
public void draw(Canvas canvas) {
final Rect bounds = getBounds();
// Calculations on the different components sizes
int size = Math.min(bounds.height(), bounds.width());
float outerRadius = (size / 2) - (ringWidth / 2);
float innerRadius = outerRadius - ringWidth / 2; // * circleScale;
float offsetX = (bounds.width() - outerRadius * 2) / 2;
float offsetY = (bounds.height() - outerRadius * 2) / 2;
// Outline Circle
paint.setStyle(Paint.Style.STROKE);
paint.setStrokeWidth(ringWidth / 2);
paint.setColor(outlineColor);
canvas.drawCircle(bounds.centerX(), bounds.centerY(), outerRadius, paint);
// Inner circle
paint.setStyle(Paint.Style.FILL);
paint.setColor(centerColor);
canvas.drawCircle(bounds.centerX(), bounds.centerY(), innerRadius, paint);
int halfRingWidth = ringWidth / 2;
float arcX0 = offsetX + halfRingWidth;
float arcY0 = offsetY + halfRingWidth;
float arcX = offsetX + outerRadius * 2 - halfRingWidth;
float arcY = offsetY + outerRadius * 2 - halfRingWidth;
// Outer Circle
paint.setColor(ringColor);
paint.setStyle(Paint.Style.STROKE);
paint.setStrokeWidth(ringWidth);
paint.setStrokeCap(Paint.Cap.ROUND);
arcElements.set(arcX0, arcY0, arcX, arcY);
if (indeterminate) {
canvas.drawArc(arcElements, progress, 90, false, paint);
} else {
canvas.drawArc(arcElements, 89, progress, false, paint);
}
}
@Override
public void doDraw(Canvas canvas, Paint paint) {
Rect bounds = getBounds();
int size = Math.min(bounds.width(), bounds.height());
float scale = mCurrentScale;
int rippleColor = mRippleColor;
int bgColor = mRippleBgColor;
float radius = (size / 2);
float radiusAnimated = radius * scale;
if (scale > INACTIVE_SCALE) {
if (bgColor != 0) {
paint.setColor(bgColor);
paint.setAlpha(decreasedAlpha(Color.alpha(bgColor)));
canvas.drawCircle(bounds.centerX(), bounds.centerY(), radius, paint);
}
if (rippleColor != 0) {
paint.setColor(rippleColor);
paint.setAlpha(modulateAlpha(Color.alpha(rippleColor)));
canvas.drawCircle(bounds.centerX(), bounds.centerY(), radiusAnimated, paint);
}
}
}
@Override
public void onDraw(Canvas canvas) {
mPaint.setStrokeWidth(mInnerStroke);
canvas.drawCircle(mCenterX, mCenterY, mMinCircle, mPaint);
canvas.drawCircle(mCenterX, mCenterY, mMaxCircle, mPaint);
canvas.drawLine(mCenterX - mMinCircle, mCenterY, mCenterX - mMaxCircle - 4, mCenterY, mPaint);
mPaint.setStrokeWidth(mOuterStroke);
canvas.drawCircle((float) mCenterX, (float) mCenterY, (float) mCircleSize, mPaint);
String txt = mZoomSig + "." + mZoomFraction + "x";
mTextPaint.getTextBounds(txt, 0, txt.length(), mTextBounds);
canvas.drawText(
txt, mCenterX - mTextBounds.centerX(), mCenterY - mTextBounds.centerY(), mTextPaint);
}
private void centerAboutIcon() {
DragLayer.LayoutParams lp = (DragLayer.LayoutParams) getLayoutParams();
int width = getPaddingLeft() + getPaddingRight() + mContent.getDesiredWidth();
int height =
getPaddingTop() + getPaddingBottom() + mContent.getDesiredHeight() + mFolderNameHeight;
DragLayer parent = (DragLayer) mLauncher.findViewById(R.id.drag_layer);
parent.getDescendantRectRelativeToSelf(mFolderIcon, mTempRect);
int centerX = mTempRect.centerX();
int centerY = mTempRect.centerY();
int centeredLeft = centerX - width / 2;
int centeredTop = centerY - height / 2;
// We first fetch the currently visible CellLayoutChildren
CellLayout currentPage = mLauncher.getWorkspace().getCurrentDropLayout();
CellLayoutChildren boundingLayout = currentPage.getChildrenLayout();
Rect bounds = new Rect();
parent.getDescendantRectRelativeToSelf(boundingLayout, bounds);
// We need to bound the folder to the currently visible CellLayoutChildren
int left = Math.min(Math.max(bounds.left, centeredLeft), bounds.left + bounds.width() - width);
int top = Math.min(Math.max(bounds.top, centeredTop), bounds.top + bounds.height() - height);
// If the folder doesn't fit within the bounds, center it about the desired bounds
if (width >= bounds.width()) {
left = bounds.left + (bounds.width() - width) / 2;
}
if (height >= bounds.height()) {
top = bounds.top + (bounds.height() - height) / 2;
}
int folderPivotX = width / 2 + (centeredLeft - left);
int folderPivotY = height / 2 + (centeredTop - top);
setPivotX(folderPivotX);
setPivotY(folderPivotY);
int folderIconPivotX = (int) (mFolderIcon.getMeasuredWidth() * (1.0f * folderPivotX / width));
int folderIconPivotY = (int) (mFolderIcon.getMeasuredHeight() * (1.0f * folderPivotY / height));
mFolderIcon.setPivotX(folderIconPivotX);
mFolderIcon.setPivotY(folderIconPivotY);
if (mMode == PARTIAL_GROW) {
lp.width = width;
lp.height = height;
lp.x = left;
lp.y = top;
} else {
mNewSize.set(left, top, left + width, top + height);
}
}
private void clickNodeToShowSelectionHandles(String nodeId) throws Throwable {
Rect nodeWindowBounds = getNodeBoundsPix(nodeId);
TouchCommon touchCommon = new TouchCommon(this);
int centerX = nodeWindowBounds.centerX();
int centerY = nodeWindowBounds.centerY();
touchCommon.longPressView(getContentViewCore().getContainerView(), centerX, centerY);
assertWaitForHandlesShowingEquals(true);
assertWaitForHandleViewStopped(getStartHandle());
// No words wrap in the sample text so handles should be at the same y
// position.
assertEquals(getStartHandle().getPositionY(), getEndHandle().getPositionY());
}
@Override
public void onSideSwitch(SwitchCompat v) {
Rect rect = new Rect();
v.getGlobalVisibleRect(rect);
final int cy = rect.centerY() - getStatusBarHeight();
final int halfThumbWidth = v.getThumbDrawable().getIntrinsicWidth() / 2;
final int cx;
if (this instanceof BrightSideFragment && v.isChecked()) {
cx = rect.right - halfThumbWidth;
postGoToSide(cy, cx, "dark");
} else if (!v.isChecked()) {
cx = rect.left + halfThumbWidth;
postGoToSide(cy, cx, "bright");
}
}
/**
* This is meant to be a "pure" tile drawing function that doesn't take into account
* osmdroid-specific characteristics (like osmdroid's canvas's having 0,0 as the center rather
* than the upper-left corner). Once the tile is ready to be drawn, it is passed to
* onTileReadyToDraw where custom manipulations can be made before drawing the tile.
*/
public void drawTiles(
final Canvas c,
final Projection projection,
final int zoomLevel,
final int tileSizePx,
final Rect viewPort) {
mProjection = projection;
mTileLooper.loop(c, zoomLevel, tileSizePx, viewPort);
// draw a cross at center in debug mode
if (DEBUGMODE) {
// final GeoPoint center = osmv.getMapCenter();
final Point centerPoint = new Point(viewPort.centerX(), viewPort.centerY());
c.drawLine(centerPoint.x, centerPoint.y - 9, centerPoint.x, centerPoint.y + 9, mDebugPaint);
c.drawLine(centerPoint.x - 9, centerPoint.y, centerPoint.x + 9, centerPoint.y, mDebugPaint);
}
}
@Override
public Rect getChildBoundingBox(int index) throws IndexOutOfBoundsException {
// Make sure the child index is valid
checkChildIndex(index);
// Gets the needed sizes and centres
final Rect childRect = getChild(index).getBoundingBox();
final int parentheseWidth = (int) (childRect.height() * PARENTHESES_RATIO);
Rect textBounding = sizeAddPadding(getSize(findTextSize()));
// Align the child's vertical centre with the text's vertical centre
// also offset it horizontally to place it behind the opening bracket
childRect.offsetTo(
textBounding.width() + parentheseWidth,
Math.max(textBounding.centerY() - getChild(index).getCenter().y, 0));
// Return the result
return childRect;
}
@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
mScroller.fling(
mRect.centerX(),
mRect.centerY(),
Math.round(velocityX),
Math.round(velocityY),
0,
getWidth() - SIZE,
0,
getHeight() - SIZE,
SIZE / 2,
SIZE / 2);
ViewCompat.postInvalidateOnAnimation(ScrollerView.this);
return true;
}
private void drawBackspace(
Canvas canvas, Keyboard.Key key, String color, String strokeColor, String textColor) {
int fontValue = 140;
int maxTextSize = (int) getDensityPixels(fontValue);
Rect keyRectangle = new Rect(key.x, key.y, key.x + key.width, key.y + key.height);
if (mPaint == null) {
mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
}
mPaint.setStyle(Paint.Style.FILL);
mPaint.setColor(Color.parseColor(color));
canvas.drawRect(keyRectangle, mPaint);
mPaint.setColor(Color.parseColor(strokeColor));
mPaint.setStyle(Paint.Style.STROKE);
mPaint.setStrokeWidth(getDensityPixels(5));
canvas.drawRect(keyRectangle, mPaint);
mPaint.setColor(Color.parseColor(textColor));
mPaint.setTextAlign(Paint.Align.CENTER);
mPaint.setTextSize(maxTextSize);
mPaint.setStyle(Paint.Style.FILL);
Rect bounds = new Rect();
mPaint.getTextBounds(key.label.toString(), 0, key.label.length(), bounds);
while (bounds.height() > (keyRectangle.height() / 10) * 6
|| bounds.width() >= (keyRectangle.width() / 10) * 9) {
fontValue -= 1;
mPaint.setTextSize(getDensityPixels(fontValue));
mPaint.getTextBounds(key.label.toString(), 0, key.label.length(), bounds);
}
canvas.drawText(
key.label.toString(),
keyRectangle.centerX(),
keyRectangle.centerY() - bounds.exactCenterY(),
mPaint);
}
public void draw(Canvas canvas, Context context) {
for (MapCell cell : mMapCells) {
ShapeDrawable cellShape = new ShapeDrawable(new RectShape());
Rect cellBounds = cell.getBounds();
cellShape.setBounds(
cellBounds.left + mOriginX,
cellBounds.top + mOriginY,
cellBounds.right + mOriginX,
cellBounds.bottom + mOriginY);
cellShape.getPaint().setColor(ContextCompat.getColor(context, R.color.colorDarkerForeground));
cellShape.draw(canvas);
Paint textPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
textPaint.setColor(ContextCompat.getColor(context, R.color.colorPrimary));
textPaint.setTextSize((float) (14 * 3.5));
canvas.drawText(
cell.getName(),
cellBounds.centerX() + mOriginX,
cellBounds.centerY() + mOriginY,
textPaint);
}
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
if (location == null
|| foregroundBounds == null
|| backgroundBounds == null
|| accuracyAnimator == null) {
// Not ready yet
return;
}
// Draw circle
float metersPerPixel = (float) projection.getMetersPerPixelAtLatitude(location.getLatitude());
float accuracyPixels = (Float) accuracyAnimator.getAnimatedValue() / metersPerPixel;
float maxRadius = getWidth() / 2;
canvas.drawCircle(
foregroundBounds.centerX(),
foregroundBounds.centerY(),
accuracyPixels <= maxRadius ? accuracyPixels : maxRadius,
accuracyPaint);
// Draw shadow
if (backgroundDrawable != null) {
backgroundDrawable.draw(canvas);
}
// Draw foreground
if (myBearingTrackingMode == MyBearingTracking.NONE) {
if (foregroundDrawable != null) {
foregroundDrawable.draw(canvas);
}
} else if (foregroundBearingDrawable != null && foregroundBounds != null) {
getRotateDrawable(
foregroundBearingDrawable,
myBearingTrackingMode == MyBearingTracking.COMPASS ? compassDirection : gpsDirection)
.draw(canvas);
}
}
@Override
public boolean onTouchEvent(MotionEvent event) {
int action = event.getAction();
float newX = event.getX(), newY = event.getY();
switch (action) {
case MotionEvent.ACTION_DOWN:
if (ballRect.contains((int) newX, (int) newY)) {
initX = newX;
initY = newY;
move = true;
} else {
move = false;
}
break;
case MotionEvent.ACTION_MOVE:
if (move) {
ballRect.offset((int) (newX - initX), (int) (newY - initY));
initX = newX;
initY = newY;
if ((!rect.contains(ballRect) && !rect2.contains(ballRect))
&& !conRect.contains(ballRect)) {
move = false;
ballRect.offsetTo(ballRectX, ballRectY);
Toast.makeText(mContext, "out of bounds", Toast.LENGTH_SHORT).show();
} else if (ballRect.contains(goal.centerX(), goal.centerY())) {
ballRect.offset(-30, 0);
Toast.makeText(mContext, "Congratulations\n Get UP!", Toast.LENGTH_SHORT).show();
AlarmDialog.vibrator.cancel();
((Activity) getContext()).finish();
}
}
break;
case MotionEvent.ACTION_UP:
ballRect.offsetTo(ballRectX, ballRectY);
break;
}
return (true);
}
@Override
public void draw(Canvas canvas) {
Rect bounds = getBounds();
int cellSize = Math.min(bounds.height(), bounds.width());
float x0 = bounds.left;
float y0 = bounds.top;
float x1 = bounds.right;
float y1 = bounds.bottom;
float xM = bounds.centerX();
float yM = bounds.centerY();
float border = cellSize / 8;
paint.setStyle(Paint.Style.STROKE);
paint.setStrokeWidth(border / 2);
switch (kind) {
case BRANCH_ALL:
case BRANCH_LEFT:
case BRANCH_LEFT_AND_RIGTH:
case BRANCH_RIGHT:
if (kind == Kind.BRANCH_ALL
|| kind == Kind.BRANCH_LEFT
|| kind == Kind.BRANCH_LEFT_AND_RIGTH) {
canvas.drawLine(xM, y0 + border, x0 + border, yM, paint);
}
if (kind == Kind.BRANCH_ALL || kind == Kind.BRANCH_LEFT || kind == Kind.BRANCH_RIGHT) {
canvas.drawLine(xM, y0 + border, xM, y1 - border, paint);
}
if (kind == Kind.BRANCH_ALL
|| kind == Kind.BRANCH_RIGHT
|| kind == Kind.BRANCH_LEFT_AND_RIGTH) {
canvas.drawLine(xM, y0 + border, x1 - border, yM, paint);
}
break;
case CLASSIFIER:
{
int color = paint.getColor();
paint.setColor(Colors.GRAY[1]);
paint.setStyle(Paint.Style.FILL);
canvas.drawCircle(bounds.centerX(), bounds.centerY(), cellSize / 2, paint);
paint.setColor(color);
paint.setStyle(Paint.Style.STROKE);
canvas.drawCircle(bounds.centerX(), bounds.centerY(), cellSize / 2, paint);
break;
}
case MODULE:
rect.set(bounds);
rect.bottom = x0 + 1.5f * border;
rect.right = bounds.centerX();
paint.setStyle(Paint.Style.FILL_AND_STROKE);
canvas.drawRoundRect(rect, border / 2, border / 2, paint);
rect.top = rect.centerY();
canvas.drawRect(rect, paint);
rect.set(bounds);
rect.top += 1.5 * border;
rect.bottom -= 1 * border;
paint.setStyle(Paint.Style.STROKE);
canvas.drawRoundRect(rect, border, border, paint);
break;
case CONTINUOUS_OPERATION:
paint.setUnderlineText(true);
// Fallthrough intended
case OPERATION:
rect.set(bounds);
rect.top += border;
rect.bottom -= border;
canvas.drawRoundRect(rect, border, border, paint);
// canvas.drawRect(rect, paint);
break;
case PROPERTY:
path.rewind();
path.moveTo(x0 + border, y0 + border);
path.lineTo(x1, y0 + border);
path.lineTo(x1 - border, y1 - border);
path.lineTo(x0, y1 - border);
path.close();
canvas.drawPath(path, paint);
break;
case SOUND:
path.rewind();
path.moveTo(x1 - border, y0 + border);
path.lineTo(x1 - border, y1 - border);
path.lineTo(xM, yM + 1.5f * border);
path.lineTo(xM, yM - 1.5f * border);
path.close();
canvas.drawPath(path, paint);
rect.left = x0 + border;
rect.right = xM - 1.5f * border;
rect.top = yM - 1.5f * border;
rect.bottom = yM + 1.5f * border;
canvas.drawRect(rect, paint);
return;
case TUTORIAL:
path.rewind();
path.moveTo(x1 - 2 * border, y0 + 4 * border);
path.lineTo(x1 - 2 * border, y1 - 2 * border);
path.lineTo(xM, y1 - border);
path.lineTo(x0 + 2 * border, y1 - 2 * border);
path.lineTo(x0 + 2 * border, y0 + 4 * border);
canvas.drawPath(path, paint);
path.rewind();
path.moveTo(xM, y0 + border);
path.lineTo(x1, y0 + 3 * border);
path.lineTo(xM, y0 + 5 * border);
path.lineTo(x0, y0 + 3 * border);
path.close();
canvas.drawPath(path, paint);
canvas.drawLine(x1, y0 + 3 * border, x1, yM + (text == null ? 2 : 1) * border, paint);
break;
}
if (text != null) {
paint.setStyle(Paint.Style.FILL);
if (kind == Kind.TUTORIAL) {
paint.setTextSize(cellSize * 0.33f);
paint.setTextAlign(Paint.Align.RIGHT);
TextHelper.drawText(
context,
canvas,
text,
bounds.right,
bounds.bottom,
paint,
TextHelper.VerticalAlign.BOTTOM);
} else {
paint.setTextSize(cellSize * (kind == Kind.CLASSIFIER ? 0.66f : 0.5f));
// canvas.drawText(text, bounds.centerX(), bounds.bottom - cellSize * (kind ==
// Kind.CLASSIFIER ? 0.25f : 0.33f), paint);
TextHelper.drawText(
context,
canvas,
text,
bounds.centerX(),
bounds.centerY(),
paint,
TextHelper.VerticalAlign.CENTER);
}
} /*else {
paint.setStyle(Paint.Style.FILL);
rect.set(bounds);
rect.inset(border, border);
rect.top += border;
paint.setColor(Colors.GRAY[0]);
canvas.drawRect(rect, paint);
paint.setColor(Colors.GRAY[3]);
paint.setStrokeWidth(cellSize / 16);
paint.setStyle(Paint.Style.STROKE);
canvas.drawRect(rect, paint);
path.rewind();
path.moveTo(x0 + border, y0 + 2 * border);
path.lineTo(x0 + 2 * border, y0 + border);
path.lineTo(x1 - 2 * border, y0 + border);
path.lineTo(x1 - border, y0 + 2 * border);
// path.lineTo(x1 - border, y1 - 2 * border);
// path.lineTo(xM, y1);
// path.lineTo(x0 + border, y1 - 2 * border);
// path.close();
//paint.setColor(Color.BLACK);
canvas.drawPath(path, paint);
// canvas.drawPath(path, paint);
// canvas.drawLine(x0 + border, y0 + 2 * border, xM, y0 + 4 * border, paint);
// canvas.drawLine(x1 - border, y0 + 2 * border, xM, y0 + 4 * border, paint);
// canvas.drawLine(xM, y1, xM, y0 + 4* border, paint);
}
*/
}
/** draw self */
protected void draw(Canvas canvas) {
canvas.drawText(
String.valueOf(mDayOfMonth), mBound.centerX() - dx, mBound.centerY() + dy, mPaint);
}
private float getMaxRadius(float x, float y, Rect bounds) {
float x1 = x < bounds.centerX() ? bounds.right : bounds.left;
float y1 = y < bounds.centerY() ? bounds.bottom : bounds.top;
return (float) Math.sqrt(Math.pow(x1 - x, 2) + Math.pow(y1 - y, 2));
}
/**
* @param command The {@link AndroidCommand}
* @return {@link AndroidCommandResult}
* @throws JSONException
* @see
* io.appium.android.bootstrap.CommandHandler#execute(io.appium.android.bootstrap.AndroidCommand)
*/
@Override
public AndroidCommandResult execute(final AndroidCommand command) throws JSONException {
try {
final Hashtable<String, Object> params = command.params();
AndroidElement el = null;
int clickX = -1;
int clickY = -1;
boolean isElement = false;
// isElementCommand doesn't check to see if we actually have an element
// so getElement is used instead.
try {
if (command.getElement() != null) {
isElement = true;
}
} catch (final Exception e) {
}
if (isElement) {
// extract x and y from the element.
el = command.getElement();
final Rect bounds = el.getVisibleBounds();
clickX = bounds.centerX();
clickY = bounds.centerY();
} else { // no element so extract x and y from params
final Object paramX = params.get("x");
final Object paramY = params.get("y");
double targetX = 0.5;
double targetY = 0.5;
if (paramX != null) {
targetX = Double.parseDouble(paramX.toString());
}
if (paramY != null) {
targetY = Double.parseDouble(paramY.toString());
}
final ArrayList<Integer> posVals = absPosFromCoords(new Double[] {targetX, targetY});
clickX = posVals.get(0);
clickY = posVals.get(1);
}
final Object paramDuration = params.get("duration");
int duration = 2000; // two seconds
if (paramDuration != null) {
duration = Integer.parseInt(paramDuration.toString());
}
Logger.debug(
"longClick using element? "
+ isElement
+ " x: "
+ clickX
+ ", y: "
+ clickY
+ ", duration: "
+ duration);
if (correctLongClick(clickX, clickY, duration)) {
return getSuccessResult(true);
}
// if correctLongClick failed and we have an element
// then uiautomator's longClick is used as a fallback.
if (isElement) {
Logger.debug("Falling back to broken longClick");
final boolean res = el.longClick();
return getSuccessResult(res);
}
} catch (final UiObjectNotFoundException e) {
return new AndroidCommandResult(WDStatus.NO_SUCH_ELEMENT, e.getMessage());
} catch (final ElementNotInHashException e) {
return new AndroidCommandResult(WDStatus.NO_SUCH_ELEMENT, e.getMessage());
} catch (final Exception e) {
return getErrorResult(e.getMessage());
}
return getErrorResult("Failed to long click");
}