Merge pull request #1 from MilenaMMay/master

openScale code refactoring contributions from MilenaMMay

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);

android_app/app/src/main/java/com/health/openscale/core/ScaleCalculator.java

@@ -0,0 +1,38 @@
+package com.health.openscale.core;
+
+public class ScaleCalculator {
+
+    public float weight;
+    public float fat;
+    public float water;
+    public float muscle;
+    public float waist;
+    public float hip;
+    public int body_height;
+
+    public void setScaleData(ScaleData scaleData) {
+        weight = scaleData.weight;
+        fat = scaleData.fat;
+        water = scaleData.water;
+        muscle = scaleData.weight;
+        waist = scaleData.waist;
+        hip = scaleData.hip;
+    }
+
+    public float getBMI() {
+        return weight / ((body_height / 100.0f)*(body_height / 100.0f));
+    }
+
+    public float getWHtR() {
+        return waist / (float)body_height;
+    }
+
+    public float getWHR() {
+        if (hip == 0) {
+            return 0;
+        }
+
+        return waist / hip;
+    }
+
+}

android_app/app/src/main/java/com/health/openscale/core/ScaleUser.java

@@ -49,22 +49,6 @@ public class ScaleUser {
         return false;
     }
 
-    public float getBMI(float weight) {
-        return weight / ((body_height / 100.0f)*(body_height / 100.0f));
-    }
-
-    public float getWHtR(float waist) {
-        return waist / (float)body_height;
-    }
-
-    public float getWHR(float waist, float hip) {
-        if (hip == 0) {
-            return 0;
-        }
-
-        return waist / hip;
-    }
-
 	@Override
 	public String toString()
 	{

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;
+    }
+
+}

android_app/app/src/main/java/com/health/openscale/gui/OverviewFragment.java

@@ -41,6 +41,7 @@ import com.health.openscale.core.EvaluationResult;
 import com.health.openscale.core.EvaluationSheet;
 import com.health.openscale.core.LinearGaugeView;
 import com.health.openscale.core.OpenScale;
+import com.health.openscale.core.ScaleCalculator;
 import com.health.openscale.core.ScaleData;
 import com.health.openscale.core.ScaleUser;
 
@@ -66,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;
@@ -73,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;
@@ -90,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;
@@ -112,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;
@@ -152,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);
@@ -169,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);
@@ -191,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());
@@ -212,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>());
@@ -263,16 +215,27 @@ 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();
 
+        userSelectedData = null;
+
+        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();
 
@@ -293,142 +256,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);
+        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);
     }
 
-        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);
-        }
+    private void updateLastValues() {
+        ScaleCalculator calculator = new ScaleCalculator();
+        calculator.body_height = currentScaleUser.body_height;
+        calculator.setScaleData(lastScaleData);
 
-        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);
-        }
-    }
-
-    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);
-
-        EvaluationSheet evalSheet = new EvaluationSheet(currentScaleUser);
-
-        EvaluationResult sheetWeight = evalSheet.evaluateWeight(lastScaleData.weight);
-        EvaluationResult sheetBMI = evalSheet.evaluateBMI(currentScaleUser.getBMI(lastScaleData.weight));
-        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(currentScaleUser.getWHtR(lastScaleData.waist));
-        EvaluationResult sheetWHR = evalSheet.evaluateWHR(currentScaleUser.getWHR(lastScaleData.waist, lastScaleData.hip));
-
-        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(currentScaleUser.getBMI(lastScaleData.weight));
-        linearGaugeFat.setValue(lastScaleData.fat);
-        linearGaugeMuscle.setValue(lastScaleData.muscle);
-        linearGaugeWater.setValue(lastScaleData.water);
-        linearGaugeWaist.setValue(lastScaleData.waist);
-        linearGaugeWHtR.setValue(currentScaleUser.getWHtR(lastScaleData.waist));
-        linearGaugeHip.setValue(lastScaleData.hip);
-        linearGaugeWHR.setValue(currentScaleUser.getWHR(lastScaleData.waist, lastScaleData.hip));
-    }
-
-    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() {
-        txtWeightLast.setText(lastScaleData.weight + " " + ScaleUser.UNIT_STRING[currentScaleUser.scale_unit]);
-        txtBMILast.setText(String.format("%.1f", currentScaleUser.getBMI(lastScaleData.weight)));
-        txtFatLast.setText(lastScaleData.fat + " %");
-        txtWaterLast.setText(lastScaleData.water + " %");
-        txtMuscleLast.setText(lastScaleData.muscle + " %");
-        txtWaistLast.setText(lastScaleData.waist + " cm");
-        txtWHtRLast.setText(String.format("%.2f", currentScaleUser.getWHtR(lastScaleData.waist)));
-        txtHipLast.setText(lastScaleData.hip + " cm");
-        txtWHRLast.setText(String.format("%.2f", currentScaleUser.getWHR(lastScaleData.waist, lastScaleData.hip)));
+        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) {
@@ -444,9 +296,40 @@ public class OverviewFragment extends Fragment implements FragmentUpdateListener
         long days = daysBetween(curDate, goalDate);
         txtGoalDayLeft.setText(days + " " + getResources().getString(R.string.label_days));
 
-        txtLabelGoalWeight.setText(Html.fromHtml(getResources().getString(R.string.label_goal_weight) + " <br> <font color='grey'><small>BMI " + String.format("%.1f", currentScaleUser.getBMI(currentScaleUser.goal_weight)) + " </small></font>"));
-        txtLabelGoalDiff.setText(Html.fromHtml(getResources().getString(R.string.label_weight_difference) + " <br> <font color='grey'><small>BMI " + String.format("%.1f", currentScaleUser.getBMI(lastScaleData.weight) - currentScaleUser.getBMI(currentScaleUser.goal_weight))  + " </small></font>"));
-        txtLabelDayLeft.setText(Html.fromHtml(getResources().getString(R.string.label_days_left) + " <br> <font color='grey'><small>" + getResources().getString(R.string.label_goal_date_is) + " " + DateFormat.getDateInstance(DateFormat.LONG).format(currentScaleUser.goal_date) + " </small></font>")); // currentScaleUser.goal_date
+        ScaleCalculator currentCalculator = new ScaleCalculator();
+        currentCalculator.body_height = currentScaleUser.body_height;
+        currentCalculator.weight = lastScaleData.weight;
+
+        ScaleCalculator goalCalculator = new ScaleCalculator();
+        goalCalculator.body_height = currentScaleUser.body_height;
+        goalCalculator.weight = currentScaleUser.goal_weight;
+
+        txtLabelGoalWeight.setText(
+                Html.fromHtml(
+                        getResources().getString(R.string.label_goal_weight) +
+                        " <br> <font color='grey'><small>BMI " +
+                        String.format("%.1f", goalCalculator.getBMI()) +
+                        " </small></font>"
+                )
+        );
+        txtLabelGoalDiff.setText(
+                Html.fromHtml(
+                        getResources().getString(R.string.label_weight_difference) +
+                        " <br> <font color='grey'><small>BMI " +
+                        String.format("%.1f", currentCalculator.getBMI() - goalCalculator.getBMI())  +
+                        " </small></font>"
+                )
+        );
+        txtLabelDayLeft.setText(
+                Html.fromHtml(
+                        getResources().getString(R.string.label_days_left) +
+                                " <br> <font color='grey'><small>" +
+                                getResources().getString(R.string.label_goal_date_is) +
+                                " "
+                                + DateFormat.getDateInstance(DateFormat.LONG).format(currentScaleUser.goal_date) +
+                                " </small></font>"
+                )
+        ); // currentScaleUser.goal_date
 
         ListIterator<ScaleData> scaleDataIterator = scaleDataList.listIterator();
 
@@ -457,62 +340,23 @@ public class OverviewFragment extends Fragment implements FragmentUpdateListener
                 if (scaleDataIterator.hasNext()) {
                     ScaleData diffScaleData = scaleDataIterator.next();
 
-                    double diffWeight = lastScaleData.weight - diffScaleData.weight;
-                    double diffBMI = currentScaleUser.getBMI(lastScaleData.weight) - currentScaleUser.getBMI(diffScaleData.weight);
-                    double diffFat = lastScaleData.fat - diffScaleData.fat;
-                    double diffMuscle = lastScaleData.muscle - diffScaleData.muscle;
-                    double diffWater = lastScaleData.water - diffScaleData.water;
-                    double diffWaist = lastScaleData.waist - diffScaleData.waist;
-                    double diffWHtR = currentScaleUser.getWHtR(lastScaleData.waist) - currentScaleUser.getWHtR(diffScaleData.waist);
-                    double diffHip = lastScaleData.hip - diffScaleData.hip;
-                    double diffWHR = currentScaleUser.getWHR(lastScaleData.waist, lastScaleData.hip) - currentScaleUser.getWHR(diffScaleData.waist, diffScaleData.hip);
+                    ScaleCalculator lastScaleCalculator = new ScaleCalculator();
+                    lastScaleCalculator.body_height = currentScaleUser.body_height;
+                    lastScaleCalculator.setScaleData(lastScaleData);
 
+                    ScaleCalculator diffScaleCalculator = new ScaleCalculator();
+                    diffScaleCalculator.body_height = currentScaleUser.body_height;
+                    diffScaleCalculator.setScaleData(diffScaleData);
 
-                    if (diffWeight > 0.0)
-                        txtLabelWeight.setText(Html.fromHtml(getResources().getString(R.string.label_weight) + " <br> <font color='grey'>&#x2197;<small> " + String.format("%.1f ", diffWeight) + ScaleUser.UNIT_STRING[currentScaleUser.scale_unit] + "</small></font>"));
-                    else
-                        txtLabelWeight.setText(Html.fromHtml(getResources().getString(R.string.label_weight) + " <br> <font color='grey'>&#x2198;<small> " + String.format("%.1f ", diffWeight) + ScaleUser.UNIT_STRING[currentScaleUser.scale_unit] + "</small></font>"));
-
-
-                    if (diffBMI > 0.0)
-                        txtLabelBMI.setText(Html.fromHtml(getResources().getString(R.string.label_bmi) + " <br> <font color='grey'>&#x2197;<small> " + String.format("%.1f", diffBMI) + "</small></font>"));
-                    else
-                        txtLabelBMI.setText(Html.fromHtml(getResources().getString(R.string.label_bmi) + " <br> <font color='grey'>&#x2198;<small> " + String.format("%.1f", diffBMI) + "</small></font>"));
-
-                    if (diffFat > 0.0)
-                        txtLabelFat.setText(Html.fromHtml(getResources().getString(R.string.label_fat) + " <br> <font color='grey'>&#x2197;<small> " + String.format("%.1f", diffFat) + "%</small></font>"));
-                    else
-                        txtLabelFat.setText(Html.fromHtml(getResources().getString(R.string.label_fat) + " <br> <font color='grey'>&#x2198;<small> " + String.format("%.1f", diffFat) + "%</small></font>"));
-
-                    if (diffMuscle > 0.0)
-                        txtLabelMuscle.setText(Html.fromHtml(getResources().getString(R.string.label_muscle) + " <br> <font color='grey'>&#x2197;<small> " + String.format("%.1f", diffMuscle) + "%</small></font>"));
-                    else
-                        txtLabelMuscle.setText(Html.fromHtml(getResources().getString(R.string.label_muscle) + " <br> <font color='grey'>&#x2198;<small> " + String.format("%.1f", diffMuscle) + "%</small></font>"));
-
-                    if (diffWater > 0.0)
-                        txtLabelWater.setText(Html.fromHtml(getResources().getString(R.string.label_water) + " <br> <font color='grey'>&#x2197;<small> " + String.format("%.1f", diffWater) + "%</small></font>"));
-                    else
-                        txtLabelWater.setText(Html.fromHtml(getResources().getString(R.string.label_water) + " <br> <font color='grey'>&#x2198;<small> " + String.format("%.1f", diffWater) + "%</small></font>"));
-
-                    if (diffWaist > 0.0)
-                        txtLabelWaist.setText(Html.fromHtml(getResources().getString(R.string.label_waist) + " <br> <font color='grey'>&#x2197;<small> " + String.format("%.1f", diffWaist) + "cm</small></font>"));
-                    else
-                        txtLabelWaist.setText(Html.fromHtml(getResources().getString(R.string.label_waist) + " <br> <font color='grey'>&#x2198;<small> " + String.format("%.1f", diffWaist) + "cm</small></font>"));
-
-                    if (diffWHtR > 0.0)
-                        txtLabelWHtR.setText(Html.fromHtml(getResources().getString(R.string.label_whtr) + " <br> <font color='grey'>&#x2197;<small> " + String.format("%.2f", diffWHtR) + "</small></font>"));
-                    else
-                        txtLabelWHtR.setText(Html.fromHtml(getResources().getString(R.string.label_whtr) + " <br> <font color='grey'>&#x2198;<small> " + String.format("%.2f", diffWHtR) + "</small></font>"));
-
-                    if (diffHip > 0.0)
-                        txtLabelHip.setText(Html.fromHtml(getResources().getString(R.string.label_hip) + " <br> <font color='grey'>&#x2197;<small> " + String.format("%.1f", diffHip) + "cm</small></font>"));
-                    else
-                        txtLabelHip.setText(Html.fromHtml(getResources().getString(R.string.label_hip) + " <br> <font color='grey'>&#x2198;<small> " + String.format("%.1f", diffHip) + "cm</small></font>"));
-
-                    if (diffWHR > 0.0)
-                        txtLabelWHR.setText(Html.fromHtml(getResources().getString(R.string.label_whr) + " <br> <font color='grey'>&#x2197;<small> " + String.format("%.2f", diffWHR) + "</small></font>"));
-                    else
-                        txtLabelWHR.setText(Html.fromHtml(getResources().getString(R.string.label_whr) + " <br> <font color='grey'>&#x2198;<small> " + String.format("%.2f", diffWHR) + "</small></font>"));
+                    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());
                 }
             }
         }
@@ -557,32 +401,36 @@ public class OverviewFragment extends Fragment implements FragmentUpdateListener
         {
             histDate.setTime(scaleData.date_time);
 
+            ScaleCalculator calculator = new ScaleCalculator();
+            calculator.body_height = currentScaleUser.body_height;
+            calculator.setScaleData(scaleData);
+
             if (weekPastDate.before(histDate)) {
                 weekSize++;
 
                 weekAvgWeight += scaleData.weight;
-                weekAvgBMI += currentScaleUser.getBMI(scaleData.weight);
+                weekAvgBMI += calculator.getBMI();
                 weekAvgFat += scaleData.fat;
                 weekAvgWater += scaleData.water;
                 weekAvgMuscle += scaleData.muscle;
                 weekAvgWaist += scaleData.waist;
                 weekAvgHip += scaleData.hip;
-                weekAvgWHtR += currentScaleUser.getWHtR(scaleData.waist);
-                weekAvgWHR += currentScaleUser.getWHR(scaleData.waist, scaleData.hip);
+                weekAvgWHtR += calculator.getWHtR();
+                weekAvgWHR += calculator.getWHR();
             }
 
             if (monthPastDate.before(histDate)) {
                 monthSize++;
 
                 monthAvgWeight += scaleData.weight;
-                monthAvgBMI += currentScaleUser.getBMI(scaleData.weight);
+                monthAvgBMI += calculator.getBMI();
                 monthAvgFat += scaleData.fat;
                 monthAvgWater += scaleData.water;
                 monthAvgMuscle += scaleData.muscle;
                 monthAvgWaist += scaleData.waist;
                 monthAvgHip += scaleData.hip;
-                monthAvgWHtR += currentScaleUser.getWHtR(scaleData.waist);
-                monthAvgWHR += currentScaleUser.getWHR(scaleData.waist, scaleData.hip);
+                monthAvgWHtR += calculator.getWHtR();
+                monthAvgWHR += calculator.getWHR();
             } else {
                 break;
             }
@@ -911,21 +759,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);
-            }
-        }
-    }
 }

android_app/app/src/main/java/com/health/openscale/gui/ScaleDiff.java

@@ -0,0 +1,35 @@
+package com.health.openscale.gui;
+
+import android.text.Html;
+import android.widget.TextView;
+
+public class ScaleDiff {
+    private static String SYMBOL_UP = "↗";
+    private static String SYMBOL_DOWN = "↘";
+
+    public static void setDiff(TextView txtLabel,
+                        double diff,
+                        String labelResource,
+                        String format) {
+
+        String symbol;
+
+        if (diff > 0.0) {
+            symbol = SYMBOL_UP;
+        } else {
+            symbol = SYMBOL_DOWN;
+        }
+
+        txtLabel.setText(
+                Html.fromHtml(
+                        labelResource +
+                                " <br> <font color='grey'>" +
+                                symbol +
+                                "<small> " +
+                                String.format(format, diff) +
+                                "</small></font>"
+                )
+        );
+    }
+}
+