DesignDayGridView.cpp

/***********************************************************************************************************************
*  OpenStudio(R), Copyright (c) OpenStudio Coalition and other contributors.
*  See also https://openstudiocoalition.org/about/software_license/
***********************************************************************************************************************/

#include "DesignDayGridView.hpp"

#include "../shared_gui_components/OSCheckBox.hpp"
#include "../shared_gui_components/OSGridView.hpp"
#include "../shared_gui_components/OSObjectSelector.hpp"

#include "ModelObjectItem.hpp"
#include "OSAppBase.hpp"
#include "OSDocument.hpp"
#include "OSDropZone.hpp"

#include <openstudio/model/DesignDay.hpp>
#include <openstudio/model/DesignDay_Impl.hpp>
#include <openstudio/model/ScheduleDay.hpp>
#include <openstudio/model/ScheduleDay_Impl.hpp>

#include <openstudio/utilities/core/Compare.hpp>
#include <openstudio/utilities/idd/IddEnums.hxx>
#include <openstudio/utilities/idd/SizingPeriod_DesignDay_FieldEnums.hxx>

#include <QBoxLayout>
#include <QCheckBox>
#include <QLabel>
#include <QScrollArea>
#include <QSettings>
#include <QTimer>

// These defines provide a common area for field display names
// used on column headers, and other grid widgets

#define NAME openstudio::DesignDayGridView::tr("Design Day Name")
#define SELECTED openstudio::DesignDayGridView::tr("All")

// DATE
#define DAYOFMONTH openstudio::DesignDayGridView::tr("Day Of Month")
#define MONTH openstudio::DesignDayGridView::tr("Month")
#define DAYTYPE openstudio::DesignDayGridView::tr("Day Type")
#define DAYLIGHTSAVINGTIMEINDICATOR openstudio::DesignDayGridView::tr("Daylight Saving Time Indicator")

// TEMPERATURE
#define MAXIMUMDRYBULBTEMPERATURE openstudio::DesignDayGridView::tr("Maximum Dry Bulb Temperature")
#define DAILYDRYBULBTEMPERATURERANGE openstudio::DesignDayGridView::tr("Daily Dry Bulb Temperature Range")
#define DAILYWETBULBTEMPERATURERANGE openstudio::DesignDayGridView::tr("Daily Wet Bulb Temperature Range")
#define DRYBULBTEMPERATURERANGEMODIFIERTYPE openstudio::DesignDayGridView::tr("Dry Bulb Temperature Range Modifier Type")
#define DRYBULBTEMPERATURERANGEMODIFIERSCHEDULE openstudio::DesignDayGridView::tr("Dry Bulb Temperature Range Modifier Schedule")

// HUMIDITY
#define HUMIDITYINDICATINGCONDITIONSATMAXIMUMDRYBULB openstudio::DesignDayGridView::tr("Humidity Indicating Conditions At Maximum Dry Bulb")
#define HUMIDITYINDICATINGTYPE openstudio::DesignDayGridView::tr("Humidity Indicating Type")
#define HUMIDITYINDICATINGDAYSCHEDULE openstudio::DesignDayGridView::tr("Humidity Indicating Day Schedule")

// PRESSURE / WIND / PRECIP
#define BAROMETRICPRESSURE openstudio::DesignDayGridView::tr("Barometric Pressure")
#define WINDSPEED openstudio::DesignDayGridView::tr("Wind Speed")
#define WINDDIRECTION openstudio::DesignDayGridView::tr("Wind Direction")
#define RAININDICATOR openstudio::DesignDayGridView::tr("Rain Indicator")
#define SNOWINDICATOR openstudio::DesignDayGridView::tr("Snow Indicator")

// SOLAR
#define SOLARMODELINDICATOR openstudio::DesignDayGridView::tr("Solar Model Indicator")
#define BEAMSOLARDAYSCHEDULE openstudio::DesignDayGridView::tr("Beam Solar Day Schedule")
#define DIFFUSESOLARDAYSCHEDULE openstudio::DesignDayGridView::tr("Diffuse Solar Day Schedule")
#define ASHRAETAUB openstudio::DesignDayGridView::tr("ASHRAE Taub")
#define ASHRAETAUD openstudio::DesignDayGridView::tr("ASHRAE Taud")
#define SKYCLEARNESS openstudio::DesignDayGridView::tr("Sky Clearness")

namespace openstudio {

DesignDayGridView::DesignDayGridView(bool isIP, const model::Model& model, QWidget* parent) : QWidget(parent), m_isIP(isIP) {
  auto* layout = new QVBoxLayout();
  layout->setSpacing(0);
  layout->setContentsMargins(0, 0, 0, 0);
  setLayout(layout);

  auto designDays = model.getConcreteModelObjects<model::DesignDay>();
  auto designDayModelObjects = subsetCastVector<model::ModelObject>(designDays);

  m_gridController = new DesignDayGridController(m_isIP, tr("Design Days"), IddObjectType::OS_SizingPeriod_DesignDay, model, designDayModelObjects);
  m_gridView = new OSGridView(m_gridController, tr("Design Days"), tr("Drop\nZone"), true, parent);

  connect(m_gridView, &OSGridView::dropZoneItemClicked, this, &DesignDayGridView::dropZoneItemClicked);

  //isConnected = connect(this, SIGNAL(itemSelected(OSItem *)), gridView, SIGNAL(itemSelected(OSItem*)));
  //OS_ASSERT(isConnected);
  //isConnected = connect(this, SIGNAL(selectionCleared()), gridView, SLOT(onSelectionCleared()));
  //OS_ASSERT(isConnected);
  //isConnected = connect(gridView, SIGNAL(gridRowSelected(OSItem*)), this, SIGNAL(gridRowSelected(OSItem*)));
  //OS_ASSERT(isConnected);

  m_gridView->showDropZone(false);

  layout->addWidget(m_gridView, 0, Qt::AlignTop);

  layout->addStretch(1);

  connect(this, &DesignDayGridView::toggleUnitsClicked, m_gridController, &DesignDayGridController::toggleUnitsClicked);

  connect(this, &DesignDayGridView::toggleUnitsClicked, m_gridController, &DesignDayGridController::onToggleUnits);
}

void DesignDayGridView::onAddClicked() {
  // Always make at least one
  if (m_gridController->selectedObjects().empty()) {
    model::DesignDay(m_gridController->model());
  } else {
    for (const auto& obj : m_gridController->selectedObjects()) {
      // TODO: copy properties of selected to new?
      addObject(obj);
    }
  }
}

void DesignDayGridView::onCopyClicked() {
  for (const auto& obj : m_gridController->selectedObjects()) {
    if (!obj.handle().isNull()) {
      copyObject(obj);
    }
  }
}

void DesignDayGridView::onRemoveClicked() {
  for (const auto& obj : m_gridController->selectedObjects()) {
    removeObject(obj);
  }
}

void DesignDayGridView::onPurgeClicked() {
  purgeObjects(IddObjectType::OS_SizingPeriod_DesignDay);
}

void DesignDayGridView::addObject(const model::ModelObject& /*modelObject*/) {
  model::DesignDay(m_gridController->model());
}

void DesignDayGridView::copyObject(const openstudio::model::ModelObject& modelObject) {
  modelObject.clone(m_gridController->model());
}

void DesignDayGridView::removeObject(openstudio::model::ModelObject modelObject) {
  modelObject.remove();
}

void DesignDayGridView::purgeObjects(const IddObjectType& /*iddObjectType*/) {
  for (auto& mo : m_gridController->model().getConcreteModelObjects<model::DesignDay>()) {
    mo.remove();
  }
}

std::set<model::ModelObject> DesignDayGridView::selectedObjects() const {
  return m_gridController->selectedObjects();
}

DesignDayGridController::DesignDayGridController(bool isIP, const QString& headerText, IddObjectType iddObjectType, const model::Model& model,
                                                 const std::vector<model::ModelObject>& modelObjects)
  : OSGridController(isIP, headerText, iddObjectType, model, modelObjects) {
  setCategoriesAndFields();
}

void DesignDayGridController::setCategoriesAndFields() {
  {
    std::vector<QString> fields{
      DAYOFMONTH,
      MONTH,
      DAYTYPE,
      DAYLIGHTSAVINGTIMEINDICATOR,
    };
    std::pair<QString, std::vector<QString>> categoryAndFields = std::make_pair(tr("Date"), fields);
    addCategoryAndFields(categoryAndFields);
  }

  {
    std::vector<QString> fields{
      MAXIMUMDRYBULBTEMPERATURE,
      DAILYDRYBULBTEMPERATURERANGE,
      DAILYWETBULBTEMPERATURERANGE,
      DRYBULBTEMPERATURERANGEMODIFIERTYPE,
      DRYBULBTEMPERATURERANGEMODIFIERSCHEDULE,
    };
    std::pair<QString, std::vector<QString>> categoryAndFields = std::make_pair(tr("Temperature"), fields);
    addCategoryAndFields(categoryAndFields);
  }

  {
    std::vector<QString> fields{
      HUMIDITYINDICATINGCONDITIONSATMAXIMUMDRYBULB,
      HUMIDITYINDICATINGTYPE,
      HUMIDITYINDICATINGDAYSCHEDULE,
    };
    std::pair<QString, std::vector<QString>> categoryAndFields = std::make_pair(tr("Humidity"), fields);
    addCategoryAndFields(categoryAndFields);
  }

  {
    std::vector<QString> fields{
      BAROMETRICPRESSURE, WINDSPEED, WINDDIRECTION, RAININDICATOR, SNOWINDICATOR,
    };
    std::pair<QString, std::vector<QString>> categoryAndFields = std::make_pair(tr("Pressure\nWind\nPrecipitation"), fields);
    addCategoryAndFields(categoryAndFields);
  }

  {
    std::vector<QString> fields{
      SOLARMODELINDICATOR, BEAMSOLARDAYSCHEDULE, DIFFUSESOLARDAYSCHEDULE, ASHRAETAUB, ASHRAETAUD, SKYCLEARNESS,
    };
    std::pair<QString, std::vector<QString>> categoryAndFields = std::make_pair(tr("Solar"), fields);
    addCategoryAndFields(categoryAndFields);
  }

  OSGridController::setCategoriesAndFields();
}

void DesignDayGridController::addColumns(const QString& /*category*/, std::vector<QString>& fields) {
  // always show name column
  fields.insert(fields.begin(), {NAME, SELECTED});

  resetBaseConcepts();

  for (const QString& field : fields) {
    // Evan note: addCheckBoxColumn does not yet handle reset and default
    if (field == DAYLIGHTSAVINGTIMEINDICATOR) {
      // We add the "Apply Selected" button to this column by passing 3rd arg, t_showColumnButton=true
      addCheckBoxColumn(Heading(DAYLIGHTSAVINGTIMEINDICATOR, true, true), std::string("Check to enable daylight saving time indicator."),
                        NullAdapter(&model::DesignDay::daylightSavingTimeIndicator), NullAdapter(&model::DesignDay::setDaylightSavingTimeIndicator));
    } else if (field == RAININDICATOR) {
      // We add the "Apply Selected" button to this column by passing 3rd arg, t_showColumnButton=true
      addCheckBoxColumn(Heading(RAININDICATOR, true, true), std::string("Check to enable rain indicator."),
                        NullAdapter(&model::DesignDay::rainIndicator), NullAdapter(&model::DesignDay::setRainIndicator));
    } else if (field == SNOWINDICATOR) {
      // We add the "Apply Selected" button to this column by passing 3rd arg, t_showColumnButton=true
      addCheckBoxColumn(Heading(SNOWINDICATOR, true, true), std::string("Check to enable snow indicator."),
                        NullAdapter(&model::DesignDay::snowIndicator), NullAdapter(&model::DesignDay::setSnowIndicator));
    } else if (field == SELECTED) {
      auto checkbox = QSharedPointer<OSSelectAllCheckBox>(new OSSelectAllCheckBox());
      checkbox->setToolTip(tr("Check to select all rows"));
      connect(checkbox.data(), &OSSelectAllCheckBox::checkStateChanged, this, &DesignDayGridController::onSelectAllStateChanged);
      connect(this, &DesignDayGridController::gridRowSelectionChanged, checkbox.data(), &OSSelectAllCheckBox::onGridRowSelectionChanged);
      addSelectColumn(Heading(SELECTED, false, false, checkbox), "Check to select this row");
    }
    // INTEGER
    else if (field == DAYOFMONTH) {
      addValueEditColumn(
        Heading(DAYOFMONTH), NullAdapter(&model::DesignDay::dayOfMonth), NullAdapter(&model::DesignDay::setDayOfMonth),
        boost::optional<std::function<void(model::DesignDay*)>>(CastNullAdapter<model::DesignDay>(&model::DesignDay::resetDayOfMonth)),
        boost::optional<std::function<bool(model::DesignDay*)>>(CastNullAdapter<model::DesignDay>(&model::DesignDay::isDayOfMonthDefaulted)),
        boost::optional<DataSource>());
    } else if (field == MONTH) {
      addValueEditColumn(
        Heading(MONTH), NullAdapter(&model::DesignDay::month), NullAdapter(&model::DesignDay::setMonth),
        boost::optional<std::function<void(model::DesignDay*)>>(CastNullAdapter<model::DesignDay>(&model::DesignDay::resetMonth)),
        boost::optional<std::function<bool(model::DesignDay*)>>(CastNullAdapter<model::DesignDay>(&model::DesignDay::isMonthDefaulted)),
        boost::optional<DataSource>());
    }
    // DOUBLE
    else if (field == SKYCLEARNESS) {
      addValueEditColumn(
        Heading(SKYCLEARNESS), NullAdapter(&model::DesignDay::skyClearness), NullAdapter(&model::DesignDay::setSkyClearness),
        boost::optional<std::function<void(model::DesignDay*)>>(CastNullAdapter<model::DesignDay>(&model::DesignDay::resetSkyClearness)),
        boost::optional<std::function<bool(model::DesignDay*)>>(CastNullAdapter<model::DesignDay>(&model::DesignDay::isSkyClearnessDefaulted)),
        boost::optional<DataSource>());
    } else if (field == ASHRAETAUB) {
      addValueEditColumn(Heading(ASHRAETAUB), NullAdapter(&model::DesignDay::ashraeClearSkyOpticalDepthForBeamIrradiance),
                         NullAdapter(&model::DesignDay::setAshraeClearSkyOpticalDepthForBeamIrradiance),
                         boost::optional<std::function<void(model::DesignDay*)>>(
                           CastNullAdapter<model::DesignDay>(&model::DesignDay::resetAshraeClearSkyOpticalDepthForBeamIrradiance)),
                         boost::optional<std::function<bool(model::DesignDay*)>>(
                           CastNullAdapter<model::DesignDay>(&model::DesignDay::isAshraeClearSkyOpticalDepthForBeamIrradianceDefaulted)),
                         boost::optional<DataSource>());
    } else if (field == ASHRAETAUD) {
      addValueEditColumn(Heading(ASHRAETAUD), NullAdapter(&model::DesignDay::ashraeClearSkyOpticalDepthForDiffuseIrradiance),
                         NullAdapter(&model::DesignDay::setAshraeClearSkyOpticalDepthForDiffuseIrradiance),
                         boost::optional<std::function<void(model::DesignDay*)>>(
                           CastNullAdapter<model::DesignDay>(&model::DesignDay::resetAshraeClearSkyOpticalDepthForDiffuseIrradiance)),
                         boost::optional<std::function<bool(model::DesignDay*)>>(
                           CastNullAdapter<model::DesignDay>(&model::DesignDay::isAshraeClearSkyOpticalDepthForDiffuseIrradianceDefaulted)),
                         boost::optional<DataSource>());
    } else if (field == WINDDIRECTION) {
      addValueEditColumn(
        Heading(WINDDIRECTION), NullAdapter(&model::DesignDay::windDirection), NullAdapter(&model::DesignDay::setWindDirection),
        boost::optional<std::function<void(model::DesignDay*)>>(CastNullAdapter<model::DesignDay>(&model::DesignDay::resetWindDirection)),
        boost::optional<std::function<bool(model::DesignDay*)>>(CastNullAdapter<model::DesignDay>(&model::DesignDay::isWindDirectionDefaulted)),
        boost::optional<DataSource>());
    }
    // STRING
    else if (field == NAME) {
      addParentNameLineEditColumn(Heading(NAME, false, false), false, CastNullAdapter<model::DesignDay>(&model::DesignDay::name),
                                  CastNullAdapter<model::DesignDay>(&model::DesignDay::setName));
    } else if (field == MAXIMUMDRYBULBTEMPERATURE) {
      addQuantityEditColumn(
        Heading(MAXIMUMDRYBULBTEMPERATURE), QString("C"), QString("C"), QString("F"), isIP(),
        NullAdapter(&model::DesignDay::maximumDryBulbTemperature), NullAdapter(&model::DesignDay::setMaximumDryBulbTemperature),
        boost::optional<std::function<void(model::DesignDay*)>>(CastNullAdapter<model::DesignDay>(&model::DesignDay::resetMaximumDryBulbTemperature)),
        boost::optional<std::function<bool(model::DesignDay*)>>(
          CastNullAdapter<model::DesignDay>(&model::DesignDay::isMaximumDryBulbTemperatureDefaulted)),
        boost::optional<DataSource>());
    } else if (field == DAILYDRYBULBTEMPERATURERANGE) {
      addQuantityEditColumn(Heading(DAILYDRYBULBTEMPERATURERANGE), QString("K"), QString("K"), QString("R"), isIP(),
                            NullAdapter(&model::DesignDay::dailyDryBulbTemperatureRange),
                            NullAdapter(&model::DesignDay::setDailyDryBulbTemperatureRange),
                            boost::optional<std::function<void(model::DesignDay*)>>(
                              CastNullAdapter<model::DesignDay>(&model::DesignDay::resetDailyDryBulbTemperatureRange)),
                            boost::optional<std::function<bool(model::DesignDay*)>>(
                              CastNullAdapter<model::DesignDay>(&model::DesignDay::isDailyDryBulbTemperatureRangeDefaulted)),
                            boost::optional<DataSource>());
    }

    // This should be reset when the humidity indication condition type is changed to something incompatible
    else if (field == HUMIDITYINDICATINGCONDITIONSATMAXIMUMDRYBULB) {
      // This was replaced by three separate numeric fields, which is harder to fit on the tab, so for now just disabling the deprecated warnings

#if defined(_MSC_VER)
#  pragma warning(push)
#  pragma warning(disable : 4996)
#elif (defined(__GNUC__))
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
      addQuantityEditColumn(Heading(HUMIDITYINDICATINGCONDITIONSATMAXIMUMDRYBULB), QString("C"), QString("C"), QString("F"), isIP(),
                            NullAdapter(&model::DesignDay::humidityIndicatingConditionsAtMaximumDryBulb),
                            NullAdapter(&model::DesignDay::setHumidityIndicatingConditionsAtMaximumDryBulb),
                            boost::optional<std::function<void(model::DesignDay*)>>(
                              CastNullAdapter<model::DesignDay>(&model::DesignDay::resetHumidityIndicatingConditionsAtMaximumDryBulb)),
                            boost::optional<std::function<bool(model::DesignDay*)>>(
                              CastNullAdapter<model::DesignDay>(&model::DesignDay::isHumidityIndicatingConditionsAtMaximumDryBulbDefaulted)),
                            boost::optional<DataSource>());
#if defined(_MSC_VER)
#  pragma warning(pop)
#elif (defined(__GNUC__))
#  pragma GCC diagnostic pop
#endif
    }

    else if (field == BAROMETRICPRESSURE) {
      addQuantityEditColumn(
        Heading(BAROMETRICPRESSURE), QString("Pa"), QString("Pa"), QString("inHg"), isIP(), NullAdapter(&model::DesignDay::barometricPressure),
        NullAdapter(&model::DesignDay::setBarometricPressure),
        boost::optional<std::function<void(model::DesignDay*)>>(CastNullAdapter<model::DesignDay>(&model::DesignDay::resetBarometricPressure)),
        boost::optional<std::function<bool(model::DesignDay*)>>(CastNullAdapter<model::DesignDay>(&model::DesignDay::isBarometricPressureDefaulted)),
        boost::optional<DataSource>());
    } else if (field == WINDSPEED) {
      addQuantityEditColumn(
        Heading(WINDSPEED), QString("m/s"), QString("m/s"), QString("miles/hr"), isIP(), NullAdapter(&model::DesignDay::windSpeed),
        NullAdapter(&model::DesignDay::setWindSpeed),
        boost::optional<std::function<void(model::DesignDay*)>>(CastNullAdapter<model::DesignDay>(&model::DesignDay::resetWindSpeed)),
        boost::optional<std::function<bool(model::DesignDay*)>>(CastNullAdapter<model::DesignDay>(&model::DesignDay::isWindSpeedDefaulted)),
        boost::optional<DataSource>());
    } else if (field == DAILYWETBULBTEMPERATURERANGE) {
      addQuantityEditColumn(Heading(DAILYWETBULBTEMPERATURERANGE), QString("K"), QString("K"), QString("R"), isIP(),
                            NullAdapter(&model::DesignDay::dailyWetBulbTemperatureRange),
                            NullAdapter(&model::DesignDay::setDailyWetBulbTemperatureRange));
    } else if (field == DAYTYPE) {
      addComboBoxColumn<std::string, model::DesignDay>(
        Heading(DAYTYPE), static_cast<std::string (*)(const std::string&)>(&openstudio::toString),
        std::function<std::vector<std::string>()>(&model::DesignDay::validDayTypeValues),
        CastNullAdapter<model::DesignDay>(&model::DesignDay::dayType), CastNullAdapter<model::DesignDay>(&model::DesignDay::setDayType),
        CastNullAdapter<model::DesignDay>(&model::DesignDay::resetDayType), CastNullAdapter<model::DesignDay>(&model::DesignDay::isDayTypeDefaulted),
        boost::optional<DataSource>());
    } else if (field == DRYBULBTEMPERATURERANGEMODIFIERTYPE) {
      addComboBoxColumn<std::string, model::DesignDay>(
        Heading(DRYBULBTEMPERATURERANGEMODIFIERTYPE), static_cast<std::string (*)(const std::string&)>(&openstudio::toString),
        std::function<std::vector<std::string>()>(&model::DesignDay::validDryBulbTemperatureRangeModifierTypeValues),
        CastNullAdapter<model::DesignDay>(&model::DesignDay::dryBulbTemperatureRangeModifierType),
        CastNullAdapter<model::DesignDay>(&model::DesignDay::setDryBulbTemperatureRangeModifierType),
        CastNullAdapter<model::DesignDay>(&model::DesignDay::resetDryBulbTemperatureRangeModifierType),
        CastNullAdapter<model::DesignDay>(&model::DesignDay::isDryBulbTemperatureRangeModifierTypeDefaulted), boost::optional<DataSource>());
    } else if (field == HUMIDITYINDICATINGTYPE) {
      // I don't see any problem here, yet the box stays empty. Checked the ReverseTranslator, it does its job too
      addComboBoxColumn<std::string, model::DesignDay>(
        Heading(HUMIDITYINDICATINGTYPE), static_cast<std::string (*)(const std::string&)>(&openstudio::toString),
        std::function<std::vector<std::string>()>(&model::DesignDay::validHumidityConditionTypeValues),
        CastNullAdapter<model::DesignDay>(&model::DesignDay::humidityConditionType),
        CastNullAdapter<model::DesignDay>(&model::DesignDay::setHumidityConditionType),
        CastNullAdapter<model::DesignDay>(&model::DesignDay::resetHumidityConditionType),
        CastNullAdapter<model::DesignDay>(&model::DesignDay::isHumidityConditionTypeDefaulted), boost::optional<DataSource>());
    } else if (field == SOLARMODELINDICATOR) {
      addComboBoxColumn<std::string, model::DesignDay>(
        Heading(SOLARMODELINDICATOR), static_cast<std::string (*)(const std::string&)>(&openstudio::toString),
        std::function<std::vector<std::string>()>(&model::DesignDay::validSolarModelIndicatorValues),
        CastNullAdapter<model::DesignDay>(&model::DesignDay::solarModelIndicator),
        CastNullAdapter<model::DesignDay>(&model::DesignDay::setSolarModelIndicator),
        CastNullAdapter<model::DesignDay>(&model::DesignDay::resetSolarModelIndicator),
        CastNullAdapter<model::DesignDay>(&model::DesignDay::isSolarModelIndicatorDefaulted), boost::optional<DataSource>());
    } else if (field == DRYBULBTEMPERATURERANGEMODIFIERSCHEDULE) {
      addDropZoneColumn(Heading(DRYBULBTEMPERATURERANGEMODIFIERSCHEDULE),
                        CastNullAdapter<model::DesignDay>(&model::DesignDay::dryBulbTemperatureRangeModifierDaySchedule),
                        CastNullAdapter<model::DesignDay>(&model::DesignDay::setDryBulbTemperatureRangeModifierDaySchedule),
                        boost::optional<std::function<void(model::DesignDay*)>>(
                          CastNullAdapter<model::DesignDay>(&model::DesignDay::resetDryBulbTemperatureRangeModifierDaySchedule)));
    }

    else if (field == BEAMSOLARDAYSCHEDULE) {
      addDropZoneColumn(
        Heading(BEAMSOLARDAYSCHEDULE), CastNullAdapter<model::DesignDay>(&model::DesignDay::beamSolarDaySchedule),
        CastNullAdapter<model::DesignDay>(&model::DesignDay::setBeamSolarDaySchedule),
        boost::optional<std::function<void(model::DesignDay*)>>(CastNullAdapter<model::DesignDay>(&model::DesignDay::resetBeamSolarDaySchedule)));
    }

    else if (field == HUMIDITYINDICATINGDAYSCHEDULE) {
      addDropZoneColumn(Heading(HUMIDITYINDICATINGDAYSCHEDULE), CastNullAdapter<model::DesignDay>(&model::DesignDay::humidityConditionDaySchedule),
                        CastNullAdapter<model::DesignDay>(&model::DesignDay::setHumidityConditionDaySchedule),
                        boost::optional<std::function<void(model::DesignDay*)>>(
                          CastNullAdapter<model::DesignDay>(&model::DesignDay::resetHumidityConditionDaySchedule)));
    }

    else if (field == DIFFUSESOLARDAYSCHEDULE) {
      addDropZoneColumn(
        Heading(DIFFUSESOLARDAYSCHEDULE), CastNullAdapter<model::DesignDay>(&model::DesignDay::diffuseSolarDaySchedule),
        CastNullAdapter<model::DesignDay>(&model::DesignDay::setDiffuseSolarDaySchedule),
        boost::optional<std::function<void(model::DesignDay*)>>(CastNullAdapter<model::DesignDay>(&model::DesignDay::resetDiffuseSolarDaySchedule)));
    } else {
      // unhandled
      OS_ASSERT(false);
    }
  }
}

QString DesignDayGridController::getColor(const model::ModelObject& /*modelObject*/) {
  QColor defaultColor(Qt::lightGray);
  QString color(defaultColor.name());

  return color;
}

void DesignDayGridController::checkSelectedFields() {
  if (!this->hasHorizontalHeader()) {
    return;
  }

  OSGridController::checkSelectedFields();
}

void DesignDayGridController::onItemDropped(const OSItemId& itemId) {
  boost::optional<model::ModelObject> modelObject = OSAppBase::instance()->currentDocument()->getModelObject(itemId);
  if (modelObject) {
    if (modelObject->optionalCast<model::DesignDay>()) {
      modelObject->clone(model());
    }
  }
}

void DesignDayGridController::refreshModelObjects() {
  auto designDays = model().getConcreteModelObjects<model::DesignDay>();
  std::sort(designDays.begin(), designDays.end(), openstudio::WorkspaceObjectNameLess());
  setModelObjects(subsetCastVector<model::ModelObject>(designDays));
}

void DesignDayGridController::onComboBoxIndexChanged(int index) {}

}  // namespace openstudio