Bonjour tout le monde je travail sur une appli android qui fait le recadrage d'une image j'ai cherché un peu a droite a gauche sur internet et livre et voila ce que j'ai trouvé voir le code en dessous:  
 le probleme c'est que : eclipse me signale une erreur au niveau des portions de code en rouge (TextureImageDetailsActivity) et je sais pas comment les resoudre aidez mois svp a les resoudres  merci infiniment            
 
 
Code :
class ImageViewWithRectangle extends ImageView {
// Enable or not the cropping rectangle
private boolean hasCropRectangle = false;
// Cropping rectangle that we are drawing over the image
private RectF croppingRect = new RectF();
private RectF intialcroppingRect;
private boolean cropRectInitialized = false;
// Turns this boolean to false when we touch inside it
private boolean moveRectangle = false;
// Turns this boolean to true when we touch the border of the rectangle
private boolean resizeRectangle = false;
// Index of the corner that the user is currently dragging
private int sideIndex = -1;
// Maximum distance from a side to consider that we are touching it
private final float MAXDIST = 20;
// Minimum size of the cropping rectangle
private final int MINSIZE = 5;
// Values to deal with the touching
private float oldTouchValueX;
private float oldTouchValueY;
// This is the bounds of the drawable inside the image view
private RectF drawableRect;
TextureImageDetailsActivity parentContext;
public ImageViewWithRectangle(Context context, AttributeSet attrs) {
 super(context, attrs);
 intialcroppingRect = new RectF(20f, 20f, 80f, 80f);
}
// Set the parent so we can tell it when the crop rectangle is moved
public void setParentContext(TextureImageDetailsActivity context) {
 parentContext = context;
}
@Override
public void setImageDrawable (Drawable drawable) {
 super.setImageDrawable(drawable);
 intialcroppingRect.set(20f, 20f, 80f, 80f);
}
public void setIsCropped(boolean cropRectangleActivated) {
 hasCropRectangle = cropRectangleActivated;
 cropRectInitialized = false;
 // Invalidate the view so show or hide the rectangle
 invalidate();
}
// Set the cropping rectangle by given value in percentage
public void setCroppingRectangle(RectF cropRect) {
 intialcroppingRect = cropRect;
 cropRectInitialized = false;
}
public RectF getCroppingRectangle() {
 return croppingRect;
}
@Override
protected void onDraw (Canvas canvas) {
 // Let the image draw itself first
 super.onDraw(canvas);
 if (hasCropRectangle) {
  // If we draw the image for the first time we need to initialize the crop rectangle.
  if (!cropRectInitialized) {
   computeDrawableRect();
   float widthratio = drawableRect.width()/100f;
   float heightratio = drawableRect.height()/100f;
   croppingRect.set(intialcroppingRect.left*widthratio + drawableRect.left,
        intialcroppingRect.top*heightratio  + drawableRect.top,
        intialcroppingRect.right*widthratio + drawableRect.left,
        intialcroppingRect.bottom*heightratio + drawableRect.top);
   cropRectInitialized = true;
  }
  // Creates a paint object and sets its attributes
  Paint paint = new Paint();
  // Depending if we move the rectangle or not, we use a different color
  if (moveRectangle)
   paint.setColor(Color.GREEN);
  else
   paint.setColor(Color.RED);
  paint.setStrokeWidth(3);
  paint.setStyle(Style.STROKE);
  // Draw a rectangle
  canvas.drawRect(croppingRect, paint);
  // Set the color to green to draw the selected side
  paint.setColor(Color.GREEN);
  // Change the color of the touched side if we are in the operation of resizing the rectangle
  if (sideIndex == 0)
   // Top side
   canvas.drawLine(croppingRect.left, croppingRect.top, croppingRect.right, croppingRect.top, paint);
  else if (sideIndex == 1)
   //  Right side
   canvas.drawLine(croppingRect.right, croppingRect.top, croppingRect.right, croppingRect.bottom, paint);
  else if (sideIndex == 2)
   // Bottom side
   canvas.drawLine(croppingRect.right, croppingRect.bottom, croppingRect.left, croppingRect.bottom, paint);
  else if (sideIndex == 3)
   // Left side
   canvas.drawLine(croppingRect.left, croppingRect.bottom, croppingRect.left, croppingRect.top, paint);
  // From here we darken the outside of the cropping rectangle to  
  // give a better view of what is ketp.
  paint.setColor(Color.BLACK);
  paint.setAlpha(100);
  paint.setStyle(Paint.Style.FILL);
  // Create a path with the imageview bounds minus the cropping rectangle.
  Path path = new Path();
  path.addRect(0, 0, getWidth(), getHeight(), Path.Direction.CW);
  path.addRect(croppingRect, Path.Direction.CCW);
  path.setFillType(Path.FillType.EVEN_ODD);
  // Draw this path.
  canvas.drawPath(path, paint);
 }
}
    @Override
    public boolean dispatchTouchEvent(MotionEvent ev){
        super.dispatchTouchEvent(ev);
        return onTouchEvent(ev);
    }
    // Calculate drawable rect
    private void computeDrawableRect() {
   
     // Ratio of the imageView
 float imageRatio = (float)getWidth()/getHeight();
 float drawableRatio = (float)getDrawable().getIntrinsicWidth()/getDrawable().getIntrinsicHeight();
 float dWidth = getDrawable().getIntrinsicWidth();
 float dHeight = getDrawable().getIntrinsicHeight();
 drawableRect = new RectF();
 // If the images have the same ratio, the drawable rect is the same than the image view
 if (imageRatio == drawableRatio)
  drawableRect.set(0, 0, getWidth(), getHeight());
 // If the width is the biggest side in both image
 else if (imageRatio < drawableRatio) {
  // Get the ratio between the two width
  float ratio = dWidth/getWidth();
  // So calculate the new size of the height
  float height = dHeight/ratio;
  float diff = (getHeight() - height)/2f;
  // We have now the size of the scaled drawable
  drawableRect.set(0, diff, getWidth(), diff + height);
 }
 // If the height is the biggest side in both image
 else if (imageRatio > drawableRatio) {
  // Get the ratio between the two width
  float ratio = dHeight/getHeight();
  // So calculate the new size of the height
  float width = dWidth/ratio;
  float diff = (getWidth() - width)/2f;
  // We have now the size of the scaled drawable
  drawableRect.set(diff, 0, diff + width, getHeight());
 }
    }
   
@Override
public boolean onTouchEvent(MotionEvent event) {
 // Reimplement the touch event to resize and move the position of the cropping rectangle
 switch (event.getAction())
 {
 case MotionEvent.ACTION_DOWN:
 {
  oldTouchValueX = event.getX();
  oldTouchValueY = event.getY();
  // Test if the finger touch one of the side
  // The side index goes from 0 to 3 with 0 as the top, 1 is the right,  
  //                  2 bottom and 3 left
  if (oldTouchValueX > croppingRect.left && oldTouchValueX < croppingRect.right
   && Math.abs(oldTouchValueY - croppingRect.top) < MAXDIST)
   sideIndex = 0;
  else if (oldTouchValueY > croppingRect.top && oldTouchValueY < croppingRect.bottom
    && Math.abs(oldTouchValueX - croppingRect.right) < MAXDIST)
   sideIndex = 1;
  else if (oldTouchValueX > croppingRect.left && oldTouchValueX < croppingRect.right
    && Math.abs(oldTouchValueY - croppingRect.bottom) < MAXDIST)
   sideIndex = 2;
  else if (oldTouchValueY > croppingRect.top && oldTouchValueY < croppingRect.bottom
    && Math.abs(oldTouchValueX - croppingRect.left) < MAXDIST)
   sideIndex = 3;
  if (sideIndex != -1)
   resizeRectangle = true;
  else if (croppingRect.contains(oldTouchValueX, oldTouchValueY))
   moveRectangle = true;
  // Invalidate the view so the rectangle is getting redraw
  invalidate();
  return resizeRectangle || moveRectangle;
 }
 case MotionEvent.ACTION_MOVE:
 {
  // Get the new position of the finger
  float currentX = event.getX();
  float currentY = event.getY();
  if (hasCropRectangle) {
   // If in the right mode, moves the rectangle by the difference  
   if (moveRectangle) {
    float offsetX = currentX-oldTouchValueX;
    float offsetY = currentY-oldTouchValueY;
    // Check if the offset will not make the rectangle to go outside of the view
    if (croppingRect.right + offsetX > drawableRect.right)
     offsetX = 0;
    else if (croppingRect.left + offsetX < drawableRect.left)
     offsetX = 0;
    if (croppingRect.top + offsetY < drawableRect.top)
     offsetY = 0;
    else if (croppingRect.bottom + offsetY > drawableRect.bottom)
     offsetY = 0;
    croppingRect.offset(offsetX, offsetY);
    // Invalidate the view so the rectangle is getting redraw
    invalidate();
   }
   else if (resizeRectangle) {
    float width = drawableRect.right;
    float height = drawableRect.bottom;
    // Depending on the side we are currently touching,  
    // we change the coordinate of the appropriate parameter
    switch (sideIndex) {
    case 0 : if (currentY > drawableRect.top && currentY < height && currentY < (croppingRect.bottom - MINSIZE)) croppingRect.top = currentY;
       break;
    case 1 : if (currentX > drawableRect.left && currentX < width && croppingRect.left < (currentX - MINSIZE)) croppingRect.right = currentX;
       break;
    case 2 : if (currentY > drawableRect.top && currentY < height && croppingRect.top < (currentY - MINSIZE)) croppingRect.bottom = currentY;
            break;
    case 3 : if (currentX > drawableRect.left && currentX < width && currentX < (croppingRect.right - MINSIZE)) croppingRect.left = currentX;
       break;
    }
    // Invalidate the view so the rectangle is getting redraw
    invalidate();
   }
  }
  // Register the position of the finger at the end of the move
  oldTouchValueX = currentX;
  oldTouchValueY = currentY;
  return true;
 }
 case MotionEvent.ACTION_UP:
 {
  // When the finger is lift, we turn every boolean to false
  moveRectangle = false;
  resizeRectangle = false;
  sideIndex = -1;
  // Tells the parent the rectangle was moved
  parentContext.setCropRect();
  // Invalidate the view so the rectangle is getting redraw
  invalidate();
  return true;
 }
 }
 return super.onTouchEvent(event);
}
// Returns the ratio width/height of the crop rectangle
public float getRatio() {
 return croppingRect.width()/croppingRect.height();
}
// Returns the cropping rectangle in percentage of the width and height
RectF getCropRectInBitmapCoordinate() {
 if (drawableRect == null)
  return intialcroppingRect;
 float widthratio = 100f/drawableRect.width();
 float heightratio = 100f/drawableRect.height();
 RectF cropRect = new RectF((croppingRect.left - drawableRect.left)*widthratio,
        (croppingRect.top - drawableRect.top)*heightratio,
        (croppingRect.right - drawableRect.left)*widthratio,
        (croppingRect.bottom - drawableRect.top)*heightratio);
 return cropRect;
}
// Returns a bitmap which is cropped with the cropping rectangle
public Bitmap getBitmap() {
 if (getDrawable() == null)
  return null;
 // Return the complete image or the cropped rectangle
 else if (hasCropRectangle) {
  Bitmap bitmap = ((BitmapDrawable)getDrawable()).getBitmap();
  return Bitmap.createBitmap(bitmap,
    Math.round(croppingRect.left), Math.round(croppingRect.top),
    Math.round(croppingRect.width()), Math.round(croppingRect.height()));
 }
 else
  return ((BitmapDrawable)getDrawable()).getBitmap();
}
}

Ce sujet a été déplacé de la catégorie OS Alternatifs vers la categorie Technologies Mobiles par O'gure