---

mrprjContent.cc

Go to the documentation of this file.

/*
 * Copyright (C) 2001 Karsten Reincke <karsten.reincke@karubik.de>
 *  
 * This file is part of of the software-project MRPROJEXT.
 * 
 * MRPROJEXT is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * MRPROJEXT is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *  
 * file <mrprjContent.h> version <#1.3.1#> of project <MrProjext>
 */   

#include <iostream.h>
#include "mrprjContent.h"

/* &&& (1) local preprocessor-defines &&&&&&&&&&&&&&&&&&&&&&& */

/* &&& (2) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* &&&     methods for class DateStringConverter */

/*
 *  \brief constructor for the class DateStringConverter
 *
 *  needs nothing, does nothing
 */
mrprj::DateStringConverter::DateStringConverter()
{
}

/*
 *  \brief destructor for the class DateStringConverter
 *
 *  does nothing
 */
mrprj::DateStringConverter::~DateStringConverter()
{
}

string mrprj::DateStringConverter::formYankDateString
(
  const string& pMrprojectDateString
) const
{
  string year="2000";
  string month="01";
  string day="01";
  string hours="00";
  string minutes="00";
  string seconds="00";
  
  if (pMrprojectDateString.size()>=4)
    year=pMrprojectDateString.substr(0,4);

  if (pMrprojectDateString.size()>=6)
    month=pMrprojectDateString.substr(4,2);

  if (pMrprojectDateString.size()>=8)
    day=pMrprojectDateString.substr(6,2);

  if (pMrprojectDateString.size()>=11)
    hours=pMrprojectDateString.substr(9,2);

  if (pMrprojectDateString.size()>=13)
    minutes=pMrprojectDateString.substr(11,2);

  if (pMrprojectDateString.size()>=15)
    seconds=pMrprojectDateString.substr(13,2);
    
  return (year + "-" + month + "-" + day + " " 
          + hours + ":" + minutes + ":" + seconds);
}

string mrprj::DateStringConverter::formGermanDateString
(
  const string& pMrprojectDateString
) const
{
  string year="2000";
  string month="01";
  string day="01";
  string hours="00";
  string minutes="00";
  string seconds="00";
  
  if (pMrprojectDateString.size()>=4)
    year=pMrprojectDateString.substr(0,4);

  if (pMrprojectDateString.size()>=6)
    month=pMrprojectDateString.substr(4,2);

  if (pMrprojectDateString.size()>=8)
    day=pMrprojectDateString.substr(6,2);

  if (pMrprojectDateString.size()>=11)
    hours=pMrprojectDateString.substr(9,2);

  if (pMrprojectDateString.size()>=13)
    minutes=pMrprojectDateString.substr(11,2);

  if (pMrprojectDateString.size()>=15)
    seconds=pMrprojectDateString.substr(13,2);
    
  return (day + "." + month + "."  + year + " "+ hours + "." + minutes);
}

/* &&& (3) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* &&&     methods for class XmlNodeReader */

mrprj::XmlNodeReader::XmlNodeReader()                       
{
}

mrprj::XmlNodeReader::~XmlNodeReader()
{
}

bool mrprj::XmlNodeReader::getStringProperty
( 
  const xmlDocPtr xmlDoc,
  const xmlNodePtr pPropertyNode, 
  const string& pPropertySigner,
  string& pPropertyValue
)
{
  char *propertyCstr;
  
  propertyCstr=(char *)
    xmlGetProp(pPropertyNode, (xmlChar *)pPropertySigner.c_str());
  if (!(propertyCstr))
    return false;
    
  char* propertyEncodeCstr
    =(char *)xmlEncodeEntitiesReentrant(xmlDoc, (xmlChar *)propertyCstr);
  free(propertyCstr);  
  string propertyStr=propertyEncodeCstr;  
  free(propertyEncodeCstr);  
  pPropertyValue=xmlConverter.decode(propertyStr);
  
  return true;
}


/* &&& (4) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* --- (4) public constructors, inits & operators :-:-:-:-: */
mrprj::Property::Property
( 
  krmuo::LoggingUnit& pLoggingUnit,
  const string& pName,
  const string& pType,
  const string& pOwner,
  const string& pLabel,
  const string& pDescription
)                       
: 
  mLoggingUnit(pLoggingUnit),
  mName(pName),
  mType(pType),
  mOwner(pOwner),
  mLabel(pLabel),
  mDescription(pDescription)
{
  string propDescr=("property<" + mName +">:<"+ mLabel+">");
  mLoggingUnit.makeEntry("creating property",propDescr,HM);
}

mrprj::Property::~Property()
{
  string propDescr=("property<" + mName +">:<"+ mLabel+">");
  mLoggingUnit.makeEntry("deleting property",propDescr,HM);
} 


/* &&& (5) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* --- (5) public constructors, inits & operators :-:-:-:-: */
mrprj::Phase::Phase
( 
  krmuo::LoggingUnit& pLoggingUnit,
  const string& pName
)                       
: 
  mLoggingUnit(pLoggingUnit),
  mName(pName)
{
  string phaseDescr=("phase<" + mName +">");
  mLoggingUnit.makeEntry("creating phase",phaseDescr,HM);
}

mrprj::Phase::~Phase()
{
  string phaseDescr=("phase<" + mName +">");
  mLoggingUnit.makeEntry("deleting phase",phaseDescr,HM);
} 


/* &&& (6) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* --- (6) public constructors, inits & operators :-:-:-:-: */
mrprj::DayType::DayType
( 
  krmuo::LoggingUnit& pLoggingUnit,
  const string& pId,
  const string& pName,
  const string& pDescription
)                       
: 
  mLoggingUnit(pLoggingUnit),
  mId(pId),
  mName(pName),
  mDescription(pDescription)
{
  string dayTypeDescr=("dayType<" + mId +"><" + mName +">");
  mLoggingUnit.makeEntry("creating",dayTypeDescr,HM);
}

mrprj::DayType::~DayType()
{
  string dayTypeDescr=("dayType<" + mId +"><" + mName +">");
  mLoggingUnit.makeEntry("deleting",dayTypeDescr,HM);
} 

mrprj::DayType::DayType(const mrprj::DayType& co)
: mLoggingUnit(co.mLoggingUnit),
  mId(co.mId),
  mName(co.mName),
  mDescription(co.mDescription)
{

  string dayTypeDescr=("dayType<" + mId +"><" + mName +">");
  mLoggingUnit.makeEntry("copying",dayTypeDescr,HM);

}

/* &&& (7) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* --- (7) public constructors, inits & operators :-:-:-:-: */
mrprj::Interval::Interval
( 
  krmuo::LoggingUnit& pLoggingUnit,
  const string& pStart,
  const string& pEnd
)                       
: 
  mLoggingUnit(pLoggingUnit),
  mStart(pStart),
  mEnd(pEnd)
{
  string intervalDescr=("interval<" + mStart +"><" + mEnd +">");
  mLoggingUnit.makeEntry("creating",intervalDescr,HM);
}

mrprj::Interval::~Interval()
{
  string intervalDescr=("interval<" + mStart +"><" + mEnd +">");
  mLoggingUnit.makeEntry("deleting",intervalDescr,HM);
} 

mrprj::Interval::Interval(const mrprj::Interval& co)  
: mLoggingUnit(co.mLoggingUnit),
  mStart(co.mStart),
  mEnd(co.mEnd)
{
  string intervalDescr=("interval<" + mStart +"><" + mEnd +">");
  mLoggingUnit.makeEntry("copying",intervalDescr,HM);
}


/* &&& (8) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* --- (8) public constructors, inits & operators :-:-:-:-: */
mrprj::OverriddenDayType::OverriddenDayType
( 
  krmuo::LoggingUnit& pLoggingUnit,
  const string& pId
)                       
: 
  mLoggingUnit(pLoggingUnit),
  mId(pId)
{
  string overriddenDayTypeDescr=("overriddenDayType<" + mId +">");
  mIntervalList.clear();
  mLoggingUnit.makeEntry("creating",overriddenDayTypeDescr,HM);
}

mrprj::OverriddenDayType::~OverriddenDayType()
{
  string overriddenDayTypeDescr=("overriddenDayType<" + mId +">");
  mLoggingUnit.makeEntry("deleting",overriddenDayTypeDescr,HM);
  mIntervalList.clear();
} 

mrprj::OverriddenDayType::OverriddenDayType(const OverriddenDayType& co)
: mIntervalList(co.mIntervalList),
  mLoggingUnit(co.mLoggingUnit),
  mId(co.mId)
{

} 

/* &&& (9) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* --- (9) public constructors, inits & operators :-:-:-:-: */
mrprj::Day::Day
( 
  krmuo::LoggingUnit& pLoggingUnit,
  const string& pDate,
  const string& pType,
  const string& pId
)                       
: mLoggingUnit(pLoggingUnit),
  mDate(pDate),
  mType(pType),
  mId(pId)
{
  string dayDescr=("day<" + mId +"><" + mDate +">");
  mLoggingUnit.makeEntry("creating",dayDescr,HM);
}

mrprj::Day::~Day()
{
  string dayDescr=("day<" + mId +"><" + mDate +">");
  mLoggingUnit.makeEntry("deleting",dayDescr,HM);
} 

mrprj::Day::Day(const mrprj::Day& co)    
: mLoggingUnit(co.mLoggingUnit),
  mDate(co.mDate),
  mType(co.mType),
  mId(co.mId)
{
  string dayDescr=("day<" + mId +"><" + mDate +">");
  mLoggingUnit.makeEntry("copying",dayDescr,HM);

}


/* &&& (10) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* --- (10) public constructors, inits & operators :-:-:-:-: */
mrprj::Calendar::Calendar
( 
  krmuo::LoggingUnit& pLoggingUnit,
  const string& pId,
  const string& pName
)                       
: mMon(""),
  mTue(""),
  mWed(""),
  mThu(""),
  mFri(""),
  mSat(""),
  mSun(""),
  mLoggingUnit(pLoggingUnit),
  mId(pId),
  mName(pName)
{
  string CalendarDescr=("Calendar<" + mId +"><" + mName +">");
  mOverriddenDayTypeList.clear();
  mDayList.clear();
  mLoggingUnit.makeEntry("creating",CalendarDescr,HM);
}

mrprj::Calendar::~Calendar()
{
  string CalendarDescr=("Calendar<" + mId +"><" + mName +">");
  mOverriddenDayTypeList.clear();
  mDayList.clear();
  mLoggingUnit.makeEntry("deleting",CalendarDescr,HM);
} 



/* &&& (11) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* &&&     methods for class Task Predecessor &&& */

mrprj::Predecessor::Predecessor
( 
  const string& pEntryId,
  const string& pPredecessorTaskId,
  const string& pType  
)                       
: mEntryId(pEntryId),
  mPredecessorTaskId(pPredecessorTaskId),
  mType(pType)
{
}


mrprj::Predecessor::~Predecessor()
{
}


/* &&& (12) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* :-: (12.A) public constructors, inits & operators -:-:-:-: */

mrprj::Task::Task
( 
  krmuo::LoggingUnit& pLoggingUnit,
  const string& pTaskId,
  const string& pTaskTitle,
  const string& pTaskDescription,
  const string& pTaskStartDate,
  const string& pTaskEndDate,
  const int pFullFilledPercent,
  const bool pIsEmptyTopTask
)                       
: mTaskId(pTaskId),
  mTaskTitle(pTaskTitle),
  mTaskDescription(pTaskDescription),
  mTaskStartDate(pTaskStartDate),
  mTaskEndDate(pTaskEndDate),
  mFullFilledPercent(pFullFilledPercent),
  mIsEmptyTopTask(pIsEmptyTopTask),
  mSubTaskMap(),
  mSubTaskOrderList(),
  mPredecessorMap(),
  mLoggingUnit(pLoggingUnit),
  mIsActive(true),
  mIsAllocated(false),
  mAnyDaughterIsActive(false),
  mXrowspan(0),
  mXrowTacker(0),
  mNodeEmbeddedLevel(0),
  mXdoPrint(true)
{
  mLoggingUnit.makeEntry("creating task",mTaskTitle,HM);
}


mrprj::Task::~Task()
{
  // (a) at first we delete all allocated subtasks
  map<string, Task*>::iterator subTaskMapIterator=mSubTaskMap.begin();
  while(subTaskMapIterator!=mSubTaskMap.end())
  {
    delete subTaskMapIterator->second;
    subTaskMapIterator++;
  }
  // (b) sometimes we are paranoic: we explicitely delete the map-content itself ...  
  mSubTaskMap.clear();
  // (c) .. and the order-list too
  mSubTaskOrderList.clear();
  // (d) then we delete all allocated predecessor-objects
  map<string,Predecessor*>::iterator predecessorMapIterator=mPredecessorMap.begin();
  while(predecessorMapIterator!=mPredecessorMap.end())
  {
    delete predecessorMapIterator->second;
    predecessorMapIterator++;
  }  
  // (e) at last we are paranoic again 
  mPredecessorMap.clear();
  mLoggingUnit.makeEntry("deleting task",mTaskTitle,HM);
}

/* :-: (12.B) public others -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */

void mrprj::Task::setPassiveIfAllDaughtersPassive()
{
  
  if (mSubTaskMap.size()!=0)
  {
    map<string, Task*>::const_iterator
      mSubTaskMapIterator=mSubTaskMap.begin();
    bool allDaughtersArePassive=true;
    while(mSubTaskMapIterator!=mSubTaskMap.end())
    {
      mSubTaskMapIterator->second->setPassiveIfAllDaughtersPassive();
      
      if (mSubTaskMapIterator->second->isActive())
        allDaughtersArePassive=false;
      mSubTaskMapIterator++;
    }
   
    if (allDaughtersArePassive)
      setPassive();
    else
      setAnyDaughterIsActive();    
  }
  else
  {
    if (mIsActive)
      setAnyDaughterIsActive();
  }
}

bool mrprj::Task::fillTaskSubStructureByMrPrjXmlTaskNodes
(
  xmlDocPtr xmlDoc, 
  const xmlNodePtr pFirstTaskSubnode,
  map<string,Task*>& pGlobalTaskMap
)
{ 
  string taskId;
  string taskTitle;
  string taskDescr;
  string taskStart;
  string taskEnd;
  int fullFilledPerCent;
  XmlNodeReader xmlNodeReader;

  if (!(pFirstTaskSubnode))
    return false;
  mrprj::Task* newSubTask;
  
  xmlNodePtr xmlTaskTreeListRunner=pFirstTaskSubnode;
  while(xmlTaskTreeListRunner)
  {
    if (strcmp((char *)xmlTaskTreeListRunner->name,"predecessors")==0)
    {
      fillTaskPredecessorByMrPrjXmlPredecessorNodes(xmlDoc,xmlTaskTreeListRunner->xmlChildrenNode);
    }
    if (strcmp((char *)xmlTaskTreeListRunner->name,"task")==0)
    {
      assert(xmlNodeReader.getStringProperty(xmlDoc,xmlTaskTreeListRunner,"id",taskId));
      if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlTaskTreeListRunner,"name",taskTitle)))
        taskTitle="???";
      
      if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlTaskTreeListRunner,"note",taskDescr)))
        taskDescr="???";

      assert(xmlNodeReader.getStringProperty(xmlDoc,xmlTaskTreeListRunner,"start",taskStart));
      assert(xmlNodeReader.getStringProperty(xmlDoc,xmlTaskTreeListRunner,"end",taskEnd));

      if (!(xmlNodeReader.getIntProperty(xmlDoc,xmlTaskTreeListRunner,"percent-complete",fullFilledPerCent)))
        fullFilledPerCent=0;
        
      newSubTask
        =insertSubTask
          ( taskId,taskTitle,taskDescr,taskStart,taskEnd,fullFilledPerCent);
      pGlobalTaskMap.insert(pair<string,Task*>(newSubTask->mTaskId,newSubTask));
      newSubTask->fillTaskSubStructureByMrPrjXmlTaskNodes
        (xmlDoc,xmlTaskTreeListRunner->xmlChildrenNode,pGlobalTaskMap);
    }
    xmlTaskTreeListRunner=xmlTaskTreeListRunner->next;
  }
  return true;
}

bool  mrprj::Task::limitToTimeSlot
(
  const string& pTimeSlotStart,
  const string& pTimeSlotEnd
)
{
  if (!(isEmptyTopTask()))
  {    
    if (  (getEndDate()<pTimeSlotStart)
       || (getStartDate()>pTimeSlotEnd)
       )
    {
      setPassive();
    }
    else
    {
      if (getStartDate()<pTimeSlotStart)
        setStartDate(pTimeSlotStart);
      if (getEndDate()>pTimeSlotEnd)
        setEndDate(pTimeSlotEnd);
    }
  }
 
  list<string>::iterator 
    mSubTaskOrderListIterator
      =mSubTaskOrderList.begin();
  while(mSubTaskOrderListIterator!=mSubTaskOrderList.end())
  {
    mSubTaskMap[*mSubTaskOrderListIterator]->limitToTimeSlot(pTimeSlotStart,pTimeSlotEnd);
    mSubTaskOrderListIterator++;
  }
  return true;
}

bool  mrprj::Task::limitToOpenTasks()
{
  if (!(isEmptyTopTask()))
  {
    if (getFullFilledPercent()==100)
      setPassive();
  }
 
  list<string>::iterator 
    mSubTaskOrderListIterator
      =mSubTaskOrderList.begin();
  while(mSubTaskOrderListIterator!=mSubTaskOrderList.end())
  {
    mSubTaskMap[*mSubTaskOrderListIterator]->limitToOpenTasks();
    mSubTaskOrderListIterator++;
  }
  return true;
}


int mrprj::Task::insertXYposition
( 
  const int pEmbeddedLevel,
  int& pMaxEmbeddedLevel
)
{
   
  mNodeEmbeddedLevel=pEmbeddedLevel; 
  if (isLeafNode())
  {
    mXrowspan=1;
    mXrowTacker=1;
    /*
    printf("%d,%s:%s (x(%d),y(%d),r(%d),c(%d))\n",
    pEmbeddedLevel,
    getTaskId().c_str(),
    getTaskTitle().c_str(),
    mXposition,
    mYposition,
    mXrowspan,
    mYcolspan
    );
    */
    if (pEmbeddedLevel>pMaxEmbeddedLevel)
      pMaxEmbeddedLevel=pEmbeddedLevel;
    return 1;
  }
  
  
  list<string>::iterator 
    mSubTaskOrderListIterator
      =mSubTaskOrderList.begin();
  mXrowspan=0;
  while(mSubTaskOrderListIterator!=mSubTaskOrderList.end())
  {
    mXrowspan=
      ( mSubTaskMap[*mSubTaskOrderListIterator]
          ->insertXYposition
            ( (pEmbeddedLevel+1),
              pMaxEmbeddedLevel
            )
      + mXrowspan);
    mSubTaskOrderListIterator++;
  }
  /*
  printf("%d,%s:%s (x(%d),y(%d),r(%d),c(%d))\n",
    pEmbeddedLevel,
    getTaskId().c_str(),
    getTaskTitle().c_str(),
    mXposition,
    mYposition,
    mXrowspan,
    mYcolspan
    );
  */
  mXrowTacker=mXrowspan;
  return mXrowspan;
}

bool mrprj::Task::printTaskAsMrPrjXmlFileMember(int pBlankIndents)const
{
  krmuo::XmlConverter xmlConverter;
  
  string pBlankPrefix="";
  for(int i=0;i<pBlankIndents;i++)
  {
     pBlankPrefix+=" ";
  }
  
    // (0) if it's the virtual main task we are writing the opening task-list-tag
  if (isEmptyTopTask())
    printf("%s<tasks>\n",pBlankPrefix.c_str());
  else
  {
    if ((mIsActive)||(mAnyDaughterIsActive))
    {
      // (1) the we are writing the task itself (if it's not the virtual main task)
      printf("%s<task id=\"%s\" name=\"%s\" "
             "start=\"%s\" end=\"%s\" "
             "percent-complete=\"%d\" "
             "note=\"%s\" "
             " >\n",
              pBlankPrefix.c_str(),
              xmlConverter.encode(getTaskId()).c_str(),
              xmlConverter.encode(getTaskTitle()).c_str(),
              xmlConverter.encode(getStartDate()).c_str(),
              xmlConverter.encode(getEndDate()).c_str(),
              getFullFilledPercent(),
        xmlConverter.encode(getTaskDescription()).c_str()
            );
      // (2) followed by the list of all denoted predecessors
      if (mPredecessorMap.size()==0)
      {
        printf("%s  <predecessors />\n",pBlankPrefix.c_str());
      }
      else
      {
        printf("%s  <predecessors>\n",pBlankPrefix.c_str());
        map<string,Predecessor*>::const_iterator mPredecessorMapIterator=mPredecessorMap.begin();
        while(mPredecessorMapIterator!=mPredecessorMap.end())
        {
          printf("%s    <predecessor id=\"%s\" predecessor-id=\"%s\" type=\"%s\" />\n",
                  pBlankPrefix.c_str(),
                  mPredecessorMapIterator->second->getEntryId().c_str(),
                  mPredecessorMapIterator->second->getPredecessorTaskId().c_str(),
                  mPredecessorMapIterator->second->getType().c_str()
                );
          mPredecessorMapIterator++;
        }
        printf("%s  </predecessors>\n",pBlankPrefix.c_str());
      }
    }
  }
 
    // (3) at last we are writing all subtasks by respecting the order of the original mrproject-xml-file 
   list<string>::const_iterator 
    mSubTaskOrderListIterator
      =mSubTaskOrderList.begin();
  map<string, Task*>::const_iterator mSubTaskMapIterator;
  while(mSubTaskOrderListIterator!=mSubTaskOrderList.end())
  {
    mSubTaskMapIterator=mSubTaskMap.find(*mSubTaskOrderListIterator);
    mSubTaskMapIterator->second->printTaskAsMrPrjXmlFileMember((pBlankIndents+2));
    mSubTaskOrderListIterator++;
  }
  
  
  if (isEmptyTopTask())
    printf("%s</tasks>\n",pBlankPrefix.c_str());
  else
  {
    if ((mIsActive)||(mAnyDaughterIsActive))
      printf("%s</task>\n",pBlankPrefix.c_str());
  }
  return true;
}

bool mrprj::Task::printTaskAsLeafMemoListMember
( const string& pTaskPrefix,
  const string& pLevelOrderString,
  const map<string,Resource*>& pResourceMap,
  const list<Allocation*>& pAllocationList,
  const bool pIso8601
)const
{

  string actualPrefix=(pTaskPrefix+ "/");
 
  if(mSubTaskOrderList.size()>0)
  {
    string actualLevelOrderString=(pLevelOrderString + ".");

    if (!(isEmptyTopTask()))
    {
      actualPrefix=(actualPrefix + getTaskTitle());  
    }
    else
    {
      actualLevelOrderString="";
      actualPrefix="";
    }
    
    list<string>::const_iterator 
      mSubTaskOrderListIterator
        =mSubTaskOrderList.begin();
    int levelSorter=1;
    char buffer[120];
    string nextOrderString="";
    map<string, Task*>::const_iterator mSubTaskMapIterator;

    while(mSubTaskOrderListIterator!=mSubTaskOrderList.end())
    {
      sprintf(buffer,"%d",levelSorter);
      nextOrderString=(actualLevelOrderString+buffer);
      
      mSubTaskMapIterator=mSubTaskMap.find(*mSubTaskOrderListIterator);
      mSubTaskMapIterator->second->printTaskAsLeafMemoListMember
          ( actualPrefix,
            nextOrderString,
            pResourceMap,
            pAllocationList,
            pIso8601
          );
      mSubTaskOrderListIterator++;
      levelSorter++;
    }
    return true;
  }
  
  if (mIsActive)
  {
    string resourceId;
    string resourceName;
    if(!(getResourceInfos(pResourceMap,pAllocationList,resourceId,resourceName)))
    {
      resourceId=-1;
      resourceName="?";
    }
    string startDate="";
    string endDate="";
    if (pIso8601)
    {
      startDate=getStartDate();
      endDate=getEndDate();
    }
    else
    {
      DateStringConverter dateStringConverter;
      startDate=dateStringConverter.formGermanDateString(getStartDate());
      endDate=dateStringConverter.formGermanDateString(getEndDate());
    }
    printf("<%s> %s (%s):\n  %s\n    [%s - %s]\n      (%s):\n        %s\n",
            resourceName.c_str(),
            pLevelOrderString.c_str(),
            getDoneDescription().c_str(),           
            getTaskTitle().c_str(),
            startDate.c_str(),
            endDate.c_str(),
            actualPrefix.c_str(),
            getTaskDescriptionAsFormattedString("",64).c_str()
           );
  }
  return true;
}

bool mrprj::Task::printTaskAsTreeMemoMember
( const string& pLevelOrderString,
  int pTreeDepth,
  const map<string,Resource*>& pResourceMap,
  const list<Allocation*>& pAllocationList,
  const bool pIso8601 
)const
{
  string pBlankPrefix="";
  for(int i=0;i<pTreeDepth;i++)
  {
     pBlankPrefix+="  ";
  }

  if (((mIsActive)||(mAnyDaughterIsActive))&&(!(mIsEmptyTopTask)))
  {
    string resourceId;
    string resourceName;
    if(!(getResourceInfos(pResourceMap,pAllocationList,resourceId,resourceName)))
    {
      resourceId=-1;
      resourceName="?";
    }
    string startDate="";
    string endDate="";
    if (pIso8601)
    {
      startDate=getStartDate();
      endDate=getEndDate();
    }
    else
    {
      DateStringConverter dateStringConverter;
      startDate=dateStringConverter.formGermanDateString(getStartDate());
      endDate=dateStringConverter.formGermanDateString(getEndDate());
    }

    printf("%s%s [%s - %s] %s(%s,%s):\n%s  %s\n",
            pBlankPrefix.c_str(),
            getTaskTitle().c_str(),
            startDate.c_str(),
            endDate.c_str(),
            getDoneDescription().c_str(),
            resourceName.c_str(),
            pLevelOrderString.c_str(),
            pBlankPrefix.c_str(),
            (getTaskDescriptionAsFormattedString((pBlankPrefix+" "),64) + "\n").c_str()
           );
  }
  
  string actualLevelOrderString="";
  if (!(mIsEmptyTopTask))
  {
    actualLevelOrderString=(pLevelOrderString+".");
  }
    
  list<string>::const_iterator 
    mSubTaskOrderListIterator
      =mSubTaskOrderList.begin();
  int levelSorter=1;
  char buffer[120];
  string nextOrderString="";
  map<string, Task*>::const_iterator mSubTaskMapIterator;
  while(mSubTaskOrderListIterator!=mSubTaskOrderList.end())
  {
    sprintf(buffer,"%d",levelSorter);
    nextOrderString=(actualLevelOrderString+buffer);
    mSubTaskMapIterator=mSubTaskMap.find(*mSubTaskOrderListIterator);
    mSubTaskMapIterator->second->printTaskAsTreeMemoMember
        ( nextOrderString,
          pTreeDepth+1,
          pResourceMap,
          pAllocationList,
          pIso8601
        );
    mSubTaskOrderListIterator++;
    levelSorter++;
  }
  
  return true;
}

bool mrprj::Task::printTaskAsLeafVTodoMember
( const map<string,Resource*>& pResourceMap,
  const list<Allocation*>& pAllocationList,
  const string& pConnectedProjectName
)const
{
  if (mIsEmptyTopTask)
    printf("BEGIN:VCALENDAR\n");
    
  if (  ((mIsActive)||(mAnyDaughterIsActive))
     && (!(mIsEmptyTopTask))
     && (mSubTaskOrderList.size()==0)
     )
  {
    string resourceId;
    string resourceName;
    if(!(getResourceInfos(pResourceMap,pAllocationList,resourceId,resourceName)))
    {
      resourceId=-1;
      resourceName="?";
    }
        
    printf("BEGIN:VTODO\n");
    printf("UID:mrproject-%s-%s\n",pConnectedProjectName.c_str(),getTaskId().c_str());
    printf("SEQUENCE:-1\n");
    printf("DTSTART:%s\n",getStartDate().c_str());
    printf("DUE:%s\n",getEndDate().c_str());
    printf("DCREATED:%s\n",getStartDate().c_str());
    printf("DESCRIPTION:%s for/by %s: %s\n",
      getDoneDescription().c_str(),resourceName.c_str(),getTaskDescriptionAsOneLine().c_str());
       
    printf("SUMMARY:%s\n",getTaskTitle().c_str());
    if (isOpenTask())
      printf("STATUS:NEEDS ACTION\n");
    printf("CLASS:PUBLIC\n");
    printf("PRIORITY:5\n");
    printf("TRANSP:0\n");
    printf("X-PILOTID:0\n");
    printf("X-PILOTSTAT:1\n");
    printf("X-PILOT-NOTIME:0\n");
    printf("END:VTODO\n\n");
  }
      
  list<string>::const_iterator 
    mSubTaskOrderListIterator
      =mSubTaskOrderList.begin();
  map<string, Task*>::const_iterator mSubTaskMapIterator;
  while(mSubTaskOrderListIterator!=mSubTaskOrderList.end())
  {
    mSubTaskMapIterator=mSubTaskMap.find(*mSubTaskOrderListIterator);
    mSubTaskMapIterator->second->printTaskAsLeafVTodoMember
        ( pResourceMap,
          pAllocationList,
          pConnectedProjectName
        );
    mSubTaskOrderListIterator++;
  }
  if (mIsEmptyTopTask)
    printf("END:VCALENDAR\n");

  return true;
}

bool mrprj::Task::printTaskAsTreeVTodoMember
( const map<string,Resource*>& pResourceMap,
  const list<Allocation*>& pAllocationList,
  const string& pConnectedProjectName
)const
{
  if (mIsEmptyTopTask)
    printf("BEGIN:VCALENDAR\n");
    
  if (  ((mIsActive)||(mAnyDaughterIsActive))
     && (!(mIsEmptyTopTask))
     )
  {
    string resourceId;
    string resourceName;
    if(!(getResourceInfos(pResourceMap,pAllocationList,resourceId,resourceName)))
    {
      resourceId=-1;
      resourceName="?";
    }
        
    printf("BEGIN:VTODO\n");
    printf("UID:mrproject-%s-%s\n",pConnectedProjectName.c_str(),getTaskId().c_str());
    printf("SEQUENCE:-1\n");
    printf("DTSTART:%s\n",getStartDate().c_str());
    printf("DUE:%s\n",getEndDate().c_str());
    printf("DCREATED:%s\n",getStartDate().c_str());
    printf("DESCRIPTION:%s for/by %s: %s\n",
      getDoneDescription().c_str(),resourceName.c_str(),getTaskDescriptionAsOneLine().c_str());
       
    printf("SUMMARY:%s\n",getTaskTitle().c_str());
    if (isOpenTask())
      printf("STATUS:NEEDS ACTION\n");
    printf("CLASS:PUBLIC\n");
    printf("PRIORITY:5\n");
    printf("TRANSP:0\n");
    printf("X-PILOTID:0\n");
    printf("X-PILOTSTAT:1\n");
    printf("X-PILOT-NOTIME:0\n");
    printf("END:VTODO\n\n");
  }
      
  list<string>::const_iterator 
    mSubTaskOrderListIterator
      =mSubTaskOrderList.begin();
  map<string, Task*>::const_iterator mSubTaskMapIterator;
  while(mSubTaskOrderListIterator!=mSubTaskOrderList.end())
  {
    mSubTaskMapIterator=mSubTaskMap.find(*mSubTaskOrderListIterator);
    mSubTaskMapIterator->second->printTaskAsTreeVTodoMember
        ( pResourceMap,
          pAllocationList,
          pConnectedProjectName
        );
    mSubTaskOrderListIterator++;
  }
  
  if (mIsEmptyTopTask)
    printf("END:VCALENDAR\n");

  return true;
}

bool mrprj::Task::printTaskAsPilotTreeTodoMember
( const string& pLevelOrderString,
  const map<string,Resource*>& pResourceMap,
  const list<Allocation*>& pAllocationList
)const
{
  if (((mIsActive)||(mAnyDaughterIsActive))&&(!(mIsEmptyTopTask)))
  {
    string resourceId;
    string resourceName;
    if(!(getResourceInfos(pResourceMap,pAllocationList,resourceId,resourceName)))
    {
      resourceId=-1;
      resourceName="?";
    }

    printf("%s [%s - %s] <%s(%s,%s)>\n",
            getTaskTitle().c_str(),
            getStartDate().c_str(),
            getEndDate().c_str(),
            getDoneDescription().c_str(),
            resourceName.c_str(),
            pLevelOrderString.c_str()
           );
  }
  
  string actualLevelOrderString="";
  if (!(mIsEmptyTopTask))
  {
    actualLevelOrderString=(pLevelOrderString+".");
  }
    
  list<string>::const_iterator 
    mSubTaskOrderListIterator
      =mSubTaskOrderList.begin();
  int levelSorter=1;
  char buffer[120];
  string nextOrderString="";
  map<string, Task*>::const_iterator mSubTaskMapIterator;
  while(mSubTaskOrderListIterator!=mSubTaskOrderList.end())
  {
    sprintf(buffer,"%d",levelSorter);
    nextOrderString=(actualLevelOrderString+buffer);
    mSubTaskMapIterator=mSubTaskMap.find(*mSubTaskOrderListIterator);
    mSubTaskMapIterator->second->printTaskAsPilotTreeTodoMember
        ( nextOrderString,
          pResourceMap,
          pAllocationList
        );
    mSubTaskOrderListIterator++;
    levelSorter++;
  }
  
  return true;
}

bool mrprj::Task::printTaskAsPilotLeafTodoMember
( const string& pLevelOrderString,
  const map<string,Resource*>& pResourceMap,
  const list<Allocation*>& pAllocationList
)const
{
  if (((mIsActive)||(mAnyDaughterIsActive))&&(!(mIsEmptyTopTask))&&(mSubTaskOrderList.size()==0))
  {
    string resourceId;
    string resourceName;
    if(!(getResourceInfos(pResourceMap,pAllocationList,resourceId,resourceName)))
    {
      resourceId=-1;
      resourceName="?";
    }

    printf("%s [%s - %s] <%s(%s,%s)>\n",
            getTaskTitle().c_str(),
            getStartDate().c_str(),
            getEndDate().c_str(),
            getDoneDescription().c_str(),
            resourceName.c_str(),
            pLevelOrderString.c_str()
           );
  }
  
  string actualLevelOrderString="";
  if (!(mIsEmptyTopTask))
  {
    actualLevelOrderString=(pLevelOrderString+".");
  }
    
  list<string>::const_iterator 
    mSubTaskOrderListIterator
      =mSubTaskOrderList.begin();
  int levelSorter=1;
  char buffer[120];
  string nextOrderString="";
  map<string, Task*>::const_iterator mSubTaskMapIterator;
  while(mSubTaskOrderListIterator!=mSubTaskOrderList.end())
  {
    sprintf(buffer,"%d",levelSorter);
    nextOrderString=(actualLevelOrderString+buffer);
    mSubTaskMapIterator=mSubTaskMap.find(*mSubTaskOrderListIterator);
    mSubTaskMapIterator->second->printTaskAsPilotTreeTodoMember
        ( nextOrderString,
          pResourceMap,
          pAllocationList
        );
    mSubTaskOrderListIterator++;
    levelSorter++;
  }
  
  return true;
}

bool mrprj::Task::printTaskAsLeafYankTodoMember
( const map<string,Resource*>& pResourceMap,
  const list<Allocation*>& pAllocationList
)const
{
  krmuo::XmlConverter xmlConverter; 
  mrprj::DateStringConverter dateStringConverter;
  
  if (  ((mIsActive)||(mAnyDaughterIsActive))
     && (!(mIsEmptyTopTask))
     && (mSubTaskOrderList.size()==0)
     )
  {
    string resourceId;
    string resourceName;
    if(!(getResourceInfos(pResourceMap,pAllocationList,resourceId,resourceName)))
    {
      resourceId=-1;
      resourceName="?";
    }
    printf("  <Node Type=\"TodoNote\" ");
    printf("User=\"%s\" ",(xmlConverter.encode(resourceName)).c_str() );
    printf("Priority=\"3\" ");
    printf("Deadline=\"%s\" ",dateStringConverter.formYankDateString(getEndDate()).c_str());
    printf("Complete=\"%f\" ",(float)getFullFilledPercent());
    if (getFullFilledPercent()==100)
      printf("Todo=\"1\" ");
    else
      printf("Todo=\"0\" ");
              
    printf(">\n");
    printf("    <ID>%s</ID>\n",getTaskId().c_str());
    printf("    <Title>%s</Title>\n",(xmlConverter.encode(getTaskTitle())).c_str());
    printf("    <Text>\n%s for/by %s:\n%s\n    </Text>\n",
                      getDoneDescription().c_str(),
                      (xmlConverter.encode(resourceName)).c_str(),
                      (xmlConverter.encode(getTaskDescriptionAsFormattedString("",60))).c_str());
    printf("  </Node>\n");
  }

  list<string>::const_iterator 
    mSubTaskOrderListIterator
      =mSubTaskOrderList.begin();
  map<string, Task*>::const_iterator mSubTaskMapIterator;
  while(mSubTaskOrderListIterator!=mSubTaskOrderList.end())
  {
    mSubTaskMapIterator=mSubTaskMap.find(*mSubTaskOrderListIterator);
    mSubTaskMapIterator->second->printTaskAsLeafYankTodoMember
        ( pResourceMap,
          pAllocationList
        );
    mSubTaskOrderListIterator++;
  }

  return true;
}

bool mrprj::Task::printTaskAsTreeYankTodoMember
( const map<string,Resource*>& pResourceMap,
  const list<Allocation*>& pAllocationList,
  const int pBlankIndents
)const
{
  krmuo::XmlConverter xmlConverter; 
  mrprj::DateStringConverter dateStringConverter;

  string pBlankPrefix="";
  for(int i=0;i<pBlankIndents;i++)
  {
     pBlankPrefix+=" ";
  }

  if (  ((mIsActive)||(mAnyDaughterIsActive))
     && (!(mIsEmptyTopTask))
     )
  {
    string resourceId;
    string resourceName;
    if(!(getResourceInfos(pResourceMap,pAllocationList,resourceId,resourceName)))
    {
      resourceId=-1;
      resourceName="?";
    }
    printf("%s<Node Type=\"TodoNote\" ",pBlankPrefix.c_str());
    printf("User=\"%s\" ",(xmlConverter.encode(resourceName)).c_str() );
    printf("Priority=\"3\" ");
    printf("Deadline=\"%s\" ",dateStringConverter.formYankDateString(getEndDate()).c_str());
    printf("Complete=\"%f\" ",(float)getFullFilledPercent());
    if (getFullFilledPercent()==100)
      printf("Todo=\"1\" ");
    else
      printf("Todo=\"0\" ");
    printf(">\n");
    printf("%s  <ID>%s</ID>\n",pBlankPrefix.c_str(),getTaskId().c_str());
    printf("%s  <Title>%s</Title>\n",pBlankPrefix.c_str(),(xmlConverter.encode(getTaskTitle())).c_str());
    printf("%s  <Text>\n%s for/by %s:\n%s\n%s</Text>\n",
                      pBlankPrefix.c_str(),
                      getDoneDescription().c_str(),
                      (xmlConverter.encode(resourceName)).c_str(),
                      (xmlConverter.encode(getTaskDescriptionAsFormattedString("",60))).c_str(),
                      pBlankPrefix.c_str());
  }
      
  list<string>::const_iterator 
    mSubTaskOrderListIterator
      =mSubTaskOrderList.begin();
  map<string, Task*>::const_iterator mSubTaskMapIterator;
  while(mSubTaskOrderListIterator!=mSubTaskOrderList.end())
  {
    mSubTaskMapIterator=mSubTaskMap.find(*mSubTaskOrderListIterator);
    mSubTaskMapIterator->second->printTaskAsTreeYankTodoMember
        ( pResourceMap,
          pAllocationList,
          (pBlankIndents +2)
        );
    mSubTaskOrderListIterator++;
  }
  
  if (  ((mIsActive)||(mAnyDaughterIsActive))
     && (!(mIsEmptyTopTask))
     )
    printf("%s</Node>\n",pBlankPrefix.c_str());

  return true;
}

bool mrprj::Task::printTaskAsLeafCslTodoMember
( const string& pLevelOrderString,
  const map<string,Resource*>& pResourceMap,
  const list<Allocation*>& pAllocationList
)const
{
  mrprj::DateStringConverter dateStringConverter;
  
  if (  ((mIsActive)||(mAnyDaughterIsActive))
     && (!(mIsEmptyTopTask))
     && (mSubTaskOrderList.size()==0)
     )
  {
    string resourceId;
    string resourceName;
    if(!(getResourceInfos(pResourceMap,pAllocationList,resourceId,resourceName)))
    {
      resourceId=-1;
      resourceName="?";
    }
    
    printf("\"%s:\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\"\n",
            pLevelOrderString.c_str(),
            getTaskTitle().c_str(),
            getClearTaskDescriptionAsOneLine().c_str(),
            resourceName.c_str(),
            dateStringConverter.formGermanDateString(getStartDate()).c_str(),
            dateStringConverter.formGermanDateString(getEndDate()).c_str(),
            getDoneDescription().c_str(),
            getPredecessorString().c_str()
          );
  }

  string actualLevelOrderString="";
  if (!(mIsEmptyTopTask))
  {
    actualLevelOrderString=(pLevelOrderString+".");
  }
  list<string>::const_iterator 
    mSubTaskOrderListIterator
      =mSubTaskOrderList.begin();
  int levelSorter=1;
  char buffer[120];
  string nextOrderString="";
  map<string, Task*>::const_iterator mSubTaskMapIterator;
  while(mSubTaskOrderListIterator!=mSubTaskOrderList.end())
  {
    sprintf(buffer,"%d",levelSorter);
    nextOrderString=(actualLevelOrderString+buffer);
    mSubTaskMapIterator=mSubTaskMap.find(*mSubTaskOrderListIterator);
    mSubTaskMapIterator->second->printTaskAsLeafCslTodoMember
        ( nextOrderString,
          pResourceMap,
          pAllocationList
        );
    mSubTaskOrderListIterator++;
    levelSorter++;
  }

  return true;
}

bool mrprj::Task::printTaskAsTreeCslTodoMember
( const string& pLevelOrderString,
  const map<string,Resource*>& pResourceMap,
  const list<Allocation*>& pAllocationList
)const
{
  krmuo::XmlConverter xmlConverter; 
  mrprj::DateStringConverter dateStringConverter;

  if (  ((mIsActive)||(mAnyDaughterIsActive))
     && (!(mIsEmptyTopTask))
     )
  {
    string resourceId;
    string resourceName;
    if(!(getResourceInfos(pResourceMap,pAllocationList,resourceId,resourceName)))
    {
      resourceId=-1;
      resourceName="?";
    }
    printf("\"%s:\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\",\"%s\"\n",
            pLevelOrderString.c_str(),
            getTaskTitle().c_str(),
            getClearTaskDescriptionAsOneLine().c_str(),
            resourceName.c_str(),
            dateStringConverter.formGermanDateString(getStartDate()).c_str(),
            dateStringConverter.formGermanDateString(getEndDate()).c_str(),
            getDoneDescription().c_str(),
            getPredecessorString().c_str()
          );
  }
      
  string actualLevelOrderString="";
  if (!(mIsEmptyTopTask))
  {
    actualLevelOrderString=(pLevelOrderString+".");
  }
  list<string>::const_iterator 
    mSubTaskOrderListIterator
      =mSubTaskOrderList.begin();
  int levelSorter=1;
  char buffer[120];
  string nextOrderString="";
  map<string, Task*>::const_iterator mSubTaskMapIterator;
  while(mSubTaskOrderListIterator!=mSubTaskOrderList.end())
  {
    sprintf(buffer,"%d",levelSorter);
    nextOrderString=(actualLevelOrderString+buffer);
    mSubTaskMapIterator=mSubTaskMap.find(*mSubTaskOrderListIterator);
    mSubTaskMapIterator->second->printTaskAsTreeCslTodoMember
        ( nextOrderString,
          pResourceMap,
          pAllocationList
        );
    mSubTaskOrderListIterator++;
    levelSorter++;
  }
  
  return true;
}


bool mrprj::Task::printTaskAsHtmlSurveyMember
( const map<string,Resource*>& pResourceMap,
  const list<Allocation*>& pAllocationList,
  const int maxPathLength,
  const string& pSurveyReferenceDayString
)
{
  krmuo::HtmlConverter htmlConverter; 
  mrprj::DateStringConverter dateStringConverter;

  if (mIsEmptyTopTask)
  {

    list<string>::const_iterator 
      mSubTaskOrderListIterator
        =mSubTaskOrderList.begin();
    map<string, Task*>::const_iterator mSubTaskMapIterator;
    while(mSubTaskOrderListIterator!=mSubTaskOrderList.end())
    {

      mSubTaskMapIterator=mSubTaskMap.find(*mSubTaskOrderListIterator);
 
      while(mSubTaskMapIterator->second->mXrowTacker>0)
      {
        printf("  <tr>\n");
      
        mSubTaskMapIterator->second->printTaskAsHtmlSurveyMember
          ( pResourceMap,
            pAllocationList,
            maxPathLength,
            pSurveyReferenceDayString
          );
        printf("  </tr>\n");
      }
      mSubTaskOrderListIterator++;
    }
  
    return true;
  }
  
  //printf("%s->%d\n",getTaskId().c_str(),mXrowTacker);

  if (mXrowTacker==0)
    return false;
    
  if (mXdoPrint)
  {
    int colspanValue=1;
    if (mSubTaskOrderList.size()==0)
    {
      colspanValue=(maxPathLength-mNodeEmbeddedLevel)+1;    
    }
    
    string startDate=getStartDate();
    string endDate=getEndDate();
    string fullFillDegree="fullFilledTask";
    if (mFullFilledPercent<100)
    {
      if (pSurveyReferenceDayString>endDate)
        fullFillDegree="tolateTask";
      else if (pSurveyReferenceDayString<startDate)
        fullFillDegree="openLaterTask";
      else
        fullFillDegree="openNowTask";
    }

    printf("    <td rowspan=\"%d\" colspan=\"%d\" class=\"%s\">\n",
      mXrowspan,colspanValue,fullFillDegree.c_str());
    printf("      <span id=\"taskTitle\">\n");
    printf("        %s [%s]:\n",
      htmlConverter.encode(getTaskTitle()).c_str(),
      getTaskId().c_str()
      );
    printf("      </span>\n");
    printf("      <span id=\"taskDescription\">\n");
    printf("        %s\n",htmlConverter.encode(getClearTaskDescriptionAsOneLine()).c_str());
    printf("      </span>\n");
    printf("      <br />\n");
    printf("      <span id=\"taskTimeslot\">\n");
    printf("        %s - %s\n",
      htmlConverter.encode(dateStringConverter.formGermanDateString(getStartDate())).c_str(),
      htmlConverter.encode(dateStringConverter.formGermanDateString(getEndDate())).c_str()
      );
    printf("      </span>\n");
    
    printf("      <span id=\"taskState\">\n");
    printf("        [%s]\n",
       htmlConverter.encode(getDoneDescription()).c_str()
      );
    printf("      </span>\n");
    
    printf("      <br />\n");
    printf("      <span id=\"taskResource\">\n");
    string resourceId;
    string resourceName;
    if(!(getResourceInfos(pResourceMap,pAllocationList,resourceId,resourceName)))
    {
      resourceId=-1;
      resourceName="?";
    }
    printf("        %s\n",htmlConverter.encode(resourceName).c_str());    
    printf("      </span>\n");
    printf("      <br />\n");
    
    printf("    </td>\n");
    
    mXdoPrint=false;
  }
  
  mXrowTacker-=1;

      
  list<string>::const_iterator 
    mSubTaskOrderListIterator
      =mSubTaskOrderList.begin();
  map<string, Task*>::const_iterator mSubTaskMapIterator;
  bool nextFieldHasBeenPrinted=false;
  while(mSubTaskOrderListIterator!=mSubTaskOrderList.end()&&(!(nextFieldHasBeenPrinted)))
  {
    mSubTaskMapIterator=mSubTaskMap.find(*mSubTaskOrderListIterator);
    nextFieldHasBeenPrinted=
      mSubTaskMapIterator->second->printTaskAsHtmlSurveyMember
        ( pResourceMap,
          pAllocationList,
          maxPathLength,
          pSurveyReferenceDayString
        );
    mSubTaskOrderListIterator++;
  }
  
  return true;
}


/* :-: (5.B.4) private others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
mrprj::Task* mrprj::Task::insertSubTask
( 
  const string& pSubTaskId,
  const string& pSubTaskTitle,
  const string& pSubTaskDescription,
  const string& pSubTaskStartDate,
  const string& pSubTaskEndDate,
  const int pFullFilledPercent
)
{
  if (mSubTaskMap.find(pSubTaskId)!=mSubTaskMap.end())
    return NULL;
  
  Task* 
    newSubTask
      =new  Task
            ( mLoggingUnit,
              pSubTaskId,
              pSubTaskTitle,
              pSubTaskDescription,
              pSubTaskStartDate,
              pSubTaskEndDate,
              pFullFilledPercent
            );
  assert(newSubTask);
  
  mLoggingUnit.makeEntry("inserting task", pSubTaskTitle,HM);
  mSubTaskMap.insert(pair<string,Task*>(pSubTaskId,newSubTask));
  mSubTaskOrderList.push_back(pSubTaskId);
  return newSubTask;
}

bool mrprj::Task::fillTaskPredecessorByMrPrjXmlPredecessorNodes
( 
   xmlDocPtr xmlDoc,
  const xmlNodePtr pFirstPredecessor
)
{
  XmlNodeReader xmlNodeReader;
  if (!(pFirstPredecessor))
    return false;

  xmlNodePtr xmlPredecessorListRunner=pFirstPredecessor;
  while(xmlPredecessorListRunner)
  {
    if (strcmp((char *)xmlPredecessorListRunner->name,"predecessor")==0)
    {
      
      string entryId,predTaskId;
      string predRelationType;
      assert(xmlNodeReader.getStringProperty(xmlDoc,xmlPredecessorListRunner,"id",entryId));
      assert(xmlNodeReader.getStringProperty(xmlDoc,xmlPredecessorListRunner,"predecessor-id",predTaskId));
      assert(xmlNodeReader.getStringProperty(xmlDoc,xmlPredecessorListRunner,"type",predRelationType));
      
      Predecessor* newPredecessor
        =new Predecessor(entryId,predTaskId,predRelationType);
      assert(newPredecessor);
      mPredecessorMap.insert(pair<string,Predecessor*>(entryId,newPredecessor));

    }
    xmlPredecessorListRunner=xmlPredecessorListRunner->next;
  }
  
  return true;
}

bool mrprj::Task::getResourceInfos
(
  const map<string,Resource*>& pResourceMap,
  const list<Allocation*>& pAllocationList,
  string& pResourceId,
  string& pResourceTitle
)const
{

  pResourceId="-1";
  pResourceTitle="?";
  list<Allocation*>
    ::const_iterator 
      pAllocationListIterator
        =pAllocationList.begin();
  while( pAllocationListIterator!=pAllocationList.end()
         && pResourceId=="-1"
         )
  {
    if ((*pAllocationListIterator)->getTaskId()==mTaskId)
        pResourceId=(*pAllocationListIterator)->getResourceId();
    pAllocationListIterator++;
  }
  if (pResourceId=="-1")
    return false;
 
  const map<string,Resource*>
    ::const_iterator 
      pResourceMapIterator
        = pResourceMap.find(pResourceId);
  if (pResourceMapIterator==pResourceMap.end())
    return false;
  
  pResourceTitle=pResourceMapIterator->second->getResourceTitle();
  return true;
}

const string  mrprj::Task::getTaskDescriptionAsOneLine() const
{
  string taskDescriptionAsOneLine="";
  string::const_iterator mTaskDescriptionIterator=mTaskDescription.begin();
  while(mTaskDescriptionIterator!=mTaskDescription.end())
  {
    if ((*mTaskDescriptionIterator<' ')&&(*mTaskDescriptionIterator>0))
      taskDescriptionAsOneLine+=' ';
    else
      taskDescriptionAsOneLine+=*mTaskDescriptionIterator;
    mTaskDescriptionIterator++;
  }
  return taskDescriptionAsOneLine;
}

const string  mrprj::Task::getTaskDescriptionAsFormattedString
( const string& pIndent,
  const int pLineLength
) const
{
  const string taskDescriptionAsOneLine=getTaskDescriptionAsOneLine();
  string taskDescriptionAsFormattedString="";
  string::const_iterator mTaskDescriptionIterator=taskDescriptionAsOneLine.begin();
  int signs=pIndent.length();
  bool split=false;
  while(mTaskDescriptionIterator!=taskDescriptionAsOneLine.end())
  {
    if (signs==pLineLength)
      split=true;
    if (split && (*mTaskDescriptionIterator==' '))
    {
      split=false;
      signs=0;
      taskDescriptionAsFormattedString+=("\n" + pIndent);
     
    }
    signs+=1;
    taskDescriptionAsFormattedString+=*mTaskDescriptionIterator;
    mTaskDescriptionIterator++;
  }
  return taskDescriptionAsFormattedString;
}

const string  mrprj::Task::getClearTaskDescriptionAsOneLine
() const
{
  string description=getTaskDescriptionAsOneLine();
  string::iterator c=description.begin();
  
  while(c!=description.end())
  {
    if (*c == '"')
      *c='\'';
    if (*c == ',')
      *c=';';
      
    c++;
  }
  return description;
}

const string  mrprj::Task::getPredecessorString()
const
{
  string thePredecessors="";
  
  thePredecessors=(getTaskId() + "<-[");
    
  map<string,Predecessor*>::const_iterator 
    mPredecessorMapIterator
      =mPredecessorMap.begin();

  while(mPredecessorMapIterator!=mPredecessorMap.end())
  {
    if (mPredecessorMapIterator==mPredecessorMap.begin())
    {
      thePredecessors=
        (thePredecessors + mPredecessorMapIterator->second->getPredecessorTaskId());
    }
    else
    {
      thePredecessors= 
        ( thePredecessors + "+" +mPredecessorMapIterator->second->getPredecessorTaskId());
    }
    mPredecessorMapIterator++;
  }
  
  thePredecessors=(thePredecessors+"]");
  return thePredecessors;
}

/* &&& (6) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* --- (6.A) public constructors, inits & operators :-:-:-:-: */
mrprj::ResourceGroup::ResourceGroup
( 
  krmuo::LoggingUnit& pLoggingUnit,
  const string& pGroupId,
  const string& pGroupTitle,
  const string& pGroupDescription,
  const string& pGroupAdminName,
  const string& pGroupAdminPhone,
  const string& pGroupAdminEmail
)                       
: 
  mGroupId(pGroupId),
  mGroupTitle(pGroupTitle),
  mGroupDescription(pGroupDescription),
  mGroupAdminName(pGroupAdminName),
  mGroupAdminPhone(pGroupAdminPhone),
  mGroupAdminEmail(pGroupAdminEmail),
  mLoggingUnit(pLoggingUnit)

{
  mLoggingUnit.makeEntry("creating ResourceGroup",mGroupTitle,HM);
}

mrprj::ResourceGroup::~ResourceGroup()
{
  mLoggingUnit.makeEntry("deleting ResourceGroup",mGroupTitle,HM);
} 



/* &&& (7) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* --- (7) public constructors, inits & operators :-:-:-:-: */
mrprj::Resource::Resource
( 
  krmuo::LoggingUnit& pLoggingUnit,
  const string& pResourceId,
  const string& pResourceGroupId,      
  const string& pResourceTitle,
  const string& pResourceDescription,
  const int pResourceType,
  const long pResourceUnits,
  const string& pRecourceEmail,
  float pRecourceStdRate,
  float pRecourceOvtRate
)                       
: 
  mResourceId(pResourceId),
  mResourceGroupId(pResourceGroupId),      
  mResourceTitle(pResourceTitle),
  mResourceDescription(pResourceDescription),
  mResourceType(pResourceType),
  mResourceUnits(pResourceUnits),
  mRecourceEmail(pRecourceEmail),
  mRecourceStdRate(pRecourceStdRate),
  mRecourceOvtRate(pRecourceOvtRate),
  mLoggingUnit(pLoggingUnit) 
{
  mLoggingUnit.makeEntry("creating resource",mResourceTitle,HM);
}

mrprj::Resource::~Resource()
{
  mLoggingUnit.makeEntry("deleting resource",mResourceTitle,HM);
} 

/* &&& (8) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* --- (8) public constructors, inits & operators :-:-:-:-: */
mrprj::Allocation::Allocation
( 
  krmuo::LoggingUnit& pLoggingUnit,
  const string& pTaskId,
  const string& pResourceId      
)                       
: 
  mTaskId(pTaskId),
  mResourceId(pResourceId),
  mLoggingUnit(pLoggingUnit) 
{
  string alloDescr=("task<" + mTaskId +">:<"+ mResourceId+">");
  mLoggingUnit.makeEntry("creating allocation",alloDescr,HM);
}

mrprj::Allocation::~Allocation()
{
  string alloDescr=("task<" + mTaskId +">:<"+ mResourceId+">");
  mLoggingUnit.makeEntry("deleting allocation",alloDescr,HM);
} 





/* &&& (9) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* &&&     methods for class TaskField &&& */

/* --- (9.A) - public ----------------------------------------- */
/* :-: (9.A.1) public constructors, inits & operators :-:-:-:-: */
mrprj::TaskField::TaskField(krmuo::LoggingUnit& pLoggingUnit)                       
: 
  mMainTask(pLoggingUnit,"-1","topTask","container for all real tasks","-","-",0,true),
  mResourceGroupMap(),
  mDefaultResourceGroup("-1"),
  mResourceMap(),
  mAllocationList(),
  mPropertyList(),
  mPhaseList(),
  mDayTypeList(),
  mCalendarList(),
  mLoggingUnit(pLoggingUnit),
  mProjectName(""),
  mProjectCompany(""),
  mProjectManager(""),
  mProjectPhase(""),
  mProjectStart(""),
  mProjectMrpVersion(""),
  mProjectCalendar(""),
  mRealTimeslotStart(""),
  mRealTimeslotEnd("")
{
  mLoggingUnit.makeEntry("creating the mainTask",DM);
}

mrprj::TaskField::~TaskField()
{
  mLoggingUnit.makeEntry("deleting taskField",DM);
  map<string,ResourceGroup*>::iterator 
    resourceGroupMapIterator
      =mResourceGroupMap.begin();
  while(resourceGroupMapIterator!=mResourceGroupMap.end())
  {
    delete(resourceGroupMapIterator->second);
    resourceGroupMapIterator++;
  }

  map<string,Resource*>::iterator 
    resourceMapIterator
      =mResourceMap.begin();
  while(resourceMapIterator!=mResourceMap.end())
  {
    delete(resourceMapIterator->second);
    resourceMapIterator++;
  }
  
  list<Allocation*>::iterator 
    mAllocationListIterator
      =mAllocationList.begin();
  while(mAllocationListIterator!=mAllocationList.end())
  {
    delete(*mAllocationListIterator);
    mAllocationListIterator++;
  }
  list<Property*>::iterator 
    mPropertyListIterator
      =mPropertyList.begin();
  while(mPropertyListIterator!=mPropertyList.end())
  {
    delete(*mPropertyListIterator);
    mPropertyListIterator++;
  }

  list<Phase*>::iterator 
    mPhaseListIterator
      =mPhaseList.begin();
  while(mPhaseListIterator!=mPhaseList.end())
  {
    delete(*mPhaseListIterator);
    mPhaseListIterator++;
  }

  list<DayType*>::iterator 
    mDayTypeListIterator
      =mDayTypeList.begin();
  while(mDayTypeListIterator!=mDayTypeList.end())
  {
    delete(*mDayTypeListIterator);
    mDayTypeListIterator++;
  }

  list<Calendar*>::iterator 
    mCalendarListIterator
      =mCalendarList.begin();
  while(mCalendarListIterator!=mCalendarList.end())
  {
    delete(*mCalendarListIterator);
    mCalendarListIterator++;
  }
  
  
  mGlobalTaskMap.clear();
} 

/* :-: (9.A.4) public others -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */

bool mrprj::TaskField::fillTaskFieldByMrPrjXmlFileContent
( 
  krmuo::LoggingUnit& pLoggingUnit,
  const string& mrprjBaseFileContent
)
{
  XmlNodeReader xmlNodeReader;

  xmlDocPtr xmlDoc=xmlParseMemory(mrprjBaseFileContent.c_str(),mrprjBaseFileContent.size());
  if (!(xmlDoc))
  {
    pLoggingUnit.makeEntry("can't parse the the content of  the mrprj-xml-master-file",SM);
    return false;
  } 
  
  // (2) take the correct root-xml-node
  xmlNodePtr xmlTopNode=xmlDocGetRootElement(xmlDoc);
  if (!(xmlTopNode))
  {
    pLoggingUnit.makeEntry("no topnode found",SM);
    return false;
  }
  
  if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlTopNode,"name",mProjectName)))
    mProjectName="";
  if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlTopNode,"company",mProjectCompany)))
    mProjectCompany="";
  if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlTopNode,"manager",mProjectManager)))
    mProjectManager="";
  if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlTopNode,"phase",mProjectPhase)))
    mProjectPhase="";
  if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlTopNode,"project-start",mProjectStart)))
    mProjectStart="";
  if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlTopNode,"mrproject-version",mProjectMrpVersion)))
    mProjectMrpVersion="";
  if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlTopNode,"calendar",mProjectCalendar)))
    mProjectCalendar="";
  
  
  
  // (3) for all childs of the root-xml-node do
  xmlNodePtr xmlListNode=xmlTopNode->xmlChildrenNode;
  while(xmlListNode)
  {
    // (3.A) read the task-list
    if (strcmp((char *)xmlListNode->name,(char *)"tasks")==0)
    {
      mMainTask.fillTaskSubStructureByMrPrjXmlTaskNodes
        (xmlDoc,xmlListNode->xmlChildrenNode,mGlobalTaskMap);
    }
    
    // (3.B) read the resource-group-list
    if (strcmp((char *)xmlListNode->name,(char *)"resource-groups")==0)
    {
      if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlListNode,"default_group",mDefaultResourceGroup)))
        mDefaultResourceGroup="-1";
      fillResourceGroupMapByMrPrjXmlEntries
        (pLoggingUnit,xmlDoc,xmlListNode->xmlChildrenNode);
    }
    // (3.C) read the resource-list
    if (strcmp((char *)xmlListNode->name,(char *)"resources")==0)
    {
      fillResourceMapByMrPrjXmlEntries
        (pLoggingUnit,xmlDoc,xmlListNode->xmlChildrenNode);
    }
    // (3.D) read the allocation-list
    if (strcmp((char *)xmlListNode->name,(char *)"allocations")==0)
    {
      fillAllocationListByMrPrjXmlEntries
        (pLoggingUnit,xmlDoc,xmlListNode->xmlChildrenNode);
    }
    
    // (3.E) read the property-list
    if (strcmp((char *)xmlListNode->name,(char *)"properties")==0)
    {
      fillPropertyListByMrPrjXmlEntries
        (pLoggingUnit,xmlDoc,xmlListNode->xmlChildrenNode);
    }
    
    // (3.F) read the property-list
    if (strcmp((char *)xmlListNode->name,(char *)"phases")==0)
    {
      fillPhaseListByMrPrjXmlEntries
        (pLoggingUnit,xmlDoc,xmlListNode->xmlChildrenNode);
    }
    
    if (strcmp((char *)xmlListNode->name,(char *)"calendars")==0)
    {
      fillCalendarListByMrPrjXmlEntries
        (pLoggingUnit,xmlDoc,xmlListNode->xmlChildrenNode);
    }


    xmlListNode=xmlListNode->next;
    
    
  }
  //(4) don't become a memory leak
  xmlFreeDoc(xmlDoc);

  return true;
}


bool mrprj::TaskField::limitToResource(const string& pResourceTitel)
{

  map<string,Resource*>::const_iterator 
    mResourceMapIterator
      =mResourceMap.begin();
  string allowedResourceId="-1";
  while(mResourceMapIterator!=mResourceMap.end())
  {
    if (  mResourceMapIterator->second->getResourceTitle()
       == pResourceTitel
       )
      allowedResourceId=mResourceMapIterator->second->getResourceId();
    mResourceMapIterator++;
  }

  if (allowedResourceId=="-1")
    return false;
    
  list<Allocation*>::const_iterator
    mAllocationListIterator
     =mAllocationList.begin();
  while(mAllocationListIterator!=mAllocationList.end())
  {
    if (  (*mAllocationListIterator)->getResourceId()
        !=
          allowedResourceId
        )
      mGlobalTaskMap[(*mAllocationListIterator)->getTaskId()]->setPassive();
    mAllocationListIterator++;
  }

  map<string,Task*>::const_iterator 
    mGlobalTaskMapIterator
      = mGlobalTaskMap.begin();
  while (mGlobalTaskMapIterator != mGlobalTaskMap.end())
  {
    if (  (mGlobalTaskMapIterator->second->numberOfDaughters()==0)
       && (!(mGlobalTaskMapIterator->second->isAllocated()))
       )
      mGlobalTaskMapIterator->second->setPassive();
      mGlobalTaskMapIterator++;
  }
  return true;
}

bool mrprj::TaskField::limitToResourceGroup(const string& pResourceGroupTitel)
{

  map<string,ResourceGroup*>::const_iterator 
    mResourceGroupMapIterator
      =mResourceGroupMap.begin();
  string allowedResourceGroupId="-1";
  while(mResourceGroupMapIterator!=mResourceGroupMap.end())
  {
    if (  mResourceGroupMapIterator->second->getGroupTitle()
       == pResourceGroupTitel
       )
      allowedResourceGroupId=mResourceGroupMapIterator->second->getGroupId();
    mResourceGroupMapIterator++;
  }

  if (allowedResourceGroupId=="-1")
    return false;

  list<Allocation*>::const_iterator
    mAllocationListIterator
     =mAllocationList.begin();
  string realRecourceId;
  string realTaskId;
  while(mAllocationListIterator!=mAllocationList.end())
  {
    // for each member of the allocation list do
    // set passive if their recource-group doesn't match
    realRecourceId=(*mAllocationListIterator)->getResourceId();
    realTaskId=(*mAllocationListIterator)->getTaskId();
   
    map<string,Resource*>::const_iterator
      mResourceMapIterator=mResourceMap.find(realRecourceId);
      
    if (mResourceMapIterator!=mResourceMap.end())
    {
      if (allowedResourceGroupId!=mResourceMapIterator->second->getResourceGroupId())
      {
        mGlobalTaskMap[realTaskId]->setPassive();
      }
    }
    
    
    mAllocationListIterator++;
  }

  // for all existing tasks do
  map<string,Task*>::const_iterator 
    mGlobalTaskMapIterator
      = mGlobalTaskMap.begin();
  while (mGlobalTaskMapIterator != mGlobalTaskMap.end())
  {
    if (  (mGlobalTaskMapIterator->second->numberOfDaughters()==0)
       && (!(mGlobalTaskMapIterator->second->isAllocated()))
       )
      mGlobalTaskMapIterator->second->setPassive();
      mGlobalTaskMapIterator++;
  }
  
  return true;
}

bool mrprj::TaskField::printTaskFieldAsMrPrjXmlFile()const
{
  krmuo::XmlConverter xmlConverter;
  // (1) write the headers
  printf("<?xml version=\"1.0\"?>\n");
  printf("<project xmlns=\"http://mrproject.codefactory.se/format/project/1\" "
          "name=\"%s\" company=\"%s\" manager=\"%s\" "
          "phase=\"%s\" project-start=\"%s\" mrproject-version=\"%s\" calendar=\"%s\">\n",
          mProjectName.c_str(), 
          mProjectCompany.c_str(),
          mProjectManager.c_str(),
          mProjectPhase.c_str(),
          mProjectStart.c_str(),
          mProjectMrpVersion.c_str(),
          mProjectCalendar.c_str()         
        );
  
  
  // (2) write the property-list    
  printf("  <properties>\n");
  list<Property*>::const_iterator
    mPropertyListIterator
      =mPropertyList.begin();
  
  while(mPropertyListIterator!=mPropertyList.end())
  {
    printf(
      "    <property name=\"%s\" type =\"%s\" owner=\"%s\" label=\"%s\" description=\"%s\"/>\n",
      ((*mPropertyListIterator)->getName()).c_str(),
      ((*mPropertyListIterator)->getType()).c_str(),
      ((*mPropertyListIterator)->getOwner()).c_str(),
      ((*mPropertyListIterator)->getLabel()).c_str(),
      ((*mPropertyListIterator)->getDescription()).c_str()
    );
    
    mPropertyListIterator++; 
  }
  printf("  </properties>\n");
  
  // (3) write the phase-list    
  printf("  <phases>\n");
  list<Phase*>::const_iterator
    mPhaseListIterator
      =mPhaseList.begin();
  
  while(mPhaseListIterator!=mPhaseList.end())
  {
    printf("    <phase name=\"%s\" />\n",((*mPhaseListIterator)->getName()).c_str());    
    mPhaseListIterator++; 
  }
  printf("  </phases>\n");
  

  // (4) write the phase-list    
  printf("  <calendars>\n");
  
  printf("    <day-types>\n");
  list<DayType*>::const_iterator
    mDayTypeListIterator
      =mDayTypeList.begin();
  
  while(mDayTypeListIterator!=mDayTypeList.end())
  {
    printf("      <day-type id=\"%s\" name=\"%s\" description=\"%s\"/>\n",
              ((*mDayTypeListIterator)->getId()).c_str(),
              ((*mDayTypeListIterator)->getName()).c_str(),
              ((*mDayTypeListIterator)->getDescription()).c_str()
    );    
    mDayTypeListIterator++; 
  }
  printf("    </day-types>\n");
  
  
  list<Calendar*>::const_iterator
    mCalendarListIterator
      =mCalendarList.begin();
  
  while(mCalendarListIterator!=mCalendarList.end())
  {
    printf("    <calendar id=\"%s\"  name=\"%s\" >\n",
      ((*mCalendarListIterator)->getId()).c_str(),
      ((*mCalendarListIterator)->getName()).c_str()
      );
    
    printf("      <default-week mon=\"%s\" tue=\"%s\" wed=\"%s\" thu=\"%s\" fri=\"%s\" sat=\"%s\" sun=\"%s\"/>\n",
        ((*mCalendarListIterator)->mMon).c_str(),
        ((*mCalendarListIterator)->mTue).c_str(),
        ((*mCalendarListIterator)->mWed).c_str(),
        ((*mCalendarListIterator)->mThu).c_str(),
        ((*mCalendarListIterator)->mFri).c_str(),
        ((*mCalendarListIterator)->mSat).c_str(),
        ((*mCalendarListIterator)->mSun).c_str() 
        );
    
    printf("      <overridden-day-types>\n");
    list<OverriddenDayType>::const_iterator
      mOverriddenDayTypeListIterator
        =((*mCalendarListIterator)->mOverriddenDayTypeList).begin();
    while(mOverriddenDayTypeListIterator!=((*mCalendarListIterator)->mOverriddenDayTypeList).end())
    {
      printf("        <overridden-day-type id=\"%s\">\n",(mOverriddenDayTypeListIterator->getId().c_str()));
      list<Interval>::const_iterator
      intervalListIterator
        =(mOverriddenDayTypeListIterator->mIntervalList).begin();
      while(intervalListIterator!=(mOverriddenDayTypeListIterator->mIntervalList).end())
      {
        printf("          <interval start=\"%s\" end=\"%s\" />\n",
          (intervalListIterator->getStart()).c_str(),
          (intervalListIterator->getEnd()).c_str() 
        );
        
        intervalListIterator++;
      }
      printf("        </overridden-day-type>\n");    
      mOverriddenDayTypeListIterator++; 
    } 
    printf("      </overridden-day-types>\n");

    printf("      <days>\n");
    list<Day>::const_iterator
      mDayListIterator
        =((*mCalendarListIterator)->mDayList).begin();
    while(mDayListIterator!=((*mCalendarListIterator)->mDayList).end())
    {
      printf("        <day date=\"%s\" type=\"%s\" id=\"%s\" />\n",
        (mDayListIterator->getDate()).c_str(),
        (mDayListIterator->getType()).c_str(),
        (mDayListIterator->getId()).c_str()
        
        );
      mDayListIterator++; 
    } 
    printf("      </days>\n");
    printf("    </calendar>\n");
    
    mCalendarListIterator++; 
  }
  printf("  </calendars>\n");
  
  
  // (2) write the task-list  
  mMainTask.printTaskAsMrPrjXmlFileMember(2);
    
  // (3) write the resource-group-list 
  if ((mDefaultResourceGroup=="")||(mDefaultResourceGroup=="-1"))
    printf("  <resource-groups>\n");
  else
    printf("  <resource-groups default_group=\"%s\" >\n",mDefaultResourceGroup.c_str());
    
  map<string,ResourceGroup*>::const_iterator
    resourceGroupMapIterator=
      mResourceGroupMap.begin();
  while(resourceGroupMapIterator!=mResourceGroupMap.end())
  {
    printf( "    <group id=\"%s\" name=\"%s\" "
           "admin-name=\"%s\" admin-phone=\"%s\" admin-email=\"%s\" />\n",
            xmlConverter.encode(resourceGroupMapIterator->second->getGroupId()).c_str(),
            xmlConverter.encode(resourceGroupMapIterator->second->getGroupTitle()).c_str(),
            xmlConverter.encode(resourceGroupMapIterator->second->getGroupAdminName()).c_str(),
            xmlConverter.encode(resourceGroupMapIterator->second->getGroupAdminPhone()).c_str(),
            xmlConverter.encode(resourceGroupMapIterator->second->getGroupAdminEmail()).c_str());
    resourceGroupMapIterator++;
  }
  printf("  </resource-groups>\n");
  
  // (4) write the resource-list    
  printf("  <resources>\n");
  map<string,Resource*>::const_iterator 
    resourceMapIterator=
      mResourceMap.begin();
  while(resourceMapIterator!=mResourceMap.end())
  {
     printf( "    <resource id=\"%s\" name=\"%s\" group=\"%s\" "
             "type=\"%d\" units=\"%ld\" email=\"%s\" "
             "std-rate=\"%f\" ovt-rate=\"%f\" />\n",
             xmlConverter.encode(resourceMapIterator->second->getResourceId()).c_str(),
             xmlConverter.encode(resourceMapIterator->second->getResourceTitle()).c_str(),
             xmlConverter.encode(resourceMapIterator->second->getResourceGroupId()).c_str(),
             resourceMapIterator->second->getResourceType(),
             resourceMapIterator->second->getResourceUnits(),
             resourceMapIterator->second->getRecourceEmail().c_str(),
             resourceMapIterator->second->getRecourceStdRate(),
             resourceMapIterator->second->getRecourceOvtRate());
    resourceMapIterator++;
  }
  
  printf("  </resources>\n");
  
  // (5) write the allocation-list    
  printf("  <allocations>\n");
  list<Allocation*>::const_iterator
    mAllocationListIterator
      =mAllocationList.begin();
  string taskId,resourceId;
  map<string,Task*>::const_iterator mGlobalTaskMapIterator;
  
  while(mAllocationListIterator!=mAllocationList.end())
  {
    taskId=(*mAllocationListIterator)->getTaskId();
    resourceId=(*mAllocationListIterator)->getResourceId();
    mGlobalTaskMapIterator=mGlobalTaskMap.find(taskId);
    if (mGlobalTaskMapIterator->second->isActive())
    {
      printf("    <allocation task-id=\"%s\" resource-id=\"%s\" />\n",taskId.c_str(),resourceId.c_str());
    }
    mAllocationListIterator++; 
  }
  printf("  </allocations>\n");
  printf("</project>\n");

  return true;
}
bool mrprj::TaskField::printTaskFieldAsLeafListMemo(bool pIso8601)
{
  // (1) write the headers
  storeRealTimeSlot();
  printf("tasks between %s and %s\n\n",
          mRealTimeslotStart.c_str(),
          mRealTimeslotEnd.c_str()
        );
  
  // (2) write the task-list  
  mMainTask.printTaskAsLeafMemoListMember("","",mResourceMap,mAllocationList,pIso8601);
  
  return true;
}
bool mrprj::TaskField:: printTaskFieldAsTreeMemo(bool pIso8601)
{
  // (1) write the headers
  storeRealTimeSlot();
  printf("tasks between %s and %s\n\n",
          mRealTimeslotStart.c_str(),
          mRealTimeslotEnd.c_str()
        );
  
  // (2) write the task-list  
  mMainTask.printTaskAsTreeMemoMember("",-1,mResourceMap,mAllocationList,pIso8601);
  
  return true;
}

void mrprj::TaskField::printTaskFieldAsLeafYankTodo()
{
  printf("<?xml version=\"1.0\"?>\n");
  printf("<yank>\n");
  mMainTask.printTaskAsLeafYankTodoMember(mResourceMap,mAllocationList);
  printf("</yank>\n");

}

void mrprj::TaskField:: printTaskFieldAsTreeYankTodo()
{
  printf("<?xml version=\"1.0\"?>\n");
  printf("<yank>\n");
  mMainTask.printTaskAsTreeYankTodoMember(mResourceMap,mAllocationList,2);
  printf("</yank>\n");

}

void mrprj::TaskField::printTaskFieldAsLeafCslTodo()
{
   printf("\"Nr.\",\"Task\",\"Description\","
        "\"Actor\",\"Begin\",\"End\","
        "\"State\",\"Conditions\"\n");
  mMainTask.printTaskAsLeafCslTodoMember("",mResourceMap,mAllocationList);
}

void mrprj::TaskField:: printTaskFieldAsTreeCslTodo()
{
  printf("\"Nr.\",\"Task\",\"Description\","
        "\"Actor\",\"Begin\",\"End\","
        "\"State\",\"Conditions\"\n");
  mMainTask.printTaskAsTreeCslTodoMember("",mResourceMap,mAllocationList);
}


void mrprj::TaskField::printTaskHtmlSurvey(const string& pSurveyReferenceDayString)
{
   
   printf("<html>\n");
   printf("<head>\n");
   printf("<title>%s: fullfilled taskstructure with respect to %s</title>\n",
    mProjectName.c_str(),pSurveyReferenceDayString.c_str());
   printf("</title>\n");
   printf("<style type=\"text/css\">\n<!--\n");
   printf("body.default {\n"
          "  background-color: #ffffff;\n"     
          "  color: #000000;\n"
          "  font-size: 12pt;\n"
          "  font-style: normal;\n"
          "  font-weight: normal;\n"
          "  font-family: century schoolbook,Times,Serif;\n"
          "}\n");
          
   printf("td.fullFilledTask {\n"
          "  background-color: #00ff00;\n"
          "}\n");
   
   printf("td.tolateTask {\n"
          "  background-color: #ff0000;\n"
          "}\n");

   printf("td.openLaterTask {\n"
          "  background-color: #bbbbbb;\n"
          "}\n");

   printf("td.openNowTask {\n"
          "  background-color: #ffbb00;\n"
          "}\n");
    
   printf("#taskTitle {\n"
          "  font-family: Helvetica,Arial,Sans-Serif;\n"
          "  font-weight: bold;\n"
          "  font-size: 12pt;\n"
          "  font-style: normal;\n"
          "}\n");
    
   printf("#taskDescription {\n"
          "  font-family: Times,Serif;\n"
          "  font-weight: normal;\n"
          "  font-size: 12pt;\n"
          "  font-style: oblique;\n"
          "}\n");

   printf("#taskResource {\n"
          "  font-family: Helvetica,Arial,Sans-Serif;\n"
          "  font-weight: bold;\n"
          "  font-size: 12pt;\n"
          "  font-style: oblique;\n"
          "}\n");

   printf("#taskTimeslot {\n"
          "  font-family: Helvetica,Arial,Sans-Serif;\n"
          "  font-weight: normal;\n"
          "  font-size: 12pt;\n"
          "  color: blue;\n"
          "  font-style: normal;\n"
          "}\n");

   printf("#taskState {\n"
          "  font-family: Helvetica,Arial,Sans-Serif;\n"
          "  font-weight: bold;\n"
          "  font-size: 12pt;\n"
          "  color: black;\n"
          "  font-style: normal;\n"
          "}\n");

    
   printf("-->\n</style>\n");
   printf("</head>\n");
   printf("<body class=\"default\">\n");
   int maxPathLength=0;  
   mMainTask.insertXYposition(0,maxPathLength);
   printf("<table border=\"1\">\n");   
   mMainTask.printTaskAsHtmlSurveyMember
    (mResourceMap,mAllocationList,maxPathLength,pSurveyReferenceDayString);
   printf("</table>\n");
   printf("</body>\n");
   printf("</html>\n");
};

/* :-: (9.B.1) private getters :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
string mrprj::TaskField::getConnectProjectName()const
{
  string connectedProjectName=mProjectName;
  string::iterator connectedProjectNameInterator=connectedProjectName.begin();
  while(connectedProjectNameInterator != connectedProjectName.end())
  {
    if ( *connectedProjectNameInterator <= ' ')
      *connectedProjectNameInterator='-';
    connectedProjectNameInterator++;
  }
  return connectedProjectName;
}
/* :-: (9.B.4) private others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */

bool mrprj::TaskField::fillResourceGroupMapByMrPrjXmlEntries
(
  krmuo::LoggingUnit& pLoggingUnit,
  xmlDocPtr xmlDoc, 
  const xmlNodePtr pFirstResourceGroup
)
{
  if (!(pFirstResourceGroup))
    return false;
  
  string lResourceGroupId;
  string lResourceGroupName;
  string lResourceGroupAdminName;
  string lResourceGroupAdminPhone;
  string lResourceGroupAdminEmail;
  XmlNodeReader xmlNodeReader;
  
  xmlNodePtr xmlResourceGroupListRunner=pFirstResourceGroup;
  while(xmlResourceGroupListRunner)
  {
    if (strcmp((char *)xmlResourceGroupListRunner->name,"group")==0)
    {
      assert(xmlNodeReader.getStringProperty(xmlDoc,xmlResourceGroupListRunner,"id",lResourceGroupId));
      if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlResourceGroupListRunner,"name",lResourceGroupName)))
        lResourceGroupName="???";
      if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlResourceGroupListRunner,"admin-name",lResourceGroupAdminName)))
        lResourceGroupAdminName="???";
      if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlResourceGroupListRunner,"admin-phone",lResourceGroupAdminPhone)))
        lResourceGroupAdminPhone="???";
      if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlResourceGroupListRunner,"admin-email",lResourceGroupAdminEmail)))
        lResourceGroupAdminEmail="???";
        
      ResourceGroup* newResourceGroup
        =new ResourceGroup(pLoggingUnit,
                           lResourceGroupId,
                           lResourceGroupName,
                           "---",
                           lResourceGroupAdminName,
                           lResourceGroupAdminPhone,
                           lResourceGroupAdminEmail
                          );
      assert(newResourceGroup);
      mResourceGroupMap.insert(pair<string,ResourceGroup*>(lResourceGroupId,newResourceGroup));
    }
    xmlResourceGroupListRunner=xmlResourceGroupListRunner->next;
  }
  return true;
}

bool mrprj::TaskField::fillResourceMapByMrPrjXmlEntries
( 
  krmuo::LoggingUnit& pLoggingUnit,
  xmlDocPtr xmlDoc, 
  const xmlNodePtr pFirstResource 
)
{
  if (!(pFirstResource))
    return false;
  
  string resourceId,resourceGroupId;
  long resourceUnits;
  string resourceTitle,resourceEmail;
  int resourceType;
  float resourceStdRate,resourceOvtRate;
  XmlNodeReader xmlNodeReader;
  
  xmlNodePtr xmlResourceListRunner=pFirstResource;
  while(xmlResourceListRunner)
  {
    if (strcmp((char *)xmlResourceListRunner->name,"resource")==0)
    {
      assert(xmlNodeReader.getStringProperty(xmlDoc,xmlResourceListRunner,"id",resourceId));
      if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlResourceListRunner,"group",resourceGroupId)))
        resourceGroupId=-1;
      if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlResourceListRunner,"name",resourceTitle)))
        resourceTitle="???";
      if (!(xmlNodeReader.getStringProperty(xmlDoc,xmlResourceListRunner,"email",resourceEmail)))
        resourceEmail="???";
      if (!(xmlNodeReader.getIntProperty(xmlDoc,xmlResourceListRunner,"type",resourceType)))
        resourceType=-1;
      if (!(xmlNodeReader.getLongProperty(xmlDoc,xmlResourceListRunner,"units",resourceUnits)))
        resourceUnits=100;
      if (!(xmlNodeReader.getFloatProperty(xmlDoc,xmlResourceListRunner,"std-rate",resourceStdRate)))
        resourceStdRate=0.0;
      if (!(xmlNodeReader.getFloatProperty(xmlDoc,xmlResourceListRunner,"ovt-rate",resourceOvtRate)))
        resourceOvtRate=0.0;
 
      Resource* newResource
        =new Resource(pLoggingUnit,
                      resourceId,
                      resourceGroupId,
                      resourceTitle,
                      "---",
                      resourceType,
                      resourceUnits,
                      resourceEmail,
                      resourceStdRate,
                      resourceOvtRate
                     );
 
      assert(newResource);
      mResourceMap.insert(pair<string,Resource*>(resourceId,newResource));
    }
    xmlResourceListRunner=xmlResourceListRunner->next;
  }  
  return true;
}

bool mrprj::TaskField::fillAllocationListByMrPrjXmlEntries
( 
  krmuo::LoggingUnit& pLoggingUnit,
  xmlDocPtr xmlDoc, 
  const xmlNodePtr pFirstAllocation
)
{
  XmlNodeReader xmlNodeReader;
  if (!(pFirstAllocation))
    return false;
  string taskId,resourceId;

  xmlNodePtr xmlAllocationListRunner=pFirstAllocation;
  while(xmlAllocationListRunner)
  {
    if (strcmp((char *)xmlAllocationListRunner->name,"allocation")==0)
    {
      if (  xmlNodeReader.getStringProperty(xmlDoc,xmlAllocationListRunner,"task-id",taskId)
         &&
            xmlNodeReader.getStringProperty(xmlDoc,xmlAllocationListRunner,"resource-id",resourceId)
          )
      {
        Allocation* newAllocation
          =new Allocation(pLoggingUnit,
                          taskId,
                          resourceId
                          );
        assert(newAllocation);
        mAllocationList.push_back(newAllocation);
        mGlobalTaskMap[taskId]->setAllocated();
      }
    }
    xmlAllocationListRunner=xmlAllocationListRunner->next;
  }
  return true;
}

bool mrprj::TaskField::fillPropertyListByMrPrjXmlEntries
( 
  krmuo::LoggingUnit& pLoggingUnit,
  xmlDocPtr xmlDoc, 
  const xmlNodePtr pFirstProperty
)
{
  XmlNodeReader xmlNodeReader;
  if (!(pFirstProperty))
    return false;
  string name,type,owner,label,description;

  xmlNodePtr xmlPropertyListRunner=pFirstProperty;
  while(xmlPropertyListRunner)
  {
    if (strcmp((char *)xmlPropertyListRunner->name,"property")==0)
    {
      if (  xmlNodeReader.getStringProperty(xmlDoc,xmlPropertyListRunner,"name",name)
          &&
            xmlNodeReader.getStringProperty(xmlDoc,xmlPropertyListRunner,"type",type)
          &&
            xmlNodeReader.getStringProperty(xmlDoc,xmlPropertyListRunner,"owner",owner)
          &&
            xmlNodeReader.getStringProperty(xmlDoc,xmlPropertyListRunner,"label",label)
          &&
            xmlNodeReader.getStringProperty(xmlDoc,xmlPropertyListRunner,"description",description)
            
          )
        
      {
        Property* newProperty
          =new Property(pLoggingUnit,name,type,owner,label,description);
        assert(newProperty);
        mPropertyList.push_back(newProperty);
      }
    }
    xmlPropertyListRunner=xmlPropertyListRunner->next;
  }
  return true;
}

bool mrprj::TaskField::fillPhaseListByMrPrjXmlEntries
( 
  krmuo::LoggingUnit& pLoggingUnit,
  xmlDocPtr xmlDoc, 
  const xmlNodePtr pFirstPhase
)
{
  XmlNodeReader xmlNodeReader;
  if (!(pFirstPhase))
    return false;
  string name;

  xmlNodePtr xmlPhaseListRunner=pFirstPhase;
  while(xmlPhaseListRunner)
  {
    if (strcmp((char *)xmlPhaseListRunner->name,"phase")==0)
    {
      if ( xmlNodeReader.getStringProperty(xmlDoc,xmlPhaseListRunner,"name",name))
        
      {
        Phase* newPhase
          =new Phase(pLoggingUnit,name);
        assert(newPhase);
        mPhaseList.push_back(newPhase);
      }
    }
    xmlPhaseListRunner=xmlPhaseListRunner->next;
  }
  return true;
}

bool mrprj::TaskField::fillDayTypeListByMrPrjXmlEntries
( 
  krmuo::LoggingUnit& pLoggingUnit,
  xmlDocPtr xmlDoc, 
  const xmlNodePtr pFirstDayType
)
{
  XmlNodeReader xmlNodeReader;
  if (!(pFirstDayType))
    return false;
  string id;
  string name;
  string description;

  xmlNodePtr xmlDayTypeListRunner=pFirstDayType;
  while(xmlDayTypeListRunner)
  {
    if (strcmp((char *)xmlDayTypeListRunner->name,"day-type")==0)
    {
      if (( ( xmlNodeReader.getStringProperty(xmlDoc,xmlDayTypeListRunner,"name",name))
          && ( xmlNodeReader.getStringProperty(xmlDoc,xmlDayTypeListRunner,"id",id))
          )
          &&
          ( xmlNodeReader.getStringProperty(xmlDoc,xmlDayTypeListRunner,"description",description))
        )
        
      {
        DayType* newDayType
          =new DayType(pLoggingUnit,id,name,description);
        assert(newDayType);
        mDayTypeList.push_back(newDayType);
      }
    }
    xmlDayTypeListRunner=xmlDayTypeListRunner->next;
  }
  return true;
}

bool mrprj::TaskField::fillIntervalListByMrPrjXmlEntries
( 
  krmuo::LoggingUnit& pLoggingUnit,
  xmlDocPtr xmlDoc, 
  const xmlNodePtr pFirstInterval,
  list<Interval>& pIntervalList
)
{
  XmlNodeReader xmlNodeReader;
  if (!(pFirstInterval))
    return false;

  string startTime,endTime;
  
  xmlNodePtr xmlIntervalListRunner=pFirstInterval;
  while(xmlIntervalListRunner)
  {
    if (strcmp((char *)xmlIntervalListRunner->name,"interval")==0)
    {
      if (  ( xmlNodeReader.getStringProperty(xmlDoc,xmlIntervalListRunner,"start",startTime))
         && ( xmlNodeReader.getStringProperty(xmlDoc,xmlIntervalListRunner,"end",endTime))
         )
      {               
        Interval newInterval(pLoggingUnit,startTime,endTime);
        pIntervalList.push_back(newInterval);
      }
    }
    xmlIntervalListRunner=xmlIntervalListRunner->next;
  }
  return true;
}


bool mrprj::TaskField::fillOverriddenDayTypeListByMrPrjXmlEntries
( 
  krmuo::LoggingUnit& pLoggingUnit,
  xmlDocPtr xmlDoc, 
  const xmlNodePtr pFirstOverriddenDayType,
  list<OverriddenDayType>& pOverriddenDayTypeList
)
{
  XmlNodeReader xmlNodeReader;
  if (!(pFirstOverriddenDayType))
    return false;

  string id;
  
  xmlNodePtr xmlOverriddenDayTypeListRunner=pFirstOverriddenDayType;
  while(xmlOverriddenDayTypeListRunner)
  {
    if (strcmp((char *)xmlOverriddenDayTypeListRunner->name,"overridden-day-type")==0)
    {
      if ( xmlNodeReader.getStringProperty(xmlDoc,xmlOverriddenDayTypeListRunner,"id",id))
      {               
        OverriddenDayType newOverriddenDayType(pLoggingUnit,id);
        fillIntervalListByMrPrjXmlEntries
        (pLoggingUnit,xmlDoc,xmlOverriddenDayTypeListRunner->xmlChildrenNode,newOverriddenDayType.mIntervalList);
        pOverriddenDayTypeList.push_back(newOverriddenDayType);
      }
      
    }
    xmlOverriddenDayTypeListRunner=xmlOverriddenDayTypeListRunner->next;
  }
  return true;
}

bool mrprj::TaskField::fillDayListByMrPrjXmlEntries
( 
  krmuo::LoggingUnit& pLoggingUnit,
  xmlDocPtr xmlDoc, 
  const xmlNodePtr pFirstDay,
  list<Day>& pDayList
)
{
  XmlNodeReader xmlNodeReader;
  if (!(pFirstDay))
    return false;
  string date;
  string type;
  string id;
  
  xmlNodePtr xmlDayListRunner=pFirstDay;
  while(xmlDayListRunner)
  {
    if (strcmp((char *)xmlDayListRunner->name,"day")==0)
    {
      if (  ( ( xmlNodeReader.getStringProperty(xmlDoc,xmlDayListRunner,"date",date))
            && ( xmlNodeReader.getStringProperty(xmlDoc,xmlDayListRunner,"type",type))
            )
          && xmlNodeReader.getStringProperty(xmlDoc,xmlDayListRunner,"id",id)
        )
       {
               
        Day newDay(pLoggingUnit,date,type,id);
        pDayList.push_back(newDay);
      }
    }
    xmlDayListRunner=xmlDayListRunner->next;
  }
  return true;
}

bool mrprj::TaskField::fillCalSubPartByMrPrjXmlEntries
( 
  krmuo::LoggingUnit& pLoggingUnit,
  xmlDocPtr xmlDoc, 
  const xmlNodePtr pFirstCalSubPart,
  Calendar* pCalendar
)
{
  XmlNodeReader xmlNodeReader;
  if (!(pFirstCalSubPart))
    return false;
  string dayx;

  xmlNodePtr xmlCalSubPartListRunner=pFirstCalSubPart;
  while(xmlCalSubPartListRunner)
  {
    if (strcmp((char *)xmlCalSubPartListRunner->name,"overridden-day-types")==0)
    {
      fillOverriddenDayTypeListByMrPrjXmlEntries
      ( pLoggingUnit,xmlDoc,xmlCalSubPartListRunner->xmlChildrenNode,pCalendar->mOverriddenDayTypeList);
      
    }
    
    if (strcmp((char *)xmlCalSubPartListRunner->name,"days")==0)
       fillDayListByMrPrjXmlEntries(pLoggingUnit,xmlDoc,xmlCalSubPartListRunner->xmlChildrenNode,pCalendar->mDayList);
    
    
    if (strcmp((char *)xmlCalSubPartListRunner->name,"default-week")==0)
    {
    
      if ( xmlNodeReader.getStringProperty(xmlDoc,xmlCalSubPartListRunner,"mon",dayx))
        pCalendar->mMon=dayx;
      if ( xmlNodeReader.getStringProperty(xmlDoc,xmlCalSubPartListRunner,"tue",dayx))
        pCalendar->mTue=dayx;
      if ( xmlNodeReader.getStringProperty(xmlDoc,xmlCalSubPartListRunner,"wed",dayx))
        pCalendar->mWed=dayx;
      if ( xmlNodeReader.getStringProperty(xmlDoc,xmlCalSubPartListRunner,"thu",dayx))
        pCalendar->mThu=dayx;
      if ( xmlNodeReader.getStringProperty(xmlDoc,xmlCalSubPartListRunner,"fri",dayx))
        pCalendar->mFri=dayx;
      if ( xmlNodeReader.getStringProperty(xmlDoc,xmlCalSubPartListRunner,"sat",dayx))
        pCalendar->mSat=dayx;
      if ( xmlNodeReader.getStringProperty(xmlDoc,xmlCalSubPartListRunner,"sun",dayx))
        pCalendar->mSun=dayx;

    }
    
    
    
    xmlCalSubPartListRunner=xmlCalSubPartListRunner->next;
  }
  return true;
}

bool mrprj::TaskField::fillCalendarListByMrPrjXmlEntries
( 
  krmuo::LoggingUnit& pLoggingUnit,
  xmlDocPtr xmlDoc, 
  const xmlNodePtr pFirstCalendar
)
{
  XmlNodeReader xmlNodeReader;
  if (!(pFirstCalendar))
    return false;
  string id;
  string name;
  string description;

  xmlNodePtr xmlCalendarListRunner=pFirstCalendar;
  while(xmlCalendarListRunner)
  {
    if (strcmp((char *)xmlCalendarListRunner->name,"day-types")==0)
    {
      fillDayTypeListByMrPrjXmlEntries
        (pLoggingUnit,xmlDoc,xmlCalendarListRunner->xmlChildrenNode);
      
    }
    if (strcmp((char *)xmlCalendarListRunner->name,"calendar")==0)
    {
      if (  ( xmlNodeReader.getStringProperty(xmlDoc,xmlCalendarListRunner,"name",name))
          && ( xmlNodeReader.getStringProperty(xmlDoc,xmlCalendarListRunner,"id",id))
          )
      {
        Calendar* newCalendar
          =new Calendar(pLoggingUnit,id,name);
        assert(newCalendar);
        mCalendarList.push_back(newCalendar);
        fillCalSubPartByMrPrjXmlEntries(pLoggingUnit,xmlDoc,xmlCalendarListRunner->xmlChildrenNode,newCalendar);
        
      }
      
    }
    
    xmlCalendarListRunner=xmlCalendarListRunner->next;
  }
  return true;
}


void mrprj::TaskField::storeRealTimeSlot()
{
  mRealTimeslotStart="99991231T240000";
  mRealTimeslotEnd="00000101T000000";
  
  map<string,Task*>::const_iterator 
    mGlobalTaskMapIterator
      =mGlobalTaskMap.begin();
  while(mGlobalTaskMapIterator!=mGlobalTaskMap.end())
  {
    if ( mGlobalTaskMapIterator->second->getStartDate() < mRealTimeslotStart)
      mRealTimeslotStart=mGlobalTaskMapIterator->second->getStartDate();
      
    if ( mGlobalTaskMapIterator->second->getEndDate() > mRealTimeslotEnd)
      mRealTimeslotEnd=mGlobalTaskMapIterator->second->getEndDate();
      
    mGlobalTaskMapIterator++;
  }
}

---