layout inflater problem

Basic Tutorials concerning: GUI, Views, Activites, XML, Layouts, Intents, ...

layout inflater problem

Postby yusuf » Fri Mar 26, 2010 3:57 pm

Hey guys i have used layout inflater to show a mail list.but i'm facing a problem i wanted to show a mail on onclick event of subject (shown in image example : subject 0) but isn't working plzzz help me guys how to do that.


this is my code

Syntax: [ Download ] [ Hide ]
Using java Syntax Highlighting
  1. package com.google;
  2.  
  3.  
  4.  
  5.  
  6.  
  7. import java.util.ArrayList;  
  8.  
  9. import java.util.List;  
  10.  
  11.  
  12.  
  13.  
  14.  
  15. import com.google.ClickableListAdapter.ViewHolder;
  16.  
  17. import android.app.Dialog;
  18.  
  19. import android.app.ListActivity;  
  20.  
  21. import android.content.Context;  
  22.  
  23. import android.content.Intent;
  24.  
  25. import android.graphics.Bitmap;  
  26.  
  27. import android.graphics.BitmapFactory;  
  28.  
  29. import android.os.Bundle;  
  30.  
  31. import android.view.View;  
  32.  
  33. import android.view.View.OnClickListener;
  34.  
  35. import android.widget.Button;
  36.  
  37. import android.widget.CheckBox;
  38.  
  39. import android.widget.ImageButton;
  40.  
  41. import android.widget.ImageView;  
  42.  
  43. import android.widget.TableRow;
  44.  
  45. import android.widget.TextView;  
  46.  
  47.  
  48.  
  49.  
  50.  
  51. /**
  52.  
  53.  * An example how to implement the ClickableListAdapter for a list view layout containing
  54.  
  55.  * a TextView and an ImageView.
  56.  
  57.  * @author poss3x
  58.  
  59.  */  
  60.  
  61. public class mailslist extends ListActivity  {  
  62.  
  63.         Dialog dialog;// = new Dialog(this);
  64.  
  65.     /**
  66.  
  67.      * Our data class. This data will be bound to  
  68.  
  69.      * MyViewHolder, which in turn is used for the  
  70.  
  71.      * ListView.  
  72.  
  73.      */  
  74.  
  75.        
  76.  
  77.     static class MyData {  
  78.  
  79.         public MyData(String t,String t1,String t2, boolean e) {  
  80.  
  81.             text = t;
  82.  
  83.             text1 = t1;
  84.  
  85.             text2 = t2;
  86.  
  87.            
  88.  
  89.             enable = e;  
  90.  
  91.         }  
  92.  
  93.  
  94.  
  95.         String text,text1,text2;  
  96.  
  97.         Bitmap i1;
  98.  
  99.         boolean enable;  
  100.  
  101.     }  
  102.  
  103.      
  104.  
  105.     /**
  106.  
  107.      * Our very own holder referencing the view elements
  108.  
  109.      * of our ListView layout
  110.  
  111.      */  
  112.  
  113.     static class MyViewHolder extends ViewHolder {  
  114.  
  115.  
  116.  
  117.         public MyViewHolder(TextView t,TextView t1,TextView t2) {  
  118.  
  119.             sub = t;  
  120.  
  121.             from=t1;
  122.  
  123.             date=t2;
  124.  
  125.          
  126.  
  127.         }  
  128.  
  129.         TextView sub;  
  130.  
  131.        TextView from;
  132.  
  133.         TextView date;
  134.  
  135.     }  
  136.  
  137.  
  138.  
  139.     /**
  140.  
  141.      * The implementation of ClickableListAdapter
  142.  
  143.      */  
  144.  
  145.     private class MyClickableListAdapter extends ClickableListAdapter  {  
  146.  
  147.  
  148.  
  149.         public MyClickableListAdapter(Context context, int viewid,  
  150.  
  151.                         List<MyData> objects) {  
  152.  
  153.             super(context, viewid, objects);  
  154.  
  155.             // nothing to do  
  156.  
  157.         }  
  158.  
  159.  
  160.  
  161.         protected void bindHolder(ViewHolder h) {  
  162.  
  163.             // Binding the holder keeps our data up to date.  
  164.  
  165.             // In contrast to createHolder this method is called for all items  
  166.  
  167.             // So, be aware when doing a lot of heavy stuff here.  
  168.  
  169.             // we simply transfer our object's data to the list item representatives  
  170.  
  171.             MyViewHolder mvh = (MyViewHolder) h;  
  172.  
  173.             MyData mo = (MyData)mvh.data;  
  174.  
  175.              
  176.  
  177.             mvh.sub.setText(mo.text);
  178.  
  179.             mvh.from.setText(mo.text1);
  180.  
  181.             mvh.date.setText(mo.text2);
  182.  
  183.  
  184.  
  185.         }  
  186.  
  187.  
  188.  
  189.         @Override  
  190.  
  191.         protected ViewHolder createHolder(View v) {  
  192.  
  193.             // createHolder will be called only as long, as the ListView is not filled  
  194.  
  195.             // entirely. That is, where we gain our performance:  
  196.  
  197.             // We use the relatively costly findViewById() methods and  
  198.  
  199.             // bind the view's reference to the holder objects.  
  200.  
  201.           /*  TextView text = (TextView) v.findViewById(R.id.text);  
  202.  
  203.            
  204.  
  205.             ImageButton button = (ImageButton) v.findViewById(R.id.Button);*/
  206.  
  207.                 TextView sub = (TextView) v.findViewById(R.id.lblSubject);
  208.  
  209.                 TextView from = (TextView) v.findViewById(R.id.lblfrom);
  210.  
  211.                 TextView date = (TextView) v.findViewById(R.id.lbldate);
  212.  
  213.  
  214.  
  215.                 ViewHolder mvh = new MyViewHolder(sub,from,date);  
  216.  
  217.            
  218.  
  219.  
  220.  
  221.                                
  222.  
  223.                
  224.  
  225.                
  226.  
  227.            
  228.  
  229.             // Additionally, we make some icons clickable  
  230.  
  231.             // Mind, that item becomes clickable, when adding a click listener (see API)  
  232.  
  233.             // so, it is not necessary to use the android:clickable attribute in XML  
  234.  
  235.          
  236.  
  237.                
  238.  
  239.         /*      sub.setOnClickListener(new ClickableListAdapter.OnClickListener(mvh) {  
  240.  
  241.  
  242.  
  243.                 public void onClick(View v, ViewHolder viewHolder) {  
  244.  
  245.                     // we toggle the enabled state and also switch the icon  
  246.  
  247.         /*            MyViewHolder mvh = (MyViewHolder) viewHolder;  
  248.  
  249.                     MyData mo = (MyData) mvh.data;  
  250.  
  251.                     mo.enable = !mo.enable; // toggle  
  252.  
  253.                     ImageView icon = (ImageView) v;  
  254.  
  255.                     icon.setImageBitmap(  
  256.  
  257.                             mo.enable ? mailslist.this.mIconEnabled  
  258.  
  259.                                     : mailslist.this.mIconDisabled);
  260.  
  261.                        
  262.  
  263.          
  264.  
  265.                          
  266.  
  267.                     MyViewHolder mvh = (MyViewHolder) viewHolder;  
  268.  
  269.                     MyData mo = (MyData)mvh.data;  
  270.  
  271.                      
  272.  
  273.                     // we toggle an '*' in our text element  
  274.  
  275.                     String s = mo.text;  
  276.  
  277.                     if (s.charAt(0) == '*') {  
  278.  
  279.                         mo.text = s.substring(1);  
  280.  
  281.                     } else {  
  282.  
  283.                         mo.text = '*' + s;
  284.  
  285.                        
  286.  
  287.                         }  
  288.  
  289.                     mvh.sub.setText(mo.text);
  290.  
  291.                        
  292.  
  293.          //try onlick (intent) here
  294.  
  295.                 }  
  296.  
  297.                
  298.  
  299.             });*/
  300.  
  301.  
  302.  
  303.  
  304.  
  305.    
  306.  
  307.            
  308.  
  309.            
  310.  
  311.            
  312.  
  313.            
  314.  
  315.            
  316.  
  317.            
  318.  
  319.            
  320.  
  321.             // for text we implement a long click listener  
  322.  
  323.  
  324.  
  325.             sub.setOnLongClickListener(new ClickableListAdapter.OnLongClickListener(mvh) {  
  326.  
  327.                
  328.  
  329.                 @Override  
  330.  
  331.                 public void onLongClick(View v, ViewHolder viewHolder) {  
  332.  
  333.                          
  334.  
  335.                     MyViewHolder mvh = (MyViewHolder) viewHolder;  
  336.  
  337.                     MyData mo = (MyData)mvh.data;  
  338.  
  339.                      
  340.  
  341.                     // we toggle an '*' in our text element  
  342.  
  343.                     String s = mo.text;  
  344.  
  345.                     if (s.charAt(0) == '*') {  
  346.  
  347.                         mo.text = s.substring(1);  
  348.  
  349.                     } else {  
  350.  
  351.                         mo.text = '*' + s;
  352.  
  353.                        
  354.  
  355.                         }  
  356.  
  357.                     mvh.sub.setText(mo.text);  
  358.  
  359.                   /* dialog.setContentView(R.layout.contextdialog);
  360.  
  361.                     dialog.setTitle("Current Context");
  362.  
  363.                         dialog.show();*/
  364.  
  365.                    
  366.  
  367.                
  368.  
  369.  
  370.  
  371.                 }  
  372.  
  373.  
  374.  
  375.             });  
  376.  
  377.  
  378.  
  379.             return mvh; // finally, we return our new holder  
  380.  
  381.         }
  382.  
  383.  
  384.  
  385.                 protected void disp() {
  386.  
  387.                         // TODO Auto-generated method stub
  388.  
  389.                        
  390.  
  391.                 }
  392.  
  393.  
  394.  
  395.                
  396.  
  397.        
  398.  
  399.  
  400.  
  401.    
  402.  
  403.     }  
  404.  
  405.    
  406.  
  407.  
  408.  
  409.      
  410.  
  411.     @Override  
  412.  
  413.     public void onCreate(Bundle savedInstanceState) {  
  414.  
  415.         super.onCreate(savedInstanceState);  
  416.  
  417.  
  418.  
  419.      
  420.  
  421.        
  422.  
  423.         // fill list with some items...  
  424.  
  425.         // to demonstrate the performance we create a bunch of data objects  
  426.  
  427.        
  428.  
  429.         for (int i = 0; i < 10; ++i) {  
  430.  
  431.             //if ka logic laga na hai ider
  432.  
  433.                 //if(i%2) 24 feb(00 hrs)
  434.  
  435.                 mObjectList.add(new MyData("Subject" + i,"abc"+i+"@gmail.com", +i+" Days ago",true));
  436.  
  437.            
  438.  
  439.         }
  440.  
  441.      
  442.  
  443.         //here we set our adapter  
  444.  
  445.         setListAdapter(new MyClickableListAdapter(this,  
  446.  
  447.                 R.layout.maillist, mObjectList));  
  448.  
  449.  
  450.  
  451.    
  452.  
  453.     }  
  454.  
  455.  
  456.  
  457.     // --------------- field section -----------------  
  458.  
  459.     private Bitmap mIconEnabled;  
  460.  
  461.     private Bitmap mIconDisabled;  
  462.  
  463.    
  464.  
  465.       public TableRow tab;
  466.  
  467.   public List<MyData> mObjectList=new ArrayList<MyData>();
  468.  
  469.  
  470.  
  471.  
  472.  
  473. }  
Parsed in 0.053 seconds, using GeSHi 1.0.8.4




This my abstract class which enable click event


Syntax: [ Download ] [ Hide ]
Using java Syntax Highlighting
  1. package com.google;
  2.  
  3.  
  4.  
  5. import java.util.ArrayList;
  6.  
  7. import java.util.List;
  8.  
  9.  
  10.  
  11. import android.content.Context;
  12.  
  13. import android.view.LayoutInflater;
  14.  
  15. import android.view.View;
  16.  
  17. import android.view.ViewGroup;
  18.  
  19. import android.widget.BaseAdapter;
  20.  
  21.  
  22.  
  23. public abstract class ClickableListAdapter extends BaseAdapter {  
  24.  
  25.     private LayoutInflater mInflater;  
  26.  
  27.     private List mDataObjects; // our generic object list  
  28.  
  29.     private int mViewId;  
  30.  
  31.  
  32.  
  33.     /**
  34.  
  35.      * This is the holder will provide fast access to arbitrary objects and
  36.  
  37.      * views. Use a subclass to adapt it for your personal needs.
  38.  
  39.      */  
  40.  
  41.     public static class ViewHolder {  
  42.  
  43.         // back reference to our list object  
  44.  
  45.         public Object data;
  46.  
  47.                 public Object icon;  
  48.  
  49.     }  
  50.  
  51.  
  52.  
  53.     /**
  54.  
  55.      * The click listener base class.
  56.  
  57.      */  
  58.  
  59.     public static abstract class OnClickListener implements  
  60.  
  61.             View.OnClickListener {  
  62.  
  63.  
  64.  
  65.         private ViewHolder mViewHolder;  
  66.  
  67.  
  68.  
  69.         /**
  70.  
  71.          * @param holder The holder of the clickable item
  72.  
  73.          */  
  74.  
  75.         public OnClickListener(ViewHolder holder) {  
  76.  
  77.             mViewHolder = holder;  
  78.  
  79.         }  
  80.  
  81.  
  82.  
  83.         // delegates the click event  
  84.  
  85.         public void onClick(View v) {  
  86.  
  87.             onClick(v, mViewHolder);  
  88.  
  89.         }  
  90.  
  91.  
  92.  
  93.         /**
  94.  
  95.          * Implement your click behavior here
  96.  
  97.          * @param v  The clicked view.
  98.  
  99.          */  
  100.  
  101.         public abstract void onClick(View v, ViewHolder viewHolder);  
  102.  
  103.     };  
  104.  
  105.  
  106.  
  107.     /**
  108.  
  109.      * The long click listener base class.
  110.  
  111.      */  
  112.  
  113.     public static abstract class OnLongClickListener implements  
  114.  
  115.             View.OnLongClickListener {  
  116.  
  117.         private ViewHolder mViewHolder;  
  118.  
  119.  
  120.  
  121.         /**
  122.  
  123.          * @param holder The holder of the clickable item
  124.  
  125.          */  
  126.  
  127.         public OnLongClickListener(ViewHolder holder) {  
  128.  
  129.             mViewHolder = holder;  
  130.  
  131.         }  
  132.  
  133.  
  134.  
  135.         // delegates the click event  
  136.  
  137.         public boolean onLongClick(View v) {  
  138.  
  139.             onLongClick(v, mViewHolder);  
  140.  
  141.             return true;  
  142.  
  143.         }  
  144.  
  145.  
  146.  
  147.         /**
  148.  
  149.          * Implement your click behavior here
  150.  
  151.          * @param v  The clicked view.
  152.  
  153.          */  
  154.  
  155.         public abstract void onLongClick(View v, ViewHolder viewHolder);  
  156.  
  157.  
  158.  
  159.     };  
  160.  
  161.  
  162.  
  163.     /**
  164.  
  165.      * @param context The current context
  166.  
  167.      * @param viewid The resource id of your list view item
  168.  
  169.      * @param objects The object list, or null, if you like to indicate an empty
  170.  
  171.      * list
  172.  
  173.      */  
  174.  
  175.     public ClickableListAdapter(Context context, int viewid, List objects) {  
  176.  
  177.  
  178.  
  179.         // Cache the LayoutInflate to avoid asking for a new one each time.  
  180.  
  181.         mInflater = LayoutInflater.from(context);  
  182.  
  183.         mDataObjects = objects;  
  184.  
  185.         mViewId = viewid;  
  186.  
  187.  
  188.  
  189.         if (objects == null) {  
  190.  
  191.             mDataObjects = new ArrayList<Object>();  
  192.  
  193.         }  
  194.  
  195.     }  
  196.  
  197.  
  198.  
  199.     /**
  200.  
  201.      * The number of objects in the list.
  202.  
  203.      */  
  204.  
  205.     public int getCount() {  
  206.  
  207.         return mDataObjects.size();  
  208.  
  209.     }  
  210.  
  211.  
  212.  
  213.     /**
  214.  
  215.      * @return We simply return the object at position of our object list Note,
  216.  
  217.      *         the holder object uses a back reference to its related data
  218.  
  219.      *         object. So, the user usually should use {@link ViewHolder#data}
  220.  
  221.      *         for faster access.
  222.  
  223.      */  
  224.  
  225.     public Object getItem(int position) {  
  226.  
  227.         return mDataObjects.get(position);  
  228.  
  229.     }  
  230.  
  231.  
  232.  
  233.     /**
  234.  
  235.      * We use the array index as a unique id. That is, position equals id.
  236.  
  237.      *  
  238.  
  239.      * @return The id of the object
  240.  
  241.      */  
  242.  
  243.     public long getItemId(int position) {  
  244.  
  245.         return position;  
  246.  
  247.     }  
  248.  
  249.  
  250.  
  251.     /**
  252.  
  253.      * Make a view to hold each row. This method is instantiated for each list
  254.  
  255.      * object. Using the Holder Pattern, avoids the unnecessary
  256.  
  257.      * findViewById()-calls.
  258.  
  259.      */  
  260.  
  261.     public View getView(int position, View view, ViewGroup parent) {  
  262.  
  263.         // A ViewHolder keeps references to children views to avoid uneccessary  
  264.  
  265.         // calls  
  266.  
  267.         // to findViewById() on each row.  
  268.  
  269.         ViewHolder holder;  
  270.  
  271.  
  272.  
  273.         // When view is not null, we can reuse it directly, there is no need  
  274.  
  275.         // to reinflate it. We only inflate a new View when the view supplied  
  276.  
  277.         // by ListView is null.  
  278.  
  279.         if (view == null) {  
  280.  
  281.  
  282.  
  283.             view = mInflater.inflate(mViewId, null);  
  284.  
  285.             // call the user's implementation  
  286.  
  287.             holder = createHolder(view);  
  288.  
  289.             // we set the holder as tag  
  290.  
  291.             view.setTag(holder);  
  292.  
  293.  
  294.  
  295.         } else {  
  296.  
  297.             // get holder back...much faster than inflate  
  298.  
  299.             holder = (ViewHolder) view.getTag();  
  300.  
  301.         }  
  302.  
  303.  
  304.  
  305.         // we must update the object's reference  
  306.  
  307.         holder.data = getItem(position);  
  308.  
  309.         // call the user's implementation  
  310.  
  311.         bindHolder(holder);  
  312.  
  313.  
  314.  
  315.         return view;  
  316.  
  317.     }  
  318.  
  319.  
  320.  
  321.     /**
  322.  
  323.      * Creates your custom holder, that carries reference for e.g. ImageView
  324.  
  325.      * and/or TextView. If necessary connect your clickable View object with the
  326.  
  327.      * PrivateOnClickListener, or PrivateOnLongClickListener
  328.  
  329.      *  
  330.  
  331.      * @param vThe view for the new holder object
  332.  
  333.      */  
  334.  
  335.     protected abstract ViewHolder createHolder(View v);  
  336.  
  337.  
  338.  
  339.     /**
  340.  
  341.      * Binds the data from user's object to the holder
  342.  
  343.      * @param h  The holder that shall represent the data object.
  344.  
  345.      */  
  346.  
  347.     protected abstract void bindHolder(ViewHolder h);  
  348.  
  349. }  
  350.  
  351.  
  352.  
  353.  
Parsed in 0.047 seconds, using GeSHi 1.0.8.4




hey i have also attached the image of the view of list
onclick of subject a view should be appeared.
plzzz help me

n

any suggestions are accepted.
Attachments
untitled.jpg
Mail List
untitled.jpg (93.61 KiB) Viewed 647 times
Androiding.........................
yusuf
Experienced Developer
Experienced Developer
 
Posts: 57
Joined: Mon Feb 15, 2010 4:25 pm
Location: Pune,India

Top

Return to Novice Tutorials

Who is online

Users browsing this forum: No registered users and 4 guests