First commit

1 files changed, 2193 insertions, 0 deletions

diff --git a/src/cgeo/geocaching/cgeocaches.java b/src/cgeo/geocaching/cgeocaches.java
new file mode 100644
index 0000000..9c730de
--- /dev/null
+++ b/src/cgeo/geocaching/cgeocaches.java
@@ -0,0 +1,2193 @@
+package cgeo.geocaching;
+
+import gnu.android.app.appmanualclient.*;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import android.os.Handler;
+import android.os.Message;
+import android.os.Bundle;
+import android.util.Log;
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.ListActivity;
+import android.app.ProgressDialog;
+import android.content.DialogInterface;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.content.Intent;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.net.Uri;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.LayoutInflater;
+import android.view.SubMenu;
+import android.view.View;
+import android.view.WindowManager;
+import android.widget.AdapterView.AdapterContextMenuInfo;
+import android.widget.EditText;
+import android.widget.ListView;
+import android.widget.RelativeLayout;
+import android.widget.TextView;
+import cgeo.geocaching.filter.cgFilterBySize;
+import cgeo.geocaching.filter.cgFilterByTrackables;
+import cgeo.geocaching.filter.cgFilterByType;
+
+import com.google.android.apps.analytics.GoogleAnalyticsTracker;
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.util.Locale;
+
+public class cgeocaches extends ListActivity {
+
+	private GoogleAnalyticsTracker tracker = null;
+	private String action = null;
+	private String type = null;
+	private Double latitude = null;
+	private Double longitude = null;
+	private String cachetype = null;
+	private String keyword = null;
+	private String address = null;
+	private String username = null;
+	private Long searchId = null;
+	private ArrayList<cgCache> cacheList = new ArrayList<cgCache>();
+	private cgeoapplication app = null;
+	private Resources res = null;
+	private static Activity activity = null;
+	private cgCacheListAdapter adapter = null;
+	private LayoutInflater inflater = null;
+	private View listFooter = null;
+	private TextView listFooterText = null;
+	private cgSettings settings = null;
+	private cgBase base = null;
+	private cgWarning warning = null;
+	private ProgressDialog waitDialog = null;
+	private Double northHeading = new Double(0);
+	private cgGeo geo = null;
+	private cgDirection dir = null;
+	private cgUpdateLoc geoUpdate = new update();
+	private cgUpdateDir dirUpdate = new updateDir();
+	private String title = "";
+	private int detailTotal = 0;
+	private int detailProgress = 0;
+	private Long detailProgressTime = 0l;
+	private geocachesLoadDetails threadD = null;
+	private geocachesLoadFromWeb threadW = null;
+	private geocachesDropDetails threadR = null;
+	private int listId = 0;
+	private ArrayList<cgList> lists = null;
+	private String selectedFilter = null;
+	private cgCacheGeocodeComparator gcComparator = new cgCacheGeocodeComparator();
+	private Handler loadCachesHandler = new Handler() {
+
+		@Override
+		public void handleMessage(Message msg) {
+			try {
+				if (searchId != null && searchId > 0) {
+					base.setTitle(activity, title + " [" + app.getCount(searchId) + "]");
+					cacheList.clear();
+
+					final ArrayList<cgCache> cacheListTmp = app.getCaches(searchId);
+					if (cacheListTmp != null && cacheListTmp.isEmpty() == false) {
+						cacheList.addAll(cacheListTmp);
+						cacheListTmp.clear();
+
+						Collections.sort((List<cgCache>)cacheList, gcComparator);
+					}
+				} else {
+					base.setTitle(activity, title);
+				}
+
+				setAdapter();
+
+				if (cacheList == null) {
+					warning.showToast(res.getString(R.string.err_list_load_fail));
+					setMoreCaches(false);
+				} else {
+					final Integer count = app.getTotal(searchId);
+
+					if (count != null && count > 0) {
+						if (cacheList.size() < app.getTotal(searchId) && cacheList.size() < 1000) {
+							setMoreCaches(true);
+						} else {
+							setMoreCaches(false);
+						}
+					} else {
+						setMoreCaches(false);
+					}
+				}
+
+				if (cacheList != null && app.getError(searchId) != null && app.getError(searchId).equalsIgnoreCase(cgBase.errorRetrieve.get(-7)) == true) {
+					AlertDialog.Builder dialog = new AlertDialog.Builder(activity);
+					dialog.setTitle(res.getString(R.string.license));
+					dialog.setMessage(res.getString(R.string.err_license));
+					dialog.setCancelable(true);
+					dialog.setNegativeButton(res.getString(R.string.license_dismiss), new DialogInterface.OnClickListener() {
+
+						public void onClick(DialogInterface dialog, int id) {
+							settings.deleteCookies();
+							dialog.cancel();
+						}
+					});
+					dialog.setPositiveButton(res.getString(R.string.license_show), new DialogInterface.OnClickListener() {
+
+						public void onClick(DialogInterface dialog, int id) {
+							settings.deleteCookies();
+							activity.startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("http://www.geocaching.com/software/agreement.aspx?ID=0")));
+						}
+					});
+
+					AlertDialog alert = dialog.create();
+					alert.show();
+				} else if (app != null && app.getError(searchId) != null && app.getError(searchId).length() > 0) {
+					warning.showToast(res.getString(R.string.err_download_fail) + app.getError(searchId) + ".");
+
+					hideLoading();
+					base.showProgress(activity, false);
+
+					finish();
+					return;
+				}
+
+				if (geo != null && geo.latitudeNow != null && geo.longitudeNow != null) {
+					adapter.setActualCoordinates(geo.latitudeNow, geo.longitudeNow);
+					adapter.setActualHeading(northHeading);
+				}
+			} catch (Exception e) {
+				warning.showToast(res.getString(R.string.err_detail_cache_find_any));
+				Log.e(cgSettings.tag, "cgeocaches.loadCachesHandler: " + e.toString());
+
+				hideLoading();
+				base.showProgress(activity, false);
+
+				finish();
+				return;
+			}
+
+			try {
+				hideLoading();
+				base.showProgress(activity, false);
+			} catch (Exception e2) {
+				Log.e(cgSettings.tag, "cgeocaches.loadCachesHandler.2: " + e2.toString());
+			}
+
+			if (adapter != null) {
+				adapter.setSelectMode(false, true);
+			}
+		}
+	};
+	private Handler loadNextPageHandler = new Handler() {
+
+		@Override
+		public void handleMessage(Message msg) {
+			try {
+				if (searchId != null && searchId > 0) {
+					base.setTitle(activity, title + " [" + app.getCount(searchId) + "]");
+					cacheList.clear();
+
+					final ArrayList<cgCache> cacheListTmp = app.getCaches(searchId);
+					if (cacheListTmp != null && cacheListTmp.isEmpty() == false) {
+						cacheList.addAll(cacheListTmp);
+						cacheListTmp.clear();
+						Collections.sort((List<cgCache>)cacheList, gcComparator);
+					}
+					if(adapter != null){
+						adapter.reFilter();
+					}
+				} else {
+					base.setTitle(activity, title);
+				}
+
+				setAdapter();
+
+				if (cacheList == null) {
+					warning.showToast(res.getString(R.string.err_list_load_fail));
+					setMoreCaches(false);
+				} else {
+					final Integer count = app.getTotal(searchId);
+					if (count != null && count > 0) {
+						if (cacheList.size() < app.getTotal(searchId) && cacheList.size() < 1000) {
+							setMoreCaches(true);
+						} else {
+							setMoreCaches(false);
+						}
+					} else {
+						setMoreCaches(false);
+					}
+				}
+
+				if (app.getError(searchId) != null && app.getError(searchId).length() > 0) {
+					warning.showToast(res.getString(R.string.err_download_fail) + app.getError(searchId) + ".");
+
+					listFooter.setOnClickListener(new moreCachesListener());
+					hideLoading();
+					base.showProgress(activity, false);
+
+					finish();
+					return;
+				}
+
+				if (geo != null && geo.latitudeNow != null && geo.longitudeNow != null) {
+					adapter.setActualCoordinates(geo.latitudeNow, geo.longitudeNow);
+					adapter.setActualHeading(northHeading);
+				}
+			} catch (Exception e) {
+				warning.showToast(res.getString(R.string.err_detail_cache_find_next));
+				Log.e(cgSettings.tag, "cgeocaches.loadNextPageHandler: " + e.toString());
+			}
+
+			listFooter.setOnClickListener(new moreCachesListener());
+
+			hideLoading();
+			base.showProgress(activity, false);
+
+			if (adapter != null) {
+				adapter.setSelectMode(false, true);
+			}
+		}
+	};
+	private Handler loadDetailsHandler = new Handler() {
+
+		@Override
+		public void handleMessage(Message msg) {
+			setAdapter();
+
+			if (msg.what > -1) {
+				if (waitDialog != null) {
+					cacheList.get(msg.what).statusChecked = false;
+
+					if (adapter != null) {
+						adapter.notifyDataSetChanged();
+					}
+
+					Float diffTime = new Float((System.currentTimeMillis() - detailProgressTime) / 1000); // seconds left
+					Float oneCache = diffTime / detailProgress; // left time per cache
+					int etaTime = (int) ((detailTotal - detailProgress) * oneCache / 60); // seconds remaining
+
+					waitDialog.setProgress(detailProgress);
+					if (etaTime < 1) {
+						waitDialog.setMessage(res.getString(R.string.caches_downloading) + " " + res.getString(R.string.caches_eta_ltm));
+					} else if (etaTime == 1) {
+						waitDialog.setMessage(res.getString(R.string.caches_downloading) + " " + etaTime + " " + res.getString(R.string.caches_eta_min));
+					} else {
+						waitDialog.setMessage(res.getString(R.string.caches_downloading) + " " + etaTime + " " + res.getString(R.string.caches_eta_mins));
+					}
+				}
+			} else {
+				if (cacheList != null && searchId != null) {
+					final ArrayList<cgCache> cacheListTmp = app.getCaches(searchId);
+					if (cacheListTmp != null && cacheListTmp.isEmpty() == false) {
+						cacheList.clear();
+						cacheList.addAll(cacheListTmp);
+						cacheListTmp.clear();
+						Collections.sort((List<cgCache>)cacheList, gcComparator);
+					}
+				}
+
+				if (geo != null && geo.latitudeNow != null && geo.longitudeNow != null) {
+					adapter.setActualCoordinates(geo.latitudeNow, geo.longitudeNow);
+					adapter.setActualHeading(northHeading);
+				}
+
+				base.showProgress(activity, false);
+				if (waitDialog != null) {
+					waitDialog.dismiss();
+					waitDialog.setOnCancelListener(null);
+				}
+
+				if (geo == null) {
+					geo = app.startGeo(activity, geoUpdate, base, settings, warning, 0, 0);
+				}
+				if (settings.livelist == 1 && settings.useCompass == 1 && dir == null) {
+					dir = app.startDir(activity, dirUpdate, warning);
+				}
+			}
+		}
+	};
+	private Handler downloadFromWebHandler = new Handler() {
+		@Override
+		public void handleMessage(Message msg) {
+			setAdapter();
+			
+			if (adapter != null) {
+				adapter.notifyDataSetChanged();
+			}
+
+			if (msg.what == 0) { //no caches
+				waitDialog.setMessage(res.getString(R.string.web_import_waiting));
+			} else if (msg.what == 1) { //cache downloading
+				waitDialog.setMessage(res.getString(R.string.web_downloading)+" "+(String)msg.obj+"...");
+			} else if (msg.what == 2) { //Cache downloaded
+				waitDialog.setMessage(res.getString(R.string.web_downloaded)+" "+(String)msg.obj+".");
+				//Once a cache is downloaded I used switchList to refresh it.
+				switchList(listId, -1);
+                        } else if (msg.what == -2) {
+				if (waitDialog != null) {
+					waitDialog.dismiss();
+					waitDialog.setOnCancelListener(null);
+				}
+                                getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+                                warning.showToast(res.getString(R.string.gpx_import_no_files));
+				finish();
+				return; 
+			} else {
+				if (adapter != null) {
+					adapter.setSelectMode(false, true);
+				}
+
+				cacheList.clear();
+
+				final ArrayList<cgCache> cacheListTmp = app.getCaches(searchId);
+				if (cacheListTmp != null && cacheListTmp.isEmpty() == false) {
+					cacheList.addAll(cacheListTmp);
+					cacheListTmp.clear();
+
+					Collections.sort((List<cgCache>)cacheList, gcComparator);
+				}
+
+				if (waitDialog != null) {
+					waitDialog.dismiss();
+					waitDialog.setOnCancelListener(null);
+				}
+                                getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+			}
+		}
+	};
+	private Handler dropDetailsHandler = new Handler() {
+
+		@Override
+		public void handleMessage(Message msg) {
+			setAdapter();
+
+			if (msg.what > -1) {
+				cacheList.get(msg.what).statusChecked = false;
+			} else {
+				if (adapter != null) {
+					adapter.setSelectMode(false, true);
+				}
+
+				cacheList.clear();
+
+				final ArrayList<cgCache> cacheListTmp = app.getCaches(searchId);
+				if (cacheListTmp != null && cacheListTmp.isEmpty() == false) {
+					cacheList.addAll(cacheListTmp);
+					cacheListTmp.clear();
+
+					Collections.sort((List<cgCache>)cacheList, gcComparator);
+				}
+
+				if (waitDialog != null) {
+					waitDialog.dismiss();
+					waitDialog.setOnCancelListener(null);
+				}
+			}
+		}
+	};
+	private ContextMenuInfo lastMenuInfo;
+
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		// init
+		activity = this;
+		res = this.getResources();
+		app = (cgeoapplication) this.getApplication();
+		app.setAction(action);
+		settings = new cgSettings(this, getSharedPreferences(cgSettings.preferences, 0));
+		base = new cgBase(app, settings, getSharedPreferences(cgSettings.preferences, 0));
+		warning = new cgWarning(this);
+
+		// set layout
+		if (settings.skin == 1) {
+			setTheme(R.style.light);
+		} else {
+			setTheme(R.style.dark);
+		}
+		setContentView(R.layout.caches);
+		base.setTitle(activity, "caches");
+
+		// google analytics
+		tracker = GoogleAnalyticsTracker.getInstance();
+		tracker.start(cgSettings.analytics, this);
+		tracker.dispatch();
+		base.sendAnal(activity, tracker, "/cache/list");
+
+		// get parameters
+		Bundle extras = getIntent().getExtras();
+		if (extras != null) {
+			type = extras.getString("type");
+			latitude = extras.getDouble("latitude");
+			longitude = extras.getDouble("longitude");
+			cachetype = extras.getString("cachetype");
+			keyword = extras.getString("keyword");
+			address = extras.getString("address");
+			username = extras.getString("username");
+		}
+
+		init();
+
+		Thread threadPure;
+		cgSearchThread thread;
+
+		if (type.equals("offline") == true) {
+			listId = settings.getLastList();
+			if (listId <= 0) {
+				listId = 1;
+				title = res.getString(R.string.caches_stored);
+			} else {
+				final cgList list = app.getList(listId);
+				title = list.title;
+			}
+
+			base.setTitle(activity, title);
+			base.showProgress(activity, true);
+			setLoadingCaches();
+
+			threadPure = new geocachesLoadByOffline(loadCachesHandler, latitude, longitude, listId);
+			threadPure.start();
+		} else if (type.equals("history") == true) {
+			if (adapter != null) {
+				adapter.setHistoric(true);
+			}
+
+			title = res.getString(R.string.caches_history);
+			base.setTitle(activity, title);
+			base.showProgress(activity, true);
+			setLoadingCaches();
+
+			threadPure = new geocachesLoadByHistory(loadCachesHandler);
+			threadPure.start();
+		} else if (type.equals("nearest") == true) {
+			action = "pending";
+			title = res.getString(R.string.caches_nearby);
+			base.setTitle(activity, title);
+			base.showProgress(activity, true);
+			setLoadingCaches();
+
+			thread = new geocachesLoadByCoords(loadCachesHandler, latitude, longitude, cachetype);
+			thread.setRecaptchaHandler(new cgSearchHandler(activity, res, thread));
+			thread.start();
+		} else if (type.equals("coordinate") == true) {
+			action = "planning";
+			title = base.formatCoordinate(latitude, res.getString(R.string.search_lat), true) + " | " + base.formatCoordinate(longitude, res.getString(R.string.search_lon), true);
+			base.setTitle(activity, title);
+			base.showProgress(activity, true);
+			setLoadingCaches();
+
+			thread = new geocachesLoadByCoords(loadCachesHandler, latitude, longitude, cachetype);
+			thread.setRecaptchaHandler(new cgSearchHandler(activity, res, thread));
+			thread.start();
+		} else if (type.equals("keyword") == true) {
+			title = keyword;
+			base.setTitle(activity, title);
+			base.showProgress(activity, true);
+			setLoadingCaches();
+
+			thread = new geocachesLoadByKeyword(loadCachesHandler, keyword, cachetype);
+			thread.setRecaptchaHandler(new cgSearchHandler(activity, res, thread));
+			thread.start();
+		} else if (type.equals("address") == true) {
+			action = "planning";
+			if (address != null && address.length() > 0) {
+				title = address;
+				base.setTitle(activity, title);
+				base.showProgress(activity, true);
+				setLoadingCaches();
+			} else {
+				title = base.formatCoordinate(latitude, res.getString(R.string.search_lat), true) + " | " + base.formatCoordinate(longitude, res.getString(R.string.search_lon), true);
+				base.setTitle(activity, title);
+				base.showProgress(activity, true);
+				setLoadingCaches();
+			}
+
+			thread = new geocachesLoadByCoords(loadCachesHandler, latitude, longitude, cachetype);
+			thread.setRecaptchaHandler(new cgSearchHandler(activity, res, thread));
+			thread.start();
+		} else if (type.equals("username") == true) {
+			title = username;
+			base.setTitle(activity, title);
+			base.showProgress(activity, true);
+			setLoadingCaches();
+
+			thread = new geocachesLoadByUserName(loadCachesHandler, username, cachetype);
+			thread.setRecaptchaHandler(new cgSearchHandler(activity, res, thread));
+			thread.start();
+		} else if (type.equals("owner") == true) {
+			title = username;
+			base.setTitle(activity, title);
+			base.showProgress(activity, true);
+			setLoadingCaches();
+
+			thread = new geocachesLoadByOwner(loadCachesHandler, username, cachetype);
+			thread.setRecaptchaHandler(new cgSearchHandler(activity, res, thread));
+			thread.start();
+		} else {
+			title = "caches";
+			base.setTitle(activity, title);
+			Log.e(cgSettings.tag, "cgeocaches.onCreate: No action or unknown action specified");
+		}
+	}
+
+	@Override
+	public void onConfigurationChanged(Configuration newConfig) {
+		super.onConfigurationChanged(newConfig);
+
+		init();
+	}
+
+	@Override
+	public void onResume() {
+		super.onResume();
+
+		settings.load();
+		init();
+
+		if (adapter != null && geo != null && geo.latitudeNow != null && geo.longitudeNow != null) {
+			adapter.setActualCoordinates(geo.latitudeNow, geo.longitudeNow);
+			adapter.setActualHeading(northHeading);
+		}
+
+		if (adapter != null) {
+			adapter.setSelectMode(false, true);
+			if (geo != null && geo.latitudeNow != null && geo.longitudeNow != null) {
+				adapter.forceSort(geo.latitudeNow, geo.longitudeNow);
+			}
+		}
+
+		if (loadCachesHandler != null && searchId != null) {
+			loadCachesHandler.sendEmptyMessage(0);
+		}
+	}
+
+	@Override
+	public void onDestroy() {
+		if (adapter != null) {
+			adapter = null;
+		}
+
+		if (dir != null) {
+			dir = app.removeDir();
+		}
+		if (geo != null) {
+			geo = app.removeGeo();
+		}
+		if (tracker != null) {
+			tracker.stop();
+		}
+
+		super.onDestroy();
+	}
+
+	@Override
+	public void onStop() {
+		if (dir != null) {
+			dir = app.removeDir();
+		}
+		if (geo != null) {
+			geo = app.removeGeo();
+		}
+
+		super.onStop();
+	}
+
+	@Override
+	public void onPause() {
+		if (dir != null) {
+			dir = app.removeDir();
+		}
+		if (geo != null) {
+			geo = app.removeGeo();
+		}
+
+		super.onPause();
+	}
+
+	@Override
+	public boolean onCreateOptionsMenu(Menu menu) {
+		SubMenu subMenuFilter = menu.addSubMenu(0, 105, 0, res.getString(R.string.caches_filter)).setIcon(android.R.drawable.ic_menu_search);
+		subMenuFilter.setHeaderTitle(res.getString(R.string.caches_filter_title));
+		subMenuFilter.add(0, 21, 0, res.getString(R.string.caches_filter_type));
+		subMenuFilter.add(0, 22, 0, res.getString(R.string.caches_filter_size));
+		subMenuFilter.add(0, 23, 0, res.getString(R.string.caches_filter_track));
+		subMenuFilter.add(0, 24, 0, res.getString(R.string.caches_filter_clear));
+		
+		SubMenu subMenuSort = menu.addSubMenu(0, 104, 0, res.getString(R.string.caches_sort)).setIcon(android.R.drawable.ic_menu_sort_alphabetically);
+		subMenuSort.setHeaderTitle(res.getString(R.string.caches_sort_title));
+
+		// sort the context menu labels alphabetically for easier reading
+		HashMap<String, Integer> comparators = new HashMap<String, Integer>();
+		comparators.put(res.getString(R.string.caches_sort_distance), 10);
+		comparators.put(res.getString(R.string.caches_sort_difficulty), 11);
+		comparators.put(res.getString(R.string.caches_sort_terrain), 12);
+		comparators.put(res.getString(R.string.caches_sort_size), 13);
+		comparators.put(res.getString(R.string.caches_sort_favorites), 14);
+		comparators.put(res.getString(R.string.caches_sort_name), 15);
+		comparators.put(res.getString(R.string.caches_sort_gccode), 16);
+		comparators.put(res.getString(R.string.caches_sort_rating), 18);
+		comparators.put(res.getString(R.string.caches_sort_vote), 19);
+		comparators.put(res.getString(R.string.caches_sort_inventory), 20);
+
+		ArrayList<String> sortedLabels = new ArrayList<String>(comparators.keySet());
+		Collections.sort(sortedLabels);
+		for (String label : sortedLabels) {
+			Integer id = comparators.get(label);
+			subMenuSort.add(1, id, 0, label).setCheckable(true).setChecked(id == 10);
+		}
+
+		subMenuSort.setGroupCheckable(1, true, true);
+
+		menu.add(0, 0, 0, res.getString(R.string.caches_select_mode)).setIcon(android.R.drawable.ic_menu_agenda);
+		menu.add(0, 9, 0, res.getString(R.string.caches_select_invert)).setIcon(android.R.drawable.ic_menu_agenda);
+		if (type.equals("offline") == true) {
+			SubMenu subMenu = menu.addSubMenu(0, 103, 0, res.getString(R.string.caches_manage)).setIcon(android.R.drawable.ic_menu_save);
+			subMenu.add(0, 5, 0, res.getString(R.string.caches_drop_all)); // delete saved caches
+			subMenu.add(0, 1, 0, res.getString(R.string.cache_offline_refresh)); // download details for all caches
+			if (settings.webDeviceCode == null)
+			{
+				menu.add(0, 6, 0, res.getString(R.string.gpx_import_title)).setIcon(android.R.drawable.ic_menu_upload); // import gpx file
+			} else {
+				SubMenu subMenuImport = menu.addSubMenu(0, 105, 0, res.getString(R.string.import_title)).setIcon(android.R.drawable.ic_menu_upload); // import
+				subMenuImport.add(1, 6, 0, res.getString(R.string.gpx_import_title)).setCheckable(false).setChecked(false);
+				subMenuImport.add(1, 25, 0, res.getString(R.string.web_import_title)).setCheckable(false).setChecked(false);
+			}
+		} else {
+			menu.add(0, 1, 0, res.getString(R.string.caches_store_offline)).setIcon(android.R.drawable.ic_menu_set_as); // download details for all caches
+		}
+
+		final Intent intentTest = new Intent(Intent.ACTION_VIEW);
+		intentTest.setData(Uri.parse("menion.points:x"));
+		if (cgBase.isIntentAvailable(activity, intentTest) == true) {
+			SubMenu subMenu = menu.addSubMenu(0, 101, 0, res.getString(R.string.caches_on_map)).setIcon(android.R.drawable.ic_menu_mapmode);
+			subMenu.add(0, 2, 0, res.getString(R.string.caches_map_cgeo)); // show all caches on map using c:geo
+			subMenu.add(0, 3, 0, res.getString(R.string.caches_map_locus)); // show all caches on map using Locus
+		} else {
+			menu.add(0, 2, 0, res.getString(R.string.caches_on_map)).setIcon(android.R.drawable.ic_menu_mapmode); // show all caches on map
+		}
+
+		if (type.equals("offline") == true) {
+			SubMenu subMenu = menu.addSubMenu(0, 102, 0, res.getString(R.string.list_menu)).setIcon(android.R.drawable.ic_menu_more);
+			subMenu.add(0, 7, 0, res.getString(R.string.list_menu_create));
+			subMenu.add(0, 8, 0, res.getString(R.string.list_menu_drop));
+			subMenu.add(0, 17, 0, res.getString(R.string.list_menu_change));
+		}
+
+		return true;
+	}
+
+	@Override
+	public boolean onPrepareOptionsMenu(Menu menu) {
+		super.onPrepareOptionsMenu(menu);
+
+		try {
+			if (adapter != null && adapter.getSelectMode() == true) {
+				menu.findItem(0).setTitle(res.getString(R.string.caches_select_mode_exit));
+				menu.findItem(9).setVisible(true);
+			} else {
+				menu.findItem(0).setTitle(res.getString(R.string.caches_select_mode));
+				menu.findItem(9).setVisible(false);
+			}
+
+			if (type != null && type.equals("offline") == true) {
+				if (adapter != null && adapter.getChecked() > 0) {
+					menu.findItem(5).setTitle(res.getString(R.string.caches_drop_selected) + " (" + adapter.getChecked() + ")");
+				} else {
+					menu.findItem(5).setTitle(res.getString(R.string.caches_drop_all));
+				}
+
+				if (adapter != null && adapter.getChecked() > 0) {
+					menu.findItem(1).setTitle(res.getString(R.string.caches_refresh_selected) + " (" + adapter.getChecked() + ")");
+				} else {
+					menu.findItem(1).setTitle(res.getString(R.string.caches_refresh_all));
+				}
+			} else {
+				if (adapter == null) {
+					Log.i(cgSettings.tag, "No adapter");
+				} else {
+					Log.i(cgSettings.tag, "Checked: " + adapter.getChecked());
+				}
+				if (adapter != null && adapter.getChecked() > 0) {
+					menu.findItem(1).setTitle(res.getString(R.string.caches_store_selected) + " (" + adapter.getChecked() + ")");
+				} else {
+					menu.findItem(1).setTitle(res.getString(R.string.caches_store_offline));
+				}
+			}
+
+			if (type != null && type.equals("offline") == false && (cacheList != null && app != null && cacheList.size() >= app.getTotal(searchId))) { // there are no more caches
+				menu.findItem(0).setEnabled(false);
+			} else {
+				menu.findItem(0).setEnabled(true);
+			}
+
+			if (listId == 1) {
+				menu.findItem(8).setVisible(false);
+			} else {
+				menu.findItem(8).setVisible(true);
+			}
+			if (app.getLists().size() < 2) {
+				menu.findItem(17).setVisible(false);
+			} else {
+				menu.findItem(17).setVisible(true);
+			}
+		} catch (Exception e) {
+			Log.e(cgSettings.tag, "cgeocaches.onPrepareOptionsMenu: " + e.toString());
+		}
+
+		return true;
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem item) {
+		switch (item.getItemId()) {
+			case 0:
+				if (adapter != null) {
+					adapter.switchSelectMode();
+				}
+				return true;
+			case 1:
+				refreshStored();
+				return true;
+			case 2:
+				showOnMap();
+				return false;
+			case 3:
+				showOnLocus();
+				return false;
+			case 5:
+				dropStored();
+				return false;
+			case 6:
+				importGpx();
+				return false;
+			case 7:
+				createList();
+				return false;
+			case 8:
+				removeList();
+				return false;
+			case 9:
+				if (adapter != null) {
+					adapter.invertSelection();
+				}
+				return false;
+			case 10:
+				setComparator(item, null);
+				return false;
+			case 11:
+				setComparator(item, new cgCacheDifficultyComparator());
+				return false;
+			case 12:
+				setComparator(item, new cgCacheTerrainComparator());
+				return false;
+			case 13:
+				setComparator(item, new cgCacheSizeComparator());
+				return false;
+			case 14:
+				setComparator(item, new cgCachePopularityComparator());
+				return false;
+			case 15:
+				setComparator(item, new cgCacheNameComparator());
+				return false;
+			case 16:
+				setComparator(item, new cgCacheGeocodeComparator());
+				return false;
+			case 17:
+				selectList(null);
+				return false;
+			case 18:
+				setComparator(item, new cgCacheRatingComparator());
+				return false;
+			case 19:
+				setComparator(item, new cgCacheVoteComparator());
+				return false;
+			case 20:
+				setComparator(item, new cgCacheInventoryComparator());
+				return false;
+			case 21:
+				selectedFilter = res.getString(R.string.caches_filter_type);
+				openContextMenu(getListView());
+				return false;
+			case 22:
+				selectedFilter = res.getString(R.string.caches_filter_size);
+				openContextMenu(getListView());
+				return false;
+			case 23:
+				adapter.setFilter(new cgFilterByTrackables());
+				return false;
+			case 24:
+				if (adapter != null) {
+					adapter.setFilter(null);
+				}
+				return false;
+			case 25:
+				importWeb();
+				return false;
+		}
+
+		return false;
+	}
+
+	private void setComparator(MenuItem item,
+			Comparator<cgCache> comparator) {
+		if (adapter != null) {
+			adapter.setComparator(comparator);
+		}
+		item.setChecked(true);
+	}
+
+	@Override
+	public void onCreateContextMenu(ContextMenu menu, View view, ContextMenu.ContextMenuInfo info) {
+		super.onCreateContextMenu(menu, view, info);
+
+		if (adapter == null) {
+			return;
+		}
+
+		AdapterContextMenuInfo adapterInfo = null;
+		try {
+			adapterInfo = (AdapterContextMenuInfo) info;
+		} catch (Exception e) {
+			Log.w(cgSettings.tag, "cgeocaches.onCreateContextMenu: " + e.toString());
+		}
+		
+		if ((adapterInfo == null || adapterInfo.position < 0) && selectedFilter != null){
+			// Context menu opened by selecting an option on the filter submenu
+
+			if (selectedFilter.equals(res.getString(R.string.caches_filter_size))) {
+				menu.setHeaderTitle(res.getString(R.string.caches_filter_size_title));
+				menu.add(0,  8, 0, res.getString(R.string.caches_filter_size_micro));
+				menu.add(0,  9, 0, res.getString(R.string.caches_filter_size_small));
+				menu.add(0, 10, 0, res.getString(R.string.caches_filter_size_regular));
+				menu.add(0, 11, 0, res.getString(R.string.caches_filter_size_large));
+				menu.add(0, 12, 0, res.getString(R.string.caches_filter_size_other));	
+				menu.add(0, 13, 0, res.getString(R.string.caches_filter_size_virtual));	
+				menu.add(0, 14, 0, res.getString(R.string.caches_filter_size_notchosen));
+			} else if (selectedFilter.equals(res.getString(R.string.caches_filter_type))) {
+				menu.setHeaderTitle(res.getString(R.string.caches_filter_type_title));
+				menu.add(0,  15, 0, res.getString(R.string.caches_filter_type_traditional));
+				menu.add(0,  16, 0, res.getString(R.string.caches_filter_type_multi));
+				menu.add(0,  17, 0, res.getString(R.string.caches_filter_type_mystery));
+				menu.add(0,  18, 0, res.getString(R.string.caches_filter_type_letterbox));
+				menu.add(0,  19, 0, res.getString(R.string.caches_filter_type_event));
+				menu.add(0,  20, 0, res.getString(R.string.caches_filter_type_mega));
+				menu.add(0,  21, 0, res.getString(R.string.caches_filter_type_earth));
+				menu.add(0,  22, 0, res.getString(R.string.caches_filter_type_cito));
+				menu.add(0,  23, 0, res.getString(R.string.caches_filter_type_webcam));
+				menu.add(0,  24, 0, res.getString(R.string.caches_filter_type_virtual));
+				menu.add(0,  25, 0, res.getString(R.string.caches_filter_type_wherigo));
+				menu.add(0,  26, 0, res.getString(R.string.caches_filter_type_lostfound));
+				menu.add(0,  27, 0, res.getString(R.string.caches_filter_type_ape));
+				menu.add(0,  28, 0, res.getString(R.string.caches_filter_type_gchq));
+				menu.add(0,  29, 0, res.getString(R.string.caches_filter_type_gps));
+			}
+		} else{
+			final cgCache cache = adapter.getItem(adapterInfo.position);
+	
+			if (cache.name != null && cache.name.length() > 0) {
+				menu.setHeaderTitle(cache.name);
+			} else {
+				menu.setHeaderTitle(cache.geocode);
+			}
+			
+			if (cache.latitude != null && cache.longitude != null) {
+				menu.add(0, 1, 0, res.getString(R.string.cache_menu_compass));
+				menu.add(0, 2, 0, res.getString(R.string.cache_menu_radar));
+				menu.add(0, 3, 0, res.getString(R.string.cache_menu_map));
+				menu.add(0, 4, 0, res.getString(R.string.cache_menu_map_ext));
+				menu.add(0, 5, 0, res.getString(R.string.cache_menu_tbt));
+				menu.add(0, 6, 0, res.getString(R.string.cache_menu_visit));
+				menu.add(0, 7, 0, res.getString(R.string.cache_menu_details));
+			}
+		}
+		
+		ArrayList<cgList> cacheLists = app.getLists();
+		int listCount = cacheLists.size();
+		if (listCount > 1) {
+			SubMenu submenu = menu.addSubMenu(0, 8, 0, res.getString(R.string.cache_menu_move_list));
+			for (int i = 0; i < listCount; i++) {
+				cgList list = cacheLists.get(i);
+				submenu.add(Menu.NONE, 100+list.id, Menu.NONE, list.title);
+			}
+		}
+	}
+
+	@Override
+	public boolean onContextItemSelected(MenuItem item) {
+		final int id = item.getItemId();
+		ContextMenu.ContextMenuInfo info = item.getMenuInfo();
+
+		if (info == null) {
+			if(adapter != null){
+				if (id == 8) {
+					adapter.setFilter(new cgFilterBySize(res.getString(R.string.caches_filter_size_micro)));
+				} else if (id == 9) {
+					adapter.setFilter(new cgFilterBySize(res.getString(R.string.caches_filter_size_small)));
+				} else if (id == 10) {
+					adapter.setFilter(new cgFilterBySize(res.getString(R.string.caches_filter_size_regular)));
+				} else if (id == 11) {
+					adapter.setFilter(new cgFilterBySize(res.getString(R.string.caches_filter_size_large)));
+				} else if (id == 12) {
+					adapter.setFilter(new cgFilterBySize(res.getString(R.string.caches_filter_size_other)));
+				} else if (id == 13) {
+					adapter.setFilter(new cgFilterBySize(res.getString(R.string.caches_filter_size_virtual)));
+				} else if (id == 14) {
+					adapter.setFilter(new cgFilterBySize(res.getString(R.string.caches_filter_size_notchosen)));
+				} else if (id == 15) {
+					adapter.setFilter(new cgFilterByType("traditional"));
+				} else if (id == 16) {
+					adapter.setFilter(new cgFilterByType("multi"));
+				} else if (id == 17) {
+					adapter.setFilter(new cgFilterByType("mystery"));
+				} else if (id == 18) {
+					adapter.setFilter(new cgFilterByType("letterbox"));
+				} else if (id == 19) {
+					adapter.setFilter(new cgFilterByType("event"));
+				} else if (id == 20) {
+					adapter.setFilter(new cgFilterByType("mega"));
+				} else if (id == 21) {
+					adapter.setFilter(new cgFilterByType("earth"));
+				} else if (id == 22) {
+					adapter.setFilter(new cgFilterByType("cito"));
+				} else if (id == 23) {
+					adapter.setFilter(new cgFilterByType("webcam"));
+				} else if (id == 24) {
+					adapter.setFilter(new cgFilterByType("virtual"));
+				} else if (id == 25) {
+					adapter.setFilter(new cgFilterByType("wherigo"));
+				} else if (id == 26) {
+					adapter.setFilter(new cgFilterByType("lostfound"));
+				} else if (id == 27) {
+					adapter.setFilter(new cgFilterByType("ape"));
+				} else if (id == 28) {
+					adapter.setFilter(new cgFilterByType("gchq"));
+				} else if (id == 29) {
+					adapter.setFilter(new cgFilterByType("gps"));
+				} else {
+					return false;	
+				}
+				return true;
+			} else {
+				// restore menu info for sub menu items, see https://code.google.com/p/android/issues/detail?id=7139
+				info = lastMenuInfo;
+				lastMenuInfo = null;
+				return false;				
+			}
+		}
+
+		AdapterContextMenuInfo adapterInfo = null;
+		try {
+			adapterInfo = (AdapterContextMenuInfo) info;
+		} catch (Exception e) {
+			Log.w(cgSettings.tag, "cgeocaches.onContextItemSelected: " + e.toString());
+		}
+
+		final int touchedPos = adapterInfo.position;
+		final cgCache cache = adapter.getItem(touchedPos);
+
+		if (id == 1) { // compass
+			Intent navigateIntent = new Intent(activity, cgeonavigate.class);
+			navigateIntent.putExtra("latitude", cache.latitude);
+			navigateIntent.putExtra("longitude", cache.longitude);
+			navigateIntent.putExtra("geocode", cache.geocode.toUpperCase());
+			navigateIntent.putExtra("name", cache.name);
+
+			activity.startActivity(navigateIntent);
+
+			return true;
+		} else if (id == 2) { // radar
+			try {
+				if (cgBase.isIntentAvailable(activity, "com.google.android.radar.SHOW_RADAR") == true) {
+					Intent radarIntent = new Intent("com.google.android.radar.SHOW_RADAR");
+					radarIntent.putExtra("latitude", new Float(cache.latitude));
+					radarIntent.putExtra("longitude", new Float(cache.longitude));
+					activity.startActivity(radarIntent);
+				} else {
+					AlertDialog.Builder dialog = new AlertDialog.Builder(activity);
+					dialog.setTitle(res.getString(R.string.err_radar_title));
+					dialog.setMessage(res.getString(R.string.err_radar_message));
+					dialog.setCancelable(true);
+					dialog.setPositiveButton(getString(android.R.string.yes), new DialogInterface.OnClickListener() {
+
+						public void onClick(DialogInterface dialog, int id) {
+							try {
+								activity.startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("market://search?q=pname:com.eclipsim.gpsstatus2")));
+								dialog.cancel();
+							} catch (Exception e) {
+								warning.showToast(res.getString(R.string.err_radar_market));
+								Log.e(cgSettings.tag, "cgeocaches.onContextItemSelected.radar.onClick: " + e.toString());
+							}
+						}
+					});
+					dialog.setNegativeButton(getString(android.R.string.no), new DialogInterface.OnClickListener() {
+
+						public void onClick(DialogInterface dialog, int id) {
+							dialog.cancel();
+						}
+					});
+
+					AlertDialog alert = dialog.create();
+					alert.show();
+				}
+			} catch (Exception e) {
+				warning.showToast(res.getString(R.string.err_radar_generic));
+				Log.e(cgSettings.tag, "cgeocaches.onContextItemSelected.radar: " + e.toString());
+			}
+
+			return true;
+		} else if (id == 3) { // show on map
+			Intent mapIntent = new Intent(activity, settings.getMapFactory().getMapClass());
+			mapIntent.putExtra("detail", false);
+			mapIntent.putExtra("geocode", cache.geocode);
+
+			activity.startActivity(mapIntent);
+
+			return true;
+		} else if (id == 4) { // show on external map
+			base.runExternalMap(0, activity, res, warning, tracker, cache);
+
+			return true;
+		} else if (id == 5) { // turn-by-turn
+			if (geo != null) {
+				base.runNavigation(activity, res, settings, warning, tracker, cache.latitude, cache.longitude, geo.latitudeNow, geo.longitudeNow);
+			} else {
+				base.runNavigation(activity, res, settings, warning, tracker, cache.latitude, cache.longitude);
+			}
+
+			return true;
+		} else if (id == 6) { // log visit
+			if (cache.cacheid == null || cache.cacheid.length() == 0) {
+				warning.showToast(res.getString(R.string.err_cannot_log_visit));
+				return true;
+			}
+
+			Intent logVisitIntent = new Intent(activity, cgeovisit.class);
+			logVisitIntent.putExtra("id", cache.cacheid);
+			logVisitIntent.putExtra("geocode", cache.geocode.toUpperCase());
+			logVisitIntent.putExtra("type", cache.type.toLowerCase());
+
+			activity.startActivity(logVisitIntent);
+
+			return true;
+		} else if (id == 7) { // cache details
+			Intent cachesIntent = new Intent(activity, cgeodetail.class);
+			cachesIntent.putExtra("geocode", cache.geocode.toUpperCase());
+			cachesIntent.putExtra("name", cache.name);
+			activity.startActivity(cachesIntent);
+
+			return true;
+		} else if (id == 8) { // move to list (sub menu)
+			// we must remember the menu info for the sub menu, there is a bug in Android:
+			// https://code.google.com/p/android/issues/detail?id=7139
+			lastMenuInfo = info;
+			return true;
+		} else if (id >= 100) { // move to list
+			int newListId = id - 100;
+			app.moveToList(cache.geocode, newListId);
+			// refresh list by switching to the current list
+			switchListById(listId);
+			return true;
+		}
+		return false;
+	}
+	
+	@Override
+	public void onBackPressed() {
+		if (adapter != null) {
+			if (adapter.resetChecks() == true) {
+				return;
+			} else if (adapter.getSelectMode() == true) {
+				adapter.setSelectMode(false, true);
+
+				return;
+			}
+			
+			if (adapter.isFilter()) {
+				adapter.clearFilter();
+				
+				return;
+			}
+		}
+		
+		super.onBackPressed();
+		
+		return;
+	}
+
+	private void setAdapter() {
+		if (listFooter == null) {
+			if (inflater == null) {
+				inflater = activity.getLayoutInflater();
+			}
+			listFooter = inflater.inflate(R.layout.caches_footer, null);
+
+			listFooter.setClickable(true);
+			listFooter.setOnClickListener(new moreCachesListener());
+		}
+		if (listFooterText == null) {
+			listFooterText = (TextView) listFooter.findViewById(R.id.more_caches);
+		}
+
+		if (adapter == null) {
+			final ListView list = getListView();
+
+			registerForContextMenu(list);
+			list.setLongClickable(true);
+			list.addFooterView(listFooter);
+
+			adapter = new cgCacheListAdapter(activity, settings, cacheList, base);
+			setListAdapter(adapter);
+		} else {
+			adapter.notifyDataSetChanged();
+		}
+
+		if (adapter != null && geo != null) {
+			adapter.setActualCoordinates(geo.latitudeNow, geo.longitudeNow);
+		}
+		if (adapter != null && dir != null) {
+			adapter.setActualHeading(dir.directionNow);
+		}
+	}
+
+	private void setLoadingCaches() {
+		if (listFooter == null) {
+			return;
+		}
+		if (listFooterText == null) {
+			return;
+		}
+
+		listFooterText.setText(res.getString(R.string.caches_more_caches_loading));
+		listFooter.setClickable(false);
+		listFooter.setOnClickListener(null);
+	}
+
+	private void setMoreCaches(boolean more) {
+		if (listFooter == null) {
+			return;
+		}
+		if (listFooterText == null) {
+			return;
+		}
+
+		if (more == false) {
+			if (cacheList == null || cacheList.isEmpty()) {
+				listFooterText.setText(res.getString(R.string.caches_no_cache));
+			} else {
+				listFooterText.setText(res.getString(R.string.caches_more_caches_no));
+			}
+			listFooter.setClickable(false);
+			listFooter.setOnClickListener(null);
+		} else {
+			listFooterText.setText(res.getString(R.string.caches_more_caches));
+			listFooter.setClickable(true);
+			listFooter.setOnClickListener(new moreCachesListener());
+		}
+	}
+
+	private void init() {
+		// sensor & geolocation manager
+		if (geo == null) {
+			geo = app.startGeo(activity, geoUpdate, base, settings, warning, 0, 0);
+		}
+		if (settings.livelist == 1 && settings.useCompass == 1 && dir == null) {
+			dir = app.startDir(activity, dirUpdate, warning);
+		}
+
+		if (cacheList != null) {
+			base.setTitle(activity, title);
+		}
+
+		if (cacheList != null && cacheList.isEmpty() == false) {
+			final Integer count = app.getTotal(searchId);
+			if (count != null && count > 0) {
+				base.setTitle(activity, title);
+				if (cacheList.size() < app.getTotal(searchId) && cacheList.size() < 1000) {
+					setMoreCaches(true);
+				} else {
+					setMoreCaches(false);
+				}
+			} else {
+				base.setTitle(activity, title);
+				setMoreCaches(false);
+			}
+		} else {
+			base.setTitle(activity, title);
+		}
+
+		setAdapter();
+
+		if (geo != null) {
+			geoUpdate.updateLoc(geo);
+		}
+		if (dir != null) {
+			dirUpdate.updateDir(dir);
+		}
+	}
+
+	private void showOnMap() {
+		if (searchId == null || searchId == 0 || cacheList == null || cacheList.isEmpty() == true) {
+			warning.showToast(res.getString(R.string.warn_no_cache_coord));
+
+			return;
+		}
+
+		Intent mapIntent = new Intent(activity, settings.getMapFactory().getMapClass());
+		mapIntent.putExtra("detail", false);
+		mapIntent.putExtra("searchid", searchId);
+
+		activity.startActivity(mapIntent);
+	}
+
+	private void showOnLocus() {
+		if (cacheList == null || cacheList.isEmpty() == true) {
+			return;
+		}
+
+		try {
+			final Intent intentTest = new Intent(Intent.ACTION_VIEW);
+			intentTest.setData(Uri.parse("menion.points:x"));
+
+			if (cgBase.isIntentAvailable(activity, intentTest) == false) {
+				return;
+			}
+
+			final ArrayList<cgCache> cacheListTemp = (ArrayList<cgCache>) cacheList.clone();
+			final ArrayList<cgCache> cacheListCoord = new ArrayList<cgCache>();
+			for (cgCache cache : cacheListTemp) {
+				if (cache.latitude != null && cache.longitude != null) {
+					cacheListCoord.add(cache);
+				}
+			}
+			cacheListTemp.clear();
+
+			final ByteArrayOutputStream baos = new ByteArrayOutputStream();
+			final DataOutputStream dos = new DataOutputStream(baos);
+
+			dos.writeInt(1); // not used
+			dos.writeInt(cacheListCoord.size()); // cache and waypoints
+
+			// cache waypoints
+			if (cacheListCoord != null && cacheListCoord.isEmpty() == false) {
+				for (cgCache cache : cacheListCoord) {
+					final int wpIcon = base.getIcon(true, cache.type, cache.own, cache.found, cache.disabled);
+
+					if (wpIcon > 0) {
+						// load icon
+						Bitmap bitmap = BitmapFactory.decodeResource(res, wpIcon);
+						ByteArrayOutputStream baos2 = new ByteArrayOutputStream();
+						bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos2);
+						byte[] image = baos2.toByteArray();
+
+						dos.writeInt(image.length);
+						dos.write(image);
+					} else {
+						// no icon
+						dos.writeInt(0); // no image
+					}
+
+					// name
+					if (cache != null && cache.geocode != null && cache.geocode.length() > 0) {
+						dos.writeUTF(cache.geocode.toUpperCase());
+					} else {
+						dos.writeUTF("");
+					}
+
+					// description
+					if (cache != null && cache.name != null && cache.name.length() > 0) {
+						dos.writeUTF(cache.name);
+					} else {
+						dos.writeUTF("");
+					}
+
+					// additional data :: keyword, button title, package, activity, data name, data content
+					if (cache != null && cache.geocode != null && cache.geocode.length() > 0) {
+						dos.writeUTF("intent;c:geo;cgeo.geocaching;cgeo.geocaching.cgeodetail;geocode;" + cache.geocode);
+					} else {
+						dos.writeUTF("");
+					}
+
+					dos.writeDouble(cache.latitude); // latitude
+					dos.writeDouble(cache.longitude); // longitude
+				}
+			}
+
+			final Intent intent = new Intent();
+			intent.setAction(Intent.ACTION_VIEW);
+			intent.setData(Uri.parse("menion.points:data"));
+			intent.putExtra("data", baos.toByteArray());
+
+			activity.startActivity(intent);
+
+			base.sendAnal(activity, tracker, "/external/locus");
+		} catch (Exception e) {
+			// nothing
+		}
+	}
+
+	private void importGpx() {
+		final Intent intent = new Intent(activity, cgeogpxes.class);
+		intent.putExtra("list", listId);
+		activity.startActivity(intent);
+
+		finish();
+	}
+
+	public void refreshStored() {
+		if (adapter != null && adapter.getChecked() > 0) {
+			// there are some checked caches
+			detailTotal = adapter.getChecked();
+		} else {
+			// no checked caches, download everything (when already stored - refresh them)
+			detailTotal = cacheList.size();
+		}
+		detailProgress = 0;
+
+		base.showProgress(activity, false);
+		waitDialog = new ProgressDialog(this);
+		waitDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
+
+			public void onCancel(DialogInterface arg0) {
+				try {
+					if (threadD != null) {
+						threadD.kill();
+					}
+
+					if (geo == null) {
+						geo = app.startGeo(activity, geoUpdate, base, settings, warning, 0, 0);
+					}
+					if (settings.livelist == 1 && settings.useCompass == 1 && dir == null) {
+						dir = app.startDir(activity, dirUpdate, warning);
+					}
+				} catch (Exception e) {
+					Log.e(cgSettings.tag, "cgeocaches.onOptionsItemSelected.onCancel: " + e.toString());
+				}
+			}
+		});
+
+		waitDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
+		int etaTime = (int) ((detailTotal * 25) / 60);
+		if (etaTime < 1) {
+			waitDialog.setMessage(res.getString(R.string.caches_downloading) + " " + res.getString(R.string.caches_eta_ltm));
+		} else if (etaTime == 1) {
+			waitDialog.setMessage(res.getString(R.string.caches_downloading) + " " + etaTime + " " + res.getString(R.string.caches_eta_min));
+		} else {
+			waitDialog.setMessage(res.getString(R.string.caches_downloading) + " " + etaTime + " " + res.getString(R.string.caches_eta_mins));
+		}
+		waitDialog.setCancelable(true);
+		waitDialog.setMax(detailTotal);
+		waitDialog.show();
+
+		detailProgressTime = System.currentTimeMillis();
+
+		threadD = new geocachesLoadDetails(loadDetailsHandler, listId);
+		threadD.start();
+	}
+
+	public void importWeb() {
+		detailProgress = 0;
+
+                getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+		base.showProgress(activity, false);
+		waitDialog = new ProgressDialog(this);
+		waitDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
+
+			public void onCancel(DialogInterface arg0) {
+				try {
+					if (threadW != null) {
+						threadW.kill();
+					}
+
+					if (geo == null) {
+						geo = app.startGeo(activity, geoUpdate, base, settings, warning, 0, 0);
+					}
+					if (settings.livelist == 1 && settings.useCompass == 1 && dir == null) {
+						dir = app.startDir(activity, dirUpdate, warning);
+					}
+				} catch (Exception e) {
+					Log.e(cgSettings.tag, "cgeocaches.importWeb.onCancel: " + e.toString());
+				}
+			}
+		});
+
+		waitDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
+		waitDialog.setMessage(res.getString(R.string.web_import_waiting));
+		waitDialog.setCancelable(true);
+		waitDialog.show();
+
+		threadW = new geocachesLoadFromWeb(downloadFromWebHandler, listId);
+		threadW.start();
+	}
+	
+	public void dropStored() {
+		AlertDialog.Builder dialog = new AlertDialog.Builder(activity);
+		dialog.setCancelable(true);
+		dialog.setTitle(res.getString(R.string.caches_drop_stored));
+
+		if (adapter != null && adapter.getChecked() > 0) {
+			dialog.setMessage(res.getString(R.string.caches_drop_selected_ask));
+			dialog.setPositiveButton(getString(android.R.string.yes), new DialogInterface.OnClickListener() {
+
+				public void onClick(DialogInterface dialog, int id) {
+					dropSelected();
+					dialog.cancel();
+				}
+			});
+		} else {
+			dialog.setMessage(res.getString(R.string.caches_drop_all_ask));
+			dialog.setPositiveButton(getString(android.R.string.yes), new DialogInterface.OnClickListener() {
+
+				public void onClick(DialogInterface dialog, int id) {
+					dropSelected();
+					dialog.cancel();
+				}
+			});
+		}
+		dialog.setNegativeButton(getString(android.R.string.no), new DialogInterface.OnClickListener() {
+
+			public void onClick(DialogInterface dialog, int id) {
+				dialog.cancel();
+			}
+		});
+
+		AlertDialog alert = dialog.create();
+		alert.show();
+	}
+
+	public void dropSelected() {
+		waitDialog = new ProgressDialog(this);
+		waitDialog.setMessage(res.getString(R.string.caches_drop_progress));
+		waitDialog.setOnCancelListener(new DialogInterface.OnCancelListener() {
+
+			public void onCancel(DialogInterface arg0) {
+				try {
+					if (threadR != null) {
+						threadR.kill();
+					}
+				} catch (Exception e) {
+					Log.e(cgSettings.tag, "cgeocaches.onOptionsItemSelected.onCancel: " + e.toString());
+				}
+			}
+		});
+
+		waitDialog.setCancelable(true);
+		waitDialog.show();
+
+		threadR = new geocachesDropDetails(dropDetailsHandler);
+		threadR.start();
+	}
+
+	private class update extends cgUpdateLoc {
+
+		@Override
+		public void updateLoc(cgGeo geo) {
+			if (geo == null) {
+				return;
+			}
+			if (adapter == null) {
+				return;
+			}
+
+			try {
+				if (cacheList != null && geo.latitudeNow != null && geo.longitudeNow != null) {
+					adapter.setActualCoordinates(geo.latitudeNow, geo.longitudeNow);
+				}
+
+				if (settings.useCompass == 0 || (geo.speedNow != null && geo.speedNow > 5)) { // use GPS when speed is higher than 18 km/h
+					if (settings.useCompass == 0) {
+						if (geo.bearingNow != null) {
+							adapter.setActualHeading(geo.bearingNow);
+						} else {
+							adapter.setActualHeading(new Double(0));
+						}
+					}
+					if (northHeading != null) {
+						adapter.setActualHeading(northHeading);
+					}
+				}
+			} catch (Exception e) {
+				Log.w(cgSettings.tag, "Failed to update location.");
+			}
+		}
+	}
+
+	private class updateDir extends cgUpdateDir {
+
+		@Override
+		public void updateDir(cgDirection dir) {
+			if (settings.livelist == 0) {
+				return;
+			}
+			if (dir == null || dir.directionNow == null) {
+				return;
+			}
+
+			northHeading = dir.directionNow;
+			if (northHeading != null && adapter != null && (geo == null || geo.speedNow == null || geo.speedNow <= 5)) { // use compass when speed is lower than 18 km/h) {
+				adapter.setActualHeading(northHeading);
+			}
+		}
+	}
+
+	private class geocachesLoadByOffline extends Thread {
+
+		private Handler handler = null;
+		private Double latitude = null;
+		private Double longitude = null;
+		private int listId = 1;
+
+		public geocachesLoadByOffline(Handler handlerIn, Double latitudeIn, Double longitudeIn, int listIdIn) {
+			handler = handlerIn;
+			latitude = latitudeIn;
+			longitude = longitudeIn;
+			listId = listIdIn;
+		}
+
+		@Override
+		public void run() {
+			HashMap<String, Object> params = new HashMap<String, Object>();
+			if (latitude != null && longitude != null) {
+				params.put("latitude", latitude);
+				params.put("longitude", longitude);
+				params.put("cachetype", settings.cacheType);
+				params.put("list", listId);
+			}
+
+			searchId = base.searchByOffline(params);
+
+			handler.sendMessage(new Message());
+		}
+	}
+
+	private class geocachesLoadByHistory extends Thread {
+
+		private Handler handler = null;
+
+		public geocachesLoadByHistory(Handler handlerIn) {
+			handler = handlerIn;
+		}
+
+		@Override
+		public void run() {
+			HashMap<String, Object> params = new HashMap<String, Object>();
+			if (latitude != null && longitude != null) {
+				params.put("cachetype", settings.cacheType);
+			}
+
+			searchId = base.searchByHistory(params);
+
+			handler.sendMessage(new Message());
+		}
+	}
+
+	private class geocachesLoadNextPage extends cgSearchThread {
+
+		private Handler handler = null;
+
+		public geocachesLoadNextPage(Handler handlerIn) {
+			handler = handlerIn;
+		}
+
+		@Override
+		public void run() {
+			searchId = base.searchByNextPage(this, searchId, 0, settings.showCaptcha);
+
+			handler.sendMessage(new Message());
+		}
+	}
+
+	private class geocachesLoadByCoords extends cgSearchThread {
+
+		private Handler handler = null;
+		private Double latitude = null;
+		private Double longitude = null;
+		private String cachetype = null;
+
+		public geocachesLoadByCoords(Handler handlerIn, Double latitudeIn, Double longitudeIn, String cachetypeIn) {
+			setPriority(Thread.MIN_PRIORITY);
+
+			handler = handlerIn;
+			latitude = latitudeIn;
+			longitude = longitudeIn;
+			cachetype = cachetypeIn;
+
+			if (latitude == null || longitude == null) {
+				warning.showToast(res.getString(R.string.warn_no_coordinates));
+
+				finish();
+				return;
+			}
+		}
+
+		@Override
+		public void run() {
+			HashMap<String, String> params = new HashMap<String, String>();
+			params.put("latitude", String.format((Locale) null, "%.6f", latitude));
+			params.put("longitude", String.format((Locale) null, "%.6f", longitude));
+			params.put("cachetype", cachetype);
+
+			searchId = base.searchByCoords(this, params, 0, settings.showCaptcha);
+
+			handler.sendMessage(new Message());
+		}
+	}
+
+	private class geocachesLoadByKeyword extends cgSearchThread {
+
+		private Handler handler = null;
+		private String keyword = null;
+		private String cachetype = null;
+
+		public geocachesLoadByKeyword(Handler handlerIn, String keywordIn, String cachetypeIn) {
+			setPriority(Thread.MIN_PRIORITY);
+
+			handler = handlerIn;
+			keyword = keywordIn;
+			cachetype = cachetypeIn;
+
+			if (keyword == null) {
+				warning.showToast(res.getString(R.string.warn_no_keyword));
+
+				finish();
+				return;
+			}
+		}
+
+		@Override
+		public void run() {
+			HashMap<String, String> params = new HashMap<String, String>();
+			params.put("keyword", keyword);
+			params.put("cachetype", cachetype);
+
+			searchId = base.searchByKeyword(this, params, 0, settings.showCaptcha);
+
+			handler.sendMessage(new Message());
+		}
+	}
+
+	private class geocachesLoadByUserName extends cgSearchThread {
+
+		private Handler handler = null;
+		private String username = null;
+		private String cachetype = null;
+
+		public geocachesLoadByUserName(Handler handlerIn, String usernameIn, String cachetypeIn) {
+			setPriority(Thread.MIN_PRIORITY);
+
+			handler = handlerIn;
+			username = usernameIn;
+			cachetype = cachetypeIn;
+
+			if (username == null || username.length() == 0) {
+				warning.showToast(res.getString(R.string.warn_no_username));
+
+				finish();
+				return;
+			}
+		}
+
+		@Override
+		public void run() {
+			HashMap<String, String> params = new HashMap<String, String>();
+			params.put("username", username);
+			params.put("cachetype", cachetype);
+
+			searchId = base.searchByUsername(this, params, 0, settings.showCaptcha);
+
+			handler.sendMessage(new Message());
+		}
+	}
+
+	private class geocachesLoadByOwner extends cgSearchThread {
+
+		private Handler handler = null;
+		private String username = null;
+		private String cachetype = null;
+
+		public geocachesLoadByOwner(Handler handlerIn, String usernameIn, String cachetypeIn) {
+			setPriority(Thread.MIN_PRIORITY);
+
+			handler = handlerIn;
+			username = usernameIn;
+			cachetype = cachetypeIn;
+
+			if (username == null || username.length() == 0) {
+				warning.showToast(res.getString(R.string.warn_no_username));
+
+				finish();
+				return;
+			}
+		}
+
+		@Override
+		public void run() {
+			HashMap<String, String> params = new HashMap<String, String>();
+			params.put("username", username);
+			params.put("cachetype", cachetype);
+
+			searchId = base.searchByOwner(this, params, 0, settings.showCaptcha);
+
+			handler.sendMessage(new Message());
+		}
+	}
+
+	private class geocachesLoadDetails extends Thread {
+
+		private Handler handler = null;
+		private int reason = 1;
+		private volatile boolean needToStop = false;
+		private int checked = 0;
+		private long last = 0l;
+
+		public geocachesLoadDetails(Handler handlerIn, int reasonIn) {
+			setPriority(Thread.MIN_PRIORITY);
+
+			handler = handlerIn;
+			reason = reasonIn;
+
+			if (adapter != null) {
+				checked = adapter.getChecked();
+			}
+		}
+
+		public void kill() {
+			needToStop = true;
+		}
+
+		@Override
+		public void run() {
+			if (dir != null) {
+				dir = app.removeDir();
+			}
+			if (geo != null) {
+				geo = app.removeGeo();
+			}
+
+			final ArrayList<cgCache> cacheListTemp = (ArrayList<cgCache>) cacheList.clone();
+			for (cgCache cache : cacheListTemp) {
+				if (checked > 0 && cache.statusChecked == false) {
+					handler.sendEmptyMessage(0);
+
+					yield();
+					continue;
+				}
+
+				try {
+					if (needToStop == true) {
+						Log.i(cgSettings.tag, "Stopped storing process.");
+						break;
+					}
+
+					if ((System.currentTimeMillis() - last) < 1500) {
+						try {
+							int delay = 1000 + ((Double) (Math.random() * 1000)).intValue() - (int) (System.currentTimeMillis() - last);
+							if (delay < 0) {
+								delay = 500;
+							}
+
+							Log.i(cgSettings.tag, "Waiting for next cache " + delay + " ms");
+							sleep(delay);
+						} catch (Exception e) {
+							Log.e(cgSettings.tag, "cgeocaches.geocachesLoadDetails.sleep: " + e.toString());
+						}
+					}
+
+					if (needToStop == true) {
+						Log.i(cgSettings.tag, "Stopped storing process.");
+						break;
+					}
+
+					detailProgress++;
+					base.storeCache(app, activity, cache, null, reason, handler);
+
+					handler.sendEmptyMessage(cacheList.indexOf(cache));
+
+					yield();
+				} catch (Exception e) {
+					Log.e(cgSettings.tag, "cgeocaches.geocachesLoadDetails: " + e.toString());
+				}
+
+				last = System.currentTimeMillis();
+			}
+			cacheListTemp.clear();
+
+			handler.sendEmptyMessage(-1);
+		}
+	}
+	
+	//tg
+	private class geocachesLoadFromWeb extends Thread {
+
+		private Handler handler = null;
+		private int reason = 1;
+		private volatile boolean needToStop = false;
+		private int checked = 0;
+		private long last = 0l;
+
+		public geocachesLoadFromWeb(Handler handlerIn, int reasonIn) {
+			setPriority(Thread.MIN_PRIORITY);
+
+			handler = handlerIn;
+			reason = reasonIn;
+		}
+
+		public void kill() {
+			needToStop = true;
+		}
+
+		@Override
+		public void run() {
+			if (dir != null) {
+				dir = app.removeDir();
+			}
+			if (geo != null) {
+				geo = app.removeGeo();
+			}
+			
+			int delay=-1;
+			int times=0;
+
+			while (times < 36) //3 minutes max
+			{
+				if (needToStop)
+				{
+					handler.sendEmptyMessage(-1);
+					break;
+				}
+				
+				//download new code
+                                String deviceCode = settings.webDeviceCode;
+                                if (deviceCode==null) deviceCode="";
+				cgResponse responseFromWeb = base.request(false, "send2cgeo.carnero.cc", "/readCode.php", "GET", "d=" + cgBase.urlencode_rfc3986(deviceCode), 0, true);
+                                
+                                if ((responseFromWeb.getStatusCode() == 200)&&(responseFromWeb.getData().length()>2)) {
+
+                                        String GCcode = responseFromWeb.getData();
+
+                                        delay=1;
+					Message mes = new Message();
+					mes.what=1;
+					mes.obj=GCcode;
+					handler.sendMessage(mes);
+					yield();
+	
+					base.storeCache(app, activity, null, GCcode, reason, null);
+	
+					Message mes1 = new Message();
+					mes1.what=2;
+					mes1.obj=GCcode;
+					handler.sendMessage(mes1);
+					yield();
+				} else {
+					delay=0;
+					handler.sendEmptyMessage(0);
+					yield();
+                                }
+                                if (responseFromWeb.getStatusCode() != 200) {
+                                        needToStop = true;
+                                        settings.setWebNameCode(null, null);
+					handler.sendEmptyMessage(-2);
+					return;
+				}
+
+				try {
+					yield();
+					if (delay==0)
+					{
+						sleep(5000); //No caches 5s
+						times++;
+					} else {
+						sleep(500); //Cache was loaded 0.5s
+						times=0;
+					}
+				} catch (InterruptedException e) {
+					Log.e(cgSettings.tag, "cgeocaches.geocachesLoadFromWeb.sleep: " + e.toString());
+				}
+			}
+			handler.sendEmptyMessage(-1);
+		}
+	}
+	//tg
+
+	private class geocachesDropDetails extends Thread {
+
+		private Handler handler = null;
+		private volatile boolean needToStop = false;
+		private int checked = 0;
+
+		public geocachesDropDetails(Handler handlerIn) {
+			setPriority(Thread.MIN_PRIORITY);
+
+			handler = handlerIn;
+
+			if (adapter != null) {
+				checked = adapter.getChecked();
+			}
+		}
+
+		public void kill() {
+			needToStop = true;
+		}
+
+		@Override
+		public void run() {
+			if (dir != null) {
+				dir = app.removeDir();
+			}
+			if (geo != null) {
+				geo = app.removeGeo();
+			}
+
+			final ArrayList<cgCache> cacheListTemp = (ArrayList<cgCache>) cacheList.clone();
+			for (cgCache cache : cacheListTemp) {
+				if (checked > 0 && cache.statusChecked == false) {
+					handler.sendEmptyMessage(0);
+
+					yield();
+					continue;
+				}
+
+				try {
+					if (needToStop == true) {
+						Log.i(cgSettings.tag, "Stopped dropping process.");
+						break;
+					}
+
+					app.markDropped(cache.geocode);
+
+					handler.sendEmptyMessage(cacheList.indexOf(cache));
+
+					yield();
+				} catch (Exception e) {
+					Log.e(cgSettings.tag, "cgeocaches.geocachesDropDetails: " + e.toString());
+				}
+			}
+			cacheListTemp.clear();
+
+			handler.sendEmptyMessage(-1);
+		}
+	}
+
+	private class moreCachesListener implements View.OnClickListener {
+
+		@Override
+		public void onClick(View arg0) {
+			base.showProgress(activity, true);
+			setLoadingCaches();
+			listFooter.setOnClickListener(null);
+
+			geocachesLoadNextPage thread;
+			thread = new geocachesLoadNextPage(loadNextPageHandler);
+			thread.setRecaptchaHandler(new cgSearchHandler(activity, res, thread));
+			thread.start();
+		}
+	}
+
+	private void hideLoading() {
+		final ListView list = getListView();
+		final RelativeLayout loading = (RelativeLayout) findViewById(R.id.loading);
+
+		if (list.getVisibility() == View.GONE) {
+			list.setVisibility(View.VISIBLE);
+			loading.setVisibility(View.GONE);
+		}
+	}
+
+	public void selectList(View view) {
+		if (type.equals("offline") == false) {
+			return;
+		}
+
+		lists = app.getLists();
+
+		if (lists == null) {
+			return;
+		}
+
+		final ArrayList<CharSequence> listsTitle = new ArrayList<CharSequence>();
+		for (cgList list : lists) {
+			listsTitle.add(list.title);
+		}
+
+		final CharSequence[] items = new CharSequence[listsTitle.size()];
+
+		AlertDialog.Builder builder = new AlertDialog.Builder(activity);
+		builder.setTitle(res.getString(R.string.list_title));
+		builder.setItems(listsTitle.toArray(items), new DialogInterface.OnClickListener() {
+			public void onClick(DialogInterface dialogInterface, int item) {
+				switchListByOrder(item);
+
+				return;
+			}
+		});
+		builder.create().show();
+	}
+
+	public void switchListByOrder(int order) {
+		switchList(-1, order);
+	}
+
+	public void switchListById(int id) {
+		switchList(id, -1);
+	}
+
+	public void switchList(int id, int order) {
+		cgList list = null;
+
+		if (id >= 0) {
+			list = app.getList(id);
+		} else if (order >= 0) {
+			lists = app.getLists();
+			list = lists.get(order);
+		} else {
+			return;
+		}
+
+		if (list == null) {
+			return;
+		}
+
+		listId = list.id;
+		title = list.title;
+
+		settings.saveLastList(listId);
+
+		base.showProgress(activity, true);
+		setLoadingCaches();
+
+		Handler handlerMove = new Handler() {
+			@Override
+			public void handleMessage(Message msg) {
+				Thread threadPure = new geocachesLoadByOffline(loadCachesHandler, latitude, longitude, msg.what);
+				threadPure.start();
+			}
+		};
+
+		(new moveCachesToList(listId, handlerMove)).start();
+	}
+
+	private class moveCachesToList extends Thread {
+		int listId = -1;
+		Handler handler = null;
+
+		public moveCachesToList(int listIdIn, Handler handlerIn) {
+			listId = listIdIn;
+			handler = handlerIn;
+		}
+
+		@Override
+		public void run() {
+			int checked = adapter.getChecked();
+			if (checked > 0) {
+				final ArrayList<cgCache> cacheListTemp = (ArrayList<cgCache>) cacheList.clone();
+				for (cgCache cache : cacheListTemp) {
+					if (cache.statusChecked != false) {
+						app.moveToList(cache.geocode, listId);
+					}
+				}
+			}
+
+			handler.sendEmptyMessage(listId);
+		}
+	}
+
+	private void createList() {
+		final AlertDialog.Builder alert = new AlertDialog.Builder(this);
+		final View view = inflater.inflate(R.layout.list_create_dialog, null);
+		final EditText input = (EditText) view.findViewById(R.id.text);
+
+		alert.setTitle(R.string.list_dialog_create_title);
+		alert.setView(view);
+		alert.setPositiveButton(R.string.list_dialog_create, new DialogInterface.OnClickListener() {
+			public void onClick(DialogInterface dialog, int whichButton) {
+				String value = input.getText().toString();
+				// remove whitespaces added by autocompletion of Android keyboard
+				if (value != null) {
+					value = value.trim();
+				}
+
+				if (value != null && value.length() > 0) {
+					int newId = app.createList(value);
+
+					if (newId >= 10) {
+						warning.showToast(res.getString(R.string.list_dialog_create_ok));
+					} else {
+						warning.showToast(res.getString(R.string.list_dialog_create_err));
+					}
+				}
+			}
+		});
+		alert.setNegativeButton(res.getString(R.string.list_dialog_cancel), new DialogInterface.OnClickListener() {
+			public void onClick(DialogInterface dialog, int whichButton) {
+				dialog.dismiss();
+			}
+		});
+
+		alert.show();
+	}
+
+	private void removeList() {
+		final AlertDialog.Builder alert = new AlertDialog.Builder(this);
+
+		alert.setTitle(R.string.list_dialog_remove_title);
+		alert.setMessage(R.string.list_dialog_remove_description);
+		alert.setPositiveButton(R.string.list_dialog_remove, new DialogInterface.OnClickListener() {
+			public void onClick(DialogInterface dialog, int whichButton) {
+				boolean status = app.removeList(listId);
+
+				if (status) {
+					warning.showToast(res.getString(R.string.list_dialog_remove_ok));
+					switchListById(1);
+				} else {
+					warning.showToast(res.getString(R.string.list_dialog_remove_err));
+				}
+			}
+		});
+		alert.setNegativeButton(res.getString(R.string.list_dialog_cancel), new DialogInterface.OnClickListener() {
+			public void onClick(DialogInterface dialog, int whichButton) {
+				dialog.dismiss();
+			}
+		});
+
+		alert.show();
+	}
+
+	public void goMap(View view) {
+		showOnMap();
+	}
+
+	public void goHome(View view) {
+		base.goHome(activity);
+	}
+
+	public void goManual(View view) {
+		try {
+			if (type != null && type.equals("offline") == true) {
+				AppManualReaderClient.openManual(
+						"c-geo",
+						"c:geo-stored",
+						activity,
+						"http://cgeo.carnero.cc/manual/");
+			} else if (type != null && type.equals("history") == true) {
+				AppManualReaderClient.openManual(
+						"c-geo",
+						"c:geo-history",
+						activity,
+						"http://cgeo.carnero.cc/manual/");
+			} else {
+				AppManualReaderClient.openManual(
+						"c-geo",
+						"c:geo-nearby",
+						activity,
+						"http://cgeo.carnero.cc/manual/");
+			}
+		} catch (Exception e) {
+			// nothing
+		}
+	}
+}