// $Id: RepGenSlotHtml.cpp,v 1.10 2010/11/11 01:47:57 philw Exp $
//
//   class RepGenSlotHtml : public RepGenSlot
//
//--

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

static const char* HeaderBackgroundColor ("#d8d8d8");
static const char* ColMapBackgroundColor ("#ffffd8");

static const int MAX_SLOT_DATA_ROWS (300);

#ifndef RepGenSlotHtmlINCLUDED
#include "RepGenSlotHtml.hpp"
#endif

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

#ifndef RwModelReportINCLUDED
#include "RwModelReport.hpp"
#endif

#ifndef RepGenUtilsINCLUDED
#include "RepGenUtils.hpp"
#endif

#ifndef cwfstreamINCLUDED
#include "cwfstream.hpp"
#endif

#ifndef SlotINCLUDED
#include "Slot.hpp"
#endif

#ifndef SeriesSlotINCLUDED
#include "SeriesSlot.hpp"
#endif

#ifndef ListSlotINCLUDED
#include "ListSlot.hpp"
#endif

#ifndef SlotColRefINCLUDED
#include "SlotColRef.hpp"
#endif

#ifndef SimObjINCLUDED
#include "SimObj.hpp"
#endif

#ifndef SlotGUIUtilsINCLUDED
#include "SlotGUIUtils.hpp"
#endif

#include "rwStr.hpp"

#include <QString>

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

static const QString nbspQstr ("&nbsp;");

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

// constructor 1 of 1
RepGenSlotHtml::RepGenSlotHtml (RwModelReport* rep, const Slot* slotPtr)
  : RepGenSlot (rep, slotPtr)
{
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

RepGenSlotHtml::~RepGenSlotHtml()
{
   _modelReport = NULL;
   _slot = NULL;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

// virtual from RepGenSlot
void RepGenSlotHtml::writeSlotListHeader (SlotListType slotListType,
                                          const QString& slotColLabel,
                                          int indentLev, 
                                          cwofstream& os) const
{
   const QString indentStr (indentLev, QChar (' '));  // Indent String

   static const QString listRowTempl_ScalarSlot (
     "INDENT<tr bgcolor=\"%1\">\n"
     "INDENT <td colspan=\"3\"><b>%2</b></td>\n"  // type icons / name
     "INDENT <td><b>Value</b></td>\n"             // slot value
     "INDENT <td><b>Units</b></td>\n"             // slot units
     "INDENT</tr>" );
   
   static const QString listRowTempl_SeriesSlot (
     "INDENT<tr bgcolor=\"%1\">\n"
     "INDENT <td colspan=\"3\"><b>%2</b></td>\n"  // type icons / slot name
     "INDENT <td><b>Units</b></td>\n"             // slot units
     "INDENT <td><b>Rows</b></td>\n"              // slot row count
     "INDENT <td><b>Cols</b></td>\n"              // slot column count
     "INDENT <td><b>Step</b></td>\n"              // series step size
     "INDENT <td><b>Start</b></td>\n"             // start date
     "INDENT <td><b>End</b></td>\n"               // end date
     "INDENT</tr>" );

   static const QString listRowTempl_OtherSlot (
     "INDENT<tr bgcolor=\"%1\">\n"
     "INDENT <td colspan=\"3\"><b>%2</b></td>\n"  // type icons / slot name
     "INDENT <td><b>Rows</b></td>\n"              // slot row count
     "INDENT <td><b>Cols</b></td>\n"              // slot column count
     "INDENT <td><b>Column Labels</b></td>\n"     // slot column labels
     "INDENT</tr>" );

   QString formatStr ("");
   switch (slotListType)
   {
      case SlotList_Scalar: formatStr = listRowTempl_ScalarSlot;  break;
      case SlotList_Series: formatStr = listRowTempl_SeriesSlot;  break;
      case SlotList_Other:  formatStr = listRowTempl_OtherSlot;   break;
   }

   formatStr.replace (QString ("INDENT"), indentStr);

   const QString html = formatStr 
                        .arg (HeaderBackgroundColor)
                        .arg (slotColLabel);

   os << qPrintable (html) << endl;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

// virtual from RepGenSlot
void RepGenSlotHtml::writeSlotListRow (SlotListType slotListType,
                                       int indentLevel, cwofstream& os) const
{
   static const char (*mname) ("RepGenSlotHtml::writeScalarSlotListRow");

   if (_slot == NULL) return;
   //---------------------->>

   static const QString IconAndNameTD_Templ (
     "INDENT <td>T_OBJ_ICON</td>\n"                  // obj type icon
     "INDENT <td>T_SLOT_ICON</td>\n"                 // slot type icon
     "INDENT <td>T_SLOT_NAME</td>\n" );              // slot name (no link)

   static const QString ValueTD_Templ ( "INDENT <td Align_RT>T_VALUE</td>\n" );
   static const QString UnitsTD_Templ ( "INDENT <td>T_UNITS</td>\n" );
   static const QString RowsTD_Templ  ( "INDENT <td Align_RT>T_ROWS</td>\n" );
   static const QString ColsTD_Templ  ( "INDENT <td Align_RT>T_COLS</td>\n" );
   static const QString LabsTD_Templ  ( "INDENT <td>T_LABS</td>\n" );
   static const QString StepTD_Templ  ( "INDENT <td>T_STEP</td>\n" );
   static const QString StartTD_Templ ( "INDENT <td>T_START</td>\n" );
   static const QString EndTD_Templ   ( "INDENT <td>T_END</td>\n" );

   QString tabDatElement (IconAndNameTD_Templ);  // three columns

   switch (slotListType)
   {
      case SlotList_Scalar:
         tabDatElement += ValueTD_Templ; 
         tabDatElement += UnitsTD_Templ; 
         break;

      case SlotList_Series:
         tabDatElement += UnitsTD_Templ; 
         tabDatElement += RowsTD_Templ; 
         tabDatElement += ColsTD_Templ; 
         tabDatElement += StepTD_Templ; 
         tabDatElement += StartTD_Templ; 
         tabDatElement += EndTD_Templ; 
         break;

      case SlotList_Other:
         tabDatElement += RowsTD_Templ; 
         tabDatElement += ColsTD_Templ; 
         tabDatElement += LabsTD_Templ; 
         break;
   }

   QString tabRowElement = 
      QString ("INDENT<tr>\n%1"
               "INDENT</tr>\n") .arg (tabDatElement);
                                    
   // Indentation Substitution
   const QString indentStr (indentLevel, QChar (' '));  // Indent String
   tabRowElement.replace (QString ("INDENT"), indentStr);

   // Align-Right TD Attribute
   tabRowElement.replace (QString ("Align_RT"), "align=\"right\"");

   // HTML IMG ALIGN ATTRIBUTE
   static const QString iconAlignText ("");  // (No align attribute)

   const QString objIconHtml =
      RepGen::html_icon (objImgFileHtml(), objImgSize(), 0, objTypHtml(), 
                         iconAlignText);

   const QString objUrl = RepGen::localSimObjUrl (_slot->getSimObj());
   const QString objIconLinkHtml = RepGen::html_link (objIconHtml, objUrl);

   const QString slotIconHtml =
      RepGen::html_icon (slotImgFileHtml(), slotImgSize(), 0, slotTypHtml(), 
                         iconAlignText);

   QString slotNameHtmlStr (slotNameHtml());  // tentative
   const bool linkSlot (slotDetailSupported());
   if (linkSlot)
   {
      const QString slotUrl = RepGen::localSlotUrl (_slot, true); // quoted
      slotNameHtmlStr = QString ("<a href=%1>%2</a>")
                        .arg (slotUrl)
                        .arg (slotNameHtml());
   }

   tabRowElement.replace (QString ("T_OBJ_ICON"),  objIconLinkHtml);
   tabRowElement.replace (QString ("T_SLOT_ICON"), slotIconHtml);
   tabRowElement.replace (QString ("T_SLOT_NAME"), slotNameHtmlStr);
   tabRowElement.replace (QString ("T_VALUE"),     slotValHtml());
   tabRowElement.replace (QString ("T_UNITS"),     slotUnitsHtml (false));
   tabRowElement.replace (QString ("T_ROWS"),      slotRowsHtml());
   tabRowElement.replace (QString ("T_COLS"),      slotColsHtml());
   tabRowElement.replace (QString ("T_LABS"),      slotLabelsHtml());
   tabRowElement.replace (QString ("T_STEP"),      seriesStepHtml());
   tabRowElement.replace (QString ("T_START"),     seriesStartHtml());
   tabRowElement.replace (QString ("T_END"),       seriesEndHtml());

   os << qPrintable (tabRowElement) << endl;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

// private
void RepGenSlotHtml::writeSlotDetailTitleSection (cwofstream& os)
{
   if (_slot == NULL) return;
   //---------------------->>

   SimObj* obj (_slot->getSimObj());  // may be NULL

   // ********************************
   // ***  Slot HTML Named Anchor  ***
   // ********************************

   const QString objName = (obj ? obj->getCompleteName() : "SimObj");
   const QString slotName = _slot->getName();
   const QString fullSlotName = _slot->getCompleteName();
   const QString slotMunge = RepGen::reduceNameString (fullSlotName);
   const QString slotAnchor = QString ("<a name=\"%1\"></a>") .arg (slotMunge);

   QString fullSlotTitle (fullSlotName);
   fullSlotTitle.replace (QChar ('.'), QString (" . "));

   os << qPrintable (slotAnchor) << endl;

   // ****************************
   // ***  Slot Detail Header  ***
   // ****************************

   static const QString fmt (
     "<table cellpadding=\"0\" cellspacing=\"0\" border=\"0\">\n"
     " <tr>\n"
     "  <td>&nbsp;&nbsp;</td>\n"
     "  <td>\n"
     "   <table cellpadding=\"0\" cellspacing=\"0\" border=\"0\">\n"
     "    <tr>\n"
     "     <td align=\"right\"><font size=\"+2\">Object: &nbsp;</font></td>\n" 
     "     <td><font size=\"+2\">%1</font></td>\n" 
     "    </tr>\n"
     "    <tr>\n"
     "     <td align=\"right\"><font size=\"+2\">Slot: &nbsp;</font></td>\n" 
     "     <td><font size=\"+2\">%2</font></td>\n" 
     "    </tr>\n"
     "    <tr>\n"
     "     <td>&nbsp;</td>\n" 
     "     <td>\n" 
     "      <table cellpadding=\"0\" cellspacing=\"0\" border=\"0\">\n"
     "       <tr>\n"
     "        <td>%3</td>\n"
     "        <td>&nbsp;</td>\n"
     "        <td>%4</td>\n"
     "        <td>&nbsp;&nbsp;</td>\n"
     "        <td>%5</td>\n"
     "        <td>&nbsp;</td>\n"
     "        <td>%6</td>\n"
     "       </tr>\n"
     "      </table>\n"
     "     </td>\n" 
     "    </tr>\n"
     "   </table>\n"
     "  </td>\n"
     "  <td>&nbsp;&nbsp;&nbsp;</td>\n"
     " </tr>\n"
     "</table>\n" );

   static const QString iconAlignText ("");  // (No align attribute)

   const QString objIconHtml =
      RepGen::html_icon (objImgFileHtml(), objImgSize(), 0, objTypHtml(), 
                         iconAlignText);

   const QString objUrl = RepGen::localSimObjUrl (obj);
   const QString objIconLinkHtml = RepGen::html_link (objIconHtml, objUrl);
   const QString objLongTypStr (obj ? obj->getLongTypeName(true) : "");

   const QString slotIconHtml =
      RepGen::html_icon (slotImgFileHtml(), slotImgSize(), 0, slotTypHtml(), 
                         iconAlignText);

   const QString slotTitleContent = fmt .arg (objName)
                                        .arg (slotName)
                                        .arg (objIconLinkHtml)
                                        .arg (objLongTypStr)       // verbose 
                                        .arg (slotIconHtml)
                                        .arg (slotTypHtml (true)); // verbose 

   const QString boxedTitle = RepGen::htmlTableBox (0, slotTitleContent, 3);

   os << qPrintable (boxedTitle) << endl;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

// private
void RepGenSlotHtml::writeSlotDataTable (cwofstream& os)
{
   if (_slot == NULL) return;
   //---------------------->>

   // ****************************************
   // ***  Write Pre-Table Notes (if any)  ***
   // ***   (1) Row Truncation Notice      ***
   // ***   (2) Column Map Entity Name     ***
   // ****************************************

   bool paragraphWritten (false);  // tentative

   const int dataRowCnt = SlotGUIUtils::getNumSlotRows (_slot);
   const bool truncateRows = (dataRowCnt > MAX_SLOT_DATA_ROWS);

   if (truncateRows)
   {
      static const QString truncMsgFmt ( 
         "<p>The number of rows in this slot (%1) exceeds the maximum \n"
         "number of slot rows for this report (%2).  Only the first and \n"
         "last several rows are shown.</p>" );

      const QString truncMsg = truncMsgFmt .arg (dataRowCnt)
                                           .arg (MAX_SLOT_DATA_ROWS);

      os << qPrintable (truncMsg) << endl;

      paragraphWritten = true;
   }

   QString colMapEntityName ("");
   const bool colMapEntityDef =
      SlotGUIUtils::getColMapEntityName (_slot, colMapEntityName);

   if (colMapEntityDef && !colMapEntityName.isEmpty())
   {
      // Write Column Map Entity description
      static const QString colMapEntFmt (
        "<p>Numeric column header value entity: %1</p>\n");

      QString colMapEntStr = colMapEntFmt .arg (colMapEntityName);
      os << qPrintable (colMapEntStr) << endl;

      paragraphWritten = true;
   }

   if (!paragraphWritten)
   {
      os << "&nbsp;<br>" << endl;
   }

   // **************************************
   // ***  Set up HTML Table Attributes  ***
   // **************************************

   static const QString cellPaddingFmt  (" cellpadding=\"%1\"");
   static const QString cellSpacingFmt  (" cellspacing=\"%2\"");
   static const QString borderPixFmt    (" border=\"%3\"");

   const QString cellPadding (cellPaddingFmt .arg (4));         // PADDING
   const QString cellSpacing (cellSpacingFmt .arg (0));         // CELL SPACING
   const QString borderPix   (borderPixFmt   .arg (1));         // BORDER

   static const QString tableElement ( QString ("<table%1%2%3>")
                                       .arg (cellPadding)
                                       .arg (cellSpacing)
                                       .arg (borderPix) );
   // *************************
   // ***  Slot Data Table  ***
   // *************************

   os << qPrintable (tableElement) << endl;

   writeSlotDataTableColMap (1, os);
   writeSlotDataTableHeader (1, os);

   for (int rowInx = 0;  rowInx < dataRowCnt;  ++rowInx)
   {
      writeSlotDataTableRow (rowInx, 1, os);

      if (truncateRows)
      {
         if (rowInx == 4)
         {
            // Draw divider row
            writeSlotDataTableRow ((-1), 1, os);

            // Skip ahead
            rowInx = std::max (5, dataRowCnt-5);
         }
      }
   }

   os << "</table>\n" 
      << "&nbsp;<br>"
      << endl; 
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

// private
void RepGenSlotHtml::writeSlotDataTableHeader (int indentLevel, cwofstream& os)
{
   if (_slot == NULL) return;
   //---------------------->>

   // ListSlots don't need a slot data table header
   if (_slot->isA (Slot::ListSlotBit)) return;
   //--------------------------------------->>

   static const QString trFmtBeg  ("INDENT<tr bgcolor=\"%1\">\n");
   static const QString tdFmtLft  ("INDENT <td>%1</td>\n");
   static const QString tdFmtRgt  ("INDENT <td align=\"right\">%1</td>\n");
   static const QString trFmtEnd  ("INDENT</tr>\n");

   QString trElement (trFmtBeg.arg (HeaderBackgroundColor));
   trElement += tdFmtLft.arg (nbspQstr);

   const int dataColCnt = SlotGUIUtils::getNumCols (_slot);
   for (int colInx = 0;  colInx < dataColCnt;  ++colInx)
   {
      const QString colLab = 
         SlotGUIUtils::getColLabel (_slot, colInx).toLocal8Bit().constData();

      const ScaledUnitPtr scUnit = 
         SlotGUIUtils::getScaledUnitPtr (_slot, colInx);

      const QString colUnits = 
         SlotGUIUtils::scaledUnitDisplayStr (scUnit);

      bool alignRight (true);      // tentative
      QString colHeaderHtml ("");  // tentative
    
      if (!colLab.isEmpty())
      {
         alignRight = false;
         colHeaderHtml = colLab;
      }
      if (!colUnits.isEmpty())
      {
         if (!colHeaderHtml.isEmpty())
            colHeaderHtml += "<br>";
         colHeaderHtml += QString ("[%2]") .arg (colUnits);
      }
      if (colHeaderHtml.isEmpty())
      {
         colHeaderHtml = nbspQstr;
      }

      trElement += (alignRight ? tdFmtRgt : tdFmtLft)
                   .arg (colHeaderHtml);
   } 

   trElement += trFmtEnd;

   const QString indentStr (indentLevel, QChar (' '));  // Indent String
   trElement.replace (QString ("INDENT"), indentStr);

   os << qPrintable (trElement) << endl;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

// private
void RepGenSlotHtml::writeSlotDataTableColMap (int indentLevel, cwofstream& os)
{
   if (_slot == NULL) return;
   //---------------------->>

   // Only TableSlots (incl. subclasses) support Column Maps (NumericDimension)
   if (!_slot->isA (Slot::TableSlotBit)) return;
   //----------------------------------------->>

   QStringList colMapUsrValStrs;
   QString colMapUnitsStr ("");
   const bool colMapDataFound = 
      SlotGUIUtils::getColMapUsrValues (_slot, colMapUsrValStrs, 
                                               colMapUnitsStr);

   if (!colMapDataFound) return;
   //------------------------->>

   if (!colMapUnitsStr.startsWith (QChar ('[')))
      colMapUnitsStr = QString ("[%1]") .arg (colMapUnitsStr);

   static const QString trFmtBeg  ("INDENT<tr bgcolor=\"%1\">\n");
   static const QString tdFmtLft  ("INDENT <td>%1</td>\n");
   static const QString tdFmtRgt  ("INDENT <td align=\"right\">%1</td>\n");
   static const QString trFmtEnd  ("INDENT</tr>\n");

   QString trElement (trFmtBeg.arg (ColMapBackgroundColor));
   trElement += tdFmtLft.arg (nbspQstr); // blank row header column

   const int dataColCnt = SlotGUIUtils::getNumCols (_slot);
   for (int colInx = 0;  colInx < dataColCnt;  ++colInx)
   {
      const QString colMapStr = colMapUsrValStrs.value (colInx);
      const QString valStr  = colMapStr.isEmpty() ? nbspQstr : colMapStr;
      const QString unitStr = colMapStr.isEmpty() ? nbspQstr : colMapUnitsStr;

      const QString colMapHtml = QString ("%1<br>%2")
                                   .arg (valStr)
                                   .arg (unitStr);

      trElement += tdFmtRgt.arg (colMapHtml);
   } 

   trElement += trFmtEnd;

   const QString indentStr (indentLevel, QChar (' '));  // Indent String
   trElement.replace (QString ("INDENT"), indentStr);

   os << qPrintable (trElement) << endl;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

// private
void RepGenSlotHtml::writeSlotDataTableRow (int row, 
                                        int indentLevel, cwofstream& os)
{
   static const QString ellipsis ("...");

   //--------------------------------------------------------
   // NOTE: if (row < 0), show a divider row (with ellipsis).
   //--------------------------------------------------------

   if (_slot == NULL) return;
   //---------------------->>

   const bool isListSlot (_slot->isA (Slot::ListSlotBit));

   static const QString trFmtBeg  ("INDENT<tr>\n");
   static const QString tdFmtLft  ("INDENT <td>%1</td>\n");
   static const QString tdFmtRgt  ("INDENT <td align=\"right\">%1</td>\n");
   static const QString trFmtEnd  ("INDENT</tr>\n");

   QString trElement (trFmtBeg);
   
   // ***********************************
   // ***  Row Header (First Column)  ***
   // ***********************************

   const bool supportsTextRowLabel (_slot->isA (Slot::TableSlotBit)  ||
                                    _slot->isA (Slot::SeriesSlotBit) );

   QString rowLab (nbspQstr);            // tentative
   bool rowHeaderColAlignRight (true);   // tentative

   if (row < 0)
   {
      rowLab = ellipsis;
   }
   else // (row >= 0)
   {
      rowLab = QString::number (row);  // tentative
      if (supportsTextRowLabel)
      {
         const QString rowLabStr = SlotGUIUtils::getRowLabel (_slot, row); 
         if (!rowLabStr.isEmpty())
         {
            rowLab = rowLabStr;
            rowHeaderColAlignRight = false;
         }
      }
   }

   trElement += (rowHeaderColAlignRight ? tdFmtRgt.arg (rowLab) 
                                        : tdFmtLft.arg (rowLab));

   // ************************************************
   // *** Special Column for ListSlots: Item Icon  ***
   // ************************************************

   if (isListSlot)
   {
      const ListSlotBase* lslot = dynamic_cast<const ListSlotBase*> (_slot);
      if (lslot)
      {
         IconHandle lsIcon ((SimObj*) NULL, false);
         const bool iconOk = lslot->getItemIcon (row, lsIcon);
         if (iconOk)
         {
            const QString imgFileStr = 
               RepGen::imgFileStr (lsIcon, _modelReport);
            const QSize imgSize = RepGen::imgSize (lsIcon);
            const QString altText = lsIcon.iconDescStr();

            const QString objIconHtml =
               RepGen::html_icon (imgFileStr, imgSize, 0, altText, ""); 

            trElement += tdFmtLft.arg (objIconHtml);
         }
         else
         {
            trElement += tdFmtLft.arg (nbspQstr);
         }
      }
   }

   // ***************************
   // ***  Slot Data Columns  ***
   // ***************************

   const QString tdFmt (isListSlot ? tdFmtLft : tdFmtRgt);

   const int dataColCnt = SlotGUIUtils::getNumCols (_slot);
   for (int colInx = 0;  colInx < dataColCnt;  ++colInx)
   {
      if (row < 0)
      {
         trElement += tdFmt.arg (ellipsis);
      }
      else
      {
         const QString valStr = 
            SlotGUIUtils::getValueUsrStr (_slot, row, colInx,
                                          false,  //-- for edit
                                          false); //-- alt units

         trElement += tdFmt.arg (valStr);
      }
   }

   trElement += trFmtEnd;

   const QString indentStr (indentLevel, QChar (' '));  // Indent String
   trElement.replace (QString ("INDENT"), indentStr);

   os << qPrintable (trElement) << endl;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

// *****************************
// ***  HTML Slot Utilities  ***
// *****************************

QString RepGenSlotHtml::slotTypHtml (bool verbose /*=false*/) const
{
   const QString str = slotTypStr (verbose);  // [RepGenSlot]

   if (!str.isEmpty())
   {
      return (str);
   }

   return (nbspQstr);  // &nbsp;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

QString RepGenSlotHtml::slotImgFileHtml() const
{
   if (_slot)
   {
      const IconHandle slotIcon (_slot);
      const QString filename = RepGen::imgFileStr (slotIcon, _modelReport);
      return (filename);
      //-------------->>
   }

   return (nbspQstr);  // &nbsp;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

QSize RepGenSlotHtml::slotImgSize() const
{
   QSize slotTypeIconSize (0,0);  // tentative

   if (_slot)
   {
      const IconHandle slotIcon (_slot);
      slotTypeIconSize = RepGen::imgSize (slotIcon);
   }

   return (slotTypeIconSize);
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

QString RepGenSlotHtml::slotNameHtml() const
{
   const QString str = slotNameStr();  // [RepGenSlot]

   if (!str.isEmpty())
   {
      return (str);
   }

   return (nbspQstr);  // &nbsp;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

QString RepGenSlotHtml::slotValHtml() const
{
   const QString str = slotValStr();  // [RepGenSlot] (for scalars)

   if (!str.isEmpty())
   {
      return (str);
   }

   return (nbspQstr);  // &nbsp;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

QString RepGenSlotHtml::slotUnitsHtml (bool withBrackets) const
{
   const QString str = slotUnitsStr (withBrackets);  // [RepGenSlot]

   if (!str.isEmpty())
   {
      return (str);
   }

   return (nbspQstr);  // &nbsp;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

QString RepGenSlotHtml::slotRowsHtml() const
{
   const QString str = slotRowsStr();  // [RepGenSlot]

   if (!str.isEmpty())
   {
      return (str);
   }

   return (nbspQstr);  // &nbsp;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

QString RepGenSlotHtml::slotColsHtml() const
{
   const QString str = slotColsStr();  // [RepGenSlot]

   if (!str.isEmpty())
   {
      return (str);
   }

   return (nbspQstr);  // &nbsp;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

QString RepGenSlotHtml::slotLabelsHtml() const
{
   const QString str = slotLabelsStr();  // [RepGenSlot]

   if (!str.isEmpty())
   {
      return (str);
   }

   return (nbspQstr);  // &nbsp;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

QString RepGenSlotHtml::seriesStepHtml() const
{
   const QString str = seriesStepStr();  // [RepGenSlot]

   if (!str.isEmpty())
   {
      return (str);
   }

   return (nbspQstr);  // &nbsp;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

QString RepGenSlotHtml::seriesStartHtml() const
{
   const QString str = seriesStartStr();  // [RepGenSlot]

   if (!str.isEmpty())
   {
      return (str);
   }

   return (nbspQstr);  // &nbsp;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

QString RepGenSlotHtml::seriesEndHtml() const
{
   const QString str = seriesEndStr();  // [RepGenSlot]

   if (!str.isEmpty())
   {
      return (str);
   }

   return (nbspQstr);  // &nbsp;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

QString RepGenSlotHtml::objTypHtml() const
{
   const QString str = objTypStr();  // [RepGenSlot]

   if (!str.isEmpty())
   {
      return (str);
   }

   return (nbspQstr);  // &nbsp;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

QString RepGenSlotHtml::objImgFileHtml() const
{
   const SimObj* simObj = (_slot ? _slot->getSimObj() : NULL);

   if (simObj)
   {
      const IconHandle objIcon (simObj, false);  // Not Large
      const QString filename = RepGen::imgFileStr (objIcon, _modelReport);
      return (filename);
      //-------------->>
   }

   return (nbspQstr);  // &nbsp;
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

QSize RepGenSlotHtml::objImgSize() const
{
   QSize objTypeIconSize (0,0);  // tentative

   SimObj* obj = (_slot ? _slot->getSimObj() : NULL);
   if (obj)
   {
      const IconHandle objIcon (obj, false);  // not large
      objTypeIconSize = RepGen::imgSize (objIcon);
   }

   return (objTypeIconSize);
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

QString RepGenSlotHtml::objNameHtml() const
{
   const QString str = objNameStr();  // [RepGenSlot]

   if (!str.isEmpty())
   {
      return (str);
   }

   return (nbspQstr);  // &nbsp;
}

//--- (end RepGenSlotHtml.cpp) ---