refactoring: use underscore in symbolic constants

* otherwise they are not readable

17 files changed, 79 insertions, 79 deletions

diff --git a/main/src/cgeo/geocaching/CacheDetailActivity.java b/main/src/cgeo/geocaching/CacheDetailActivity.java
index 928b593..98e7112 100644
--- a/main/src/cgeo/geocaching/CacheDetailActivity.java
+++ b/main/src/cgeo/geocaching/CacheDetailActivity.java
@@ -179,7 +179,7 @@ public class CacheDetailActivity extends AbstractActivity {
 
         // TODO Why can it happen that search is not null? onCreate should be called only once and it is not set before.
         if (search != null) {
-            cache = search.getFirstCacheFromResult(LoadFlags.LOADALLDBONLY);
+            cache = search.getFirstCacheFromResult(LoadFlags.LOAD_ALL_DB_ONLY);
             if (cache != null && cache.getGeocode() != null) {
                 geocode = cache.getGeocode();
             }
@@ -622,7 +622,7 @@ public class CacheDetailActivity extends AbstractActivity {
             return;
         }
 
-        cache = search.getFirstCacheFromResult(LoadFlags.LOADALLDBONLY);
+        cache = search.getFirstCacheFromResult(LoadFlags.LOAD_ALL_DB_ONLY);
 
         if (cache == null) {
             progress.dismiss();
@@ -1508,7 +1508,7 @@ public class CacheDetailActivity extends AbstractActivity {
                     storeThread = null;
 
                     try {
-                        cache = search.getFirstCacheFromResult(LoadFlags.LOADALLDBONLY); // reload cache details
+                        cache = search.getFirstCacheFromResult(LoadFlags.LOAD_ALL_DB_ONLY); // reload cache details
                     } catch (Exception e) {
                         showToast(res.getString(R.string.err_store_failed));
 
@@ -1535,7 +1535,7 @@ public class CacheDetailActivity extends AbstractActivity {
                     refreshThread = null;
 
                     try {
-                        cache = search.getFirstCacheFromResult(LoadFlags.LOADALLDBONLY); // reload cache details
+                        cache = search.getFirstCacheFromResult(LoadFlags.LOAD_ALL_DB_ONLY); // reload cache details
                     } catch (Exception e) {
                         showToast(res.getString(R.string.err_refresh_failed));
 
@@ -1622,7 +1622,7 @@ public class CacheDetailActivity extends AbstractActivity {
 
             @Override
             public void run() {
-                app.removeCache(cache.getGeocode(), EnumSet.of(RemoveFlag.REMOVECACHE));
+                app.removeCache(cache.getGeocode(), EnumSet.of(RemoveFlag.REMOVE_CACHE));
                 search = cgBase.searchByGeocode(cache.getGeocode(), null, 0, true, handler);
 
                 handler.sendEmptyMessage(0);
diff --git a/main/src/cgeo/geocaching/SearchResult.java b/main/src/cgeo/geocaching/SearchResult.java
index c1e04ef..27efb68 100644
--- a/main/src/cgeo/geocaching/SearchResult.java
+++ b/main/src/cgeo/geocaching/SearchResult.java
@@ -145,7 +145,7 @@ public class SearchResult implements Parcelable {
         result.geocodes.clear();
 
         for (final String geocode : geocodes) {
-            cgCache cache = cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOADCACHEORDB);
+            cgCache cache = cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
             // Is there any reason to exclude the cache from the list?
             final boolean excludeCache = (excludeDisabled && cache.isDisabled()) ||
                     (excludeMine && (cache.isOwn() || cache.isFound())) ||
@@ -177,7 +177,7 @@ public class SearchResult implements Parcelable {
     /** Add the cache geocode to the search and store the cache in the CacheCache */
     public boolean addCache(final cgCache cache) {
         addGeocode(cache.getGeocode());
-        return cgeoapplication.getInstance().saveCache(cache, EnumSet.of(SaveFlag.SAVECACHE));
+        return cgeoapplication.getInstance().saveCache(cache, EnumSet.of(SaveFlag.SAVE_CACHE));
     }
 
     /** Add the cache geocodes to the search and store them in the CacheCache */
diff --git a/main/src/cgeo/geocaching/StaticMapsActivity.java b/main/src/cgeo/geocaching/StaticMapsActivity.java
index a66b409..8f6bf23 100644
--- a/main/src/cgeo/geocaching/StaticMapsActivity.java
+++ b/main/src/cgeo/geocaching/StaticMapsActivity.java
@@ -86,7 +86,7 @@ public class StaticMapsActivity extends AbstractActivity {
             dialog.dismiss();
             switch (which) {
             case DialogInterface.BUTTON_POSITIVE:
-                    cgCache cache = app.loadCache(geocode, LoadFlags.LOADCACHEORDB);
+                    cgCache cache = app.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
                     if (waypoint_id == null) {
                         StaticMapsProvider.storeCacheStaticMap(cache, StaticMapsActivity.this);
                     } else {
diff --git a/main/src/cgeo/geocaching/VisitCacheActivity.java b/main/src/cgeo/geocaching/VisitCacheActivity.java
index 6ee487a..6d0097a 100644
--- a/main/src/cgeo/geocaching/VisitCacheActivity.java
+++ b/main/src/cgeo/geocaching/VisitCacheActivity.java
@@ -258,7 +258,7 @@ public class VisitCacheActivity extends AbstractActivity implements DateDialog.D
             geocode = app.getGeocode(cacheid);
         }
 
-        cache = cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOADCACHEORDB);
+        cache = cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
 
         if (StringUtils.isNotBlank(cache.getName())) {
             setTitle(res.getString(R.string.log_new_log) + ": " + cache.getName());
@@ -716,9 +716,9 @@ public class VisitCacheActivity extends AbstractActivity implements DateDialog.D
                 }
 
                 if (cache != null) {
-                    app.saveCache(cache, EnumSet.of(SaveFlag.SAVECACHE));
+                    app.saveCache(cache, EnumSet.of(SaveFlag.SAVE_CACHE));
                 } else {
-                    app.removeCache(geocode, EnumSet.of(RemoveFlag.REMOVECACHE));
+                    app.removeCache(geocode, EnumSet.of(RemoveFlag.REMOVE_CACHE));
                 }
             }
 
diff --git a/main/src/cgeo/geocaching/cgBase.java b/main/src/cgeo/geocaching/cgBase.java
index 9e6a1ec..f069256 100644
--- a/main/src/cgeo/geocaching/cgBase.java
+++ b/main/src/cgeo/geocaching/cgBase.java
@@ -648,7 +648,7 @@ public class cgBase {
         if (Settings.getLoadDirImg())
         {
             for (String geocode : searchResult.getGeocodes()) {
-                cgCache oneCache = cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOADCACHEORDB);
+                cgCache oneCache = cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
                 if (oneCache.getCoords() == null && StringUtils.isNotEmpty(oneCache.getDirectionImg())) {
                     DirectionImage.getDrawable(oneCache.getGeocode(), oneCache.getDirectionImg());
                 }
@@ -666,7 +666,7 @@ public class cgBase {
                     if (MapUtils.isNotEmpty(ratings)) {
                         // save found cache coordinates
                         for (String geocode : searchResult.getGeocodes()) {
-                            cgCache cache = cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOADCACHEORDB);
+                            cgCache cache = cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
                             if (ratings.containsKey(cache.getGuid())) {
                                 GCVoteRating rating = ratings.get(cache.getGuid());
 
@@ -781,7 +781,7 @@ public class cgBase {
     public static SearchResult parseCache(final String page, final int listId, final CancellableHandler handler) {
         final SearchResult searchResult = parseCacheFromText(page, listId, handler);
         if (searchResult != null && !searchResult.getGeocodes().isEmpty()) {
-            final cgCache cache = searchResult.getFirstCacheFromResult(LoadFlags.LOADCACHEORDB);
+            final cgCache cache = searchResult.getFirstCacheFromResult(LoadFlags.LOAD_CACHE_OR_DB);
             getExtraOnlineInfo(cache, page, handler);
             cache.setUpdated(System.currentTimeMillis());
             cache.setDetailedUpdate(cache.getUpdated());
@@ -792,7 +792,7 @@ public class cgBase {
             // save full detailed caches
             sendLoadProgressDetail(handler, R.string.cache_dialog_offline_save_message);
             cache.setListId(StoredList.TEMPORARY_LIST_ID);
-            cgeoapplication.getInstance().saveCache(cache, EnumSet.of(SaveFlag.SAVEDB));
+            cgeoapplication.getInstance().saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB));
         }
         return searchResult;
     }
@@ -2278,7 +2278,7 @@ public class cgBase {
     };
 
     public static void postTweetCache(String geocode) {
-        final cgCache cache = cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOADCACHEORDB);
+        final cgCache cache = cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
         String status;
         final String url = cache.getUrl();
         if (url.length() >= 100) {
@@ -2626,13 +2626,13 @@ public class cgBase {
                 // only reload the cache, if it was already stored or has not all details (by checking the description)
                 if (origCache.getListId() >= StoredList.STANDARD_LIST_ID || StringUtils.isBlank(origCache.getDescription())) {
                     final SearchResult search = searchByGeocode(origCache.getGeocode(), null, listId, false, null);
-                    cache = search.getFirstCacheFromResult(LoadFlags.LOADCACHEORDB);
+                    cache = search.getFirstCacheFromResult(LoadFlags.LOAD_CACHE_OR_DB);
                 } else {
                     cache = origCache;
                 }
             } else if (StringUtils.isNotBlank(geocode)) {
                 final SearchResult search = searchByGeocode(geocode, null, listId, false, null);
-                cache = search.getFirstCacheFromResult(LoadFlags.LOADCACHEORDB);
+                cache = search.getFirstCacheFromResult(LoadFlags.LOAD_CACHE_OR_DB);
             } else {
                 cache = null;
             }
@@ -2694,7 +2694,7 @@ public class cgBase {
             }
 
             cache.setListId(listId);
-            cgeoapplication.getInstance().saveCache(cache, EnumSet.of(SaveFlag.SAVEDB));
+            cgeoapplication.getInstance().saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB));
 
             if (handler != null) {
                 handler.sendMessage(new Message());
@@ -2707,7 +2707,7 @@ public class cgBase {
     public static void dropCache(final cgCache cache, final Handler handler) {
         try {
             cgeoapplication.getInstance().markDropped(cache.getGeocode());
-            cgeoapplication.getInstance().removeCache(cache.getGeocode(), EnumSet.of(RemoveFlag.REMOVECACHE));
+            cgeoapplication.getInstance().removeCache(cache.getGeocode(), EnumSet.of(RemoveFlag.REMOVE_CACHE));
 
             handler.sendMessage(new Message());
         } catch (Exception e) {
diff --git a/main/src/cgeo/geocaching/cgCache.java b/main/src/cgeo/geocaching/cgCache.java
index 8bf8871..0197248 100644
--- a/main/src/cgeo/geocaching/cgCache.java
+++ b/main/src/cgeo/geocaching/cgCache.java
@@ -1183,7 +1183,7 @@ public class cgCache implements ICache {
         if (waypoint.isUserDefined()) {
             waypoints.remove(index);
             cgeoapplication.getInstance().deleteWaypoint(waypoint.getId());
-            cgeoapplication.getInstance().removeCache(geocode, EnumSet.of(RemoveFlag.REMOVECACHE));
+            cgeoapplication.getInstance().removeCache(geocode, EnumSet.of(RemoveFlag.REMOVE_CACHE));
             // Check status if Final is defined
             if (isFinalWithCoords(waypoint)) {
                 finalDefined = false;
diff --git a/main/src/cgeo/geocaching/cgData.java b/main/src/cgeo/geocaching/cgData.java
index 7e63fb8..73f53ad 100644
--- a/main/src/cgeo/geocaching/cgData.java
+++ b/main/src/cgeo/geocaching/cgData.java
@@ -1240,15 +1240,15 @@ public class cgData {
         }
 
         // merge always with data already stored in the CacheCache or DB
-        if (saveFlags.contains(SaveFlag.SAVECACHE)) {
+        if (saveFlags.contains(SaveFlag.SAVE_CACHE)) {
             cache.gatherMissingFrom(cacheCache.getCacheFromCache(cache.getGeocode()));
             cacheCache.putCacheInCache(cache);
         }
 
-        if (!saveFlags.contains(SaveFlag.SAVEDB)) {
+        if (!saveFlags.contains(SaveFlag.SAVE_DB)) {
             return true;
         }
-        boolean updateRequired = !cache.gatherMissingFrom(loadCache(cache.getGeocode(), LoadFlags.LOADALLDBONLY));
+        boolean updateRequired = !cache.gatherMissingFrom(loadCache(cache.getGeocode(), LoadFlags.LOAD_ALL_DB_ONLY));
 
         // only save a cache to the database if
         // - the cache is detailed
@@ -1770,7 +1770,7 @@ public class cgData {
             return null;
         }
 
-        Set<cgCache> caches = loadCaches(geocodes, LoadFlags.LOADCACHEORDB);
+        Set<cgCache> caches = loadCaches(geocodes, LoadFlags.LOAD_CACHE_OR_DB);
 
         Double latMin = 360.0;
         Double latMax = 0.0;
@@ -1828,7 +1828,7 @@ public class cgData {
         Set<cgCache> result = new HashSet<cgCache>();
         Set<String> remaining = new HashSet<String>(geocodes);
 
-        if (loadFlags.contains(LoadFlag.LOADCACHEBEFORE)) {
+        if (loadFlags.contains(LoadFlag.LOAD_CACHE_BEFORE)) {
             for (String geocode : new HashSet<String>(remaining)) {
                 cgCache cache = cacheCache.getCacheFromCache(geocode);
                 if (cache != null) {
@@ -1838,13 +1838,13 @@ public class cgData {
             }
         }
 
-        if (loadFlags.contains(LoadFlag.LOADDBMINIMAL) ||
-                loadFlags.contains(LoadFlag.LOADATTRIBUTES) ||
-                loadFlags.contains(LoadFlag.LOADWAYPOINTS) ||
-                loadFlags.contains(LoadFlag.LOADSPOILERS) ||
-                loadFlags.contains(LoadFlag.LOADLOGS) ||
-                loadFlags.contains(LoadFlag.LOADINVENTORY) ||
-                loadFlags.contains(LoadFlag.LOADOFFLINELOG)) {
+        if (loadFlags.contains(LoadFlag.LOAD_DB_MINIMAL) ||
+                loadFlags.contains(LoadFlag.LOAD_ATTRIBUTES) ||
+                loadFlags.contains(LoadFlag.LOAD_WAYPOINTS) ||
+                loadFlags.contains(LoadFlag.LOAD_SPOILERS) ||
+                loadFlags.contains(LoadFlag.LOAD_LOGS) ||
+                loadFlags.contains(LoadFlag.LOAD_INVENTORY) ||
+                loadFlags.contains(LoadFlag.LOAD_OFFLINE_LOG)) {
 
             Set<cgCache> cachesFromDB = loadCaches(remaining, null, null, null, null, loadFlags);
             if (cachesFromDB != null) {
@@ -1855,7 +1855,7 @@ public class cgData {
             }
         }
 
-        if (loadFlags.contains(LoadFlag.LOADCACHEAFTER)) {
+        if (loadFlags.contains(LoadFlag.LOAD_CACHE_AFTER)) {
             for (String geocode : new HashSet<String>(remaining)) {
                 cgCache cache = cacheCache.getCacheFromCache(geocode);
                 if (cache != null) {
@@ -1866,7 +1866,7 @@ public class cgData {
         }
 
         if (remaining.size() >= 1) {
-            Log.e(Settings.tag, "cgData.loadCaches(" + remaining.toString() + " failed");
+            Log.e(Settings.tag, "cgData.loadCaches(" + remaining.toString() + ") failed");
         }
         return result;
     }
@@ -1956,18 +1956,18 @@ public class cgData {
                         //Extracted Method = LOADDBMINIMAL
                         cgCache cache = cgData.createCacheFromDatabaseContent(cursor);
 
-                        if (loadFlags.contains(LoadFlag.LOADATTRIBUTES)) {
+                        if (loadFlags.contains(LoadFlag.LOAD_ATTRIBUTES)) {
                             cache.setAttributes(loadAttributes(cache.getGeocode()));
                         }
 
-                        if (loadFlags.contains(LoadFlag.LOADWAYPOINTS)) {
+                        if (loadFlags.contains(LoadFlag.LOAD_WAYPOINTS)) {
                             final List<cgWaypoint> waypoints = loadWaypoints(cache.getGeocode());
                             if (CollectionUtils.isNotEmpty(waypoints)) {
                                 cache.setWaypoints(waypoints);
                             }
                         }
 
-                        if (loadFlags.contains(LoadFlag.LOADSPOILERS)) {
+                        if (loadFlags.contains(LoadFlag.LOAD_SPOILERS)) {
                             final List<cgImage> spoilers = loadSpoilers(cache.getGeocode());
                             if (CollectionUtils.isNotEmpty(spoilers)) {
                                 if (cache.getSpoilers() == null) {
@@ -1979,7 +1979,7 @@ public class cgData {
                             }
                         }
 
-                        if (loadFlags.contains(LoadFlag.LOADLOGS)) {
+                        if (loadFlags.contains(LoadFlag.LOAD_LOGS)) {
                             cache.setLogs(loadLogs(cache.getGeocode()));
                             final Map<LogType, Integer> logCounts = loadLogCounts(cache.getGeocode());
                             if (MapUtils.isNotEmpty(logCounts)) {
@@ -1988,7 +1988,7 @@ public class cgData {
                             }
                         }
 
-                        if (loadFlags.contains(LoadFlag.LOADINVENTORY)) {
+                        if (loadFlags.contains(LoadFlag.LOAD_INVENTORY)) {
                             final List<cgTrackable> inventory = loadInventory(cache.getGeocode());
                             if (CollectionUtils.isNotEmpty(inventory)) {
                                 if (cache.getInventory() == null) {
@@ -2000,7 +2000,7 @@ public class cgData {
                             }
                         }
 
-                        if (loadFlags.contains(LoadFlag.LOADOFFLINELOG)) {
+                        if (loadFlags.contains(LoadFlag.LOAD_OFFLINE_LOG)) {
                             cache.setLogOffline(hasLogOffline(cache.getGeocode()));
                         }
                         cache.addStorageLocation(StorageLocation.DATABASE);
@@ -2962,7 +2962,7 @@ public class cgData {
             if (size > 0) {
                 Log.d(Settings.tag, "Database clean: removing " + size + " geocaches from listId=0");
 
-                removeCaches(geocodes, EnumSet.of(RemoveFlag.REMOVECACHE));
+                removeCaches(geocodes, EnumSet.of(RemoveFlag.REMOVE_CACHE));
                 databaseRW.execSQL("delete from " + dbTableCaches + " where " + cgData.whereGeocodeIn(geocodes));
             }
 
@@ -3019,13 +3019,13 @@ public class cgData {
 
         init();
 
-        if (removeFlags.contains(RemoveFlag.REMOVECACHE)) {
+        if (removeFlags.contains(RemoveFlag.REMOVE_CACHE)) {
             for (final String geocode : geocodes) {
                 cacheCache.removeCacheFromCache(geocode);
             }
         }
 
-        if (removeFlags.contains(RemoveFlag.REMOVEDB)) {
+        if (removeFlags.contains(RemoveFlag.REMOVE_DB)) {
             // Drop caches from the database
             final ArrayList<String> quotedGeocodes = new ArrayList<String>(geocodes.size());
             for (final String geocode : geocodes) {
diff --git a/main/src/cgeo/geocaching/cgeoapplication.java b/main/src/cgeo/geocaching/cgeoapplication.java
index 600ec04..a986dba 100644
--- a/main/src/cgeo/geocaching/cgeoapplication.java
+++ b/main/src/cgeo/geocaching/cgeoapplication.java
@@ -362,7 +362,7 @@ public class cgeoapplication extends Application {
 
     public boolean saveOwnWaypoint(int id, String geocode, cgWaypoint waypoint) {
         if (storage.saveOwnWaypoint(id, geocode, waypoint)) {
-            this.removeCache(geocode, EnumSet.of(RemoveFlag.REMOVECACHE));
+            this.removeCache(geocode, EnumSet.of(RemoveFlag.REMOVE_CACHE));
             return true;
         }
         return false;
diff --git a/main/src/cgeo/geocaching/cgeocaches.java b/main/src/cgeo/geocaching/cgeocaches.java
index 02906e7..1fc4486 100644
--- a/main/src/cgeo/geocaching/cgeocaches.java
+++ b/main/src/cgeo/geocaching/cgeocaches.java
@@ -173,7 +173,7 @@ public class cgeocaches extends AbstractListActivity {
                     setTitle(title + " [" + search.getCount() + "]");
                     cacheList.clear();
 
-                    final Set<cgCache> caches = search.getCachesFromSearchResult(LoadFlags.LOADCACHEORDB);
+                    final Set<cgCache> caches = search.getCachesFromSearchResult(LoadFlags.LOAD_CACHE_OR_DB);
                     if (CollectionUtils.isNotEmpty(caches)) {
                         cacheList.addAll(caches);
                         Collections.sort(cacheList, gcComparator);
@@ -259,7 +259,7 @@ public class cgeocaches extends AbstractListActivity {
                     setTitle(title + " [" + search.getCount() + "]");
                     cacheList.clear();
 
-                    final Set<cgCache> caches = search.getCachesFromSearchResult(LoadFlags.LOADCACHEORDB);
+                    final Set<cgCache> caches = search.getCachesFromSearchResult(LoadFlags.LOAD_CACHE_OR_DB);
                     if (CollectionUtils.isNotEmpty(caches)) {
                         cacheList.addAll(caches);
                         caches.clear();
@@ -335,7 +335,7 @@ public class cgeocaches extends AbstractListActivity {
                 }
             } else {
                 if (cacheList != null && search != null) {
-                    final Set<cgCache> cacheListTmp = search.getCachesFromSearchResult(LoadFlags.LOADCACHEORDB);
+                    final Set<cgCache> cacheListTmp = search.getCachesFromSearchResult(LoadFlags.LOAD_CACHE_OR_DB);
                     if (CollectionUtils.isNotEmpty(cacheListTmp)) {
                         cacheList.clear();
                         cacheList.addAll(cacheListTmp);
@@ -403,7 +403,7 @@ public class cgeocaches extends AbstractListActivity {
 
                 cacheList.clear();
 
-                final Set<cgCache> cacheListTmp = search.getCachesFromSearchResult(LoadFlags.LOADCACHEORDB);
+                final Set<cgCache> cacheListTmp = search.getCachesFromSearchResult(LoadFlags.LOAD_CACHE_OR_DB);
                 if (CollectionUtils.isNotEmpty(cacheListTmp)) {
                     cacheList.addAll(cacheListTmp);
                     cacheListTmp.clear();
@@ -430,7 +430,7 @@ public class cgeocaches extends AbstractListActivity {
 
             cacheList.clear();
 
-            final Set<cgCache> cacheListTmp = search.getCachesFromSearchResult(LoadFlags.LOADCACHEORDB);
+            final Set<cgCache> cacheListTmp = search.getCachesFromSearchResult(LoadFlags.LOAD_CACHE_OR_DB);
             if (CollectionUtils.isNotEmpty(cacheListTmp)) {
                 cacheList.addAll(cacheListTmp);
                 cacheListTmp.clear();
diff --git a/main/src/cgeo/geocaching/cgeopopup.java b/main/src/cgeo/geocaching/cgeopopup.java
index 4deb5bc..ace1abc 100644
--- a/main/src/cgeo/geocaching/cgeopopup.java
+++ b/main/src/cgeo/geocaching/cgeopopup.java
@@ -200,7 +200,7 @@ public class cgeopopup extends AbstractActivity {
 
         app.setAction(geocode);
 
-        cache = app.loadCache(geocode, LoadFlags.LOADCACHEORDB);
+        cache = app.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
 
         if (cache == null) {
             showToast(res.getString(R.string.err_detail_cache_find));
diff --git a/main/src/cgeo/geocaching/cgeowaypoint.java b/main/src/cgeo/geocaching/cgeowaypoint.java
index 55b0e01..f5ba7a8 100644
--- a/main/src/cgeo/geocaching/cgeowaypoint.java
+++ b/main/src/cgeo/geocaching/cgeowaypoint.java
@@ -313,7 +313,7 @@ public class cgeowaypoint extends AbstractActivity {
         public void onClick(View arg0) {
             if (app.deleteWaypoint(id)) {
                 StaticMapsProvider.removeWpStaticMaps(id, geocode);
-                app.removeCache(geocode, EnumSet.of(RemoveFlag.REMOVECACHE));
+                app.removeCache(geocode, EnumSet.of(RemoveFlag.REMOVE_CACHE));
 
                 finish();
                 return;
diff --git a/main/src/cgeo/geocaching/cgeowaypointadd.java b/main/src/cgeo/geocaching/cgeowaypointadd.java
index 6efb632..ee9de72 100644
--- a/main/src/cgeo/geocaching/cgeowaypointadd.java
+++ b/main/src/cgeo/geocaching/cgeowaypointadd.java
@@ -266,7 +266,7 @@ public class cgeowaypointadd extends AbstractActivity {
             if (waypoint != null && waypoint.getCoords() != null) {
                 gp = waypoint.getCoords();
             }
-            cgCache cache = app.loadCache(geocode, LoadFlags.LOADWAYPOINTS);
+            cgCache cache = app.loadCache(geocode, LoadFlags.LOAD_WAYPOINTS);
             cgeocoords coordsDialog = new cgeocoords(cgeowaypointadd.this, cache, gp, geo);
             coordsDialog.setCancelable(true);
             coordsDialog.setOnCoordinateUpdate(new cgeocoords.CoordinateUpdate() {
@@ -384,7 +384,7 @@ public class cgeowaypointadd extends AbstractActivity {
             if (app.saveOwnWaypoint(id, geocode, waypoint)) {
                 StaticMapsProvider.removeWpStaticMaps(id, geocode);
                 if (Settings.isStoreOfflineWpMaps()) {
-                    StaticMapsProvider.storeWaypointStaticMap(app.loadCache(geocode, LoadFlags.LOADCACHEORDB), cgeowaypointadd.this, waypoint);
+                    StaticMapsProvider.storeWaypointStaticMap(app.loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB), cgeowaypointadd.this, waypoint);
                 }
                 finish();
                 return;
diff --git a/main/src/cgeo/geocaching/enumerations/LoadFlags.java b/main/src/cgeo/geocaching/enumerations/LoadFlags.java
index 875bb98..ac1e168 100644
--- a/main/src/cgeo/geocaching/enumerations/LoadFlags.java
+++ b/main/src/cgeo/geocaching/enumerations/LoadFlags.java
@@ -10,38 +10,38 @@ import java.util.EnumSet;
 public class LoadFlags {
 
     public enum LoadFlag {
-        LOADCACHEBEFORE, // load from CacheCache
-        LOADCACHEAFTER, // load from CacheCache
-        LOADDBMINIMAL, // load minimal informations from DataBase
-        LOADATTRIBUTES,
-        LOADWAYPOINTS,
-        LOADSPOILERS,
-        LOADLOGS,
-        LOADINVENTORY,
-        LOADOFFLINELOG
+        LOAD_CACHE_BEFORE, // load from CacheCache
+        LOAD_CACHE_AFTER, // load from CacheCache
+        LOAD_DB_MINIMAL, // load minimal informations from DataBase
+        LOAD_ATTRIBUTES,
+        LOAD_WAYPOINTS,
+        LOAD_SPOILERS,
+        LOAD_LOGS,
+        LOAD_INVENTORY,
+        LOAD_OFFLINE_LOG
     }
 
     /** Retrieve cache from CacheCache only. Do not load from DB */
-    public final static EnumSet<LoadFlag> LOADCACHEONLY = EnumSet.of(LoadFlag.LOADCACHEBEFORE);
+    public final static EnumSet<LoadFlag> LOAD_CACHE_ONLY = EnumSet.of(LoadFlag.LOAD_CACHE_BEFORE);
     /** Retrieve cache from CacheCache first. If not found load from DB */
-    public final static EnumSet<LoadFlag> LOADCACHEORDB = EnumSet.of(LoadFlag.LOADCACHEBEFORE, LoadFlag.LOADDBMINIMAL);
-    /** Retrieve cache (minimalistic informations including waypoints) from DB first. If not found load from CacheCache */
-    public final static EnumSet<LoadFlag> LOADWAYPOINTS = EnumSet.of(LoadFlag.LOADCACHEAFTER, LoadFlag.LOADDBMINIMAL, LoadFlag.LOADWAYPOINTS);
+    public final static EnumSet<LoadFlag> LOAD_CACHE_OR_DB = EnumSet.of(LoadFlag.LOAD_CACHE_BEFORE, LoadFlag.LOAD_DB_MINIMAL);
+    /** Retrieve cache (minimalistic information including waypoints) from DB first. If not found load from CacheCache */
+    public final static EnumSet<LoadFlag> LOAD_WAYPOINTS = EnumSet.of(LoadFlag.LOAD_CACHE_AFTER, LoadFlag.LOAD_DB_MINIMAL, LoadFlag.LOAD_WAYPOINTS);
     /** Retrieve cache (all stored informations) from DB only. Do not load from CacheCache */
-    public final static EnumSet<LoadFlag> LOADALLDBONLY = EnumSet.range(LoadFlag.LOADDBMINIMAL, LoadFlag.LOADOFFLINELOG);
+    public final static EnumSet<LoadFlag> LOAD_ALL_DB_ONLY = EnumSet.range(LoadFlag.LOAD_DB_MINIMAL, LoadFlag.LOAD_OFFLINE_LOG);
 
     public enum SaveFlag {
-        SAVECACHE, // save only to CacheCache
-        SAVEDB // include saving to CacheCache
+        SAVE_CACHE, // save only to CacheCache
+        SAVE_DB // include saving to CacheCache
     }
 
-    public final static EnumSet<SaveFlag> SAVEALL = EnumSet.allOf(SaveFlag.class);
+    public final static EnumSet<SaveFlag> SAVE_ALL = EnumSet.allOf(SaveFlag.class);
 
     public enum RemoveFlag {
-        REMOVECACHE, // save only to CacheCache
-        REMOVEDB // includes removing from CacheCache
+        REMOVE_CACHE, // save only to CacheCache
+        REMOVE_DB // includes removing from CacheCache
     }
 
-    public final static EnumSet<RemoveFlag> REMOVEALL = EnumSet.allOf(RemoveFlag.class);
+    public final static EnumSet<RemoveFlag> REMOVE_ALL = EnumSet.allOf(RemoveFlag.class);
 
 }
\ No newline at end of file
diff --git a/main/src/cgeo/geocaching/files/GPXImporter.java b/main/src/cgeo/geocaching/files/GPXImporter.java
index 836f6e8..3d1249f 100644
--- a/main/src/cgeo/geocaching/files/GPXImporter.java
+++ b/main/src/cgeo/geocaching/files/GPXImporter.java
@@ -164,7 +164,7 @@ public class GPXImporter {
             int storedCaches = 0;

             for (cgCache cache : caches) {

                 search.addCache(cache);

-                if (app.saveCache(cache, EnumSet.of(SaveFlag.SAVEDB))) {

+                if (app.saveCache(cache, EnumSet.of(SaveFlag.SAVE_DB))) {

                     storedCaches++;

                 }

 

diff --git a/main/src/cgeo/geocaching/files/LocParser.java b/main/src/cgeo/geocaching/files/LocParser.java
index ea4c824..e3fd5e5 100644
--- a/main/src/cgeo/geocaching/files/LocParser.java
+++ b/main/src/cgeo/geocaching/files/LocParser.java
@@ -50,7 +50,7 @@ public final class LocParser extends FileParser {
         // save found cache coordinates
         for (String geocode : searchResult.getGeocodes()) {
             if (cidCoords.containsKey(geocode)) {
-                cgCache cache = cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOADCACHEORDB);
+                cgCache cache = cgeoapplication.getInstance().loadCache(geocode, LoadFlags.LOAD_CACHE_OR_DB);
                 cgCoord coord = cidCoords.get(cache.getGeocode());
 
                 copyCoordToCache(coord, cache);
diff --git a/main/src/cgeo/geocaching/filter/AttributeFilter.java b/main/src/cgeo/geocaching/filter/AttributeFilter.java
index bdf4f71..0ef0787 100644
--- a/main/src/cgeo/geocaching/filter/AttributeFilter.java
+++ b/main/src/cgeo/geocaching/filter/AttributeFilter.java
@@ -34,7 +34,7 @@ public class AttributeFilter extends AbstractFilter {
 
     @Override
     public boolean accepts(final cgCache cache) {
-        final cgCache fullCache = cgeoapplication.getInstance().loadCache(cache.getGeocode(), EnumSet.of(LoadFlag.LOADATTRIBUTES));
+        final cgCache fullCache = cgeoapplication.getInstance().loadCache(cache.getGeocode(), EnumSet.of(LoadFlag.LOAD_ATTRIBUTES));
         return fullCache.getAttributes().contains(attribute);
     }
 
diff --git a/main/src/cgeo/geocaching/maps/CGeoMap.java b/main/src/cgeo/geocaching/maps/CGeoMap.java
index d54eed7..61d7a80 100644
--- a/main/src/cgeo/geocaching/maps/CGeoMap.java
+++ b/main/src/cgeo/geocaching/maps/CGeoMap.java
@@ -1177,7 +1177,7 @@ public class CGeoMap extends AbstractMap implements OnDragListener, ViewFactory
                     return;
                 }
 
-                caches.addAll(search.getCachesFromSearchResult(LoadFlags.LOADWAYPOINTS));
+                caches.addAll(search.getCachesFromSearchResult(LoadFlags.LOAD_WAYPOINTS));
 
                 //if in live map and stored caches are found / disables are also shown.
                 if (live && Settings.isLiveMap()) {
@@ -1295,7 +1295,7 @@ public class CGeoMap extends AbstractMap implements OnDragListener, ViewFactory
                 }
 
                 if (search != null) {
-                    caches.addAll(search.getCachesFromSearchResult(LoadFlags.LOADCACHEORDB));
+                    caches.addAll(search.getCachesFromSearchResult(LoadFlags.LOAD_CACHE_OR_DB));
                 }
 
                 if (stop) {