diff --git a/android_app/app/src/main/java/com/health/openscale/core/EvaluationSheet.java b/android_app/app/src/main/java/com/health/openscale/core/EvaluationSheet.java
index f9935263..3aa4ab45 100644
--- a/android_app/app/src/main/java/com/health/openscale/core/EvaluationSheet.java
+++ b/android_app/app/src/main/java/com/health/openscale/core/EvaluationSheet.java
@@ -267,6 +267,10 @@ public class EvaluationSheet {
         return evaluateSheet(whr, bodyEvaluateSheet);
     }
 
+    public EvaluationResult evaluateHip(float hip) {
+        return evaluateSheet(hip, new ArrayList<sheetEntry>());
+    }
+
     private EvaluationResult evaluateSheet(float value, List<sheetEntry> sheet) {
         for (int i=0; i < sheet.size(); i++) {
             sheetEntry curEntry = sheet.get(i);
diff --git a/android_app/app/src/main/java/com/health/openscale/gui/Measurement.java b/android_app/app/src/main/java/com/health/openscale/gui/Measurement.java
new file mode 100644
index 00000000..3e370cf3
--- /dev/null
+++ b/android_app/app/src/main/java/com/health/openscale/gui/Measurement.java
@@ -0,0 +1,686 @@
+package com.health.openscale.gui;
+
+import android.app.Fragment;
+import android.content.SharedPreferences;
+import android.graphics.Color;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.TableLayout;
+import android.widget.TableRow;
+import android.widget.TextView;
+
+import com.health.openscale.R;
+import com.health.openscale.core.EvaluationResult;
+import com.health.openscale.core.EvaluationSheet;
+import com.health.openscale.core.LinearGaugeView;
+import com.health.openscale.core.ScaleUser;
+
+import lecho.lib.hellocharts.util.ChartUtils;
+
+abstract class Measurement {
+    private TextView txtLabel;
+    private TextView txtView;
+    private final String label;
+    private LinearGaugeView linearGaugeView;
+    private ImageView imageView;
+    private TableRow tableRow;
+
+    ScaleUser scaleUser;
+
+    public Measurement(View overviewView) {
+        txtLabel = (TextView) overviewView.findViewById(getTxtLabelId());
+        txtView = (TextView) overviewView.findViewById(getTxtViewId());
+        linearGaugeView = (LinearGaugeView) overviewView.findViewById(getLinearGaugeViewId());
+        imageView = (ImageView)overviewView.findViewById(getImageViewId());
+
+        label = overviewView.getResources().getString(getLabelId());
+
+        tableRow = (TableRow)overviewView.findViewById(getTableRowId());
+        tableRow.setOnClickListener(new onClickListenerEvaluation());
+    }
+
+    public void updateValue(float value) {
+        setText(value);
+        evaluate(value);
+    }
+
+    abstract int getTxtLabelId();
+    abstract int getTxtViewId();
+    abstract int getLabelId();
+    abstract int getLinearGaugeViewId();
+    abstract int getImageViewId();
+    abstract int getTableRowId();
+
+    abstract String getFormat();
+
+    abstract EvaluationResult evaluateSheet(EvaluationSheet evalSheet, float value);
+
+    abstract int getMinValue();
+
+    abstract int getMaxValue();
+
+    private void setText(float value) {
+        txtView.setText(String.format(getFormat(), value));
+    }
+
+    private void evaluate(float value) {
+        EvaluationSheet evalSheet = new EvaluationSheet(scaleUser);
+        EvaluationResult evalResult = evaluateSheet(evalSheet, value);
+
+        linearGaugeView.setMinMaxValue(getMinValue(), getMaxValue());
+        linearGaugeView.setLimits(evalResult.lowLimit, evalResult.highLimit);
+        linearGaugeView.setValue(value);
+
+        switch(evalResult.eval_state)
+        {
+            case LOW:
+                imageView.setBackgroundColor(ChartUtils.COLOR_BLUE);
+                break;
+            case NORMAL:
+                imageView.setBackgroundColor(ChartUtils.COLOR_GREEN);
+                break;
+            case HIGH:
+                imageView.setBackgroundColor(ChartUtils.COLOR_RED);
+                break;
+            case UNDEFINED:
+                imageView.setBackgroundColor(Color.GRAY);
+                break;
+        }
+    }
+
+    public void setDiff(float value, float diffValue) {
+        ScaleDiff.setDiff(
+                txtLabel,
+                value - diffValue,
+                label,
+                getFormat());
+    }
+
+    public void updateVisibleRow(SharedPreferences preferences){
+        if(isPreferenceSet(preferences)) {
+            tableRow.setVisibility(View.VISIBLE);
+        } else {
+            tableRow.setVisibility(View.GONE);
+        }
+    }
+
+    abstract boolean isPreferenceSet(SharedPreferences preferences);
+
+    private class onClickListenerEvaluation implements View.OnClickListener {
+        @Override
+        public void onClick(View v) {
+            TableRow row = (TableRow)v;
+
+            TableLayout tableLayout = (TableLayout)row.getParent();
+            int index = tableLayout.indexOfChild(row);
+
+            TableRow rowEvaluation = (TableRow)tableLayout.getChildAt(index+1);
+
+            if (rowEvaluation.getVisibility() == View.VISIBLE) {
+                rowEvaluation.setVisibility(View.GONE);
+            } else {
+                rowEvaluation.setVisibility(View.VISIBLE);
+            }
+        }
+    }
+}
+
+class WeightMeasurement extends Measurement {
+
+    public WeightMeasurement(View overviewView) {
+        super(overviewView);
+    }
+
+    @Override
+    int getTxtLabelId() {
+        return R.id.txtLabelWeight;
+    }
+
+    @Override
+    int getTxtViewId() {
+        return R.id.txtWeightLast;
+    }
+
+    @Override
+    int getLabelId() {
+        return R.string.label_weight;
+    }
+
+    @Override
+    int getLinearGaugeViewId() {
+       return R.id.linearGaugeWeight;
+    }
+
+    @Override
+    int getImageViewId() {
+        return R.id.indicatorWeight;
+    }
+
+    @Override
+    int getTableRowId() {
+        return R.id.tableRowWeight;
+    }
+
+    @Override
+    String getFormat() {
+        return "%.1f " + ScaleUser.UNIT_STRING[scaleUser.scale_unit];
+    }
+
+    @Override
+    boolean isPreferenceSet(SharedPreferences preferences) {
+        return preferences.getBoolean("weightEnable", true);
+    }
+
+    @Override
+    EvaluationResult evaluateSheet(EvaluationSheet evalSheet, float value) {
+        return evalSheet.evaluateWeight(value);
+    }
+
+    @Override
+    int getMinValue() {
+        return 30;
+    }
+
+    @Override
+    int getMaxValue() {
+        return 300;
+    }
+}
+
+class BMIMeasurement extends Measurement {
+
+    public BMIMeasurement(View overviewView) {
+        super(overviewView);
+    }
+
+    @Override
+    int getTxtLabelId() {
+        return R.id.txtLabelBMI;
+    }
+
+    @Override
+    int getTxtViewId() {
+        return R.id.txtBMILast;
+    }
+
+    @Override
+    int getLabelId() {
+        return R.string.label_bmi;
+    }
+
+    @Override
+    int getLinearGaugeViewId() {
+        return R.id.linearGaugeBMI;
+    }
+
+    @Override
+    int getImageViewId() {
+        return R.id.indicatorBMI;
+    }
+
+    @Override
+    int getTableRowId() {
+        return R.id.tableRowBMI;
+    }
+
+    @Override
+    String getFormat() {
+        return "%.1f";
+    }
+
+    @Override
+    boolean isPreferenceSet(SharedPreferences preferences) {
+        // TODO implement
+        return false;
+    }
+
+    @Override
+    EvaluationResult evaluateSheet(EvaluationSheet evalSheet, float value) {
+        return evalSheet.evaluateBMI(value);
+    }
+
+    @Override
+    int getMinValue() {
+        return 10;
+    }
+
+    @Override
+    int getMaxValue() {
+        return 50;
+    }
+}
+
+class WaterMeasurement extends Measurement {
+
+    public WaterMeasurement(View overviewView) {
+        super(overviewView);
+    }
+
+    @Override
+    int getTxtLabelId() {
+        return R.id.txtLabelWater;
+    }
+
+    @Override
+    int getTxtViewId() {
+        return R.id.txtWaterLast;
+    }
+
+    @Override
+    int getLabelId() {
+        return R.string.label_water;
+    }
+
+    @Override
+    int getLinearGaugeViewId() {
+        return R.id.linearGaugeWater;
+    }
+
+    @Override
+    int getImageViewId() {
+        return R.id.indicatorWater;
+    }
+
+    @Override
+    int getTableRowId() {
+        return R.id.tableRowWater;
+    }
+
+    @Override
+    String getFormat() {
+        return "%.1f %%";
+    }
+
+    @Override
+    boolean isPreferenceSet(SharedPreferences preferences) {
+        return preferences.getBoolean("waterEnable", true);
+    }
+
+    @Override
+    EvaluationResult evaluateSheet(EvaluationSheet evalSheet, float value) {
+        return evalSheet.evaluateBodyWater(value);
+    }
+
+    @Override
+    int getMinValue() {
+        return 30;
+    }
+
+    @Override
+    int getMaxValue() {
+        return 80;
+    }
+}
+
+class MuscleMeasurement extends Measurement {
+
+    public MuscleMeasurement(View overviewView) {
+        super(overviewView);
+    }
+
+    @Override
+    int getTxtLabelId() {
+        return R.id.txtLabelMuscle;
+    }
+
+    @Override
+    int getTxtViewId() {
+        return R.id.txtMuscleLast;
+    }
+
+    @Override
+    int getLabelId() {
+        return R.string.label_muscle;
+    }
+
+    @Override
+    int getLinearGaugeViewId() {
+        return R.id.linearGaugeMuscle;
+    }
+
+    @Override
+    int getImageViewId() {
+        return R.id.indicatorMuscle;
+    }
+
+    @Override
+    int getTableRowId() {
+        return R.id.tableRowMuscle;
+    }
+
+    @Override
+    String getFormat() {
+        return "%.1f %%";
+    }
+
+    @Override
+    boolean isPreferenceSet(SharedPreferences preferences) {
+        return preferences.getBoolean("muscleEnable", true);
+    }
+
+    @Override
+    EvaluationResult evaluateSheet(EvaluationSheet evalSheet, float value) {
+        return evalSheet.evaluateBodyMuscle(value);
+    }
+
+    @Override
+    int getMinValue() {
+        return 10;
+    }
+
+    @Override
+    int getMaxValue() {
+        return 80;
+    }
+}
+
+class FatMeasurement extends Measurement {
+
+    public FatMeasurement(View overviewView) {
+        super(overviewView);
+    }
+
+    @Override
+    int getTxtLabelId() {
+        return R.id.txtLabelFat;
+    }
+
+    @Override
+    int getTxtViewId() {
+        return R.id.txtFatLast;
+    }
+
+    @Override
+    int getLabelId() {
+        return R.string.label_fat;
+    }
+
+    @Override
+    int getLinearGaugeViewId() {
+        return R.id.linearGaugeFat;
+    }
+
+    @Override
+    int getImageViewId() {
+        return R.id.indicatorFat;
+    }
+
+    @Override
+    int getTableRowId() {
+        return R.id.tableRowFat;
+    }
+
+    @Override
+    String getFormat() {
+        return "%.1f %%";
+    }
+
+    @Override
+    boolean isPreferenceSet(SharedPreferences preferences) {
+        return preferences.getBoolean("fatEnable", true);
+    }
+
+    @Override
+    EvaluationResult evaluateSheet(EvaluationSheet evalSheet, float value) {
+        return evalSheet.evaluateBodyFat(value);
+    }
+
+    @Override
+    int getMinValue() {
+        return 10;
+    }
+
+    @Override
+    int getMaxValue() {
+        return 40;
+    }
+}
+
+class WaistMeasurement extends Measurement {
+
+    public WaistMeasurement(View overviewView) {
+        super(overviewView);
+    }
+
+    @Override
+    int getTxtLabelId() {
+        return R.id.txtLabelWaist;
+    }
+
+    @Override
+    int getTxtViewId() {
+        return R.id.txtWaistLast;
+    }
+
+    @Override
+    int getLabelId() {
+        return R.string.label_waist;
+    }
+
+    @Override
+    int getLinearGaugeViewId() {
+        return R.id.linearGaugeWaist;
+    }
+
+    @Override
+    int getImageViewId() {
+        return R.id.indicatorWaist;
+    }
+
+    @Override
+    int getTableRowId() {
+        return R.id.tableRowWaist;
+    }
+
+    @Override
+    String getFormat() {
+        return "%.1f cm";
+    }
+
+    @Override
+    boolean isPreferenceSet(SharedPreferences preferences) {
+        return preferences.getBoolean("waistEnable", true);
+    }
+
+    @Override
+    EvaluationResult evaluateSheet(EvaluationSheet evalSheet, float value) {
+        return evalSheet.evaluateWaist(value);
+    }
+
+    @Override
+    int getMinValue() {
+        return 30;
+    }
+
+    @Override
+    int getMaxValue() {
+        return 200;
+    }
+}
+
+class WHtRMeasurement extends Measurement {
+
+    public WHtRMeasurement(View overviewView) {
+        super(overviewView);
+    }
+
+    @Override
+    int getTxtLabelId() {
+        return R.id.txtLabelWHtR;
+    }
+
+    @Override
+    int getTxtViewId() {
+        return R.id.txtWHtRLast;
+    }
+
+    @Override
+    int getLabelId() {
+        return R.string.label_whtr;
+    }
+
+    @Override
+    int getLinearGaugeViewId() {
+        return R.id.linearGaugeWHtR;
+    }
+
+    @Override
+    int getImageViewId() {
+        return R.id.indicatorWHtR;
+    }
+
+    @Override
+    int getTableRowId() {
+        return R.id.tableRowWHtR;
+    }
+
+    @Override
+    String getFormat() {
+        return "%.2f";
+    }
+
+    @Override
+    boolean isPreferenceSet(SharedPreferences preferences) {
+        return preferences.getBoolean("waistEnable", true);
+    }
+
+    @Override
+    EvaluationResult evaluateSheet(EvaluationSheet evalSheet, float value) {
+        return evalSheet.evaluateWHtR(value);
+    }
+
+    @Override
+    int getMinValue() {
+        return 0;
+    }
+
+    @Override
+    int getMaxValue() {
+        return 1;
+    }
+}
+
+class HipMeasurement extends Measurement {
+
+    public HipMeasurement(View overviewView) {
+        super(overviewView);
+    }
+
+    @Override
+    int getTxtLabelId() {
+        return R.id.txtLabelHip;
+    }
+
+    @Override
+    int getTxtViewId() {
+        return R.id.txtHipLast;
+    }
+
+    @Override
+    int getLabelId() {
+        return R.string.label_hip;
+    }
+
+    @Override
+    int getLinearGaugeViewId() {
+        return R.id.linearGaugeHip;
+    }
+
+    @Override
+    int getImageViewId() {
+        return R.id.indicatorHip;
+    }
+
+    @Override
+    int getTableRowId() {
+        return R.id.tableRowHip;
+    }
+
+    @Override
+    String getFormat() {
+        return "%.1f cm";
+    }
+
+    @Override
+    boolean isPreferenceSet(SharedPreferences preferences) {
+        return preferences.getBoolean("hipEnable", true);
+    }
+
+    @Override
+    EvaluationResult evaluateSheet(EvaluationSheet evalSheet, float value) {
+        return evalSheet.evaluateHip(value);
+    }
+
+    @Override
+    int getMinValue() {
+        return 30;
+    }
+
+    @Override
+    int getMaxValue() {
+        return 200;
+    }
+}
+
+class WHRMeasurement extends Measurement {
+
+    public WHRMeasurement(View overviewView) {
+        super(overviewView);
+    }
+
+    @Override
+    int getTxtLabelId() {
+        return R.id.txtLabelWHR;
+    }
+
+    @Override
+    int getTxtViewId() {
+        return R.id.txtWHRLast;
+    }
+
+    @Override
+    int getLabelId() {
+        return R.string.label_whr;
+    }
+
+    @Override
+    int getLinearGaugeViewId() {
+        return R.id.linearGaugeWHR;
+    }
+
+    @Override
+    int getImageViewId() {
+        return R.id.indicatorWHR;
+    }
+
+    @Override
+    int getTableRowId() {
+        return R.id.tableRowWHR;
+    }
+
+    @Override
+    String getFormat() {
+        return "%.2f";
+    }
+
+    @Override
+    boolean isPreferenceSet(SharedPreferences preferences) {
+        return preferences.getBoolean("hipEnable", true) && preferences.getBoolean("waistEnable", true);
+    }
+
+    @Override
+    EvaluationResult evaluateSheet(EvaluationSheet evalSheet, float value) {
+        return evalSheet.evaluateWHR(value);
+    }
+
+    @Override
+    int getMinValue() {
+        return 0;
+    }
+
+    @Override
+    int getMaxValue() {
+        return 1;
+    }
+
+}
diff --git a/android_app/app/src/main/java/com/health/openscale/gui/OverviewFragment.java b/android_app/app/src/main/java/com/health/openscale/gui/OverviewFragment.java
index 5dad1fe5..61c9b84d 100644
--- a/android_app/app/src/main/java/com/health/openscale/gui/OverviewFragment.java
+++ b/android_app/app/src/main/java/com/health/openscale/gui/OverviewFragment.java
@@ -67,6 +67,7 @@ import lecho.lib.hellocharts.view.LineChartView;
 import lecho.lib.hellocharts.view.PieChartView;
 
 public class OverviewFragment extends Fragment implements FragmentUpdateListener {
+
     private View overviewView;
 
     private TextView txtTitleUser;
@@ -74,15 +75,15 @@ public class OverviewFragment extends Fragment implements FragmentUpdateListener
     private TextView txtTitleGoal;
     private TextView txtTitleStatistics;
 
-    private TextView txtWeightLast;
-    private TextView txtBMILast;
-    private TextView txtWaterLast;
-    private TextView txtMuscleLast;
-    private TextView txtFatLast;
-    private TextView txtWaistLast;
-    private TextView txtWHtRLast;
-    private TextView txtHipLast;
-    private TextView txtWHRLast;
+    private Measurement measurementWeightLast;
+    private Measurement measurementBMILast;
+    private Measurement measurementWaterLast;
+    private Measurement measurementMuscleLast;
+    private Measurement measurementFatLast;
+    private Measurement measurementWaistLast;
+    private Measurement measurementWHtRLast;
+    private Measurement measurementHipLast;
+    private Measurement measurementWHRLast;
 
     private TextView txtGoalWeight;
     private TextView txtGoalDiff;
@@ -91,16 +92,6 @@ public class OverviewFragment extends Fragment implements FragmentUpdateListener
     private TextView txtAvgWeek;
     private TextView txtAvgMonth;
 
-    private TextView txtLabelWeight;
-    private TextView txtLabelBMI;
-    private TextView txtLabelFat;
-    private TextView txtLabelMuscle;
-    private TextView txtLabelWater;
-    private TextView txtLabelWaist;
-    private TextView txtLabelWHtR;
-    private TextView txtLabelHip;
-    private TextView txtLabelWHR;
-
     private TextView txtLabelGoalWeight;
     private TextView txtLabelGoalDiff;
     private TextView txtLabelDayLeft;
@@ -113,16 +104,6 @@ public class OverviewFragment extends Fragment implements FragmentUpdateListener
 
     private Spinner spinUser;
 
-    private LinearGaugeView linearGaugeWeight;
-    private LinearGaugeView linearGaugeBMI;
-    private LinearGaugeView linearGaugeFat;
-    private LinearGaugeView linearGaugeMuscle;
-    private LinearGaugeView linearGaugeWater;
-    private LinearGaugeView linearGaugeWaist;
-    private LinearGaugeView linearGaugeWHtR;
-    private LinearGaugeView linearGaugeHip;
-    private LinearGaugeView linearGaugeWHR;
-
     private SharedPreferences prefs;
 
     private ScaleData lastScaleData;
@@ -153,15 +134,15 @@ public class OverviewFragment extends Fragment implements FragmentUpdateListener
         txtTitleGoal = (TextView) overviewView.findViewById(R.id.txtTitleGoal);
         txtTitleStatistics = (TextView) overviewView.findViewById(R.id.txtTitleStatistics);
 
-        txtWeightLast = (TextView) overviewView.findViewById(R.id.txtWeightLast);
-        txtBMILast = (TextView) overviewView.findViewById(R.id.txtBMILast);
-        txtWaterLast = (TextView) overviewView.findViewById(R.id.txtWaterLast);
-        txtMuscleLast = (TextView) overviewView.findViewById(R.id.txtMuscleLast);
-        txtFatLast = (TextView) overviewView.findViewById(R.id.txtFatLast);
-        txtWaistLast = (TextView) overviewView.findViewById(R.id.txtWaistLast);
-        txtWHtRLast = (TextView) overviewView.findViewById(R.id.txtWHtRLast);
-        txtHipLast = (TextView) overviewView.findViewById(R.id.txtHipLast);
-        txtWHRLast = (TextView) overviewView.findViewById(R.id.txtWHRLast);
+        measurementWeightLast = new WeightMeasurement(overviewView);
+        measurementBMILast = new BMIMeasurement(overviewView);
+        measurementWaterLast = new WaterMeasurement(overviewView);
+        measurementMuscleLast = new MuscleMeasurement(overviewView);
+        measurementFatLast = new FatMeasurement(overviewView);
+        measurementWaistLast = new WaistMeasurement(overviewView);
+        measurementWHtRLast = new WHtRMeasurement(overviewView);
+        measurementHipLast = new HipMeasurement(overviewView);
+        measurementWHRLast = new WHRMeasurement(overviewView);
 
         txtGoalWeight = (TextView) overviewView.findViewById(R.id.txtGoalWeight);
         txtGoalDiff = (TextView) overviewView.findViewById(R.id.txtGoalDiff);
@@ -170,16 +151,6 @@ public class OverviewFragment extends Fragment implements FragmentUpdateListener
         txtAvgWeek = (TextView) overviewView.findViewById(R.id.txtAvgWeek);
         txtAvgMonth = (TextView) overviewView.findViewById(R.id.txtAvgMonth);
 
-        txtLabelWeight = (TextView) overviewView.findViewById(R.id.txtLabelWeight);
-        txtLabelBMI = (TextView) overviewView.findViewById(R.id.txtLabelBMI);
-        txtLabelFat = (TextView) overviewView.findViewById(R.id.txtLabelFat);
-        txtLabelMuscle = (TextView) overviewView.findViewById(R.id.txtLabelMuscle);
-        txtLabelWater = (TextView) overviewView.findViewById(R.id.txtLabelWater);
-        txtLabelWaist = (TextView) overviewView.findViewById(R.id.txtLabelWaist);
-        txtLabelWHtR = (TextView) overviewView.findViewById(R.id.txtLabelWHtR);
-        txtLabelHip = (TextView) overviewView.findViewById(R.id.txtLabelHip);
-        txtLabelWHR = (TextView) overviewView.findViewById(R.id.txtLabelWHR);
-
         txtLabelGoalWeight = (TextView) overviewView.findViewById(R.id.txtLabelGoalWeight);
         txtLabelGoalDiff = (TextView) overviewView.findViewById(R.id.txtLabelGoalDiff);
         txtLabelDayLeft = (TextView) overviewView.findViewById(R.id.txtLabelDayLeft);
@@ -192,16 +163,6 @@ public class OverviewFragment extends Fragment implements FragmentUpdateListener
 
         spinUser = (Spinner) overviewView.findViewById(R.id.spinUser);
 
-        linearGaugeWeight = (LinearGaugeView) overviewView.findViewById(R.id.linearGaugeWeight);
-        linearGaugeBMI = (LinearGaugeView) overviewView.findViewById(R.id.linearGaugeBMI);
-        linearGaugeFat = (LinearGaugeView) overviewView.findViewById(R.id.linearGaugeFat);
-        linearGaugeMuscle = (LinearGaugeView) overviewView.findViewById(R.id.linearGaugeMuscle);
-        linearGaugeWater = (LinearGaugeView) overviewView.findViewById(R.id.linearGaugeWater);
-        linearGaugeWaist = (LinearGaugeView) overviewView.findViewById(R.id.linearGaugeWaist);
-        linearGaugeWHtR = (LinearGaugeView) overviewView.findViewById(R.id.linearGaugeWHtR);
-        linearGaugeHip = (LinearGaugeView) overviewView.findViewById(R.id.linearGaugeHip);
-        linearGaugeWHR = (LinearGaugeView) overviewView.findViewById(R.id.linearGaugeWHR);
-
         lineChartLast.setOnValueTouchListener(new LineChartTouchListener());
 
         pieChartLast.setOnValueTouchListener(new PieChartLastTouchListener());
@@ -213,16 +174,6 @@ public class OverviewFragment extends Fragment implements FragmentUpdateListener
             }
         });
 
-        overviewView.findViewById(R.id.tableRowWeight).setOnClickListener(new onClickListenerEvaluation());
-        overviewView.findViewById(R.id.tableRowBMI).setOnClickListener(new onClickListenerEvaluation());
-        overviewView.findViewById(R.id.tableRowFat).setOnClickListener(new onClickListenerEvaluation());
-        overviewView.findViewById(R.id.tableRowMuscle).setOnClickListener(new onClickListenerEvaluation());
-        overviewView.findViewById(R.id.tableRowWater).setOnClickListener(new onClickListenerEvaluation());
-        overviewView.findViewById(R.id.tableRowWaist).setOnClickListener(new onClickListenerEvaluation());
-        overviewView.findViewById(R.id.tableRowWHtR).setOnClickListener(new onClickListenerEvaluation());
-        overviewView.findViewById(R.id.tableRowHip).setOnClickListener(new onClickListenerEvaluation());
-        overviewView.findViewById(R.id.tableRowWHR).setOnClickListener(new onClickListenerEvaluation());
-
         userSelectedData = null;
 
         spinUserAdapter = new ArrayAdapter<>(overviewView.getContext(), R.layout.support_simple_spinner_dropdown_item, new ArrayList<String>());
@@ -264,16 +215,25 @@ public class OverviewFragment extends Fragment implements FragmentUpdateListener
         updateVisibleRows();
         updateLastPieChart();
         updateLastLineChart(scaleDataList);
-        updateLastMeasurement();
+        updateLastValues();
         updateGoal(scaleDataList);
         updateStatistics(scaleDataList);
-        updateEvaluation();
     }
 
     private void updateUserSelection() {
 
         currentScaleUser =  OpenScale.getInstance(overviewView.getContext()).getSelectedScaleUser();
 
+        measurementWeightLast.scaleUser = currentScaleUser;
+        measurementBMILast.scaleUser = currentScaleUser;
+        measurementWaterLast.scaleUser = currentScaleUser;
+        measurementMuscleLast.scaleUser = currentScaleUser;
+        measurementFatLast.scaleUser = currentScaleUser;
+        measurementWaistLast.scaleUser = currentScaleUser;
+        measurementWHtRLast.scaleUser = currentScaleUser;
+        measurementHipLast.scaleUser = currentScaleUser;
+        measurementWHRLast.scaleUser = currentScaleUser;
+
         spinUserAdapter.clear();
         ArrayList<ScaleUser> scaleUserList = OpenScale.getInstance(overviewView.getContext()).getScaleUserList();
 
@@ -294,150 +254,31 @@ public class OverviewFragment extends Fragment implements FragmentUpdateListener
     }
 
     private void updateVisibleRows() {
-        if(!prefs.getBoolean("fatEnable", true)) {
-            TableRow row = (TableRow)overviewView.findViewById(R.id.tableRowFat);
-            row.setVisibility(View.GONE);
-        } else {
-            TableRow row = (TableRow)overviewView.findViewById(R.id.tableRowFat);
-            row.setVisibility(View.VISIBLE);
-        }
-
-        if(!prefs.getBoolean("muscleEnable", true)) {
-            TableRow row = (TableRow)overviewView.findViewById(R.id.tableRowMuscle);
-            row.setVisibility(View.GONE);
-        } else {
-            TableRow row = (TableRow)overviewView.findViewById(R.id.tableRowMuscle);
-            row.setVisibility(View.VISIBLE);
-        }
-
-        if(!prefs.getBoolean("waterEnable", true)) {
-            TableRow row = (TableRow)overviewView.findViewById(R.id.tableRowWater);
-            row.setVisibility(View.GONE);
-        } else {
-            TableRow row = (TableRow)overviewView.findViewById(R.id.tableRowWater);
-            row.setVisibility(View.VISIBLE);
-        }
-
-        if(!prefs.getBoolean("waistEnable", true)) {
-            TableRow row = (TableRow)overviewView.findViewById(R.id.tableRowWaist);
-            row.setVisibility(View.GONE);
-
-            row = (TableRow)overviewView.findViewById(R.id.tableRowWHtR);
-            row.setVisibility(View.GONE);
-        } else {
-            TableRow row = (TableRow)overviewView.findViewById(R.id.tableRowWaist);
-            row.setVisibility(View.VISIBLE);
-
-            row = (TableRow)overviewView.findViewById(R.id.tableRowWHtR);
-            row.setVisibility(View.VISIBLE);
-        }
-
-        if(!prefs.getBoolean("hipEnable", true)) {
-            TableRow row = (TableRow)overviewView.findViewById(R.id.tableRowHip);
-            row.setVisibility(View.GONE);
-        } else {
-            TableRow row = (TableRow)overviewView.findViewById(R.id.tableRowHip);
-            row.setVisibility(View.VISIBLE);
-        }
-
-        if(!prefs.getBoolean("hipEnable", true) || !prefs.getBoolean("waistEnable", true)) {
-            TableRow row = (TableRow)overviewView.findViewById(R.id.tableRowWHR);
-            row.setVisibility(View.GONE);
-        } else {
-            TableRow row = (TableRow)overviewView.findViewById(R.id.tableRowWHR);
-            row.setVisibility(View.VISIBLE);
-        }
+        measurementWeightLast.updateVisibleRow(prefs);
+        measurementBMILast.updateVisibleRow(prefs);
+        measurementWaterLast.updateVisibleRow(prefs);
+        measurementMuscleLast.updateVisibleRow(prefs);
+        measurementHipLast.updateVisibleRow(prefs);
+        measurementFatLast.updateVisibleRow(prefs);
+        measurementWaistLast.updateVisibleRow(prefs);
+        measurementWHRLast.updateVisibleRow(prefs);
+        measurementWHtRLast.updateVisibleRow(prefs);
     }
 
-    private void updateEvaluation() {
-        linearGaugeWeight.setMinMaxValue(30, 300);
-        linearGaugeBMI.setMinMaxValue(10, 50);
-        linearGaugeFat.setMinMaxValue(10, 40);
-        linearGaugeMuscle.setMinMaxValue(10, 80);
-        linearGaugeWater.setMinMaxValue(30, 80);
-        linearGaugeWaist.setMinMaxValue(30, 200);
-        linearGaugeWHtR.setMinMaxValue(0, 1);
-        linearGaugeHip.setMinMaxValue(30, 200);
-        linearGaugeWHR.setMinMaxValue(0, 1);
-
+    private void updateLastValues() {
         ScaleCalculator calculator = new ScaleCalculator();
         calculator.body_height = currentScaleUser.body_height;
         calculator.setScaleData(lastScaleData);
 
-        EvaluationSheet evalSheet = new EvaluationSheet(currentScaleUser);
-
-        EvaluationResult sheetWeight = evalSheet.evaluateWeight(lastScaleData.weight);
-        EvaluationResult sheetBMI = evalSheet.evaluateBMI(calculator.getBMI());
-        EvaluationResult sheetFat = evalSheet.evaluateBodyFat(lastScaleData.fat);
-        EvaluationResult sheetMuscle = evalSheet.evaluateBodyMuscle(lastScaleData.muscle);
-        EvaluationResult sheetWater = evalSheet.evaluateBodyWater(lastScaleData.water);
-        EvaluationResult sheetWaist = evalSheet.evaluateWaist(lastScaleData.waist);
-        EvaluationResult sheetWHtR = evalSheet.evaluateWHtR(calculator.getWHtR());
-        EvaluationResult sheetWHR = evalSheet.evaluateWHR(calculator.getWHR());
-
-        updateIndicator((ImageView)overviewView.findViewById(R.id.indicatorWeight), sheetWeight.eval_state);
-        updateIndicator((ImageView)overviewView.findViewById(R.id.indicatorBMI), sheetBMI.eval_state);
-        updateIndicator((ImageView)overviewView.findViewById(R.id.indicatorFat), sheetFat.eval_state);
-        updateIndicator((ImageView)overviewView.findViewById(R.id.indicatorMuscle), sheetMuscle.eval_state);
-        updateIndicator((ImageView)overviewView.findViewById(R.id.indicatorWater), sheetWater.eval_state);
-        updateIndicator((ImageView) overviewView.findViewById(R.id.indicatorWaist), sheetWaist.eval_state);
-        updateIndicator((ImageView)overviewView.findViewById(R.id.indicatorWHtR), sheetWHtR.eval_state);
-        updateIndicator((ImageView)overviewView.findViewById(R.id.indicatorHip), EvaluationResult.EVAL_STATE.UNDEFINED);
-        updateIndicator((ImageView)overviewView.findViewById(R.id.indicatorWHR), sheetWHR.eval_state);
-
-        linearGaugeWeight.setLimits(sheetWeight.lowLimit, sheetWeight.highLimit);
-        linearGaugeBMI.setLimits(sheetBMI.lowLimit, sheetBMI.highLimit);
-        linearGaugeFat.setLimits(sheetFat.lowLimit, sheetFat.highLimit);
-        linearGaugeMuscle.setLimits(sheetMuscle.lowLimit, sheetMuscle.highLimit);
-        linearGaugeWater.setLimits(sheetWater.lowLimit, sheetWater.highLimit);
-        linearGaugeWaist.setLimits(sheetWaist.lowLimit, sheetWaist.highLimit);
-        linearGaugeWHtR.setLimits(sheetWHtR.lowLimit, sheetWHtR.highLimit);
-        linearGaugeHip.setLimits(-1f, -1f);
-        linearGaugeWHR.setLimits(sheetWHR.lowLimit, sheetWHR.highLimit);
-
-        linearGaugeWeight.setValue(lastScaleData.weight);
-        linearGaugeBMI.setValue(calculator.getBMI());
-        linearGaugeFat.setValue(lastScaleData.fat);
-        linearGaugeMuscle.setValue(lastScaleData.muscle);
-        linearGaugeWater.setValue(lastScaleData.water);
-        linearGaugeWaist.setValue(lastScaleData.waist);
-        linearGaugeWHtR.setValue(calculator.getWHtR());
-        linearGaugeHip.setValue(lastScaleData.hip);
-        linearGaugeWHR.setValue(calculator.getWHR());
-    }
-
-    private void updateIndicator(ImageView view, EvaluationResult.EVAL_STATE state) {
-        switch(state)
-        {
-            case LOW:
-                view.setBackgroundColor(ChartUtils.COLOR_BLUE);
-                break;
-            case NORMAL:
-                view.setBackgroundColor(ChartUtils.COLOR_GREEN);
-                break;
-            case HIGH:
-                view.setBackgroundColor(ChartUtils.COLOR_RED);
-                break;
-            case UNDEFINED:
-                view.setBackgroundColor(Color.GRAY);
-                break;
-        }
-    }
-
-    private void updateLastMeasurement() {
-        ScaleCalculator calculator = new ScaleCalculator();
-        calculator.body_height = currentScaleUser.body_height;
-        calculator.setScaleData(lastScaleData);
-
-        txtWeightLast.setText(lastScaleData.weight + " " + ScaleUser.UNIT_STRING[currentScaleUser.scale_unit]);
-        txtBMILast.setText(String.format("%.1f", calculator.getBMI()));
-        txtFatLast.setText(lastScaleData.fat + " %");
-        txtWaterLast.setText(lastScaleData.water + " %");
-        txtMuscleLast.setText(lastScaleData.muscle + " %");
-        txtWaistLast.setText(lastScaleData.waist + " cm");
-        txtWHtRLast.setText(String.format("%.2f", calculator.getWHtR()));
-        txtHipLast.setText(lastScaleData.hip + " cm");
-        txtWHRLast.setText(String.format("%.2f", calculator.getWHR()));
+        measurementWeightLast.updateValue(lastScaleData.weight);
+        measurementBMILast.updateValue(calculator.getBMI());
+        measurementFatLast.updateValue(lastScaleData.fat);
+        measurementWaterLast.updateValue(lastScaleData.water);
+        measurementMuscleLast.updateValue(lastScaleData.muscle);
+        measurementWaistLast.updateValue(lastScaleData.waist);
+        measurementWHtRLast.updateValue(calculator.getWHtR());
+        measurementHipLast.updateValue(lastScaleData.hip);
+        measurementWHRLast.updateValue(calculator.getWHR());
     }
 
     private void updateGoal(ArrayList<ScaleData> scaleDataList) {
@@ -505,69 +346,15 @@ public class OverviewFragment extends Fragment implements FragmentUpdateListener
                     diffScaleCalculator.body_height = currentScaleUser.body_height;
                     diffScaleCalculator.setScaleData(diffScaleData);
 
-                    ScaleDiff.setDiff(
-                            txtLabelWeight,
-                            lastScaleData.weight - diffScaleData.weight,
-                            getResources().getString(R.string.label_weight),
-                            "%.1f ",
-                            ScaleUser.UNIT_STRING[currentScaleUser.scale_unit]
-                    );
-                    ScaleDiff.setDiff(
-                            txtLabelBMI,
-                            lastScaleCalculator.getBMI() - diffScaleCalculator.getBMI(),
-                            getResources().getString(R.string.label_bmi),
-                            "%.1f ",
-                            ""
-                    );
-                    ScaleDiff.setDiff(
-                            txtLabelFat,
-                            lastScaleData.fat - diffScaleData.fat,
-                            getResources().getString(R.string.label_fat),
-                            "%.1f ",
-                            "%"
-                    );
-                    ScaleDiff.setDiff(
-                            txtLabelMuscle,
-                            lastScaleData.muscle - diffScaleData.muscle,
-                            getResources().getString(R.string.label_muscle),
-                            "%.1f ",
-                            "%"
-                    );
-                    ScaleDiff.setDiff(
-                            txtLabelWater,
-                            lastScaleData.water - diffScaleData.water,
-                            getResources().getString(R.string.label_water),
-                            "%.1f ",
-                            "%"
-                    );
-                    ScaleDiff.setDiff(
-                            txtLabelWaist,
-                            lastScaleData.waist - diffScaleData.waist,
-                            getResources().getString(R.string.label_waist),
-                            "%.1f ",
-                            "cm"
-                    );
-                    ScaleDiff.setDiff(
-                            txtLabelWHtR,
-                            lastScaleCalculator.getWHtR() - diffScaleCalculator.getWHtR(),
-                            getResources().getString(R.string.label_whtr),
-                            "%.2f ",
-                            ""
-                    );
-                    ScaleDiff.setDiff(
-                            txtLabelHip,
-                            lastScaleData.hip - diffScaleData.hip,
-                            getResources().getString(R.string.label_hip),
-                            "%.1f ",
-                            "cm"
-                    );
-                    ScaleDiff.setDiff(
-                            txtLabelWHR,
-                            lastScaleCalculator.getWHR() - diffScaleCalculator.getWHR(),
-                            getResources().getString(R.string.label_whr),
-                            "%.2f ",
-                            ""
-                    );
+                    measurementWeightLast.setDiff(lastScaleData.weight, diffScaleData.weight);
+                    measurementBMILast.setDiff(lastScaleCalculator.getBMI(), diffScaleCalculator.getBMI());
+                    measurementMuscleLast.setDiff(lastScaleData.muscle, diffScaleData.muscle);
+                    measurementFatLast.setDiff(lastScaleData.fat, diffScaleData.fat);
+                    measurementWaterLast.setDiff(lastScaleData.water, diffScaleData.water);
+                    measurementWaistLast.setDiff(lastScaleData.waist, diffScaleData.waist);
+                    measurementWHtRLast.setDiff(lastScaleCalculator.getWHtR(), diffScaleCalculator.getWHtR());
+                    measurementHipLast.setDiff(lastScaleData.hip, diffScaleData.hip);
+                    measurementWHRLast.setDiff(lastScaleCalculator.getWHR(), diffScaleCalculator.getWHR());
                 }
             }
         }
@@ -970,21 +757,4 @@ public class OverviewFragment extends Fragment implements FragmentUpdateListener
         }
     }
 
-    private class onClickListenerEvaluation implements View.OnClickListener {
-        @Override
-        public void onClick(View v) {
-            TableRow row = (TableRow)v;
-
-            TableLayout tableLayout = (TableLayout)row.getParent();
-            int index = tableLayout.indexOfChild(row);
-
-            TableRow rowEvaluation = (TableRow)tableLayout.getChildAt(index+1);
-
-            if (rowEvaluation.getVisibility() == View.VISIBLE) {
-                rowEvaluation.setVisibility(View.GONE);
-            } else {
-                rowEvaluation.setVisibility(View.VISIBLE);
-            }
-        }
-    }
 }
diff --git a/android_app/app/src/main/java/com/health/openscale/gui/ScaleDiff.java b/android_app/app/src/main/java/com/health/openscale/gui/ScaleDiff.java
index 6403a4a9..b9093a30 100644
--- a/android_app/app/src/main/java/com/health/openscale/gui/ScaleDiff.java
+++ b/android_app/app/src/main/java/com/health/openscale/gui/ScaleDiff.java
@@ -10,8 +10,7 @@ public class ScaleDiff {
     public static void setDiff(TextView txtLabel,
                         double diff,
                         String labelResource,
-                        String format,
-                        String unit) {
+                        String format) {
 
         String symbol;
 
@@ -28,7 +27,6 @@ public class ScaleDiff {
                                 symbol +
                                 "<small> " +
                                 String.format(format, diff) +
-                                unit +
                                 "</small></font>"
                 )
         );