project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/util/ObservableTreeMapAdapter.java
changeset 10017 de822cd3df3a
parent 7584 7831c84cc644
equal deleted inserted replaced
10015:4feced261c68 10017:de822cd3df3a
    26 
    26 
    27 import android.database.DataSetObserver;
    27 import android.database.DataSetObserver;
    28 import android.widget.BaseAdapter;
    28 import android.widget.BaseAdapter;
    29 
    29 
    30 public abstract class ObservableTreeMapAdapter<K,V> extends BaseAdapter {
    30 public abstract class ObservableTreeMapAdapter<K,V> extends BaseAdapter {
    31 	private boolean sourceChanged = true;
    31     private boolean sourceChanged = true;
    32 	private List<V> entries = new ArrayList<V>();
    32     private List<V> entries = new ArrayList<V>();
    33 	private ObservableTreeMap<K, V> source;
    33     private ObservableTreeMap<K, V> source;
    34 	
       
    35 	private DataSetObserver observer = new DataSetObserver() {
       
    36 		@Override
       
    37 		public void onChanged() {
       
    38 			sourceChanged = true;
       
    39 			notifyDataSetChanged();
       
    40 		}
       
    41 		
       
    42 		@Override
       
    43 		public void onInvalidated() {
       
    44 			invalidate();
       
    45 		}
       
    46 	};
       
    47 	
       
    48 	abstract protected Comparator<V> getEntryOrder();
       
    49 	
       
    50 	protected List<V> getEntries() {
       
    51 		if(sourceChanged) {
       
    52 			entries.clear();
       
    53 			entries.addAll(source.getMap().values());
       
    54 			Collections.sort(entries, getEntryOrder());
       
    55 			sourceChanged = false;
       
    56 		}
       
    57 		return entries;
       
    58 	}
       
    59 	
       
    60 	public int getCount() {
       
    61 		return getEntries().size();
       
    62 	}
       
    63 
    34 
    64 	public V getItem(int position) {
    35     private DataSetObserver observer = new DataSetObserver() {
    65 		return getEntries().get(position);
    36         @Override
    66 	}
    37         public void onChanged() {
    67 	
    38             sourceChanged = true;
    68 	public long getItemId(int position) {
    39             notifyDataSetChanged();
    69 		return position;
    40         }
    70 	}
    41 
    71 	
    42         @Override
    72 	@Override
    43         public void onInvalidated() {
    73 	public boolean hasStableIds() {
    44             invalidate();
    74 		return false;
    45         }
    75 	}
    46     };
    76 	
    47 
    77 	public void setSource(ObservableTreeMap<K,V> source) {
    48     abstract protected Comparator<V> getEntryOrder();
    78 		if(this.source != null) {
    49 
    79 			this.source.unregisterObserver(observer);
    50     protected List<V> getEntries() {
    80 		}
    51         if(sourceChanged) {
    81 		this.source = source;
    52             entries.clear();
    82 		this.source.registerObserver(observer);
    53             entries.addAll(source.getMap().values());
    83 		sourceChanged = true;
    54             Collections.sort(entries, getEntryOrder());
    84 		notifyDataSetChanged();
    55             sourceChanged = false;
    85 	}
    56         }
    86 	
    57         return entries;
    87 	public void invalidate() {
    58     }
    88 		if(source != null) {
    59 
    89 			source.unregisterObserver(observer);
    60     public int getCount() {
    90 		}
    61         return getEntries().size();
    91 		source = null;
    62     }
    92 		notifyDataSetInvalidated();
    63 
    93 	}
    64     public V getItem(int position) {
       
    65         return getEntries().get(position);
       
    66     }
       
    67 
       
    68     public long getItemId(int position) {
       
    69         return position;
       
    70     }
       
    71 
       
    72     @Override
       
    73     public boolean hasStableIds() {
       
    74         return false;
       
    75     }
       
    76 
       
    77     public void setSource(ObservableTreeMap<K,V> source) {
       
    78         if(this.source != null) {
       
    79             this.source.unregisterObserver(observer);
       
    80         }
       
    81         this.source = source;
       
    82         this.source.registerObserver(observer);
       
    83         sourceChanged = true;
       
    84         notifyDataSetChanged();
       
    85     }
       
    86 
       
    87     public void invalidate() {
       
    88         if(source != null) {
       
    89             source.unregisterObserver(observer);
       
    90         }
       
    91         source = null;
       
    92         notifyDataSetInvalidated();
       
    93     }
    94 }
    94 }