/**
   * Drawing src bitmap to dest bitmap with rounded corners
   *
   * @param src source bitmap
   * @param dest destination bitmap
   * @param radius radius in destination bitmap scale
   * @param clearColor clear color
   */
  public static void drawRoundedCorners(Bitmap src, Bitmap dest, int radius, int clearColor) {
    clearBitmap(dest, clearColor);
    Canvas canvas = new Canvas(dest);

    Rect sourceRect = WorkCache.RECT1.get();
    Rect destRect = WorkCache.RECT2.get();
    sourceRect.set(0, 0, src.getWidth(), src.getHeight());
    destRect.set(0, 0, dest.getWidth(), dest.getHeight());

    RectF roundRect = WorkCache.RECTF1.get();
    roundRect.set(0, 0, dest.getWidth(), dest.getHeight());

    Paint paint = WorkCache.PAINT.get();
    paint.reset();
    paint.setStyle(Paint.Style.FILL);
    paint.setColor(Color.RED);
    paint.setAntiAlias(true);
    canvas.drawRoundRect(roundRect, radius, radius, paint);

    paint.reset();
    paint.setFilterBitmap(true);
    paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
    canvas.drawBitmap(src, sourceRect, destRect, paint);

    canvas.setBitmap(null);
  }
示例#2
0
  private void drawPlaceHolder(Canvas canvas) {
    placeholderPaint.setColor(layout.placeHolderColor);

    placeholderTextPaint.setAlpha(255);
    placeholderPaint.setAlpha(255);
    avatarPaint.setAlpha(255);

    rect.set(
        layout.layoutAvatarLeft,
        layout.layoutAvatarTop,
        layout.layoutAvatarLeft + layout.layoutAvatarWidth,
        layout.layoutAvatarTop + layout.layoutAvatarWidth);

    canvas.drawRect(rect, placeholderPaint);
    if (layout.usePlaceholder) {
      canvas.drawText(
          layout.placeHolderName,
          layout.placeholderLeft,
          layout.placeholderTop,
          placeholderTextPaint);
    } else {
      rect2.set(0, 0, placeholder.getWidth(), placeholder.getHeight());
      canvas.drawBitmap(placeholder, rect2, rect, avatarPaint);
    }
  }
  /**
   * Drawing src bitmap to dest bitmap with round mask. Dest might be squared, src is recommended to
   * be square
   *
   * @param src source bitmap
   * @param dest destination bitmap
   * @param clearColor clear color
   */
  public static void drawInRound(Bitmap src, Bitmap dest, int clearColor) {
    if (dest.getWidth() != dest.getHeight()) {
      throw new RuntimeException("dest Bitmap must have square size");
    }
    clearBitmap(dest, clearColor);
    Canvas canvas = new Canvas(dest);

    int r = dest.getWidth() / 2;
    Rect sourceRect = WorkCache.RECT1.get();
    Rect destRect = WorkCache.RECT2.get();
    sourceRect.set(0, 0, src.getWidth(), src.getHeight());
    destRect.set(0, 0, dest.getWidth(), dest.getHeight());

    Paint paint = WorkCache.PAINT.get();
    paint.reset();
    paint.setStyle(Paint.Style.FILL);
    paint.setColor(Color.RED);
    paint.setAntiAlias(true);
    canvas.drawCircle(r, r, r, paint);

    paint.reset();
    paint.setFilterBitmap(true);
    paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
    canvas.drawBitmap(src, sourceRect, destRect, paint);

    canvas.setBitmap(null);
  }
 /**
  * Gets the crop window's position relative to the source Bitmap (not the image displayed in the
  * CropImageView) and the original rotation.
  *
  * @return a RectF instance containing cropped area boundaries of the source Bitmap
  */
 @SuppressWarnings("SuspiciousNameCombination")
 public Rect getActualCropRectNoRotation() {
   if (mBitmap != null) {
     Rect rect = getActualCropRect();
     int rotateSide = mDegreesRotated / 90;
     if (rotateSide == 1) {
       rect.set(
           rect.top, mBitmap.getWidth() - rect.right, rect.bottom, mBitmap.getWidth() - rect.left);
     } else if (rotateSide == 2) {
       rect.set(
           mBitmap.getWidth() - rect.right,
           mBitmap.getHeight() - rect.bottom,
           mBitmap.getWidth() - rect.left,
           mBitmap.getHeight() - rect.top);
     } else if (rotateSide == 3) {
       rect.set(
           mBitmap.getHeight() - rect.bottom,
           rect.left,
           mBitmap.getHeight() - rect.top,
           rect.right);
     }
     rect.set(
         rect.left * mLoadedSampleSize,
         rect.top * mLoadedSampleSize,
         rect.right * mLoadedSampleSize,
         rect.bottom * mLoadedSampleSize);
     return rect;
   } else {
     return null;
   }
 }
  @Override
  protected void onDraw(Canvas canvas) {
    if (mImage != null) {
      // Switch the current animation if needed.
      if (mCurrentAnim == null || mCurrentAnim.hasEnded()) switchAnimation(canvas);

      // Animate and draw
      mCurrentAnim.getTransformation(AnimationUtils.currentAnimationTimeMillis(), mTrans);
      mStartPos[0] = 0;
      mStartPos[1] = 0;
      mTrans.getMatrix().mapPoints(mStartPos);

      mSrc.set(0, 0, mImage.getWidth(), mImage.getHeight());
      mDst.set(
          (int) mStartPos[0],
          (int) mStartPos[1],
          (int) mStartPos[0] + mScaledImageWidth,
          (int) mStartPos[1] + mScaledImageHeight);
      mPaint.setFilterBitmap(true);
      canvas.drawBitmap(mImage, mSrc, mDst, mPaint);
      super.onDraw(canvas);

      // Request another draw operation until time is up.
      invalidate();
    }
  }
示例#6
0
  @Override
  protected void onDraw(Canvas canvas) {
    int i = 1;
    if (percentList != null && !percentList.isEmpty()) {
      for (Float f : percentList) {
        rect.set(
            BAR_SIDE_MARGIN * i + barWidth * (i - 1),
            topMargin,
            (BAR_SIDE_MARGIN + barWidth) * i,
            getHeight() - bottomTextHeight - TEXT_TOP_MARGIN);
        canvas.drawRect(rect, bgPaint);
        rect.set(
            BAR_SIDE_MARGIN * i + barWidth * (i - 1),
            topMargin + (int) ((getHeight() - topMargin) * percentList.get(i - 1)),
            (BAR_SIDE_MARGIN + barWidth) * i,
            getHeight() - bottomTextHeight - TEXT_TOP_MARGIN);
        canvas.drawRect(rect, fgPaint);
        i++;
      }
    }

    if (bottomTextList != null && !bottomTextList.isEmpty()) {
      i = 1;
      for (String s : bottomTextList) {
        canvas.drawText(
            s,
            BAR_SIDE_MARGIN * i + barWidth * (i - 1) + barWidth / 2,
            getHeight() - bottomTextDescent,
            textPaint);
        i++;
      }
    }
  }
  @Override
  public void draw(@NonNull Canvas canvas) {
    super.draw(canvas);

    int width = getWidth();
    int height = getHeight();
    if (mInsets != null && mInsetForeground != null) {
      int sc = canvas.save();
      canvas.translate(getScrollX(), getScrollY());

      // Top
      mTempRect.set(0, 0, width, mInsets.top);
      mInsetForeground.setBounds(mTempRect);
      mInsetForeground.draw(canvas);

      // Bottom
      mTempRect.set(0, height - mInsets.bottom, width, height);
      mInsetForeground.setBounds(mTempRect);
      mInsetForeground.draw(canvas);

      // Left
      mTempRect.set(0, mInsets.top, mInsets.left, height - mInsets.bottom);
      mInsetForeground.setBounds(mTempRect);
      mInsetForeground.draw(canvas);

      // Right
      mTempRect.set(width - mInsets.right, mInsets.top, width, height - mInsets.bottom);
      mInsetForeground.setBounds(mTempRect);
      mInsetForeground.draw(canvas);

      canvas.restoreToCount(sc);
    }
  }
  @Override
  public void draw(@NonNull final Canvas canvas) {
    super.draw(canvas);

    // Only recalculate the close bounds if they are dirty
    if (mCloseBoundChanged) {
      mCloseBoundChanged = false;

      mClosableLayoutRect.set(0, 0, getWidth(), getHeight());
      // Create the bounds for our close regions.
      applyCloseRegionBounds(mClosePosition, mClosableLayoutRect, mCloseRegionBounds);

      // The inset rect applies padding around the visible closeButton.
      mInsetCloseRegionBounds.set(mCloseRegionBounds);
      mInsetCloseRegionBounds.inset(mCloseButtonPadding, mCloseButtonPadding);
      // The close button sits inside the close region with padding and gravity
      // in the same way the close region sits inside the whole ClosableLayout
      applyCloseButtonBounds(mClosePosition, mInsetCloseRegionBounds, mCloseButtonBounds);
      mCloseDrawable.setBounds(mCloseButtonBounds);
    }

    // Draw last so that this gets drawn as the top layer. This is also why we override
    // draw instead of onDraw.
    if (mCloseDrawable.isVisible()) {
      mCloseDrawable.draw(canvas);
    }
  }
 @Override
 protected void onDraw(Canvas canvas) {
   Drawable backgroundDrawable = ApplicationLoader.getCachedWallpaper();
   if (ApplicationLoader.isCustomTheme() && backgroundDrawable != null) {
     phoneTextView.setTextColor(0xffffffff);
     shadowView.setVisibility(VISIBLE);
     if (backgroundDrawable instanceof ColorDrawable) {
       backgroundDrawable.setBounds(0, 0, getMeasuredWidth(), getMeasuredHeight());
       backgroundDrawable.draw(canvas);
     } else if (backgroundDrawable instanceof BitmapDrawable) {
       Bitmap bitmap = ((BitmapDrawable) backgroundDrawable).getBitmap();
       float scaleX = (float) getMeasuredWidth() / (float) bitmap.getWidth();
       float scaleY = (float) getMeasuredHeight() / (float) bitmap.getHeight();
       float scale = scaleX < scaleY ? scaleY : scaleX;
       int width = (int) (getMeasuredWidth() / scale);
       int height = (int) (getMeasuredHeight() / scale);
       int x = (bitmap.getWidth() - width) / 2;
       int y = (bitmap.getHeight() - height) / 2;
       srcRect.set(x, y, x + width, y + height);
       destRect.set(0, 0, getMeasuredWidth(), getMeasuredHeight());
       canvas.drawBitmap(bitmap, srcRect, destRect, paint);
     }
   } else {
     shadowView.setVisibility(INVISIBLE);
     phoneTextView.setTextColor(0xffc2e5ff);
     super.onDraw(canvas);
   }
 }
示例#10
0
  @Override
  protected void onLayout(boolean changed, int l, int t, int r, int b) {
    mContent.set(
        getPaddingLeft(), getPaddingTop(), r - l - getPaddingRight(), b - t - getPaddingBottom());
    final int width = mContent.width();
    final int height = mContent.height();

    // no scrolling yet, so tell dimensions to fill exactly
    mHoriz.setSize(width);
    mVert.setSize(height);

    final Rect parentRect = new Rect();
    final Rect childRect = new Rect();

    for (int i = 0; i < getChildCount(); i++) {
      final View child = getChildAt(i);
      final LayoutParams params = (LayoutParams) child.getLayoutParams();

      parentRect.set(mContent);

      if (child instanceof ChartNetworkSeriesView || child instanceof ChartGridView) {
        // series are always laid out to fill entire graph area
        // TODO: handle scrolling for series larger than content area
        Gravity.apply(params.gravity, width, height, parentRect, childRect);
        child.layout(childRect.left, childRect.top, childRect.right, childRect.bottom);

      } else if (child instanceof ChartSweepView) {
        layoutSweep((ChartSweepView) child, parentRect, childRect);
        child.layout(childRect.left, childRect.top, childRect.right, childRect.bottom);
      }
    }
  }
 protected void onDraw(Canvas canvas)
 {
     this;
     JVM INSTR monitorenter ;
     c.set(getThumbOffset(), getHeight() / 2 - f / 4, getWidth() - getThumbOffset(), getHeight() / 2 + f / 4);
     d.setColor(0xff888888);
     canvas.drawRect(c, d);
     int i = getWidth();
     int j = getHeight();
     canvas.drawBitmap(e, i / 2 - e.getWidth() / 2, j / 2 - e.getHeight() / 2, null);
     if (getProgress() > 500)
     {
         c.set(getWidth() / 2, getHeight() / 2 - f / 2, (getWidth() / 2 + (getWidth() * (getProgress() - 500)) / 1000) - ((getProgress() - 500) * getThumbOffset()) / 500, getHeight() / 2 + f / 2);
         d.setColor(g.getResources().getColor(0x7f0f0007));
         canvas.drawRect(c, d);
     }
     if (getProgress() < 500)
     {
         c.set((getWidth() / 2 - (getWidth() * (500 - getProgress())) / 1000) + ((500 - getProgress()) * getThumbOffset()) / 500, getHeight() / 2 - f / 2, getWidth() / 2, getHeight() / 2 + f / 2);
         d.setColor(g.getResources().getColor(0x7f0f0007));
         canvas.drawRect(c, d);
     }
     super.onDraw(canvas);
     this;
     JVM INSTR monitorexit ;
     return;
     canvas;
     throw canvas;
 }
  @Override
  public void onDraw(final Canvas canvas) {
    final int frame = mCurrentFrame++;
    if (mVerticalFrames) {
      final int top = mFrameSize.y * frame;
      mSource.set(0, top, mFrameSize.x, top + mFrameSize.y);
    } else {
      final int left = mFrameSize.x * frame;
      mSource.set(left, 0, left + mFrameSize.x, mFrameSize.y);
    }

    final int destWidth =
        mTileModeX == Shader.TileMode.REPEAT ? mScaledSize.x : mDestination.width();
    final int destHeight =
        mTileModeY == Shader.TileMode.REPEAT ? mScaledSize.y : mDestination.height();
    for (int l = mDestination.left, r = mDestination.right; l < r; l += destWidth) {
      for (int t = mDestination.top, b = mDestination.bottom; t < b; t += destHeight) {
        mTempDestination.left = l;
        mTempDestination.right = l + destWidth;
        mTempDestination.top = t;
        mTempDestination.bottom = t + destHeight;
        canvas.drawBitmap(mBitmap, mSource, mTempDestination, mPaint);
      }
    }
    if (mCurrentFrame >= mFrames) {
      mCurrentFrame = 0;
    }
  }
示例#13
0
 @Override
 protected void onDraw(Canvas canvas) {
   if (processor.isLoaded()) {
     int offsetLeft = (getWidth() - countInRow * smileySize) / 2;
     for (int i = 0; i < smileyIds.length; i++) {
       int row = i / countInRow;
       int col = i % countInRow;
       rect.set(
           col * smileySize + smileyPadding + offsetLeft,
           row * smileySize + smileyPadding,
           (col + 1) * smileySize - smileyPadding + offsetLeft,
           (row + 1) * smileySize - smileyPadding);
       if (!canvas.quickReject(rect.left, rect.top, rect.right, rect.bottom, Canvas.EdgeType.AA)) {
         Bitmap img = processor.getSection(smileysSections[i]);
         if (img != null) {
           sectionRect.set(
               smileysX[i] * smileySrcSize,
               smileysY[i] * smileySrcSize,
               (smileysX[i] + 1) * smileySrcSize,
               (smileysY[i] + 1) * smileySrcSize);
           canvas.drawBitmap(img, sectionRect, rect, paint);
         }
       }
     }
   }
 }
  @Override
  protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);

    // draw the entire background battery image in gray
    Rect srcRect = new Rect(0, 0, silhouette.getWidth(), silhouette.getHeight());
    Rect destRect = new Rect(0, 0, getWidth(), getHeight());

    canvas.drawBitmap(silhouette, srcRect, destRect, gray);

    Paint fillPaint;
    if (levelPercent < 20) {
      fillPaint = red;
    } else if (levelPercent < 50) {
      fillPaint = yellow;
    } else {
      fillPaint = green;
    }

    // draw a portion of the foreground battery image with the width coming from levelPercent.
    srcRect.set(0, 0, (int) (silhouette.getWidth() * levelPercent / 100f), silhouette.getHeight());
    destRect.set(0, 0, (int) (getWidth() * levelPercent / 100f), getHeight());

    canvas.drawBitmap(silhouette, srcRect, destRect, fillPaint);

    if (pluggedIn) {
      srcRect.set(0, 0, plug.getWidth(), plug.getHeight());
      destRect.set(getWidth() / 5, getHeight() / 5, (getWidth() * 4) / 5, (getHeight() * 4) / 5);

      canvas.drawBitmap(plug, srcRect, destRect, new Paint());
    }
  }
示例#15
0
  /** {@inheritDoc} */
  @Override
  public void draw(Canvas canvas) {
    super.draw(canvas);

    if (mForeground != null) {
      final Drawable foreground = mForeground;

      if (mForegroundBoundsChanged) {
        mForegroundBoundsChanged = false;
        final Rect selfBounds = mSelfBounds;
        final Rect overlayBounds = mOverlayBounds;

        final int w = mRight - mLeft;
        final int h = mBottom - mTop;

        if (mForegroundInPadding) {
          selfBounds.set(0, 0, w, h);
        } else {
          selfBounds.set(mPaddingLeft, mPaddingTop, w - mPaddingRight, h - mPaddingBottom);
        }

        final int layoutDirection = getLayoutDirection();
        Gravity.apply(
            mForegroundGravity,
            foreground.getIntrinsicWidth(),
            foreground.getIntrinsicHeight(),
            selfBounds,
            overlayBounds,
            layoutDirection);
        foreground.setBounds(overlayBounds);
      }

      foreground.draw(canvas);
    }
  }
 @Override
 protected void onDraw(Canvas canvas) {
   // TODO Auto-generated method stub
   super.onDraw(canvas);
   if (mMoveDeltX > 0 || mMoveDeltX == 0 && mSwitchOn) {
     if (mSrc != null) {
       mSrc.set(
           mMoveLength - mMoveDeltX,
           0,
           mSwitchBottom.getWidth() - mMoveDeltX,
           mSwitchFrame.getHeight());
     }
   } else if (mMoveDeltX < 0 || mMoveDeltX == 0 && !mSwitchOn) {
     if (mSrc != null) {
       mSrc.set(-mMoveDeltX, 0, mSwitchFrame.getWidth() - mMoveDeltX, mSwitchFrame.getHeight());
     }
   }
   Log.d("mAlpha", "mAlpha:" + mAlpha);
   canvas.saveLayerAlpha(
       new RectF(mDest),
       mAlpha,
       Canvas.MATRIX_SAVE_FLAG
           | Canvas.CLIP_SAVE_FLAG
           | Canvas.HAS_ALPHA_LAYER_SAVE_FLAG
           | Canvas.FULL_COLOR_LAYER_SAVE_FLAG
           | Canvas.CLIP_TO_LAYER_SAVE_FLAG);
   canvas.drawBitmap(mSwitchBottom, mSrc, mDest, null);
   canvas.drawBitmap(mSwitchThumb, mSrc, mDest, null);
   canvas.drawBitmap(mSwitchFrame, 0, 0, null);
   canvas.drawBitmap(mSwitchMask, 0, 0, mPaint);
   canvas.restore();
 }
示例#17
0
  /**
   * Draw debug information on the Canvas
   *
   * @param c Canvas to draw to
   */
  private void drawDebugInfo(Canvas c) {
    paint.setColor(Color.WHITE);
    paint.setTextSize(10);

    // Draw FPS
    c.drawText("FPS: " + dispFps, screenDims.x - 40, 10, paint);

    // Draw last touch
    c.drawText("Last touch: " + lastTouch.x + "," + lastTouch.y, screenDims.x - 95, 25, paint);

    // Draw worker/renderer ratio bar
    if (renderTime != 0) {
      paint.setColor(resources.getColor(android.R.color.holo_green_dark));
      ratioBarOuter.set(screenDims.x - 300, 30, screenDims.x, 40);
      c.drawRect(ratioBarOuter, paint);

      float percentage = ((float) updateTime / (float) renderTime);
      percentage *= 100.0F;
      int workerBarWidth = (int) percentage;
      workerBarWidth *= 3; // For 100px on a 300px bar

      //			report("drawDebugInfo()", "W/R: " + (updateTime) + "/" + (renderTime) + " = " +
      // percentage + " for " + workerBarWidth + " px width");

      paint.setColor(resources.getColor(android.R.color.holo_green_light));
      ratioBarWorker.set(screenDims.x - 300, 30, (screenDims.x - 300) + workerBarWidth, 40);
      c.drawRect(ratioBarWorker, paint);
    }

    // Draw log console
    if (console == null) console = new Console();
    console.draw(c);
  }
  @Override
  protected void onDraw(Canvas canvas) {
    final Drawable background = mBackground;

    final int right = getWidth();
    final int bottom = getHeight();

    // Draw behind recents
    if (mOrientation == VERTICAL) {
      mDrawRect.set(0, 0, right, mFavoritesStart);
    } else {
      mDrawRect.set(0, 0, mFavoritesStart, bottom);
    }
    background.setBounds(mDrawRect);
    background.draw(canvas);

    // Draw behind favorites
    if (mFavoritesStart > -1) {
      if (mOrientation == VERTICAL) {
        mDrawRect.set(0, mFavoritesStart, right, mFavoritesEnd);
      } else {
        mDrawRect.set(mFavoritesStart, 0, mFavoritesEnd, bottom);
      }
      background.setBounds(mDrawRect);
      background.draw(canvas);
    }

    super.onDraw(canvas);
  }
示例#19
0
 private void getScreenBitmap() {
   mView.getRootView().destroyDrawingCache();
   mView.getGlobalVisibleRect(mRect, point);
   realheight = mView.getHeight();
   realwidth = mView.getWidth();
   dst.set(0, 0, realwidth, realheight);
   int w = Math.round(realwidth * BITMAP_RATIO);
   int h = Math.round(realheight * BITMAP_RATIO);
   w = w & ~0x03;
   h = h & ~0x03;
   if (w <= 0 || h <= 0) return;
   if (bitmap == null || bitmap.getWidth() != w || bitmap.getHeight() != h) {
     bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
     mMatrix.setScale(BITMAP_RATIO, BITMAP_RATIO);
     mMatrix.invert(mDrawMatrix);
     src.set(0, 0, w, h);
   }
   float dx = -(Math.min(0, mView.getLeft()) + mRect.left);
   float dy = (-point.y);
   mCanvas.restoreToCount(1);
   mCanvas.setBitmap(bitmap);
   mCanvas.setMatrix(mMatrix);
   mCanvas.translate(dx, dy);
   mCanvas.save();
   mView.getRootView().draw(mCanvas);
 }
示例#20
0
  /** 画面サイズから自位置を決定します。 */
  private void updateViewLayout() {
    cancelAnimation();

    // 前の画面座標を保存
    final int oldScreenHeight = mMetrics.heightPixels;
    final int oldScreenWidth = mMetrics.widthPixels;
    final int oldPositionLimitWidth = mPositionLimitRect.width();
    final int oldPositionLimitHeight = mPositionLimitRect.height();

    // 新しい座標情報に切替
    mWindowManager.getDefaultDisplay().getMetrics(mMetrics);
    final int width = getMeasuredWidth();
    final int height = getMeasuredHeight();
    final int newScreenWidth = mMetrics.widthPixels;
    final int newScreenHeight = mMetrics.heightPixels;

    // 移動範囲の設定
    mMoveLimitRect.set(-width, -height * 2, newScreenWidth + width, newScreenHeight + height);
    mPositionLimitRect.set(
        -mOverMargin,
        0,
        newScreenWidth - width + mOverMargin,
        newScreenHeight - mStatusBarHeight - height);

    // 縦横切替の場合
    if (oldScreenWidth != newScreenWidth || oldScreenHeight != newScreenHeight) {
      // 画面端に移動する場合は現在の位置から左右端を設定
      if (mMoveDirection == FloatingViewManager.MOVE_DIRECTION_DEFAULT) {
        // 右半分にある場合
        if (mParams.x > (newScreenWidth - width) / 2) {
          mParams.x = mPositionLimitRect.right;
        }
        // 左半分にある場合
        else {
          mParams.x = mPositionLimitRect.left;
        }
      }
      // 左端に移動
      else if (mMoveDirection == FloatingViewManager.MOVE_DIRECTION_LEFT) {
        mParams.x = mPositionLimitRect.left;
      }
      // 右端に移動
      else if (mMoveDirection == FloatingViewManager.MOVE_DIRECTION_RIGHT) {
        mParams.x = mPositionLimitRect.right;
      }
      // 画面端に移動しない場合は画面座標の比率から計算
      else {
        final int newX =
            (int) (mParams.x * mPositionLimitRect.width() / (float) oldPositionLimitWidth + 0.5f);
        mParams.x = Math.min(Math.max(mPositionLimitRect.left, newX), mPositionLimitRect.right);
      }

      // スクリーン位置の比率からY座標を設定(四捨五入)
      final int newY =
          (int) (mParams.y * mPositionLimitRect.height() / (float) oldPositionLimitHeight + 0.5f);
      mParams.y = Math.min(Math.max(mPositionLimitRect.top, newY), mPositionLimitRect.bottom);
      mWindowManager.updateViewLayout(this, mParams);
    }
  }
 @Override
 public void getItemOffsets(Rect outRect, int itemPosition, RecyclerView parent) {
   if (mOrientation == VERTICAL_LIST) {
     outRect.set(0, 0, 0, mDivider.getIntrinsicHeight());
   } else {
     outRect.set(0, 0, mDivider.getIntrinsicWidth(), 0);
   }
 }
 /**
  * 给divider预留空间 与padding或margin类似,LayoutManager在测量阶段会调用该方法,计算出每一个Item的正确尺寸并设置偏移量。
  *
  * @param outRect
  * @param view
  * @param parent
  * @param state
  */
 @Override
 public void getItemOffsets(
     Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
   if (OrientationHelper.HORIZONTAL == orientation) {
     outRect.set(0, 0, mDivider.getIntrinsicWidth(), 0);
   } else {
     outRect.set(0, 0, 0, mDivider.getIntrinsicHeight());
   }
 }
 @Override
 public void getItemOffsets(
     @NonNull Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
   if (mOrientation == VERTICAL_LIST) {
     outRect.set(0, 0, 0, mDivider.getIntrinsicHeight());
   } else {
     outRect.set(0, 0, mDivider.getIntrinsicWidth(), 0);
   }
 }
示例#24
0
 /**
  * 设置item分割线的size
  *
  * @param outRect
  * @param view
  * @param parent
  * @param state
  */
 @Override
 public void getItemOffsets(
     Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
   if (mOrientation == LinearLayoutManager.VERTICAL) {
     outRect.set(0, 0, 0, mItemSize);
   } else {
     outRect.set(0, 0, mItemSize, 0);
   }
 }
 public void setFrameHeight(int height) {
   mFrameHeight = height;
   mBackgroundRect.set(0, 0, getMeasuredWidth(), Math.min(mFrameHeight, getMeasuredHeight()));
   mForegroundRect.set(
       mFrameStrokeAdjustment,
       mFrameStrokeAdjustment,
       getMeasuredWidth() - mFrameStrokeAdjustment,
       Math.min(getMeasuredHeight(), mFrameHeight) - mFrameStrokeAdjustment);
   updateGradient();
   invalidate();
 }
 /**
  * Returns the frame Rect for applications runs under compatibility mode.
  *
  * @param dm the display metrics used to compute the frame size.
  * @param orientation the orientation of the screen.
  * @param outRect the output parameter which will contain the result.
  */
 public static void updateCompatibleScreenFrame(DisplayMetrics dm, int orientation, Rect outRect) {
   int width = dm.widthPixels;
   int portraitHeight = (int) (DEFAULT_PORTRAIT_HEIGHT * dm.density + 0.5f);
   int portraitWidth = (int) (DEFAULT_PORTRAIT_WIDTH * dm.density + 0.5f);
   if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
     int xOffset = (width - portraitHeight) / 2;
     outRect.set(xOffset, 0, xOffset + portraitHeight, portraitWidth);
   } else {
     int xOffset = (width - portraitWidth) / 2;
     outRect.set(xOffset, 0, xOffset + portraitWidth, portraitHeight);
   }
 }
 /**
  * Returns the task stack bounds in the current orientation. These bounds do not account for the
  * system insets.
  */
 public void getTaskStackBounds(
     int windowWidth, int windowHeight, int topInset, int rightInset, Rect taskStackBounds) {
   Rect searchBarBounds = new Rect();
   getSearchBarBounds(windowWidth, windowHeight, topInset, searchBarBounds);
   if (isLandscape && hasTransposedSearchBar) {
     // In landscape, the search bar appears on the left, but we overlay it on top
     taskStackBounds.set(0, topInset, windowWidth - rightInset, windowHeight);
   } else {
     // In portrait, the search bar appears on the top (which already has the inset)
     taskStackBounds.set(0, searchBarBounds.bottom, windowWidth, windowHeight);
   }
 }
示例#28
0
        @Override
        public void handleTile(
            final Canvas pCanvas,
            final int pTileSizePx,
            final MapTile pTile,
            final int pX,
            final int pY) {
          // no overflow detected here Log.d(IMapView.LOGTAG, "handleTile " + pTile.toString() +
          // ","+pX + "," + pY);
          Drawable currentMapTile = mTileProvider.getMapTile(pTile);
          boolean isReusable = currentMapTile instanceof ReusableBitmapDrawable;
          final ReusableBitmapDrawable reusableBitmapDrawable =
              isReusable ? (ReusableBitmapDrawable) currentMapTile : null;
          if (currentMapTile == null) {
            currentMapTile = getLoadingTile();
          }

          if (currentMapTile != null) {
            mTilePoint.set(pX * pTileSizePx, pY * pTileSizePx);
            mTileRect.set(
                mTilePoint.x, mTilePoint.y, mTilePoint.x + pTileSizePx, mTilePoint.y + pTileSizePx);
            if (isReusable) {
              reusableBitmapDrawable.beginUsingDrawable();
            }
            try {
              if (isReusable && !((ReusableBitmapDrawable) currentMapTile).isBitmapValid()) {
                currentMapTile = getLoadingTile();
                isReusable = false;
              }
              onTileReadyToDraw(pCanvas, currentMapTile, mTileRect);
            } finally {
              if (isReusable) reusableBitmapDrawable.finishUsingDrawable();
            }
          }

          if (DEBUGMODE) {
            mTileRect.set(
                pX * pTileSizePx,
                pY * pTileSizePx,
                pX * pTileSizePx + pTileSizePx,
                pY * pTileSizePx + pTileSizePx);
            pCanvas.drawText(
                pTile.toString(),
                mTileRect.left + 1,
                mTileRect.top + mDebugPaint.getTextSize(),
                mDebugPaint);
            pCanvas.drawLine(
                mTileRect.left, mTileRect.top, mTileRect.right, mTileRect.top, mDebugPaint);
            pCanvas.drawLine(
                mTileRect.left, mTileRect.top, mTileRect.left, mTileRect.bottom, mDebugPaint);
          }
        }
 private void propagateViewportToLayouts(int contentWidth, int contentHeight) {
   int heightMinusTopControls = contentHeight - getTopControlsHeightPixels();
   mCacheViewport.set(0, (int) mLastContentOffset, contentWidth, contentHeight);
   mCacheVisibleViewport.set(0, (int) mLastVisibleContentOffset, contentWidth, contentHeight);
   // TODO(changwan): check if this can be merged with setContentMotionEventOffsets.
   if (mTabVisible != null && mTabVisible.getContentViewCore() != null) {
     mTabVisible
         .getContentViewCore()
         .setSmartClipOffsets(-mCacheViewport.left, -mCacheViewport.top);
   }
   if (mLayoutManager != null) {
     mLayoutManager.pushNewViewport(mCacheViewport, mCacheVisibleViewport, heightMinusTopControls);
   }
 }
 @Override
 public void getItemOffsets(Rect outRect, int itemPosition, RecyclerView parent) {
   int spanCount = getSpanCount(parent);
   int childCount = parent.getAdapter().getItemCount();
   if (isLastRaw(parent, itemPosition, spanCount, childCount)) // 如果是最后一行,则不需要绘制底部
   {
     outRect.set(0, 0, mDivider.getIntrinsicWidth(), 0);
   } else if (isLastColum(parent, itemPosition, spanCount, childCount)) // 如果是最后一列,则不需要绘制右边
   {
     outRect.set(0, 0, 0, mDivider.getIntrinsicHeight());
   } else {
     outRect.set(0, 0, mDivider.getIntrinsicWidth(), mDivider.getIntrinsicHeight());
   }
 }