diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/BaseCalendar.java b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/BaseCalendar.java
index 5d762771d..8fcceae1a 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/BaseCalendar.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/BaseCalendar.java
@@ -50,7 +50,7 @@ import org.navalplanner.business.workingday.ResourcesPerDay;
  * some exceptions of its parent calendar.
  * @author Manuel Rego Casasnovas <mrego@igalia.com>
  */
-public class BaseCalendar extends IntegrationEntity implements IWorkHours {
+public class BaseCalendar extends IntegrationEntity implements ICalendar {
 
     private static final EffortDuration DEFAULT_VALUE = EffortDuration.zero();
 
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/CombinedWorkHours.java b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/CombinedWorkHours.java
index 10ee8f060..6cba80b4a 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/CombinedWorkHours.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/CombinedWorkHours.java
@@ -34,22 +34,22 @@ import org.joda.time.LocalDate;
 import org.navalplanner.business.workingday.EffortDuration;
 import org.navalplanner.business.workingday.ResourcesPerDay;
 
-public abstract class CombinedWorkHours implements IWorkHours {
+public abstract class CombinedWorkHours implements ICalendar {
 
-    private final List<IWorkHours> workHours;
+    private final List<ICalendar> calendars;
 
-    public CombinedWorkHours(Collection<? extends IWorkHours> workHours) {
-        Validate.notNull(workHours);
-        Validate.isTrue(!workHours.isEmpty());
-        this.workHours = notNull(workHours);
-        Validate.isTrue(!this.workHours.isEmpty(),
+    public CombinedWorkHours(Collection<? extends ICalendar> calendars) {
+        Validate.notNull(calendars);
+        Validate.isTrue(!calendars.isEmpty());
+        this.calendars = notNull(calendars);
+        Validate.isTrue(!this.calendars.isEmpty(),
                 "there should be at least one workHours not null");
     }
 
-    private static List<IWorkHours> notNull(
-            Collection<? extends IWorkHours> workHours) {
-        List<IWorkHours> result = new ArrayList<IWorkHours>();
-        for (IWorkHours each : workHours) {
+    private static List<ICalendar> notNull(
+            Collection<? extends ICalendar> calendars) {
+        List<ICalendar> result = new ArrayList<ICalendar>();
+        for (ICalendar each : calendars) {
             if (each != null) {
                 result.add(each);
             }
@@ -57,24 +57,24 @@ public abstract class CombinedWorkHours implements IWorkHours {
         return result;
     }
 
-    public static CombinedWorkHours minOf(IWorkHours... workHours) {
+    public static CombinedWorkHours minOf(ICalendar... workHours) {
         Validate.notNull(workHours);
         return new Min(asList(workHours));
     }
 
-    public static CombinedWorkHours maxOf(IWorkHours... workHours) {
+    public static CombinedWorkHours maxOf(ICalendar... workHours) {
         return maxOf(asList(workHours));
     }
 
     public static CombinedWorkHours maxOf(
-            Collection<? extends IWorkHours> workHours) {
-        return new Max(workHours);
+            Collection<? extends ICalendar> calendars) {
+        return new Max(calendars);
     }
 
     @Override
     public EffortDuration getCapacityDurationAt(LocalDate date) {
         EffortDuration current = null;
-        for (IWorkHours workHour : workHours) {
+        for (ICalendar workHour : calendars) {
             current = current == null ? workHour.getCapacityDurationAt(date)
                     : updateCapacity(current,
                             workHour.getCapacityDurationAt(date));
@@ -85,7 +85,7 @@ public abstract class CombinedWorkHours implements IWorkHours {
     @Override
     public EffortDuration asDurationOn(LocalDate day, ResourcesPerDay amount) {
         EffortDuration result = null;
-        for (IWorkHours each : workHours) {
+        for (ICalendar each : calendars) {
             result = result == null ? each.asDurationOn(day, amount)
                     : updateDuration(result, each.asDurationOn(day, amount));
         }
@@ -95,7 +95,7 @@ public abstract class CombinedWorkHours implements IWorkHours {
     @Override
     public AvailabilityTimeLine getAvailability() {
         AvailabilityTimeLine result = AvailabilityTimeLine.allValid();
-        for (IWorkHours each : workHours) {
+        for (ICalendar each : calendars) {
             result = compoundAvailability(result, each.getAvailability());
         }
         return result;
@@ -120,8 +120,8 @@ public abstract class CombinedWorkHours implements IWorkHours {
 
 class Min extends CombinedWorkHours {
 
-    public Min(List<IWorkHours> workHours) {
-        super(workHours);
+    public Min(List<ICalendar> calendars) {
+        super(calendars);
     }
 
     @Override
@@ -146,8 +146,8 @@ class Min extends CombinedWorkHours {
 
 class Max extends CombinedWorkHours {
 
-    public Max(Collection<? extends IWorkHours> workHours) {
-        super(workHours);
+    public Max(Collection<? extends ICalendar> calendars) {
+        super(calendars);
     }
 
     @Override
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/IWorkHours.java b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/ICalendar.java
similarity index 98%
rename from navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/IWorkHours.java
rename to navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/ICalendar.java
index 0de1dcee0..54b73f395 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/IWorkHours.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/ICalendar.java
@@ -24,7 +24,7 @@ import org.joda.time.LocalDate;
 import org.navalplanner.business.workingday.EffortDuration;
 import org.navalplanner.business.workingday.ResourcesPerDay;
 
-public interface IWorkHours {
+public interface ICalendar {
 
     /**
      * Translates the received amount into the corresponding duration at the
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/SameWorkHoursEveryDay.java b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/SameWorkHoursEveryDay.java
index 733fd62df..93407fb75 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/SameWorkHoursEveryDay.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/SameWorkHoursEveryDay.java
@@ -25,7 +25,7 @@ import org.joda.time.LocalDate;
 import org.navalplanner.business.workingday.EffortDuration;
 import org.navalplanner.business.workingday.ResourcesPerDay;
 
-public class SameWorkHoursEveryDay implements IWorkHours {
+public class SameWorkHoursEveryDay implements ICalendar {
 
     private static final SameWorkHoursEveryDay DEFAULT_WORKING_DAY = new SameWorkHoursEveryDay(
             8);
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/ThereAreHoursOnWorkHoursCalculator.java b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/ThereAreHoursOnWorkHoursCalculator.java
index 0720ea544..fa7f5b270 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/ThereAreHoursOnWorkHoursCalculator.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/calendars/entities/ThereAreHoursOnWorkHoursCalculator.java
@@ -43,7 +43,7 @@ public class ThereAreHoursOnWorkHoursCalculator {
     /**
      * Caculates if there are enough hours
      */
-    public static boolean thereIsAvailableCapacityFor(IWorkHours workHours,
+    public static boolean thereIsAvailableCapacityFor(ICalendar calendar,
             AvailabilityTimeLine availability,
             ResourcesPerDay resourcesPerDay, EffortDuration effortToAllocate) {
         if (effortToAllocate.isZero()) {
@@ -52,7 +52,7 @@ public class ThereAreHoursOnWorkHoursCalculator {
         if (resourcesPerDay.isZero()) {
             return false;
         }
-        AvailabilityTimeLine realAvailability = workHours.getAvailability()
+        AvailabilityTimeLine realAvailability = calendar.getAvailability()
                 .and(availability);
         List<Interval> validPeriods = realAvailability.getValidPeriods();
         if (validPeriods.isEmpty()) {
@@ -65,7 +65,7 @@ public class ThereAreHoursOnWorkHoursCalculator {
                 || first.getStart().equals(StartOfTime.create());
 
         return isOpenEnded
-                || thereAreCapacityOn(workHours, effortToAllocate,
+                || thereAreCapacityOn(calendar, effortToAllocate,
                         resourcesPerDay,
                         validPeriods);
 
@@ -75,7 +75,7 @@ public class ThereAreHoursOnWorkHoursCalculator {
         return validPeriods.get(validPeriods.size() - 1);
     }
 
-    private static boolean thereAreCapacityOn(IWorkHours workHours,
+    private static boolean thereAreCapacityOn(ICalendar calendar,
             EffortDuration effortToAllocate,
             ResourcesPerDay resourcesPerDay, List<Interval> validPeriods) {
         EffortDuration sum = zero();
@@ -83,7 +83,7 @@ public class ThereAreHoursOnWorkHoursCalculator {
             FixedPoint start = (FixedPoint) each.getStart();
             FixedPoint end = (FixedPoint) each.getEnd();
             EffortDuration pending = effortToAllocate.minus(sum);
-            sum = sum.plus(sumDurationUntil(workHours, pending,
+            sum = sum.plus(sumDurationUntil(calendar, pending,
                     resourcesPerDay, start.getDate(), end.getDate()));
             if (sum.compareTo(effortToAllocate) >= 0) {
                 return true;
@@ -92,7 +92,7 @@ public class ThereAreHoursOnWorkHoursCalculator {
         return false;
     }
 
-    private static EffortDuration sumDurationUntil(IWorkHours workHours,
+    private static EffortDuration sumDurationUntil(ICalendar calendar,
             EffortDuration maximum,
             ResourcesPerDay resourcesPerDay,
             LocalDate start, LocalDate end) {
@@ -100,7 +100,7 @@ public class ThereAreHoursOnWorkHoursCalculator {
         int days = org.joda.time.Days.daysBetween(start, end).getDays();
         for (int i = 0; i < days; i++) {
             LocalDate current = start.plusDays(i);
-            result = result.plus(workHours.asDurationOn(current, resourcesPerDay));
+            result = result.plus(calendar.asDurationOn(current, resourcesPerDay));
             if (result.compareTo(maximum) >= 0) {
                 return maximum;
             }
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/EffortDistributor.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/EffortDistributor.java
index 7f0dc0801..d6b206e33 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/EffortDistributor.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/EffortDistributor.java
@@ -28,7 +28,7 @@ import java.util.List;
 
 import org.apache.commons.lang.Validate;
 import org.joda.time.LocalDate;
-import org.navalplanner.business.calendars.entities.IWorkHours;
+import org.navalplanner.business.calendars.entities.ICalendar;
 import org.navalplanner.business.calendars.entities.ResourceCalendar;
 import org.navalplanner.business.calendars.entities.SameWorkHoursEveryDay;
 import org.navalplanner.business.resources.entities.Resource;
@@ -88,7 +88,7 @@ public class EffortDistributor {
         }
     }
 
-    private static final IWorkHours generateWorkHoursFor(Resource resource) {
+    private static final ICalendar generateCalendarFor(Resource resource) {
         if (resource.getCalendar() != null) {
             return resource.getCalendar();
         } else {
@@ -128,12 +128,12 @@ public class EffortDistributor {
 
         public final int capacityUnits;
 
-        public final IWorkHours workHours;
+        public final ICalendar calendar;
 
         public ResourceWithDerivedData(Resource resource) {
             this.resource = resource;
             this.capacityUnits = getCapacityFor(resource);
-            this.workHours = generateWorkHoursFor(resource);
+            this.calendar = generateCalendarFor(resource);
         }
 
     }
@@ -233,11 +233,11 @@ public class EffortDistributor {
         for (int i = 0; i < resources.size(); i++) {
             List<Share> shares = new ArrayList<Share>();
             Resource resource = resources.get(i).resource;
-            IWorkHours workHoursForResource = resources.get(i).workHours;
+            ICalendar calendarForResource = resources.get(i).calendar;
             EffortDuration alreadyAssigned = assignedHoursForResource
                     .getAssignedDurationAt(resource, day);
             final int alreadyAssignedSeconds = alreadyAssigned.getSeconds();
-            Integer capacityEachOneSeconds = workHoursForResource.asDurationOn(
+            Integer capacityEachOneSeconds = calendarForResource.asDurationOn(
                     day, ONE).getSeconds();
             final int capacityUnits = resources.get(i).capacityUnits;
             assert capacityUnits >= 1;
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericResourceAllocation.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericResourceAllocation.java
index 0e55e96dd..cf3144b34 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericResourceAllocation.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/GenericResourceAllocation.java
@@ -35,7 +35,7 @@ import java.util.Set;
 import org.hibernate.validator.Valid;
 import org.joda.time.LocalDate;
 import org.navalplanner.business.calendars.entities.AvailabilityTimeLine;
-import org.navalplanner.business.calendars.entities.IWorkHours;
+import org.navalplanner.business.calendars.entities.ICalendar;
 import org.navalplanner.business.planner.entities.EffortDistributor.IResourceSelector;
 import org.navalplanner.business.planner.entities.EffortDistributor.ResourceWithAssignedDuration;
 import org.navalplanner.business.planner.entities.allocationalgorithms.HoursModification;
@@ -261,8 +261,8 @@ public class GenericResourceAllocation extends
     }
 
     @Override
-    protected IWorkHours getWorkHoursGivenTaskHours(IWorkHours taskWorkHours) {
-        return taskWorkHours;
+    protected ICalendar getCalendarGivenTaskCalendar(ICalendar taskCalendar) {
+        return taskCalendar;
     }
 
     public IAllocatable forResources(Collection<? extends Resource> resources) {
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/ResourceAllocation.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/ResourceAllocation.java
index a19b59b30..39fb3647f 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/ResourceAllocation.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/ResourceAllocation.java
@@ -45,7 +45,7 @@ import org.joda.time.LocalDate;
 import org.navalplanner.business.calendars.entities.AvailabilityTimeLine;
 import org.navalplanner.business.calendars.entities.BaseCalendar;
 import org.navalplanner.business.calendars.entities.CombinedWorkHours;
-import org.navalplanner.business.calendars.entities.IWorkHours;
+import org.navalplanner.business.calendars.entities.ICalendar;
 import org.navalplanner.business.calendars.entities.SameWorkHoursEveryDay;
 import org.navalplanner.business.common.BaseEntity;
 import org.navalplanner.business.common.Registry;
@@ -228,22 +228,21 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
                         LocalDate start,
                         ResourcesPerDayModification resourcesPerDayModification,
                         EffortDuration effortToAllocate) {
-                    IWorkHours workHoursPerDay = getWorkHoursPerDay(resourcesPerDayModification);
+                    ICalendar calendar = getCalendar(resourcesPerDayModification);
                     ResourcesPerDay resourcesPerDay = resourcesPerDayModification
                             .getGoal();
                     AvailabilityTimeLine availability = resourcesPerDayModification
                             .getAvailability();
                     availability.invalidUntil(start);
-                    return workHoursPerDay.thereAreCapacityFor(availability,
+                    return calendar.thereAreCapacityFor(availability,
                             resourcesPerDay, effortToAllocate);
                 }
 
-                private CombinedWorkHours getWorkHoursPerDay(
+                private CombinedWorkHours getCalendar(
                         ResourcesPerDayModification resourcesPerDayModification) {
                     return CombinedWorkHours.minOf(resourcesPerDayModification
-                            .getBeingModified().getTaskWorkHours(),
-                            resourcesPerDayModification
-                                    .getResourcesWorkHoursPerDay());
+                            .getBeingModified().getTaskCalendar(),
+                            resourcesPerDayModification.getResourcesCalendar());
                 }
 
                 @Override
@@ -634,7 +633,7 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
         private Share getShareAt(LocalDate day,
                 AvailabilityTimeLine availability) {
             if (availability.isValid(day)) {
-                EffortDuration capacityAtDay = getWorkHoursPerDay()
+                EffortDuration capacityAtDay = getAllocationCalendar()
                         .getCapacityDurationAt(day);
                 return new Share(-capacityAtDay.getSeconds());
             } else {
@@ -725,7 +724,7 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
 
     final EffortDuration calculateTotalToDistribute(LocalDate day,
             ResourcesPerDay resourcesPerDay) {
-        return getWorkHoursPerDay().asDurationOn(day, resourcesPerDay);
+        return getAllocationCalendar().asDurationOn(day, resourcesPerDay);
     }
 
     public ResourcesPerDay calculateResourcesPerDayFromAssignments() {
@@ -739,7 +738,7 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
         EffortDuration sumWorkableEffort = zero();
         final ResourcesPerDay ONE_RESOURCE_PER_DAY = ResourcesPerDay.amount(1);
         for (Entry<LocalDate, List<T>> entry : byDay.entrySet()) {
-            sumWorkableEffort = sumWorkableEffort.plus(getWorkHoursPerDay()
+            sumWorkableEffort = sumWorkableEffort.plus(getAllocationCalendar()
                     .asDurationOn(entry.getKey(), ONE_RESOURCE_PER_DAY));
             sumTotalEffort = sumTotalEffort.plus(getAssignedDuration(entry
                     .getValue()));
@@ -750,11 +749,11 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
         return ResourcesPerDay.calculateFrom(sumTotalEffort, sumWorkableEffort);
     }
 
-    private IWorkHours getWorkHoursPerDay() {
-        return getWorkHoursGivenTaskHours(getTaskWorkHours());
+    private ICalendar getAllocationCalendar() {
+        return getCalendarGivenTaskCalendar(getTaskCalendar());
     }
 
-    private IWorkHours getTaskWorkHours() {
+    private ICalendar getTaskCalendar() {
         if (getTask().getCalendar() == null) {
             return SameWorkHoursEveryDay.getDefaultWorkingDay();
         } else {
@@ -762,8 +761,8 @@ public abstract class ResourceAllocation<T extends DayAssignment> extends
         }
     }
 
-    protected abstract IWorkHours getWorkHoursGivenTaskHours(
-            IWorkHours taskWorkHours);
+    protected abstract ICalendar getCalendarGivenTaskCalendar(
+            ICalendar taskCalendar);
 
     private void resetGenericAssignmentsTo(List<DayAssignment> assignments) {
         resetAssignmentsTo(cast(assignments));
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java
index 1b4e81449..0b6769424 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/SpecificResourceAllocation.java
@@ -38,7 +38,7 @@ import org.hibernate.validator.Valid;
 import org.joda.time.LocalDate;
 import org.navalplanner.business.calendars.entities.AvailabilityTimeLine;
 import org.navalplanner.business.calendars.entities.CombinedWorkHours;
-import org.navalplanner.business.calendars.entities.IWorkHours;
+import org.navalplanner.business.calendars.entities.ICalendar;
 import org.navalplanner.business.common.ProportionalDistributor;
 import org.navalplanner.business.planner.entities.allocationalgorithms.HoursModification;
 import org.navalplanner.business.planner.entities.allocationalgorithms.ResourcesPerDayModification;
@@ -198,8 +198,8 @@ public class SpecificResourceAllocation extends
     }
 
     @Override
-    protected IWorkHours getWorkHoursGivenTaskHours(IWorkHours taskWorkHours) {
-        return CombinedWorkHours.minOf(taskWorkHours, getResource()
+    protected ICalendar getCalendarGivenTaskCalendar(ICalendar taskCalendar) {
+        return CombinedWorkHours.minOf(taskCalendar, getResource()
                 .getCalendar());
     }
 
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/allocationalgorithms/ResourcesPerDayModification.java b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/allocationalgorithms/ResourcesPerDayModification.java
index 12bcf95aa..5f73b53a6 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/allocationalgorithms/ResourcesPerDayModification.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/planner/entities/allocationalgorithms/ResourcesPerDayModification.java
@@ -29,7 +29,7 @@ import org.apache.commons.lang.Validate;
 import org.joda.time.LocalDate;
 import org.navalplanner.business.calendars.entities.AvailabilityTimeLine;
 import org.navalplanner.business.calendars.entities.CombinedWorkHours;
-import org.navalplanner.business.calendars.entities.IWorkHours;
+import org.navalplanner.business.calendars.entities.ICalendar;
 import org.navalplanner.business.calendars.entities.ResourceCalendar;
 import org.navalplanner.business.calendars.entities.SameWorkHoursEveryDay;
 import org.navalplanner.business.planner.entities.AvailabilityCalculator;
@@ -85,16 +85,16 @@ public abstract class ResourcesPerDayModification extends
         }
 
         @Override
-        public IWorkHours getResourcesWorkHoursPerDay() {
-            return CombinedWorkHours.maxOf(resourcesWorkHours());
+        public ICalendar getResourcesCalendar() {
+            return CombinedWorkHours.maxOf(resourcesCalendar());
         }
 
-        private List<IWorkHours> resourcesWorkHours() {
-            List<IWorkHours> workHours = new ArrayList<IWorkHours>();
+        private List<ICalendar> resourcesCalendar() {
+            List<ICalendar> calendar = new ArrayList<ICalendar>();
             for (Resource each : getResources()) {
-                workHours.add(workHoursFor(each));
+                calendar.add(calendarFor(each));
             }
-            return workHours;
+            return calendar;
         }
 
     }
@@ -140,8 +140,8 @@ public abstract class ResourcesPerDayModification extends
         }
 
         @Override
-        public IWorkHours getResourcesWorkHoursPerDay() {
-            return workHoursFor(getAssociatedResource());
+        public ICalendar getResourcesCalendar() {
+            return calendarFor(getAssociatedResource());
         }
 
     }
@@ -183,7 +183,7 @@ public abstract class ResourcesPerDayModification extends
         return result;
     }
 
-    protected static IWorkHours workHoursFor(Resource associatedResource) {
+    protected static ICalendar calendarFor(Resource associatedResource) {
         ResourceCalendar calendar = associatedResource.getCalendar();
         return calendar != null ? calendar : SameWorkHoursEveryDay
                 .getDefaultWorkingDay();
@@ -203,7 +203,7 @@ public abstract class ResourcesPerDayModification extends
         return goal;
     }
 
-    public abstract IWorkHours getResourcesWorkHoursPerDay();
+    public abstract ICalendar getResourcesCalendar();
 
     public abstract void applyAllocationOnAllTaskLength();
 
diff --git a/navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/Resource.java b/navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/Resource.java
index 02da14ce6..a8aa41f10 100644
--- a/navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/Resource.java
+++ b/navalplanner-business/src/main/java/org/navalplanner/business/resources/entities/Resource.java
@@ -45,7 +45,7 @@ import org.hibernate.validator.Valid;
 import org.joda.time.Days;
 import org.joda.time.LocalDate;
 import org.navalplanner.business.calendars.entities.BaseCalendar;
-import org.navalplanner.business.calendars.entities.IWorkHours;
+import org.navalplanner.business.calendars.entities.ICalendar;
 import org.navalplanner.business.calendars.entities.ResourceCalendar;
 import org.navalplanner.business.calendars.entities.SameWorkHoursEveryDay;
 import org.navalplanner.business.common.IntegrationEntity;
@@ -875,12 +875,12 @@ public abstract class Resource extends IntegrationEntity {
                 criterion);
     }
 
-    public IWorkHours getCalendarOrDefault() {
+    public ICalendar getCalendarOrDefault() {
         return getCalendar() != null ? getCalendar() : SameWorkHoursEveryDay
                 .getDefaultWorkingDay();
     }
 
-    private int getTotalWorkHoursFor(IWorkHours calendar, LocalDate start,
+    private int getTotalWorkHoursFor(ICalendar calendar, LocalDate start,
             LocalDate end, ICriterion criterionToSatisfy) {
         EffortDuration sum = zero();
         final int days = Days.daysBetween(start, end).getDays();
diff --git a/navalplanner-business/src/test/java/org/navalplanner/business/test/calendars/entities/CombinedWorkHoursTest.java b/navalplanner-business/src/test/java/org/navalplanner/business/test/calendars/entities/CombinedWorkHoursTest.java
index 8f6e8a663..4264332d8 100644
--- a/navalplanner-business/src/test/java/org/navalplanner/business/test/calendars/entities/CombinedWorkHoursTest.java
+++ b/navalplanner-business/src/test/java/org/navalplanner/business/test/calendars/entities/CombinedWorkHoursTest.java
@@ -31,40 +31,40 @@ import static org.junit.Assert.assertThat;
 import org.joda.time.LocalDate;
 import org.junit.Test;
 import org.navalplanner.business.calendars.entities.CombinedWorkHours;
-import org.navalplanner.business.calendars.entities.IWorkHours;
+import org.navalplanner.business.calendars.entities.ICalendar;
 import org.navalplanner.business.workingday.EffortDuration;
 
 public class CombinedWorkHoursTest {
 
     @Test(expected = IllegalArgumentException.class)
     public void cannotAcceptOnlyNullElements() {
-        IWorkHours[] nullWorkHours = null;
+        ICalendar[] nullWorkHours = null;
         CombinedWorkHours.minOf(nullWorkHours);
     }
 
     public void someElementsCanBeNull() {
         CombinedWorkHours minOf = CombinedWorkHours.minOf(null,
-                createNiceMock(IWorkHours.class));
+                createNiceMock(ICalendar.class));
         assertNotNull(minOf);
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void mustHaveatLeastOne() {
-        IWorkHours[] emptyArray = {};
+        ICalendar[] emptyArray = {};
         CombinedWorkHours.minOf(emptyArray);
     }
 
     @Test
     public void returnsTheMinOfCalendars() {
-        IWorkHours minOf = CombinedWorkHours
+        ICalendar minOf = CombinedWorkHours
                 .minOf(hours(4), hours(2), hours(7));
         EffortDuration duration = minOf.getCapacityDurationAt(new LocalDate(
                 2000, 3, 3));
         assertThat(duration, equalTo(EffortDuration.hours(2)));
     }
 
-    private IWorkHours hours(int hours) {
-        IWorkHours result = createNiceMock(IWorkHours.class);
+    private ICalendar hours(int hours) {
+        ICalendar result = createNiceMock(ICalendar.class);
         expect(result.getCapacityDurationAt(isA(LocalDate.class))).andReturn(
                 EffortDuration.hours(hours));
         replay(result);
diff --git a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/company/CompanyPlanningModel.java b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/company/CompanyPlanningModel.java
index 3859e0dad..33e3525d4 100644
--- a/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/company/CompanyPlanningModel.java
+++ b/navalplanner-webapp/src/main/java/org/navalplanner/web/planner/company/CompanyPlanningModel.java
@@ -41,7 +41,7 @@ import java.util.TreeMap;
 
 import org.joda.time.LocalDate;
 import org.navalplanner.business.calendars.entities.BaseCalendar;
-import org.navalplanner.business.calendars.entities.IWorkHours;
+import org.navalplanner.business.calendars.entities.ICalendar;
 import org.navalplanner.business.calendars.entities.SameWorkHoursEveryDay;
 import org.navalplanner.business.common.IAdHocTransactionService;
 import org.navalplanner.business.common.IOnTransaction;
@@ -894,7 +894,7 @@ public abstract class CompanyPlanningModel implements ICompanyPlanningModel {
 
                 private EffortDuration getOverloadAt(LocalDate day,
                         Resource resource, EffortDuration assignedDuration) {
-                    IWorkHours calendar = resource.getCalendarOrDefault();
+                    ICalendar calendar = resource.getCalendarOrDefault();
                     EffortDuration workableDuration = calendar
                             .getCapacityDurationAt(day);
                     if (assignedDuration.compareTo(workableDuration) > 0) {