Jak mogę napompować niestandardowy widok w XML?

Question

To jest moja pierwsza próba użycia niestandardowego widoku w XML i nie jestem pewien, jak to zrobić. Każda pomoc będzie wielce ceniona.

Używam Interfuser's coverflow i muszę nadmuchać, gdzie mogę go używać w formacie XML, więc mogę dodać inne elementy w widoku.

Mam nadzieję, że poniższy kod pokaże, czego potrzebuję (próbuje zrobić). Jestem pewien, że to jest łatwiejsze niż myślę.

Thnx

Układ:

<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
android:layout_width="fill_parent" 
android:layout_height="fill_parent" 
android:orientation="horizontal" > 

<com.myapp.home.CoverFlow 
    android:id="@+id/coverFlow1" 
    android:layout_width="wrap_content" 
    android:layout_height="10dip" /> 

</LinearLayout> 

CoverFlow.java:

package com.myapp.home; 

public class CoverFlow extends Gallery { 

/** 
* Graphics Camera used for transforming the matrix of ImageViews 
*/ 
private Camera mCamera = new Camera(); 

/** 
* The maximum angle the Child ImageView will be rotated by 
*/  
private int mMaxRotationAngle = 60; 

/** 
* The maximum zoom on the centre Child 
*/ 
private int mMaxZoom = -120; 

/** 
* The Centre of the Coverflow 
*/ 
private int mCoveflowCenter; 

public CoverFlow(Context context) { 
super(context); 
this.setStaticTransformationsEnabled(true); 
} 

public CoverFlow(Context context, AttributeSet attrs) { 
super(context, attrs); 
    this.setStaticTransformationsEnabled(true); 
} 

public CoverFlow(Context context, AttributeSet attrs, int defStyle) { 
super(context, attrs, defStyle); 
this.setStaticTransformationsEnabled(true); 
} 

/** 
* Get the max rotational angle of the image 
* @return the mMaxRotationAngle 
*/ 
public int getMaxRotationAngle() { 
return mMaxRotationAngle; 
} 

/** 
* Set the max rotational angle of each image 
* @param maxRotationAngle the mMaxRotationAngle to set 
*/ 
public void setMaxRotationAngle(int maxRotationAngle) { 
mMaxRotationAngle = maxRotationAngle; 
} 

/** 
* Get the Max zoom of the centre image 
* @return the mMaxZoom 
*/ 
public int getMaxZoom() { 
return mMaxZoom; 
} 

/** 
* Set the max zoom of the centre image 
* @param maxZoom the mMaxZoom to set 
*/ 
public void setMaxZoom(int maxZoom) { 
mMaxZoom = maxZoom; 
} 

/** 
* Get the Centre of the Coverflow 
* @return The centre of this Coverflow. 
*/ 
private int getCenterOfCoverflow() { 
    return (getWidth() - getPaddingLeft() - getPaddingRight())/2 + getPaddingLeft(); 
} 

/** 
* Get the Centre of the View 
* @return The centre of the given view. 
*/ 
private static int getCenterOfView(View view) { 
    return view.getLeft() + view.getWidth()/2; 
} 
/** 
* {@inheritDoc} 
* 
* @see #setStaticTransformationsEnabled(boolean) 
*/ 
protected boolean getChildStaticTransformation(View child, Transformation t) { 

final int childCenter = getCenterOfView(child); 
final int childWidth = child.getWidth() ; 
int rotationAngle = 0; 

t.clear(); 
t.setTransformationType(Transformation.TYPE_MATRIX); 

    if (childCenter == mCoveflowCenter) { 
     transformImageBitmap((ImageView) child, t, 0); 
    } else {  
     rotationAngle = (int) (((float) (mCoveflowCenter - childCenter)/ childWidth) *  mMaxRotationAngle); 
     if (Math.abs(rotationAngle) > mMaxRotationAngle) { 
     rotationAngle = (rotationAngle < 0) ? -mMaxRotationAngle : mMaxRotationAngle; 
     } 
     transformImageBitmap((ImageView) child, t, rotationAngle);   
    }  

return true; 
} 

/** 
* This is called during layout when the size of this view has changed. If 
* you were just added to the view hierarchy, you're called with the old 
* values of 0. 
* 
* @param w Current width of this view. 
* @param h Current height of this view. 
* @param oldw Old width of this view. 
* @param oldh Old height of this view. 
*/ 
protected void onSizeChanged(int w, int h, int oldw, int oldh) { 
    mCoveflowCenter = getCenterOfCoverflow(); 
    super.onSizeChanged(w, h, oldw, oldh); 
} 

/** 
    * Transform the Image Bitmap by the Angle passed 
    * 
    * @param imageView ImageView the ImageView whose bitmap we want to rotate 
    * @param t transformation 
    * @param rotationAngle the Angle by which to rotate the Bitmap 
    */ 
private void transformImageBitmap(ImageView child, Transformation t, int rotationAngle) {    
    mCamera.save(); 
    final Matrix imageMatrix = t.getMatrix();; 
    final int imageHeight = child.getLayoutParams().height;; 
    final int imageWidth = child.getLayoutParams().width; 
    final int rotation = Math.abs(rotationAngle); 

    mCamera.translate(0.0f, 0.0f, 100.0f); 

    //As the angle of the view gets less, zoom in  
    if (rotation < mMaxRotationAngle) { 
    float zoomAmount = (float) (mMaxZoom + (rotation * 1.5)); 
    mCamera.translate(0.0f, 0.0f, zoomAmount);   
    } 

    mCamera.rotateY(rotationAngle); 
    mCamera.getMatrix(imageMatrix);    
    imageMatrix.preTranslate(-(imageWidth/2), -(imageHeight/2)); 
    imageMatrix.postTranslate((imageWidth/2), (imageHeight/2)); 
    mCamera.restore(); 
} 
} 

Main.java

public class Main extends Activity { 

@Override 
public void onCreate(Bundle savedInstanceState) { 
super.onCreate(savedInstanceState); 

requestWindowFeature(Window.FEATURE_NO_TITLE); 

CoverFlow coverFlow; 
coverFlow = new CoverFlow(this); 

coverFlow.setAdapter(new ImageAdapter(this)); 

ImageAdapter coverImageAdapter = new ImageAdapter(this); 

coverImageAdapter.createReflectedImages(); 

coverFlow.setAdapter(coverImageAdapter); 

coverFlow.setSpacing(-25); 
coverFlow.setSelection(4, true); 
coverFlow.setAnimationDuration(1000); 


setContentView(R.layout.main); 
} 

public class ImageAdapter extends BaseAdapter { 
int mGalleryItemBackground; 
private Context mContext; 

private FileInputStream fis; 

private Integer[] mImageIds = { 
    R.drawable.a, 
     R.drawable.b, 
     R.drawable.c, 
     R.drawable.d, 
     R.drawable.e, 
     R.drawable.f, 
     R.drawable.g, 
     R.drawable.h, 
     R.drawable.i 
}; 

private ImageView[] mImages; 

public ImageAdapter(Context c) { 
    mContext = c; 
    mImages = new ImageView[mImageIds.length]; 
} 
public boolean createReflectedImages() { 
     //The gap we want between the reflection and the original image 
     final int reflectionGap = 4; 


     int index = 0; 
     for (int imageId : mImageIds) { 
    Bitmap originalImage = BitmapFactory.decodeResource(getResources(), 
     imageId); 
     int width = originalImage.getWidth(); 
     int height = originalImage.getHeight(); 


     //This will not scale but will flip on the Y axis 
     Matrix matrix = new Matrix(); 
     matrix.preScale(1, -1); 

     //Create a Bitmap with the flip matrix applied to it. 
     //We only want the bottom half of the image 
     Bitmap reflectionImage = Bitmap.createBitmap(originalImage, 0, height/2, width, height/2, matrix, false); 


     //Create a new bitmap with same width but taller to fit reflection 
     Bitmap bitmapWithReflection = Bitmap.createBitmap(width 
     , (height + height/2), Config.ARGB_8888); 

     //Create a new Canvas with the bitmap that's big enough for 
     //the image plus gap plus reflection 
     Canvas canvas = new Canvas(bitmapWithReflection); 
     //Draw in the original image 
     canvas.drawBitmap(originalImage, 0, 0, null); 
     //Draw in the gap 
     Paint deafaultPaint = new Paint(); 
     canvas.drawRect(0, height, width, height + reflectionGap, deafaultPaint); 
     //Draw in the reflection 
     canvas.drawBitmap(reflectionImage,0, height + reflectionGap, null); 

     //Create a shader that is a linear gradient that covers the reflection 
     Paint paint = new Paint(); 
     LinearGradient shader = new LinearGradient(0, originalImage.getHeight(), 0, 
     bitmapWithReflection.getHeight() + reflectionGap, 0x70ffffff, 0x00ffffff, 
     TileMode.CLAMP); 
     //Set the paint to use this shader (linear gradient) 
     paint.setShader(shader); 
     //Set the Transfer mode to be porter duff and destination in 
     paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN)); 
     //Draw a rectangle using the paint with our linear gradient 
     canvas.drawRect(0, height, width, 
     bitmapWithReflection.getHeight() + reflectionGap, paint); 

     ImageView imageView = new ImageView(mContext); 
     imageView.setImageBitmap(bitmapWithReflection); 
     imageView.setLayoutParams(new CoverFlow.LayoutParams(120, 180)); 
     imageView.setScaleType(ScaleType.MATRIX); 
     mImages[index++] = imageView; 

     } 
    return true; 
} 

public int getCount() { 
    return mImageIds.length; 
} 

public Object getItem(int position) { 
    return position; 
} 

public long getItemId(int position) { 
    return position; 
} 

public View getView(int position, View convertView, ViewGroup parent) { 

    //Use this code if you want to load from resources 
    ImageView i = new ImageView(mContext); 
    i.setImageResource(mImageIds[position]); 
    i.setLayoutParams(new CoverFlow.LayoutParams(130, 130)); 
    i.setScaleType(ImageView.ScaleType.CENTER_INSIDE); 

    //Make sure we set anti-aliasing otherwise we get jaggies 
    BitmapDrawable drawable = (BitmapDrawable) i.getDrawable(); 
    drawable.setAntiAlias(true); 
    return i; 

    //return mImages[position]; 
} 
/** Returns the size (0.0f to 1.0f) of the views 
    * depending on the 'offset' to the center. */ 
    public float getScale(boolean focused, int offset) { 
    /* Formula: 1/(2^offset) */ 
     return Math.max(0, 1.0f/(float)Math.pow(2, Math.abs(offset))); 
    } 

} 
} 

Answer 1

LayoutInflater inflater = (LayoutInflater) this 
.getSystemService(Context.LAYOUT_INFLATER_SERVICE); 
final View v = inflater.inflate(R.layout."layout here", null, false); 

i użyć, na przykład:

TextView tv=(TextView)v.findViewById(R,id."id here");