diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/order/OrderPlanningModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/order/OrderPlanningModel.java
index a42dcc21f..2843f1173 100644
--- a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/order/OrderPlanningModel.java
+++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/order/OrderPlanningModel.java
@@ -103,6 +103,7 @@ import org.zkforge.timeplot.Plotinfo;
 import org.zkforge.timeplot.Timeplot;
 import org.zkforge.timeplot.geometry.TimeGeometry;
 import org.zkforge.timeplot.geometry.ValueGeometry;
+import org.zkoss.ganttz.IChartVisibilityChangedListener;
 import org.zkoss.ganttz.Planner;
 import org.zkoss.ganttz.adapters.IStructureNavigator;
 import org.zkoss.ganttz.adapters.PlannerConfiguration;
@@ -238,6 +239,8 @@ public abstract class OrderPlanningModel implements IOrderPlanningModel {
 
     private Order orderReloaded;
 
+    private List<IChartVisibilityChangedListener> keepAliveChartVisibilityListeners = new ArrayList<IChartVisibilityChangedListener>();
+
     private final class TaskElementNavigator implements
             IStructureNavigator<TaskElement> {
         @Override
@@ -302,8 +305,8 @@ public abstract class OrderPlanningModel implements IOrderPlanningModel {
         configureModificators(orderReloaded, configuration);
         planner.setConfiguration(configuration);
 
-        Timeplot chartLoadTimeplot = new Timeplot();
-        Timeplot chartEarnedValueTimeplot = new Timeplot();
+        Timeplot chartLoadTimeplot = createEmptyTimeplot();
+        Timeplot chartEarnedValueTimeplot = createEmptyTimeplot();
         OrderEarnedValueChartFiller earnedValueChartFiller = new OrderEarnedValueChartFiller(
                 orderReloaded);
         earnedValueChartFiller.calculateValues(planner.getTimeTracker()
@@ -313,19 +316,23 @@ public abstract class OrderPlanningModel implements IOrderPlanningModel {
 
         Chart loadChart = setupChart(orderReloaded,
                 new OrderLoadChartFiller(orderReloaded), chartLoadTimeplot,
-                planner.getTimeTracker(),
-                planner.getZoomLevel());
+                planner);
         refillLoadChartWhenNeeded(configuration, planner, saveCommand,
                 loadChart);
         Chart earnedValueChart = setupChart(orderReloaded,
                 earnedValueChartFiller,
-                chartEarnedValueTimeplot, planner
-                        .getTimeTracker(), planner.getZoomLevel());
+                chartEarnedValueTimeplot, planner);
         refillLoadChartWhenNeeded(configuration, planner, saveCommand,
                 earnedValueChart);
         setEventListenerConfigurationCheckboxes(earnedValueChart);
     }
 
+    private Timeplot createEmptyTimeplot() {
+        Timeplot timeplot = new Timeplot();
+        timeplot.appendChild(new Plotinfo());
+        return timeplot;
+    }
+
     private void addPrintSupport(
             PlannerConfiguration<TaskElement> configuration, final Order order) {
         configuration.setPrintAction(new IPrintAction() {
@@ -640,24 +647,31 @@ public abstract class OrderPlanningModel implements IOrderPlanningModel {
     }
 
     private void refillLoadChartWhenNeeded(
-            PlannerConfiguration<?> configuration, Planner planner,
+            PlannerConfiguration<?> configuration, final Planner planner,
             ISaveCommand saveCommand, final Chart loadChart) {
-        planner.getTimeTracker().addZoomListener(fillOnZoomChange(loadChart));
+        planner.getTimeTracker().addZoomListener(
+                fillOnZoomChange(loadChart, planner));
+        planner
+                .addChartVisibilityListener(fillOnChartVisibilityChange(loadChart));
         if(saveCommand != null) {
-            saveCommand.addListener(fillChartOnSave(loadChart));
+            saveCommand.addListener(fillChartOnSave(loadChart, planner));
         }
         taskElementAdapter.addListener(readOnlyProxy(transactionService,
                 IOnMoveListener.class, new IOnMoveListener() {
                     @Override
                     public void moved(TaskElement taskElement) {
-                        loadChart.fillChart();
+                        if (planner.isVisibleChart()) {
+                            loadChart.fillChart();
+                        }
                     }
                 }));
         configuration.addReloadChartListener(readOnlyProxy(transactionService,
                 IReloadChartListener.class, new IReloadChartListener() {
                     @Override
                     public void reloadChart() {
-                        loadChart.fillChart();
+                        if (planner.isVisibleChart()) {
+                            loadChart.fillChart();
+                        }
                     }
                 }));
     }
@@ -762,16 +776,41 @@ public abstract class OrderPlanningModel implements IOrderPlanningModel {
 
     private Chart setupChart(Order orderReloaded,
             IChartFiller loadChartFiller, Timeplot chartComponent,
-            TimeTracker timeTracker,
-            ZoomLevel defaultZoomLevel) {
+            Planner planner) {
+        TimeTracker timeTracker = planner.getTimeTracker();
         Chart result = new Chart(chartComponent, loadChartFiller,
                 timeTracker);
-        result.setZoomLevel(defaultZoomLevel);
-        result.fillChart();
+        result.setZoomLevel(planner.getZoomLevel());
+        if (planner.isVisibleChart()) {
+            result.fillChart();
+        }
         return result;
     }
 
-    private IZoomLevelChangedListener fillOnZoomChange(final Chart loadChart) {
+    private IChartVisibilityChangedListener fillOnChartVisibilityChange(
+            final Chart loadChart) {
+        IChartVisibilityChangedListener chartVisibilityChangedListener = new IChartVisibilityChangedListener() {
+
+            @Override
+            public void chartVisibilityChanged(final boolean visible) {
+                transactionService
+                        .runOnReadOnlyTransaction(new IOnTransaction<Void>() {
+                            @Override
+                            public Void execute() {
+                                if (visible) {
+                                    loadChart.fillChart();
+                                }
+                                return null;
+                            }
+                        });
+            }
+        };
+        keepAliveChartVisibilityListeners.add(chartVisibilityChangedListener);
+        return chartVisibilityChangedListener;
+    }
+
+    private IZoomLevelChangedListener fillOnZoomChange(final Chart loadChart,
+            final Planner planner) {
         IZoomLevelChangedListener zoomListener = new IZoomLevelChangedListener() {
 
             @Override
@@ -782,7 +821,9 @@ public abstract class OrderPlanningModel implements IOrderPlanningModel {
                         .runOnReadOnlyTransaction(new IOnTransaction<Void>() {
                             @Override
                             public Void execute() {
-                                loadChart.fillChart();
+                                if (planner.isVisibleChart()) {
+                                    loadChart.fillChart();
+                                }
                                 return null;
                             }
                         });
@@ -794,7 +835,8 @@ public abstract class OrderPlanningModel implements IOrderPlanningModel {
         return zoomListener;
     }
 
-    private IAfterSaveListener fillChartOnSave(final Chart loadChart) {
+    private IAfterSaveListener fillChartOnSave(final Chart loadChart,
+            final Planner planner) {
         IAfterSaveListener result = new IAfterSaveListener() {
 
                     @Override
@@ -803,7 +845,9 @@ public abstract class OrderPlanningModel implements IOrderPlanningModel {
                         .runOnReadOnlyTransaction(new IOnTransaction<Void>() {
                             @Override
                             public Void execute() {
-                                loadChart.fillChart();
+                                if (planner.isVisibleChart()) {
+                                    loadChart.fillChart();
+                                }
                                 return null;
                             }
                         });
@@ -834,6 +878,7 @@ public abstract class OrderPlanningModel implements IOrderPlanningModel {
         criterionDAO.list(Criterion.class);
         TaskGroup taskElement = orderReloaded.getAssociatedTaskElement();
         forceLoadOfChildren(Arrays.asList(taskElement));
+        forceLoadDayAssignments(orderReloaded.getResources());
         final List<Resource> allResources = resourceDAO
                 .list(Resource.class);
         PlanningState result = PlanningState.create(taskElement, orderReloaded
@@ -844,6 +889,12 @@ public abstract class OrderPlanningModel implements IOrderPlanningModel {
         return result;
     }
 
+    private void forceLoadDayAssignments(Set<Resource> resources) {
+        for (Resource resource : resources) {
+            resource.getAssignments().size();
+        }
+    }
+
     private void forceLoadOfChildren(Collection<? extends TaskElement> initial) {
         for (TaskElement each : initial) {
             forceLoadOfDataAssociatedTo(each);