[doc_tool] Moved Doxygen and Sourcecode chapter generation implementation to own...
authorDaniel G <daniel@giritzer.eu>
Mon, 14 May 2018 03:56:55 +0000 (05:56 +0200)
committerDaniel G <daniel@giritzer.eu>
Mon, 14 May 2018 03:56:55 +0000 (05:56 +0200)
Added more advanced Editor right click menu.

24 files changed:
src/Author.h
src/Chapter.h [deleted file]
src/ChapterFactory.cxx [new file with mode: 0644]
src/ChapterFactory.h [new file with mode: 0644]
src/ChapterIF.h [new file with mode: 0644]
src/Controller.cxx
src/Controller.h
src/ControllerIF.h
src/DoxygenChapter.h [new file with mode: 0644]
src/FSHelper.cxx
src/FSHelper.h
src/Model.cxx
src/Model.h
src/ModelIF.h
src/SourceChapter.h [new file with mode: 0644]
src/TextChapter.h [new file with mode: 0644]
src/View.cxx
src/View.h
src/ViewFluid.cxx
src/ViewFluid.fld
src/ViewFluid.h
src/doc_tool.cbp
src/doc_tool.depend
src/main.cxx

index 94f9d58..1dab21e 100644 (file)
@@ -69,6 +69,14 @@ public:
     {
         mTimeSpent = val;
     }
+    std::string GetID() const
+    {
+        return mID;
+    }
+    void SetID(std::string val)
+    {
+        mID = val;
+    }
     unsigned int GetXTimeSpentCoordinate() const
     {
         return mXTimeSpentCoordinate;
@@ -101,6 +109,22 @@ public:
     {
         mYTimeEstimatedCoordinate = val;
     }
+    unsigned int GetYid() const
+    {
+        return mYid;
+    }
+    void SetYid(unsigned int val)
+    {
+        mYid = val;
+    }
+    unsigned int GetXid() const
+    {
+        return mXid;
+    }
+    void SetXid(unsigned int val)
+    {
+        mXid = val;
+    }
 
     /////////////////////////////////////////////////
     /// \brief Typedef für einen shared Pointer auf
@@ -116,10 +140,13 @@ private:
     unsigned int mXNameCoordinate;
     unsigned int mYNameCoordinate;
     std::string mName;
+    std::string mID;
     std::string mTimeEstimated;
     std::string mTimeSpent;
     unsigned int mXTimeSpentCoordinate;
     unsigned int mYTimeSpentCoordinate;
+    unsigned int mXid;
+    unsigned int mYid;
     unsigned int mXTimeEstimatedCoordinate;
     unsigned int mYTimeEstimatedCoordinate;
 };
diff --git a/src/Chapter.h b/src/Chapter.h
deleted file mode 100644 (file)
index 1bd1a41..0000000
+++ /dev/null
@@ -1,99 +0,0 @@
-///////////////////////////////////////////////////////////////////////////
-// Workfile: Chapter.h
-// Author: Daniel Giritzer <daniel@giritzer.eu>
-// Date: 25.03.2018
-// Description: Einfache Klasse zum Speichern Kapiteln.
-// Remarks: Diese Klasse besteht nur aus einer Header Datei.
-///////////////////////////////////////////////////////////////////////////
-#ifndef CHAPTER_H
-#define CHAPTER_H
-
-#include <iostream>
-#include "Object.h"
-#include <fstream>
-
-/////////////////////////////////////////////////
-/// \brief Klasse zum speichern von
-///        Kapitelinformationen.
-/////////////////////////////////////////////////
-class Chapter : Object
-{
-public:
-    Chapter() = default;
-    virtual ~Chapter() = default;
-
-    std::string GetPrettyName() const
-    {
-        return mPrettyName;
-    }
-    void SetPrettyName(std::string val)
-    {
-        mPrettyName = val;
-    }
-    std::string GetOutFileName() const
-    {
-        return mOutFileName;
-    }
-    void SetOutFileName(std::string val)
-    {
-        mOutFileName = val;
-    }
-    int GetNum() const
-    {
-        return mNum;
-    }
-    void SetNum(int val)
-    {
-        mNum = val;
-    }
-    bool GetDone() const
-    {
-        return mDone;
-    }
-    void SetDone(bool done)
-    {
-        mDone = done;
-    }
-    std::string GetText() const
-    {
-        return mText;
-    }
-    void SetText(std::string const &text)
-    {
-        mText = text;
-    }
-    void WriteFile(std::string outPath)
-    {
-        std::ofstream oFstr;
-        oFstr.open(outPath + mOutFileName);
-
-        //Dateistatus Prüfen
-        if(!oFstr.good())
-            throw std::string("Could not create output file: " + outPath + mOutFileName);
-
-
-        //Buffer auf oFstr schreiben
-        oFstr << mText;
-
-        oFstr.close();
-    }
-
-    /////////////////////////////////////////////////
-    /// \brief Typedef für einen shared Pointer auf
-    ///        ein Objekt dieser Klasse oder deren
-    ///        Implementierung.
-    /////////////////////////////////////////////////
-    using SPtr = std::shared_ptr<Chapter>;
-
-
-protected:
-
-private:
-    std::string mPrettyName;
-    std::string mOutFileName;
-    std::string mText;
-    int mNum;
-    bool mDone;
-};
-
-#endif // CHAPTER_H
diff --git a/src/ChapterFactory.cxx b/src/ChapterFactory.cxx
new file mode 100644 (file)
index 0000000..29d8ba3
--- /dev/null
@@ -0,0 +1,41 @@
+///////////////////////////////////////////////////////////////////////////
+// Workfile: ChapterFactory.cpp
+// Author: Daniel Giritzer <daniel@giritzer.eu>
+// Date: 11.05.2018
+// Description: Simple Factory Klasse zum erzeugen verschiedener
+//              Kapitel Implementierungen.
+// Remarks: -
+///////////////////////////////////////////////////////////////////////////
+#include "ChapterFactory.h"
+
+
+ChapterIF::SPtr ChapterFactory::createChapter(std::string type)
+{
+
+    if(type == mChapterTypes.at(TypeTextChapter))
+    {
+        return {std::make_shared<TextChapter>(mChapterTypes.at(TypeTextChapter))};
+    }
+    else if(type == mChapterTypes.at(TypeDoxygenChapter))
+    {
+        return {std::make_shared<DoxygenChapter>(mChapterTypes.at(TypeDoxygenChapter))};
+    }
+    else if(type == mChapterTypes.at(TypeSourceChapter))
+    {
+        return {std::make_shared<SourceChapter>(mChapterTypes.at(TypeSourceChapter))};
+    }
+    else
+    {
+        throw std::string("Cannot create chapter of unknown type: " + type);
+    }
+}
+
+ChapterIF::SPtr ChapterFactory::createChapter(int type)
+{
+    return createChapter(mChapterTypes.at(type));
+}
+
+std::vector<std::string> ChapterFactory::getChapterTypes()
+{
+    return mChapterTypes;
+}
diff --git a/src/ChapterFactory.h b/src/ChapterFactory.h
new file mode 100644 (file)
index 0000000..d94636a
--- /dev/null
@@ -0,0 +1,61 @@
+///////////////////////////////////////////////////////////////////////////
+// Workfile: ChapterFactory.h
+// Author: Daniel Giritzer <daniel@giritzer.eu>
+// Date: 11.05.2018
+// Description: Simple Factory Klasse zum erzeugen verschiedener
+//              Kapitel Implementierungen.
+// Remarks: -
+///////////////////////////////////////////////////////////////////////////
+#ifndef CHAPTERFACTORY_H
+#define CHAPTERFACTORY_H
+
+#include "TextChapter.h"
+#include "DoxygenChapter.h"
+#include "SourceChapter.h"
+
+/////////////////////////////////////////////////
+/// \brief Simple Factory Klasse zum erzeugen der verschiedenen
+///        Kapitel implementierungen.
+/////////////////////////////////////////////////
+class ChapterFactory
+{
+public:
+    ChapterFactory() = default;
+    virtual ~ChapterFactory() = default;
+
+    /////////////////////////////////////////////////
+    /// \brief Erzeugt ein Kapitel, das durch den übergebenen
+    ///        String beschrieben wird.
+    /// \param type Kapiteltyp der erzeugt werden soll
+    /// \return Shared pointer des types der Interfaceklasse
+    ///         auf das erzeugte Objekt.
+    /////////////////////////////////////////////////
+    ChapterIF::SPtr createChapter(std::string type);
+
+
+    /////////////////////////////////////////////////
+    /// \brief Erzeugt ein Kapitel, das durch die übergebenen
+    ///        enum Konstante.
+    /// \param type enum Konstante die Kapiteltyp beschreibt
+    /// \return Shared pointer des types der Interfaceklasse
+    ///         auf das erzeugte Objekt.
+    /////////////////////////////////////////////////
+    ChapterIF::SPtr createChapter(int type);
+
+    /////////////////////////////////////////////////
+    /// \brief Gibt Vector mit den Namen aller möglichen
+    ///        Kapiteltypen retour.
+    /// \return vector mit strings aller Kapiteltypen.
+    /////////////////////////////////////////////////
+    std::vector<std::string> getChapterTypes();
+
+    enum ChapterTypeConstants{
+    TypeTextChapter,
+    TypeDoxygenChapter,
+    TypeSourceChapter
+    };
+private:
+    const std::vector<std::string> mChapterTypes = {"Text", "Doxygen", "Sourcecode"};
+};
+
+#endif // CHAPTERFACTORY_H
diff --git a/src/ChapterIF.h b/src/ChapterIF.h
new file mode 100644 (file)
index 0000000..365a458
--- /dev/null
@@ -0,0 +1,224 @@
+///////////////////////////////////////////////////////////////////////////
+// Workfile: ChapterIF.h
+// Author: Daniel Giritzer <daniel@giritzer.eu>
+// Date: 25.03.2018
+// Description: Interface für eine Einfache Klasse zum Speichern Kapiteln.
+// Remarks: -
+///////////////////////////////////////////////////////////////////////////
+#ifndef CHAPTERIF_H
+#define CHAPTERIF_H
+
+#include <iostream>
+#include <fstream>
+#include <memory>
+#include "ModelIF.h"
+#include "FSHelper.h"
+
+/////////////////////////////////////////////////
+/// \brief Interface für eine Einfache
+///           Klasse zum Speichern eines Kapitels
+///           und dessen Inhalt.
+/////////////////////////////////////////////////
+class ChapterIF
+{
+public:
+    // Destructor
+    ~ChapterIF() = default;
+
+    /////////////////////////////////////////////////
+    /// \brief Gibt die verwendete Überschrift des Kapitels retour.
+    ///        \return Die Kapitelüberschrift
+    /////////////////////////////////////////////////
+    std::string GetPrettyName() const
+    {
+        return mPrettyName;
+    }
+
+    /////////////////////////////////////////////////
+    /// \brief Setzt die zu verwendende Überschrift des Kapitels.
+    ///        \param val Überschrift des Kapitels.
+    /////////////////////////////////////////////////
+    void SetPrettyName(std::string val)
+    {
+        mPrettyName = val;
+    }
+
+    /////////////////////////////////////////////////
+    /// \brief Gibt den Namen der Datei in die das Kapitels geschrieben werden soll
+    ///        retour.
+    ///        \return Dateiname des Kapitels
+    /////////////////////////////////////////////////
+    std::string GetOutFileName() const
+    {
+        return mOutFileName;
+    }
+
+    /////////////////////////////////////////////////
+    /// \brief Setzt Namen der Datei in die das Kapitel geschrieben werden soll.
+    ///        \param val Dateiname.
+    /////////////////////////////////////////////////
+    void SetOutFileName(std::string val)
+    {
+        if(!mFSHelp.validFileName(val))
+            throw std::string("Filename contains illegal characters!");
+
+        mOutFileName = val;
+    }
+
+    /////////////////////////////////////////////////
+    /// \brief Gibt den Kapiteltypen retour.
+    ///        \return Kapiteltyp als string
+    /////////////////////////////////////////////////
+    virtual  std::string GetType() const = 0;
+
+    /////////////////////////////////////////////////
+    /// \brief Gibt die Nummer des Kapitels retour.
+    ///        \return Kapitelnummer als integer
+    /////////////////////////////////////////////////
+    int GetNum() const
+    {
+        return mNum;
+    }
+
+    /////////////////////////////////////////////////
+    /// \brief Setzt die Nummer des Kapitels.
+    ///        \param val Kapitelnummer
+    /////////////////////////////////////////////////
+    void SetNum(int val)
+    {
+        mNum = val;
+    }
+
+    /////////////////////////////////////////////////
+    /// \brief Gibt retour ob das Kapitel als abgeschlossen
+    ///        Markiert wurde.
+    ///        \return true falls abgeschlossen, ansonsten false
+    /////////////////////////////////////////////////
+    bool GetDone() const
+    {
+        return mDone;
+    }
+
+    /////////////////////////////////////////////////
+    /// \brief Markiert ein Kapitel als abgeschlossen oder
+    ///        nicht abgeschlossen.
+    ///        \param done true für abgeschlossen, false
+    ///        für nicht abgeschlossen.
+    /////////////////////////////////////////////////
+    void SetDone(bool done)
+    {
+        mDone = done;
+    }
+
+    /////////////////////////////////////////////////
+    /// \brief Gibt den Kapitelinhalt retour.
+    ///        \return Kapitelinhalt
+    /////////////////////////////////////////////////
+    std::string GetContent() const
+    {
+        return mContent;
+    }
+
+    /////////////////////////////////////////////////
+    /// \brief Setzt den Kapitelinhalt
+    ///        \param text Zu speichernder Kapitelinhalt.
+    /////////////////////////////////////////////////
+    void SetContent(std::string const &text)
+    {
+        mContent = text;
+    }
+
+    /////////////////////////////////////////////////
+    /// \brief Setzt die Kapitelart. 0 Kapitel
+    ///        1 Unterkapitel, 2 Unterunterkapitel
+    ///        3 Unterunterunterkapitel
+    ///        \param Kapitelhierachie
+    /////////////////////////////////////////////////
+    void SetHierachy(unsigned int val)
+    {
+        if(val > mMaxHierachy)
+            throw std::string("Invalid hierachy!:" + std::to_string(val));
+
+        if(val == 0)
+            mHierachy = "chapter";
+        else if(val == 1)
+            mHierachy = "section";
+        else if(val == 2)
+            mHierachy = "subsection";
+        else if(val == 3)
+            mHierachy = "subsubsection";
+        else
+            throw std::string("Invalid hierachy!:" + std::to_string(val));
+    }
+
+    /////////////////////////////////////////////////
+    /// \brief Setzt die Kapitelart.
+    ///        \param Kapitelhierachie
+    /////////////////////////////////////////////////
+    void SetHierachy(std::string val)
+    {
+        if(val != "chapter" &&
+                val != "section" &&
+                val != "subsection" &&
+                val != "subsubsection")
+            throw std::string("Invalid hierachy!:" + val);
+
+        mHierachy = val;
+    }
+
+    /////////////////////////////////////////////////
+    /// \brief Gibt Kapitelart zurück
+    ///        \return Kapitelhierachie
+    /////////////////////////////////////////////////
+    std::string GetHierachy()
+    {
+        return mHierachy;
+    }
+
+    /////////////////////////////////////////////////
+    /// \brief Gibt Kapitelart als integer zurück
+    ///        \return Kapitelhierachie
+    /////////////////////////////////////////////////
+    int GetHierachyAsNum()
+    {
+        if(mHierachy == "chapter")
+            return 0;
+        else if(mHierachy == "section")
+            return 1;
+        else if(mHierachy == "subsection")
+            return 2;
+        else if(mHierachy == "subsubsection")
+            return 3;
+    }
+
+    /////////////////////////////////////////////////
+    /// \brief Schreibt den Kapitelinhalt in eine Datei mit
+    ///        dem gesetzten Dateinamen.
+    ///        \param outPath Pfad in dem die Datei gespeichert werden soll.
+    /////////////////////////////////////////////////
+    virtual void WriteFile(ModelIF* model) = 0;
+
+
+    /////////////////////////////////////////////////
+    /// \brief Typedef für einen shared Pointer auf
+    ///        ein Objekt dieser Klasse oder deren
+    ///        Implementierung.
+    /////////////////////////////////////////////////
+    using SPtr = std::shared_ptr<ChapterIF>;
+
+    /// \brief Maximale Kapitelhierachestufe.
+    unsigned int mMaxHierachy = 3;
+
+protected:
+    FSHelper mFSHelp;
+    std::string mPrettyName;
+    std::string mOutFileName;
+    std::string mHierachy;
+    std::string mContent;
+    int mNum;
+    bool mDone;
+    ChapterIF() = default;
+
+};
+
+#endif // CHAPTERIF_H
index f4f4501..f11f9cb 100644 (file)
@@ -42,34 +42,38 @@ void Controller::setCurrentChapterFinished(bool val)
     mModel->notifyObservers();
 }
 
-void Controller::saveAuthorName(std::string name)
+void Controller::saveAuthor(std::string name, std::string id, std::string estTime, std::string neededTime)
 {
     mModel->getSelAuthor()->SetName(name);
+    mModel->getSelAuthor()->SetID(id);
+    mModel->getSelAuthor()->SetTimeEstimated(estTime);
+    mModel->getSelAuthor()->SetTimeSpent(neededTime);
+    mModel->notifyObservers();
 }
 
-void Controller::saveAuthorEstTime(std::string time)
-{
-    mModel->getSelAuthor()->SetTimeEstimated(time);
-}
 
-void Controller::saveAuthorSpentTime(std::string time)
+void Controller::saveContent(std::string const &text)
 {
-    mModel->getSelAuthor()->SetTimeSpent(time);
+    mModel->getSelChapter()->SetContent(text);
 }
 
-void Controller::saveWrittenText(std::string const &text)
+void Controller::saveAllWrittenTextsToFiles()
 {
-    mModel->getSelChapter()->SetText(text);
+    mModel->saveChaptersToFiles();
 }
 
-void Controller::saveAllWrittenTextsToFiles()
+void Controller::addChapter(std::string chaptName, std::string outFileName, int chaptType, int chaptHiearachy)
 {
-    mModel->saveChaptersToFiles();
+
+    mModel->chapterInsertBack(chaptName, outFileName, chaptType, chaptHiearachy);
+    mModel->notifyObservers();
 }
 
-void Controller::addChapter(std::string chaptName, std::string outFileName)
+void Controller::updateChapter(std::string chaptName, std::string outFileName, int chaptHiearachy)
 {
-    mModel->chapterInsertBack(chaptName, outFileName);
+    mModel->getSelChapter()->SetPrettyName(chaptName);
+    mModel->getSelChapter()->SetOutFileName(outFileName);
+    mModel->getSelChapter()->SetHierachy(chaptHiearachy);
     mModel->notifyObservers();
 }
 
@@ -114,76 +118,31 @@ void Controller::generateDocument()
     mModel->generateDocument();
 }
 
-void Controller::saveSourceDir(std::string dir)
-{
-    mModel->setSourceDir(dir);
-    mModel->notifyObservers();
-}
-
 void Controller::saveCoverSheet(std::string file)
 {
     mModel->setCovSheet(file);
     mModel->notifyObservers();
 }
 
-void Controller::saveAuthorEstTimeCoordiantes(int x, int y)
-{
-    mModel->getSelAuthor()->SetXTimeEstimatedCoordinate(x);
-    mModel->getSelAuthor()->SetYTimeEstimatedCoordinate(y);
-}
-
-void Controller::saveAuthorNameCoordinates(int x, int y)
-{
-    mModel->getSelAuthor()->SetXNameCoordinate(x);
-    mModel->getSelAuthor()->SetYNameCoordinate(y);
-}
-
-void Controller::saveAuthorSpentTimeCoordinates(int x, int y)
-{
-    mModel->getSelAuthor()->SetXTimeSpentCoordinate(x);
-    mModel->getSelAuthor()->SetYTimeSpentCoordinate(y);
-}
-
-
-void Controller::setAddCoverSheet(bool val)
-{
-    mModel->setAddCoverSheet(val);
-}
-
-void Controller::setAddSource(bool val)
-{
-    mModel->setAddSource(val);
-}
-
-void Controller::setGenDoxygen(bool val)
-{
-    mModel->setGenDoxygen(val);
-}
-
-void Controller::setSourceChapterName(std::string name)
-{
-    mModel->setSourceChapterName(name);
-}
-
-void Controller::setDoxygenName(std::string name)
-{
-    mModel->setDoxygenName(name);
-}
-
-void Controller::forceNotify()
+void Controller::saveAuthorCoordinates(int xName, int yName, int xID, int yID, int xEstTime, int yEstTime, int xNeededTime, int yNeededTime)
 {
+    mModel->getSelAuthor()->SetXNameCoordinate(xName);
+    mModel->getSelAuthor()->SetYNameCoordinate(yName);
+    mModel->getSelAuthor()->SetXid(xID);
+    mModel->getSelAuthor()->SetYid(yID);
+    mModel->getSelAuthor()->SetXTimeEstimatedCoordinate(xEstTime);
+    mModel->getSelAuthor()->SetYTimeEstimatedCoordinate(yEstTime);
+    mModel->getSelAuthor()->SetXTimeSpentCoordinate(xNeededTime);
+    mModel->getSelAuthor()->SetYTimeSpentCoordinate(yNeededTime);
     mModel->notifyObservers();
 }
 
 void Controller::setDocName(std::string name)
 {
     mModel->setDocName(name);
+    mModel->notifyObservers();
 }
 
-void Controller::setSubjectName(std::string name)
-{
-    mModel->setSubjectName(name);
-}
 
 void Controller::startNewTemplate(std::string name)
 {
@@ -191,29 +150,35 @@ void Controller::startNewTemplate(std::string name)
     mModel->notifyObservers();
 }
 
-void Controller::saveAsTemplate()
+void Controller::saveSettings(bool titlepage, bool coverpage, bool toc, int tocDepth,
+             std::string headerExt, std::string sourceExt,
+             std::string subjectName, std::string location)
 {
-    mModel->saveTemplFile();
+    mModel->setAddTitlePage(titlepage);
+    mModel->setAddCoverSheet(coverpage);
+    mModel->setAddTableOfContent(toc);
+    mModel->setTableOfContentDepth(tocDepth);
+    mModel->setSourceFileExtension(sourceExt);
+    mModel->setHeaderFileExtension(headerExt);
+    mModel->setSubjectName(subjectName);
+    mModel->setLocation(location);
+    mModel->notifyObservers();
 }
 
-void Controller::setLocation(std::string location)
+void Controller::saveAsTemplate()
 {
-    mModel->setLocation(location);
+    mModel->saveTemplFile();
 }
 
 void Controller::setDepartment(std::string department)
 {
     mModel->setDepartment(department);
+    mModel->notifyObservers();
 }
 
 void Controller::setDepartmentCoordiantes(unsigned int x, unsigned int y)
 {
     mModel->setDepartmentX(x);
     mModel->setDepartmentY(y);
-}
-
-void Controller::setFileExtensions(std::string header, std::string source)
-{
-    mModel->setSourceFileExtension(source);
-    mModel->setHeaderFileExtension(header);
+    mModel->notifyObservers();
 }
index cd4acfb..31efce5 100644 (file)
@@ -31,17 +31,15 @@ public:
 
     void selectedAuthor(int authorNum) override;
 
-    void saveAuthorName(std::string name) override;
+    void saveAuthor(std::string name, std::string id, std::string estTime, std::string neededTime) override;
 
-    void saveAuthorEstTime(std::string time) override;
-
-    void saveAuthorSpentTime(std::string time) override;
-
-    void saveWrittenText(std::string const &text) override;
+    void saveContent(std::string const &text) override;
 
     void setCurrentChapterFinished(bool val) override;
 
-    void addChapter(std::string chaptName, std::string outFileName) override;
+    void addChapter(std::string chaptName, std::string outFileName, int chaptType, int chaptHiearachy) override;
+
+    void updateChapter(std::string chaptName, std::string outFileName, int chaptHiearachy) override;
 
     void remChapter() override;
 
@@ -57,46 +55,26 @@ public:
 
     void generateDocument() override;
 
-    void saveSourceDir(std::string dir) override;
-
     void saveCoverSheet(std::string file) override;
 
     void saveAllWrittenTextsToFiles() override;
 
-    void saveAuthorEstTimeCoordiantes(int x, int y) override;
-
-    void saveAuthorNameCoordinates(int x, int y) override;
-
-    void saveAuthorSpentTimeCoordinates(int x, int y) override;
-
-    void setAddCoverSheet(bool val) override;
+    void saveAuthorCoordinates(int xName, int yName, int xID, int yID, int xEstTime, int yEstTime, int xNeededTime, int yNeededTime) override;
 
-    void setAddSource(bool val) override;
-
-    void setGenDoxygen(bool val) override;
-
-    void setSourceChapterName(std::string name) override;
-
-    void setDoxygenName(std::string name) override;
-
-    void forceNotify() override;
+    void saveSettings(bool titlepage, bool coverpage, bool toc, int tocDepth,
+                 std::string headerExt, std::string sourceExt,
+                 std::string subjectName, std::string location) override;
 
     void setDocName(std::string name) override;
 
-    void setSubjectName(std::string name) override;
-
     void startNewTemplate(std::string name) override;
 
-    void setLocation(std::string location) override;
-
     void setDepartment(std::string department) override;
 
     void saveAsTemplate() override;
 
     void setDepartmentCoordiantes(unsigned int x, unsigned int y) override;
 
-    void setFileExtensions(std::string header, std::string source) override;
-
     virtual ~Controller() = default;
 
 private:
index c73a7d4..0de3867 100644 (file)
@@ -45,31 +45,21 @@ public:
     virtual void selectedAuthor(int authorNum) = 0;
 
     /////////////////////////////////////////////////
-    /// \brief Speichere den Namen des Authoren.
-    /// \param name Author name.
+    /// \brief Speichere die Informationen des ausgewählten
+    ///        Autors.
+    /// \param name Autor Name.
+    /// \param id Autor ID (Benutzeridentifikation)
+    /// \param estTime vom Autor geschätzte Arbeitszeit
+    /// \param neededTime vom Autor benötigte Arbeitszeit.
     /////////////////////////////////////////////////
-    virtual void saveAuthorName(std::string name) = 0;
+    virtual void saveAuthor(std::string name, std::string id, std::string estTime, std::string neededTime) = 0;
 
     /////////////////////////////////////////////////
-    /// \brief Speichere die für das jeweilige Dokument
-    ///        vom Author geschätzte Arbeitszeit.
-    /// \param geschätzte Arbeitszeit.
-    /////////////////////////////////////////////////
-    virtual void saveAuthorEstTime(std::string time) = 0;
-
-    /////////////////////////////////////////////////
-    /// \brief Speichere die für das jeweilige Dokument
-    ///        vom Author benötigte Arbeitszeit.
-    /// \param benötigte Arbeitszeit.
-    /////////////////////////////////////////////////
-    virtual void saveAuthorSpentTime(std::string time) = 0;
-
-    /////////////////////////////////////////////////
-    /// \brief Speichere den geschriebenen Text in
+    /// \brief Speichere den Kapitelinhalt in
     ///        die interne Datenstruktur.
     /// \param text zu speichernder Text.
     /////////////////////////////////////////////////
-    virtual void saveWrittenText(std::string const & text) = 0;
+    virtual void saveContent(std::string const & text) = 0;
 
     /////////////////////////////////////////////////
     /// \brief Speichere alle intern gespeicherten Texte
@@ -89,8 +79,19 @@ public:
     /// \brief Füge ein neues Kapitel hinzu.
     /// \param chaptName Name des Kapitels
     /// \param outFileName name der Ausgabedatei.
+    /// \param chaptType Kapiteltyp
+    /// \param chaptHiearachy Kapitelhierachietyp
+    /////////////////////////////////////////////////
+    virtual void addChapter(std::string chaptName, std::string outFileName, int chaptType, int chaptHiearachy) = 0;
+
+    /////////////////////////////////////////////////
+    /// \brief Ändert die Eistellung des gewählten
+    ///        Kapitels
+    /// \param chaptName Name des Kapitels
+    /// \param outFileName name der Ausgabedatei.
+    /// \param chaptHiearachy Kapitelhierachietyp
     /////////////////////////////////////////////////
-    virtual void addChapter(std::string chaptName, std::string outFileName) = 0;
+    virtual void updateChapter(std::string chaptName, std::string outFileName, int chaptHiearachy) = 0;
 
     /////////////////////////////////////////////////
     /// \brief Lösche ausgewähltes Kapitel.
@@ -132,76 +133,43 @@ public:
     virtual void generateDocument() = 0;
 
     /////////////////////////////////////////////////
-    /// \brief Wähle Quellcode Ordner.
-    /// \param dir Quellcode Ordner.
-    /////////////////////////////////////////////////
-    virtual void saveSourceDir(std::string dir) = 0;
-
-    /////////////////////////////////////////////////
     /// \brief Wähle Angabeblatt.
     /// \param file Angabeblatt
     /////////////////////////////////////////////////
     virtual void saveCoverSheet(std::string file) = 0;
 
     /////////////////////////////////////////////////
-    /// \brief Setzte Deckblattkoordinaten für
-    ///        geschätzte Zeit eines Authors.
-    /// \param x X Koordinate
-    /// \param y Y Koordinate
-    /////////////////////////////////////////////////
-    virtual void saveAuthorEstTimeCoordiantes(int x, int y) = 0;
-
-    /////////////////////////////////////////////////
-    /// \brief Setzte Deckblattkoordinaten für
-    ///        den Namen eines Authors.
-    /// \param x X Koordinate
-    /// \param y Y Koordinate
-    /////////////////////////////////////////////////
-    virtual void saveAuthorNameCoordinates(int x, int y) = 0;
-
-
-    /////////////////////////////////////////////////
-    /// \brief Setzte Deckblattkoordinaten für
-    ///        benötigte Zeit eines Authors.
-    /// \param x X Koordinate
-    /// \param y Y Koordinate
-    /////////////////////////////////////////////////
-    virtual void saveAuthorSpentTimeCoordinates(int x, int y) = 0;
-
-    /////////////////////////////////////////////////
-    /// \brief Konfiguriere ob Dokument ein Angabeblatt
-    ///        besitzt.
-    /// \param bool true -> ja, false -> nein
-    /////////////////////////////////////////////////
-    virtual void setAddCoverSheet(bool val) = 0;
-
-    /////////////////////////////////////////////////
-    /// \brief Konfiguriere ob Dokument ein Quellcode
-    ///        Kapitel besitzt.
-    /// \param bool true -> ja, false -> nein
+    /// \brief Setzte Deckblattkoordinaten für die
+    ///        auszufüllenden Parameter eines Autors.
+    /// \param xName X Koordinate für Autor Namen
+    /// \param yName Y Koordinate für Autor Namen
+    /// \param xID X Koordinate für ID des Autors
+    /// \param yID Y Koordinate für ID des Autors
+    /// \param xEstTime X Koordinate für die geschätzte Zeit
+    /// \param yEstTime Y Koordinate für die geschätzte Zeit
+    /// \param xNeededTime X Koordinate für die benötigte Zeit
+    /// \param yNeededTime Y Koordinate für die benötigte Zeit
     /////////////////////////////////////////////////
-    virtual void setAddSource(bool val) = 0;
+    virtual void saveAuthorCoordinates(int xName, int yName, int xID, int yID, int xEstTime, int yEstTime, int xNeededTime, int yNeededTime) = 0;
 
     /////////////////////////////////////////////////
-    /// \brief Konfiguriere ob Dokument ein Doxygen
-    ///        Kapitel besitzt.
-    /// \param bool true -> ja, false -> nein
+    /// \brief Speichere alle Dokumenteinstellungen
+    /// \param titlepage Gibt an ob eine Titelseite erzeugt
+    ///                  werden soll oder nicht
+    /// \param coverpage Gibt an ob ein Deckblatt hinzugefügt werden
+    ///                  soll oder nicht.
+    /// \param toc Gibt an ob ein Inhaltsverzeichnis erzeugt werden soll
+    ///            oder nicht.
+    /// \param tocDepth Gibt die Nummerierungstiefe des Inhaltsverzeichnisses
+    ///                 an.
+    /// \param headerExt Dateiendung von Headerdateien
+    /// \param sourceExt Dateiendung von Quellcodedateien
+    /// \param subjectName  Name des Dokumenttyps
+    /// \param location Verfassungsort des Dokuments
     /////////////////////////////////////////////////
-    virtual void setGenDoxygen(bool val) = 0;
-
-    /////////////////////////////////////////////////
-    /// \brief Konfiguriere Kapitelnamen des Quellcode
-    ///        Kapitels.
-    /// \param name Kapitelname
-    /////////////////////////////////////////////////
-    virtual void setSourceChapterName(std::string name) = 0;
-
-    /////////////////////////////////////////////////
-    /// \brief Konfiguriere Kapitelnamen des Doxygen
-    ///        Kapitels.
-    /// \param name Kapitelname
-    /////////////////////////////////////////////////
-    virtual void setDoxygenName(std::string name) = 0;
+    virtual void saveSettings(bool titlepage, bool coverpage, bool toc, int tocDepth,
+             std::string headerExt, std::string sourceExt,
+             std::string subjectName, std::string location) = 0;
 
     /////////////////////////////////////////////////
     /// \brief Konfiguriere den Namen des Dokuments
@@ -209,11 +177,6 @@ public:
     /////////////////////////////////////////////////
     virtual void setDocName(std::string name) = 0;
 
-    /////////////////////////////////////////////////
-    /// \brief Konfiguriere den Namen der Dokumentgruppe
-    /// \param name Dokumentgruppenname
-    /////////////////////////////////////////////////
-    virtual void setSubjectName(std::string name) = 0;
 
     /////////////////////////////////////////////////
     /// \brief Starte ein komplett neues Dokument.
@@ -229,12 +192,6 @@ public:
     virtual void saveAsTemplate() = 0;
 
     /////////////////////////////////////////////////
-    /// \brief Konfiguriere dan Namen des Verfassungsortes.
-    /// \param location name Ortsname
-    /////////////////////////////////////////////////
-    virtual void setLocation(std::string location) = 0;
-
-    /////////////////////////////////////////////////
     /// \brief Konfiguriere dan Namen der Arbeitsgruppe.
     /// \param department name Arbeitsgruppenname
     /////////////////////////////////////////////////
@@ -249,19 +206,6 @@ public:
     virtual void setDepartmentCoordiantes(unsigned int x,unsigned int y) = 0;
 
     /////////////////////////////////////////////////
-    /// \brief Wähle Dateiendungen der Quellcode Dateien
-    /// \param header Dateiendung für Header Dateien (z.B. .h)
-    /// \param source Dateiendung für Source Dateien (z.B. .cpp)
-    /////////////////////////////////////////////////
-    virtual void setFileExtensions(std::string header, std::string source) = 0;
-
-    /////////////////////////////////////////////////
-    /// \brief Rufe notifyObersvers funktion des Models
-    ///        auf.
-    /////////////////////////////////////////////////
-    virtual void forceNotify() = 0;
-
-    /////////////////////////////////////////////////
     /// \brief Typedef für einen shared Pointer auf
     ///        ein Objekt dieser Klasse oder deren
     ///        Implementierung.
diff --git a/src/DoxygenChapter.h b/src/DoxygenChapter.h
new file mode 100644 (file)
index 0000000..225361a
--- /dev/null
@@ -0,0 +1,126 @@
+///////////////////////////////////////////////////////////////////////////
+// Workfile: Doxygenhapter.h
+// Author: Daniel Giritzer <daniel@giritzer.eu>
+// Date: 25.03.2018
+// Description: Einfache Klasse zum Speichern von Doxygen Kapiteln.
+// Remarks: Diese Klasse besteht nur aus einer Header Datei.
+///////////////////////////////////////////////////////////////////////////
+#ifndef DOXYGENCHAPTER_H
+#define DOXYGENCHAPTER_H
+
+#include <iostream>
+#include "Object.h"
+#include <algorithm>
+
+
+/////////////////////////////////////////////////
+/// \brief Klasse zum speichern von
+///        Doxygen Kapitelinformationen.
+/////////////////////////////////////////////////
+class DoxygenChapter : public Object, public ChapterIF
+{
+public:
+
+    DoxygenChapter(std::string type)
+    {
+        mType = type;
+    }
+    virtual ~DoxygenChapter() = default;
+
+    std::string GetType() const
+    {
+        return mType;
+    }
+
+    void WriteFile(ModelIF* model)
+    {
+        if(!mFSHelp.dirExists(model->getOutPath()))
+            throw std::string("Output directory does not exist: " + model->getOutPath());
+
+        std::string outPath = mFSHelp.addDirLastSlash(model->getOutPath());
+
+        if(!mFSHelp.dirExists(mContent))
+            throw std::string("The source directory entered in Chapter " + mPrettyName + " (" + std::to_string(mNum) + ")" + " does not exist!\n" + mContent);
+
+        std::string doxyOut = mFSHelp.addDirLastSlash(outPath + mOutFileName + "_doxygen");
+        std::string doxySrc = mFSHelp.addDirLastSlash(outPath + mOutFileName + "_src");
+        mFSHelp.copyDir(mContent, doxySrc);
+        mFSHelp.makeDir(doxyOut);
+
+
+        // Kopiere doxyfile
+        mFSHelp.copyFile(mFSHelp.addDirLastSlash(model->getConfDir()) + "doxyfile", outPath + "doxyfile");
+
+        // Passe doxyfile an
+        std::ofstream doxyFileStream;
+        doxyFileStream.open(outPath + "doxyfile", std::ios_base::app);
+        if(!doxyFileStream.good())
+            throw std::string("Could not open file for writing: " + outPath + "doxyfile");
+
+        doxyFileStream << "LATEX_OUTPUT = " + doxyOut << std::endl;
+        doxyFileStream << "INPUT = " + doxySrc << std::endl;
+        doxyFileStream.close();
+
+        // Starte DoxyGen
+        std::vector<std::string> paramsDoxy = {outPath + "doxyfile"};
+        mFSHelp.executeCommand(outPath, "doxygen", paramsDoxy, outPath + model->getLogFile());
+
+        mFSHelp.copyFile(doxyOut + "doxygen.sty", outPath + "doxygen.sty");
+
+        // Lade ausgabedateien
+        std::vector<FSHelper::File> doxyFiles;
+        if(!mFSHelp.listFilesRecursive(doxyOut, doxyFiles, true))
+            throw std::string("Failed to get filenames of source files!");
+
+        // Nach class_ filtern
+        auto it = std::remove_if(doxyFiles.begin(),
+                                 doxyFiles.end(),
+                                 [](FSHelper::File x)
+        {
+
+            unsigned int ind = x.second.find_first_of("_");
+            if(ind ==  std::string::npos) return true; //Keine Dateiendung
+
+            // Dateien beginnend mit class_
+            if((x.second.substr(0, ind+1) == "class_"))
+                return false;
+
+            // Alle anderen
+            return true;
+        });
+        doxyFiles.erase(it, doxyFiles.end());
+
+        // Nach namen sortieren
+        std::sort(doxyFiles.begin(), doxyFiles.end(),
+                  [](FSHelper::File left, FSHelper::File right)
+                    {
+                        return left.second < right.second;
+                    }
+
+                 );
+
+        // dateien in tex datei schreiben
+        std::ofstream out;
+        out.open(outPath + mOutFileName, std::ios_base::out);
+        if(!out.good())
+            throw std::string("Failed to write doxygen chapter.");
+
+        out << "\\input{" + mOutFileName + "_doxygen/hierarchy.tex}" << std::endl;
+        out << "\\input{" + mOutFileName + "_doxygen/annotated.tex}" << std::endl;
+        for(auto curElem : doxyFiles)
+        {
+            curElem.first.replace(curElem.first.find(outPath), outPath.length(), ""); //Erzeuge relativen Pfade
+            out << "\\input{" << mFSHelp.convertPathToUnix(curElem.first) << curElem.second <<"}" << std::endl;
+        }
+
+        // Lösche doxyfile
+        mFSHelp.removeFile(outPath + "doxyfile");
+        out.close();
+    }
+
+private:
+    std::string mType;
+
+};
+
+#endif // DOXYGENCHAPTER_H
index aa6e477..41c7f84 100644 (file)
@@ -77,7 +77,7 @@ void FSHelper::makeDir(std::string const& dir)
 
 void FSHelper::createFile(std::string const& path)
 {
-    std::ofstream file(path);
+    std::ofstream file(path, std::ios::out);
 
     if(!file.good())
         throw std::string("Failed to create file: " + path);
@@ -85,6 +85,14 @@ void FSHelper::createFile(std::string const& path)
     file.close();
 }
 
+void FSHelper::removeFile(std::string const& path)
+{
+    if(!fileExists(path))
+        return;
+
+    remove(path.c_str());
+}
+
 void FSHelper::copyDir(std::string const &src, std::string const &dest)
 {
     std::string from = addDirLastSlash(src);
@@ -325,16 +333,43 @@ std::string FSHelper::findExecutableInPath(std::string executable)
     throw std::string("Executable not found in PATH!: " + executable);
 }
 
+std::string FSHelper::getFileName(std::string file)
+{
+    unsigned int ind = file.find_last_of("/");
+    if(ind !=  std::string::npos)
+        file = file.substr(ind + 1, file.size());
+
+    ind = file.find_last_of("\\");
+    if(ind !=  std::string::npos)
+        file = file.substr(ind + 1, file.size());
+
+    return file;
+}
+
+std::string FSHelper::getPath(std::string file)
+{
+    unsigned int ind = file.find_last_of("/");
+    if(ind !=  std::string::npos)
+        file = file.substr(0, ind + 1);
+
+    ind = file.find_last_of("\\");
+    if(ind !=  std::string::npos)
+        file = file.substr(0, ind + 1);
+
+    return file;
+}
+
 void FSHelper::executeCommand(const std::string& path, const std::string& command, std::vector<std::string> params, std::string log)
 {
 
     if((!path.empty()) && !dirExists(path))
         throw std::string("Path does not exist: " + path);
 
+    std::string execCommand = findExecutableInPath(command);
+
     if(!log.empty() && !fileExists(log))
         createFile(log);
 
-    std::string execCommand = findExecutableInPath(command);
 
 #if defined(_WIN32)
     std::string paramString;
@@ -362,25 +397,34 @@ void FSHelper::executeCommand(const std::string& path, const std::string& comman
     // String vector zu char array
     std::vector<char*> charParams;
 
+
+
     if(!log.empty())
         FILE* logFile = freopen(log.c_str(),"a",stdout);
 
+    // Param Array muss wie folgt aufgebaut sein:
+    // 0 -> command
+    // 1 -> param 1
+    // x -> param x
+    // last -> nullptr
+
     // Falls DynLoader gesetzt ist dynloader erster parameter
-    // im array
+    // im array (weil command)
     if(!mLinuxDynLoader.empty())
     {
         char *pc = new char[mLinuxDynLoader.size()+1];
         std::strcpy(pc, mLinuxDynLoader.c_str());
         charParams.emplace_back(pc);
-        execCommand = mLinuxDynLoader;
+        execCommand = mLinuxDynLoader; //Auszuführender befehl ist dynloader, kommando
+        //ist dann erster parameter (= zweites element im array)
     }
 
-    // command muss auch immer im array gespeichert sein
+    // Kommando zu array
     char *pc = new char[findExecutableInPath(command).size()+1];
     std::strcpy(pc, findExecutableInPath(command).c_str());
     charParams.emplace_back(pc);
 
-    // vector zu char array convertieren
+    // param vector zu char array convertieren
     std::transform(params.begin(), params.end(), std::back_inserter(charParams),
                    [](const std::string & s)
 
index abbd7f3..8a82e7b 100644 (file)
@@ -109,8 +109,8 @@ public:
 /////////////////////////////////////////////////
 /// \brief Entfernt, falls existent, einen Slash
 ///        am ende eines Pfades.
-/// \param dir pfad
-/// \return pfad garantiert ohne slash am ende
+/// \param dir Pfad
+/// \return Pfad garantiert ohne slash am ende
 /////////////////////////////////////////////////
     std::string rmDirLastSlash(std::string const& dir);
 
@@ -122,11 +122,17 @@ public:
 
 /////////////////////////////////////////////////
 /// \brief Erstellt eine Datei.
-/// \param dir pfad der zu erstellenden Datei.
+/// \param path Pfad + Dateiname der zu erstellenden Datei.
 /////////////////////////////////////////////////
     void createFile(std::string const& path);
 
 /////////////////////////////////////////////////
+/// \brief Löscht eine Datei.
+/// \param path Pfad + Dateiname der zu löschenden Datei.
+/////////////////////////////////////////////////
+    void removeFile(std::string const& path);
+
+/////////////////////////////////////////////////
 /// \brief Diese funktion gibt alle Deteien eines
 ///        Ordners und dessen Unterordner zurück.
 /// \param [IN] src Ordner dessen Dateien zurückgegeben
@@ -197,6 +203,20 @@ public:
 /////////////////////////////////////////////////
     std::string findExecutableInPath(std::string executable);
 
+/////////////////////////////////////////////////
+/// \brief Gibt Dateinamen einer Datei mit Pfad retour.
+/// \param file Dateiname mit Pfad
+/// \return Dateiname
+/////////////////////////////////////////////////
+    std::string getFileName(std::string file);
+
+/////////////////////////////////////////////////
+/// \brief Gibt Pfad einer Datei mit Pfad retour.
+/// \param file Dateiname mit Pfad
+/// \return Pfad
+/////////////////////////////////////////////////
+    std::string getPath(std::string file);
+
 private:
     std::string mLinuxDynLoader;
 
index 06b98cf..9d3327b 100644 (file)
@@ -88,16 +88,13 @@ void Model::clearMembers()
     mChapters.clear();
     mTemplFileString.clear();
     mOutPath.clear();
-    mSourcePath.clear();
     mCoverSheet.clear();
-    //mConfDir.clear();
     mDocName.clear();
     mSubject.clear();
-    bool mDoxygen=false;
-    mDoxygenName.clear();
-    bool mSourceChapter=false;
-    mSourceChapterName.clear();
     bool mHasCoverSheet=false;
+    bool mHasTitlePage=false;
+    bool mHasTableOfContent=false;
+    unsigned int mTableOfContentDepth=3;
     int mChapterNum=1;
     int mAuthorNum=0;
 }
@@ -105,11 +102,11 @@ void Model::clearMembers()
 void Model::newTemplate(std::string name)
 {
     setSubjectName(name);
-    chapterInsertBack("Example", "Example.tex");
+    chapterInsertBack("Example", "Example.tex", ChapterFactory::TypeTextChapter);
     authorInsertBack();
     mChapterNum = 1;
     mAuthorNum = 0;
-    getSelChapter()->SetText("%Example Chapter");
+    getSelChapter()->SetContent("%Example Chapter");
 }
 
 void Model::setTemplFile(std::string templFile)
@@ -166,155 +163,70 @@ void Model::setTemplFile(std::string templFile)
     throwXmlError(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("department")->FirstChildElement("x_coor")->QueryUnsignedText(&mDepartmentX));
     throwXmlError(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("department")->FirstChildElement("y_coor")->QueryUnsignedText(&mDepartmentY));
 
-    //------------ Parse Titelseite ------------
+    //------------ Parse Deckblatt ------------
     if(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("cover_sheet") == nullptr)
         throw std::string("Missing config: <docsettings> -> <cover_sheet>");
 
-    std::string str = mTemplFile.FirstChildElement("docsettings")->FirstChildElement("cover_sheet")->GetText();
-    if(str == "true")
-        mHasCoverSheet = true;
-    else if(str == "false")
-        mHasCoverSheet = false;
-    else
-        throw std::string("Wrong config value <docsettings> -> <cover_sheet>: " + str);
-
-
-
-    //------------ Parse Quellcode Kapitel ------------
-    if(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("sourcecode")==nullptr)
-        throw std::string("Missing config: <docsettings> -> <sourcecode>");
-
-    if(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("sourcecode")->FirstChildElement("enabled")==nullptr)
-        throw std::string("Missing config: <docsettings> -> <sourcecode> -> <enabled>");
-
-    if(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("sourcecode")->FirstChildElement("chaptername")==nullptr)
-        throw std::string("Missing config: <docsettings> -> <sourcecode> -> <chaptername>");
-
-    mSourceChapterName = mTemplFile.FirstChildElement("docsettings")->FirstChildElement("sourcecode")->FirstChildElement("chaptername")->GetText();
-    str = mTemplFile.FirstChildElement("docsettings")->FirstChildElement("sourcecode")->FirstChildElement("enabled")->GetText();
-    if(str == "true")
-        mSourceChapter = true;
-    else if(str == "false")
-        mSourceChapter = false;
-    else
-        throw std::string("Wrong config value <docsettings> -> <sourcecode> -> <enabled>: " + str);
-
+    throwXmlError(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("cover_sheet")->QueryBoolText(&mHasCoverSheet));
 
+    //------------ Parse Titelseite ------------
+    if(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("title_page") == nullptr)
+        throw std::string("Missing config: <docsettings> -> <title_page>");
 
-    //------------ Parse Doxygen Kapitel ------------
-    if(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("doxygen")==nullptr)
-        throw std::string("Missing config: <docsettings> -> <doxygen>");
+    throwXmlError(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("title_page")->QueryBoolText(&mHasTitlePage));
 
-    if(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("doxygen")->FirstChildElement("enabled")==nullptr)
-        throw std::string("Missing config: <docsettings> -> <doxygen> -> <enabled>");
+    //------------ Parse Inhaltsverzeichnis ------------
+    if(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("toc") == nullptr)
+        throw std::string("Missing config: <docsettings> -> <toc>");
 
-    if(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("doxygen")->FirstChildElement("chaptername")==nullptr)
-        throw std::string("Missing config: <docsettings> -> <doxygen> -> <chaptername>");
+    if(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("toc")->FirstChildElement("enabled") == nullptr)
+        throw std::string("Missing config: <docsettings> -> <toc> -> <enabled>");
 
-    mDoxygenName = mTemplFile.FirstChildElement("docsettings")->FirstChildElement("doxygen")->FirstChildElement("chaptername")->GetText();
-    str = mTemplFile.FirstChildElement("docsettings")->FirstChildElement("doxygen")->FirstChildElement("enabled")->GetText();
-    if(str == "true")
-        mDoxygen = true;
-    else if(str == "false")
-        mDoxygen = false;
-    else
-        throw std::string("Wrong config value <docsettings> -> <doxygen> -> <enabled>: " + str);
+    if(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("toc")->FirstChildElement("depth") == nullptr)
+        throw std::string("Missing config: <docsettings> -> <toc> -> <depth>");
 
+    throwXmlError(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("toc")->FirstChildElement("depth")->QueryUnsignedText(&mTableOfContentDepth));
+    throwXmlError(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("toc")->FirstChildElement("enabled")->QueryBoolText(&mHasTableOfContent));
 
     //------------ Parse Kapitel ------------
-    Chapter curChap;
-    int val = 0;
-
     if(mTemplFile.FirstChildElement("chapters")==nullptr)
         throw std::string("XML Syntax error: Missing <chapters> tag");
 
-    tinyxml2::XMLElement* curElem = mTemplFile.FirstChildElement("chapters")->FirstChildElement("chapter");
-
-    // Erstes Element
-    if( curElem == nullptr ||
-            curElem->FirstChildElement("num") == nullptr ||
-            curElem->FirstChildElement("filename") == nullptr ||
-            curElem->FirstChildElement("prettyName") == nullptr)
-        throw std::string("XML Syntax error parsing Chapter content.");
-
-    curElem->FirstChildElement("num")->QueryIntText(&val);
-    curChap.SetNum(val);
-    curChap.SetOutFileName(curElem->FirstChildElement("filename")->GetText());
-    curChap.SetPrettyName(curElem->FirstChildElement("prettyName")->GetText());
-    curChap.SetDone(false);
-    curChap.SetText(curElem->FirstChildElement("textTemplate")->GetText());
-    mChapters.push_back(std::make_shared<Chapter>(curChap));
-
-    // Alle weiteren Elemente
-    while(curElem != mTemplFile.FirstChildElement("chapters")->LastChildElement("chapter"))
+    for(tinyxml2::XMLElement* curElem = mTemplFile.FirstChildElement("chapters")->FirstChildElement("chapter");
+            curElem != nullptr;
+            curElem = curElem->NextSiblingElement("chapter"))
     {
-        curElem = curElem->NextSiblingElement("chapter");
 
         if( curElem == nullptr ||
                 curElem->FirstChildElement("num") == nullptr ||
                 curElem->FirstChildElement("filename") == nullptr ||
-                curElem->FirstChildElement("prettyName") == nullptr)
+                curElem->FirstChildElement("prettyName") == nullptr ||
+                curElem->FirstChildElement("content") == nullptr ||
+                curElem->FirstChildElement("hierachy") == nullptr ||
+                curElem->FirstChildElement("type") == nullptr)
             throw std::string("XML Syntax error parsing Chapter content.");
 
+        int val = 0;
+        ChapterIF::SPtr curChap = mChaptFactory.createChapter(curElem->FirstChildElement("type")->GetText());
         curElem->FirstChildElement("num")->QueryIntText(&val);
-        curChap.SetNum(val);
-        curChap.SetOutFileName(curElem->FirstChildElement("filename")->GetText());
-        curChap.SetPrettyName(curElem->FirstChildElement("prettyName")->GetText());
-        curChap.SetDone(false);
-        curChap.SetText(curElem->FirstChildElement("textTemplate")->GetText());
-        mChapters.push_back(std::make_shared<Chapter>(curChap));
+        curChap->SetNum(val);
+        curChap->SetOutFileName(curElem->FirstChildElement("filename")->GetText());
+        curChap->SetPrettyName(curElem->FirstChildElement("prettyName")->GetText());
+        curChap->SetDone(false);
+        curChap->SetContent(curElem->FirstChildElement("content")->GetText());
+        curChap->SetHierachy(curElem->FirstChildElement("hierachy")->GetText());
+        mChapters.push_back(curChap);
     }
     mChapterNum = 1;
 
-    //------------ Parse Author ------------
-    Author curAuthor;
-    unsigned int num = 0;
-    unsigned int name_x = 0;
-    unsigned int name_y = 0;
-    unsigned int time_spent_x = 0;
-    unsigned int time_spent_y = 0;
-    unsigned int time_est_x = 0;
-    unsigned int time_est_y = 0;
-
+    //------------ Parse Autoren ------------
     if(mTemplFile.FirstChildElement("docsettings")->FirstChildElement("authors")==nullptr)
         throw std::string("XML Syntax error: Missing <authors> tag");
 
-    curElem = mTemplFile.FirstChildElement("docsettings")->FirstChildElement("authors")->FirstChildElement("author");
-
-    // Erstes Element
-    if( curElem == nullptr ||
-            curElem->FirstChildElement("num") == nullptr ||
-            curElem->FirstChildElement("x_coor") == nullptr ||
-            curElem->FirstChildElement("y_coor") == nullptr ||
-            curElem->FirstChildElement("time_spent")->FirstChildElement("x_coor") == nullptr ||
-            curElem->FirstChildElement("time_spent")->FirstChildElement("y_coor") == nullptr ||
-            curElem->FirstChildElement("time_estimated")->FirstChildElement("x_coor") == nullptr ||
-            curElem->FirstChildElement("time_estimated")->FirstChildElement("y_coor") == nullptr)
-        throw std::string("XML syntax error parsing author content.");
-
-    throwXmlError(curElem->FirstChildElement("num")->QueryUnsignedText(&num));
-    throwXmlError(curElem->FirstChildElement("x_coor")->QueryUnsignedText(&name_x));
-    throwXmlError(curElem->FirstChildElement("y_coor")->QueryUnsignedText(&name_y));
-    throwXmlError(curElem->FirstChildElement("time_spent")->FirstChildElement("x_coor")->QueryUnsignedText(&time_spent_x));
-    throwXmlError(curElem->FirstChildElement("time_spent")->FirstChildElement("y_coor")->QueryUnsignedText(&time_spent_y));
-    throwXmlError(curElem->FirstChildElement("time_estimated")->FirstChildElement("x_coor")->QueryUnsignedText(&time_est_x));
-    throwXmlError(curElem->FirstChildElement("time_estimated")->FirstChildElement("y_coor")->QueryUnsignedText(&time_est_y));
-    curAuthor.SetNum(num);
-    curAuthor.SetXNameCoordinate(name_x);
-    curAuthor.SetYNameCoordinate(name_y);
-    curAuthor.SetXTimeEstimatedCoordinate(time_est_x);
-    curAuthor.SetYTimeEstimatedCoordinate(time_est_y);
-    curAuthor.SetXTimeSpentCoordinate(time_spent_x);
-    curAuthor.SetYTimeSpentCoordinate(time_spent_y);
-    curAuthor.SetName("Author " + std::to_string(num));
-    curAuthor.SetTimeEstimated("0 h");
-    curAuthor.SetTimeSpent("0 h");
-    mAuthors.push_back(std::make_shared<Author>(curAuthor));
-
-    // Alle weiteren Elemente
-    while(curElem != mTemplFile.FirstChildElement("docsettings")->FirstChildElement("authors")->LastChildElement("author"))
+    for(tinyxml2::XMLElement* curElem = mTemplFile.FirstChildElement("docsettings")->FirstChildElement("authors")->FirstChildElement("author");
+            curElem != nullptr;
+            curElem = curElem->NextSiblingElement("author"))
     {
-        curElem = curElem->NextSiblingElement("author");
 
         if( curElem == nullptr ||
                 curElem->FirstChildElement("num") == nullptr ||
@@ -322,10 +234,23 @@ void Model::setTemplFile(std::string templFile)
                 curElem->FirstChildElement("y_coor") == nullptr ||
                 curElem->FirstChildElement("time_spent")->FirstChildElement("x_coor") == nullptr ||
                 curElem->FirstChildElement("time_spent")->FirstChildElement("y_coor") == nullptr ||
+                curElem->FirstChildElement("id")->FirstChildElement("x_coor") == nullptr ||
+                curElem->FirstChildElement("id")->FirstChildElement("y_coor") == nullptr ||
                 curElem->FirstChildElement("time_estimated")->FirstChildElement("x_coor") == nullptr ||
                 curElem->FirstChildElement("time_estimated")->FirstChildElement("y_coor") == nullptr)
             throw std::string("XML syntax error parsing author content.");
 
+        Author curAuthor;
+        unsigned int num = 0;
+        unsigned int name_x = 0;
+        unsigned int name_y = 0;
+        unsigned int id_x = 0;
+        unsigned int id_y = 0;
+        unsigned int time_spent_x = 0;
+        unsigned int time_spent_y = 0;
+        unsigned int time_est_x = 0;
+        unsigned int time_est_y = 0;
+
         throwXmlError(curElem->FirstChildElement("num")->QueryUnsignedText(&num));
         throwXmlError(curElem->FirstChildElement("x_coor")->QueryUnsignedText(&name_x));
         throwXmlError(curElem->FirstChildElement("y_coor")->QueryUnsignedText(&name_y));
@@ -333,6 +258,8 @@ void Model::setTemplFile(std::string templFile)
         throwXmlError(curElem->FirstChildElement("time_spent")->FirstChildElement("y_coor")->QueryUnsignedText(&time_spent_y));
         throwXmlError(curElem->FirstChildElement("time_estimated")->FirstChildElement("x_coor")->QueryUnsignedText(&time_est_x));
         throwXmlError(curElem->FirstChildElement("time_estimated")->FirstChildElement("y_coor")->QueryUnsignedText(&time_est_y));
+        throwXmlError(curElem->FirstChildElement("id")->FirstChildElement("x_coor")->QueryUnsignedText(&id_x));
+        throwXmlError(curElem->FirstChildElement("id")->FirstChildElement("y_coor")->QueryUnsignedText(&id_y));
         curAuthor.SetNum(num);
         curAuthor.SetXNameCoordinate(name_x);
         curAuthor.SetYNameCoordinate(name_y);
@@ -340,6 +267,8 @@ void Model::setTemplFile(std::string templFile)
         curAuthor.SetYTimeEstimatedCoordinate(time_est_y);
         curAuthor.SetXTimeSpentCoordinate(time_spent_x);
         curAuthor.SetYTimeSpentCoordinate(time_spent_y);
+        curAuthor.SetXid(id_x);
+        curAuthor.SetYid(id_y);
         curAuthor.SetName("Author " + std::to_string(num));
         curAuthor.SetTimeEstimated("0 h");
         curAuthor.SetTimeSpent("0 h");
@@ -352,7 +281,7 @@ void Model::setTemplFile(std::string templFile)
     {
         return first->GetNum() < sec->GetNum();
     });
-    std::sort(mChapters.begin(), mChapters.end(), [](const Chapter::SPtr first, const Chapter::SPtr sec)
+    std::sort(mChapters.begin(), mChapters.end(), [](const ChapterIF::SPtr first, const ChapterIF::SPtr sec)
     {
         return first->GetNum() < sec->GetNum();
     });
@@ -397,7 +326,7 @@ Author::SPtr Model::getSelAuthor()
     return mAuthors.at(mAuthorNum);
 }
 
-Chapter::SPtr Model::getSelChapter()
+ChapterIF::SPtr Model::getSelChapter()
 {
     return mChapters.at(mChapterNum-1);
 }
@@ -466,7 +395,7 @@ void Model::chapterDown()
     }
 }
 
-void Model::chapterInsertBack(std::string chaptName, std::string outFileName)
+void Model::chapterInsertBack(std::string chaptName, std::string outFileName, std::string type, int hierachy)
 {
     if(chaptName.empty())
         throw std::string("Please set an chapter name!");
@@ -475,7 +404,7 @@ void Model::chapterInsertBack(std::string chaptName, std::string outFileName)
         throw std::string("Please set an output file name!");
 
     // Überprüfe ob ein anderes kapitel den selben dateinamen besitzt
-    auto found = std::find_if(mChapters.begin(), mChapters.end(), [outFileName](Chapter::SPtr chapt)
+    auto found = std::find_if(mChapters.begin(), mChapters.end(), [outFileName](ChapterIF::SPtr chapt)
     {
         return (outFileName == chapt->GetOutFileName());
     }
@@ -484,15 +413,21 @@ void Model::chapterInsertBack(std::string chaptName, std::string outFileName)
     if(found !=  std::end(mChapters))
         throw std::string("Filename " + outFileName + " is already used by chapter " + std::to_string((*found)->GetNum()) + " (" + (*found)->GetPrettyName()  + ")" );
 
-    Chapter::SPtr newChapt {std::make_shared<Chapter>()};
+    ChapterIF::SPtr newChapt = mChaptFactory.createChapter(type);
     newChapt->SetNum(getNumChapters() + 1);
     newChapt->SetOutFileName(outFileName);
     newChapt->SetPrettyName(chaptName);
+    newChapt->SetHierachy(hierachy);
     newChapt->SetDone(false);
     mChapters.push_back(newChapt);
     setOutPath(mOutPath); // Lade text aus hinzugefügter kapiteldatei, falls sie existiert
 }
 
+void Model::chapterInsertBack(std::string chaptName, std::string outFileName, int type, int hierachy)
+{
+    chapterInsertBack(chaptName, outFileName, mChaptFactory.getChapterTypes().at(type), hierachy);
+}
+
 void Model::authorInsertBack()
 {
     Author::SPtr newAuthor {std::make_shared<Author>()};
@@ -503,6 +438,8 @@ void Model::authorInsertBack()
     newAuthor->SetYTimeEstimatedCoordinate(0);
     newAuthor->SetXTimeSpentCoordinate(0);
     newAuthor->SetYTimeSpentCoordinate(0);
+    newAuthor->SetXid(0);
+    newAuthor->SetYid(0);
     newAuthor->SetTimeEstimated("0 h");
     newAuthor->SetTimeSpent("0 h");
 
@@ -514,7 +451,7 @@ void Model::chapterRemove()
 {
     if(getNumChapters()-1>0)
     {
-        std::vector <Chapter::SPtr>::iterator it;
+        std::vector <ChapterIF::SPtr>::iterator it;
         for( it = mChapters.begin()+mChapterNum-1; it != mChapters.end(); it++)
             (*it)->SetNum((*it)->GetNum()-1);
 
@@ -548,22 +485,25 @@ void Model::setOutPath(std::string outPath)
 
     mOutPath = mFSHelp.addDirLastSlash(outPath);
 
-    // Lade text aus ev. existierenden Dateien
+    // Lade text aus ev. existierenden Text Dateien
     for(auto curChapt : mChapters)
     {
-        std::ifstream iFstr;
-        iFstr.open(mOutPath + curChapt->GetOutFileName());
-        if(iFstr.good())
+        if(curChapt->GetType() == mChaptFactory.getChapterTypes().at(ChapterFactory::TypeTextChapter))
         {
-            std::stringstream buffer;
-            buffer << iFstr.rdbuf();
-            if(buffer.good())
-                curChapt->SetText(buffer.str());
-            else
-                throw std::string("Error reading existing chapter file!");
+            std::ifstream iFstr;
+            iFstr.open(mOutPath + curChapt->GetOutFileName());
+            if(iFstr.good())
+            {
+                std::stringstream buffer;
+                buffer << iFstr.rdbuf();
+                if(buffer.good())
+                    curChapt->SetContent(buffer.str());
+                else
+                    throw std::string("Error reading existing chapter file!");
 
+            }
+            iFstr.close();
         }
-        iFstr.close();
     }
 }
 
@@ -573,6 +513,7 @@ void Model::generateDocument()
     if(!mFSHelp.dirExists(mOutPath))
         throw std::string("Output path not found! Please set an existing output directory.");
 
+    // Kopiere Vorlage
     mFSHelp.copyFile(mConfDir + "packages.tex", mOutPath + "packages.tex");
     mFSHelp.copyFile(mConfDir + "doxygen.sty", mOutPath + "doxygen.sty");
     mFSHelp.copyFile(mConfDir + "setup_doxygen.tex", mOutPath + "setup_doxygen.tex");
@@ -580,14 +521,14 @@ void Model::generateDocument()
     mFSHelp.copyFile(mConfDir + "main.tex", mOutPath + "main.tex");
     mFSHelp.copyFile(mConfDir + "docsettings.tex", mOutPath + "docsettings.tex");
 
-    // Öffne main.tex
+    // main.tex
     std::ofstream mainFile;
     mainFile.open( mOutPath + "main.tex", std::ios_base::app);
     if(!mainFile.good())
         throw std::string("Could not open main.tex");
 
-    // Füge subjec name hinzu
-    mainFile << "\\newcommand{\\headerleft}{" << mSubject <<"}" << std::endl;
+    // Füge subject name hinzu
+    mainFile << "\\newcommand{\\docsubject}{" << mSubject <<"}" << std::endl;
 
     // Füge Abteilug hinzu
     mainFile << "\\newcommand{\\department}{" << mDepartment <<"}" << std::endl;
@@ -595,8 +536,10 @@ void Model::generateDocument()
     // Füge dokumentennamen hinzu
     mainFile << "\\title{" << mDocName << "}" << std::endl;
 
+    // Ort hinzufügen
     mainFile << "\\date{\\today{}, " << mLocation << "}" << std::endl;
 
+    // AUthoren hinzufügen
     mainFile << "\\author{";
     for(auto curAuthor : mAuthors)
     {
@@ -606,193 +549,66 @@ void Model::generateDocument()
     }
     mainFile << "}" << std::endl;
 
-
+    // Einstellungsdateien/Styledateien eibinden
     mainFile << std::endl;
     mainFile << "\\input{codesettings.tex}" << std::endl;
     mainFile << "\\begin{document}" << std::endl;
     mainFile << "\\input{docsettings.tex}" << std::endl;
     mainFile << std::endl;
 
-    // FÃ\9cge kapitel hinzu
+    // Füge kapitel hinzu + erzeuge Kapiteldateien
     for(auto curChap : mChapters)
     {
-        curChap->WriteFile(mOutPath);
-        mainFile << "\t\\chapter{" << curChap->GetPrettyName() << "}" << std::endl;
+        curChap->WriteFile(this);
+        mainFile << "\t\\"+curChap->GetHierachy()+"{" << curChap->GetPrettyName() << "}" << std::endl;
         mainFile << "\t\t\\input{" << curChap->GetOutFileName() << "}" << std::endl;
         mainFile << std::endl;
     }
 
 
-    //Füge Angabenseite hinzu
-    if(shouldAddCoverSheet())
-    {
-        // Öffne docsettings.tex
-        std::ofstream docSettingsFile;
-        docSettingsFile.open( mOutPath + "docsettings.tex", std::ios_base::app);
-        if(!docSettingsFile.good())
-            throw std::string("Could not open docsettings.tex");
+    // Öffne docsettings.tex
+    std::ofstream docSettingsFile;
+    docSettingsFile.open( mOutPath + "docsettings.tex", std::ios_base::app);
+    if(!docSettingsFile.good())
+        throw std::string("Could not open docsettings.tex");
 
+    //---- Füge Angabenseite/Deckblatt hinzu ----
+    if(mHasCoverSheet)
+    {
+        mFSHelp.copyFile(mCoverSheet, mOutPath + "coversheet.pdf");
 
+        // Deckblatt ausfüllen
         docSettingsFile << "\\begin{titlepage}\n\t\\includepdf[pages={-},\n\t\tpicturecommand*={" << std::endl;
         for(auto curAuthor : mAuthors)
         {
             docSettingsFile << "\t\t\\put(" << curAuthor->GetXNameCoordinate() << "," << curAuthor->GetYNameCoordinate() << "){" << curAuthor->GetName() << "}" << std::endl;
             docSettingsFile << "\t\t\\put(" << curAuthor->GetXTimeEstimatedCoordinate() << "," << curAuthor->GetYTimeEstimatedCoordinate() << "){" << curAuthor->GetTimeEstimated() << "}" << std::endl;
             docSettingsFile << "\t\t\\put(" << curAuthor->GetXTimeSpentCoordinate() << "," << curAuthor->GetYTimeSpentCoordinate() << "){" << curAuthor->GetTimeSpent() << "}" << std::endl;
+            docSettingsFile << "\t\t\\put(" << curAuthor->GetXid() << "," << curAuthor->GetYid() << "){" << curAuthor->GetID() << "}" << std::endl;
         }
-
         docSettingsFile << "\t\t\\put(" << mDepartmentX << "," << mDepartmentY << "){" << mDepartment << "}" << std::endl;
-
         docSettingsFile << "\t}]{coversheet.pdf}\n\\end{titlepage}" << std::endl;
-
-        docSettingsFile.close();
     }
 
-    std::ofstream docSettingsFile;
-    docSettingsFile.open( mOutPath + "docsettings.tex", std::ios_base::app);
-    if(!docSettingsFile.good())
-        throw std::string("Could not open docsettings.tex");
+    // Latex Titelblatt erzeugen
+    if(mHasTitlePage)
+        docSettingsFile << "\\maketitle" << std::endl;
 
-    // Hardcoded settings
-    docSettingsFile << "\\maketitle" << std::endl;
-    docSettingsFile << "\\tableofcontents" << std::endl;
-    docSettingsFile << "\\setcounter{tocdepth}{3}" << std::endl;
-    docSettingsFile << "\\newpage" << std::endl;
+    // Inhaltsverzeichnis erzeugen
+    if(mHasTableOfContent)
+        docSettingsFile << "\\tableofcontents" << std::endl << "\\setcounter{tocdepth}{"+
+        std::to_string(mTableOfContentDepth) +"}" << std::endl << "\\newpage" << std::endl;
 
     docSettingsFile.close();
 
 
-    if(shouldGenDoxygen())
-    {
-        mFSHelp.copyDir(mSourcePath, mOutPath + "src");
-        mFSHelp.copyFile(mConfDir + "doxyfile", mOutPath + "doxyfile");
-        mFSHelp.makeDir(mOutPath + "doxygen");
-
-        // Starte DoxyGen
-        std::vector<std::string> paramsDoxy = {mOutPath + "doxyfile"};
-        mFSHelp.executeCommand(mOutPath, "doxygen", paramsDoxy, mFSHelp.addDirLastSlash(mOutPath) + mLogFile);
-
-        mFSHelp.copyFile(mOutPath + "doxygen/doxygen.sty", mOutPath + "doxygen.sty");
-
-        std::vector<FSHelper::File> doxyFiles;
-        if(!mFSHelp.listFilesRecursive(mOutPath + "doxygen", doxyFiles, true))
-            throw std::string("Failed to get filenames of source files!");
-
-        // Nach class_ filtern
-        auto it = std::remove_if(doxyFiles.begin(),
-                                 doxyFiles.end(),
-                                 [](FSHelper::File x)
-        {
-
-            unsigned int ind = x.second.find_first_of("_");
-            if(ind ==  std::string::npos) return true; //Keine Dateiendung
-
-            // Daeien beginnend mit class_
-            if((x.second.substr(0, ind+1) == "class_"))
-                return false;
-
-            // Alle anderen
-            return true;
-        });
-        doxyFiles.erase(it, doxyFiles.end());
-
-        // Nach namen sortieren
-        std::sort(doxyFiles.begin(), doxyFiles.end(),
-                  [](FSHelper::File left, FSHelper::File right)
-        {
-            return left.second < right.second;
-        }
-
-                 );
-
-        std::ofstream out;
-        out.open(mOutPath + "doxyfiles.tex", std::ios_base::out);
-        if(out.good())
-        {
-            out << "\\input{doxygen/hierarchy.tex}" << std::endl;
-            out << "\\input{doxygen/annotated.tex}" << std::endl;
-            for(auto curElem : doxyFiles)
-            {
-                curElem.first.replace(curElem.first.find(mOutPath), mOutPath.length(), ""); //Erzeuge relativen Pfade
-                out << "\\input{" << mFSHelp.convertPathToUnix(curElem.first) << curElem.second <<"}" << std::endl;
-            }
-        }
-        else
-            throw std::string("Failed to write doxygen chapter.");
-
-        out.close();
-
-        mainFile << "\t\\chapter{" << mDoxygenName << "}" << std::endl;
-        mainFile << "\t\t\\input{doxyfiles.tex}" << std::endl;
-        mainFile << std::endl;
-    }
-
-    // Füge Quellcode hinzu
-    if(shouldAddSource())
-    {
-        mFSHelp.copyDir(mSourcePath, mOutPath + "src");
-
-        std::vector<FSHelper::File> sourceFiles;
-        if(!mFSHelp.listFilesRecursive(mOutPath + "src", sourceFiles, true))
-            throw std::string("Failed to get filenames of source files!");
-
-
-
-        // Nach dateiendung filtern
-        auto it = std::remove_if(sourceFiles.begin(),
-                                 sourceFiles.end(),
-                                 [this](FSHelper::File x)
-        {
-
-            unsigned int ind = x.second.find_last_of(".");
-            if(ind ==  std::string::npos) return true; //Keine Dateiendung
-
-            // Dateiendung cpp oder h
-            if((x.second.substr(ind) == mSourceExtension) ||
-               (x.second.substr(ind) == mHeaderExtension))
-                return false;
-
-            // Alle anderen
-            return true;
-        });
-        sourceFiles.erase(it, sourceFiles.end());
-
-        // Nach namen sortieren (header vor cpp)
-        std::sort(sourceFiles.begin(), sourceFiles.end(),
-                  [](FSHelper::File left, FSHelper::File right)
-                    {
-                        return left.second > right.second;
-                    }
-
-                 );
-
-        std::ofstream out;
-        out.open(mOutPath + "sourcefiles.tex", std::ios_base::out);
-        if(out.good())
-            for(auto curElem : sourceFiles)
-            {
-                curElem.first.replace(curElem.first.find(mOutPath), mOutPath.length(), ""); //Erzeuge relativen Pfade
-                out << "\\lstinputlisting[language=C++]{" << mFSHelp.convertPathToUnix(curElem.first) << curElem.second <<"}" << std::endl;
-            }
-        else
-            throw std::string("Failed to write sourcefiles chapter.");
-
-        out.close();
-
-        mainFile << "\t\\chapter{" << mSourceChapterName << "}" << std::endl;
-        mainFile << "\t\t\\input{sourcefiles.tex}" << std::endl;
-        mainFile << std::endl;
-    }
-
-    if(shouldAddCoverSheet())
-        mFSHelp.copyFile(mCoverSheet, mOutPath + "coversheet.pdf");
-
+    // kopiere resources ordner
     mFSHelp.copyDir(mConfDir + "resources", mOutPath + "resources");
 
     mainFile << "\\end{document}" << std::endl;
     mainFile.close();
 
-    //start dokument generierung
+    // Generiere Dokument
     std::vector<std::string> paramsDryRun = {"-draftmode", "-interaction=nonstopmode", "main.tex"};
     std::vector<std::string> paramsGen = {"-interaction=nonstopmode", "main.tex"};
     mFSHelp.executeCommand(mOutPath, "pdflatex", paramsDryRun, mFSHelp.addDirLastSlash(mOutPath) + mLogFile);
@@ -813,12 +629,25 @@ void Model::saveTemplFile()
     tinyxml2::XMLElement * pSubjName = outDoc.NewElement("subjectname");
     tinyxml2::XMLElement * pLocation = outDoc.NewElement("location");
     tinyxml2::XMLElement * pCoverSheet = outDoc.NewElement("cover_sheet");
+    tinyxml2::XMLElement * pTitlePage = outDoc.NewElement("title_page");
     pSubjName->SetText(mSubject.c_str());
     pLocation->SetText(mLocation.c_str());
     pCoverSheet->SetText(mHasCoverSheet);
+    pTitlePage->SetText(mHasTitlePage);
     pDocSettings->InsertEndChild(pSubjName);
     pDocSettings->InsertEndChild(pLocation);
     pDocSettings->InsertEndChild(pCoverSheet);
+    pDocSettings->InsertEndChild(pTitlePage);
+
+    // Inhaltsverzeichnis
+    tinyxml2::XMLNode * pToC = outDoc.NewElement("toc");
+    tinyxml2::XMLElement * pToCenabled = outDoc.NewElement("enabled");
+    tinyxml2::XMLElement * pToCdepth = outDoc.NewElement("depth");
+    pToCenabled->SetText(mHasTableOfContent);
+    pToCdepth->SetText(mTableOfContentDepth);
+    pToC->InsertEndChild(pToCenabled);
+    pToC->InsertEndChild(pToCdepth);
+    pDocSettings->InsertEndChild(pToC);
 
     // Fileextensions
     tinyxml2::XMLNode * pFileExtensions= outDoc.NewElement("fileextensions");
@@ -833,19 +662,6 @@ void Model::saveTemplFile()
     pFileExtensions->InsertEndChild(pFileExtSource);
     pDocSettings->InsertEndChild(pFileExtensions);
 
-    // Doxygen
-    tinyxml2::XMLNode * pDoxyGen = outDoc.NewElement("doxygen");
-    tinyxml2::XMLElement * pDoxyEnabled = outDoc.NewElement("enabled");
-    tinyxml2::XMLElement * pDoxyChaptName = outDoc.NewElement("chaptername");
-    pDoxyEnabled->SetText(mDoxygen);
-    if(mDoxygen)
-        pDoxyChaptName->SetText(mDoxygenName.c_str());
-    else
-        pDoxyChaptName->SetText("Not set");
-    pDoxyGen->InsertEndChild(pDoxyChaptName);
-    pDoxyGen->InsertEndChild(pDoxyEnabled);
-    pDocSettings->InsertEndChild(pDoxyGen);
-
     // Department
     tinyxml2::XMLNode * pDepartment = outDoc.NewElement("department");
     tinyxml2::XMLElement * pDepX = outDoc.NewElement("x_coor");
@@ -856,20 +672,7 @@ void Model::saveTemplFile()
     pDepartment->InsertEndChild(pDepY);
     pDocSettings->InsertEndChild(pDepartment);
 
-    // Sourcecode
-    tinyxml2::XMLNode * pSource= outDoc.NewElement("sourcecode");
-    tinyxml2::XMLElement * pSrcEnabled = outDoc.NewElement("enabled");
-    tinyxml2::XMLElement * pSrcChaptName = outDoc.NewElement("chaptername");
-    pSrcEnabled->SetText(mSourceChapter);
-    if(mSourceChapter)
-        pSrcChaptName->SetText(mSourceChapterName.c_str());
-    else
-        pSrcChaptName->SetText("Not set");
-    pSource->InsertEndChild(pSrcEnabled);
-    pSource->InsertEndChild(pSrcChaptName);
-    pDocSettings->InsertEndChild(pSource);
-
-    // Speichere Kapitel zu XML
+    // Speichere Autoren zu XML
     tinyxml2::XMLNode * pAuthors = outDoc.NewElement("authors");
     for(auto curAuth: mAuthors)
     {
@@ -880,6 +683,7 @@ void Model::saveTemplFile()
         tinyxml2::XMLElement * pNameY = outDoc.NewElement("y_coor");
         tinyxml2::XMLNode * pTimeEst= outDoc.NewElement("time_estimated");
         tinyxml2::XMLNode * pTimeSpent = outDoc.NewElement("time_spent");
+        tinyxml2::XMLNode * pId = outDoc.NewElement("id");
 
         tinyxml2::XMLElement * pTimeEstX = outDoc.NewElement("x_coor");
         tinyxml2::XMLElement * pTimeEstY = outDoc.NewElement("y_coor");
@@ -887,6 +691,9 @@ void Model::saveTemplFile()
         tinyxml2::XMLElement * pTimeSpenX = outDoc.NewElement("x_coor");
         tinyxml2::XMLElement * pTimeSpenY = outDoc.NewElement("y_coor");
 
+        tinyxml2::XMLElement * pIdX = outDoc.NewElement("x_coor");
+        tinyxml2::XMLElement * pIdY = outDoc.NewElement("y_coor");
+
         pNum->SetText(curAuth->GetNum());
         pNameX->SetText(curAuth->GetXNameCoordinate());
         pNameY->SetText(curAuth->GetYNameCoordinate());
@@ -894,6 +701,8 @@ void Model::saveTemplFile()
         pTimeSpenY->SetText(curAuth->GetYTimeSpentCoordinate());
         pTimeEstX->SetText(curAuth->GetXTimeEstimatedCoordinate());
         pTimeEstY->SetText(curAuth->GetYTimeEstimatedCoordinate());
+        pIdX->SetText(curAuth->GetXid());
+        pIdY->SetText(curAuth->GetYid());
 
         pAuthor->InsertEndChild(pNum);
         pAuthor->InsertEndChild(pNameX);
@@ -903,6 +712,10 @@ void Model::saveTemplFile()
         pTimeEst->InsertEndChild(pTimeEstY);
         pAuthor->InsertEndChild(pTimeEst);
 
+        pId->InsertEndChild(pIdX);
+        pId->InsertEndChild(pIdY);
+        pAuthor->InsertEndChild(pId);
+
         pTimeSpent->InsertEndChild(pTimeSpenX);
         pTimeSpent->InsertEndChild(pTimeSpenY);
         pAuthor->InsertEndChild(pTimeSpent);
@@ -919,21 +732,32 @@ void Model::saveTemplFile()
         tinyxml2::XMLElement * pNum = outDoc.NewElement("num");
         tinyxml2::XMLElement * pName = outDoc.NewElement("prettyName");
         tinyxml2::XMLElement * pFileName = outDoc.NewElement("filename");
-        tinyxml2::XMLElement * pText = outDoc.NewElement("textTemplate");
+        tinyxml2::XMLElement * pContent = outDoc.NewElement("content");
+        tinyxml2::XMLElement * pType = outDoc.NewElement("type");
+        tinyxml2::XMLElement * pHierachy = outDoc.NewElement("hierachy");
 
         pNum->SetText(curChapt->GetNum());
         pName->SetText(curChapt->GetPrettyName().c_str());
         pFileName->SetText(curChapt->GetOutFileName().c_str());
+        pType->SetText(curChapt->GetType().c_str());
+        pHierachy->SetText(curChapt->GetHierachy().c_str());
 
-        if(curChapt->GetText().empty())
-            pText->SetText("% Enter text here.");
+        if(curChapt->GetType() == "Text")
+        {
+            if(curChapt->GetContent().empty())
+                pContent->SetText("% Enter text here.");
+            else
+                pContent->SetText(curChapt->GetContent().c_str());
+        }
         else
-            pText->SetText(curChapt->GetText().c_str());
+            pContent->SetText("Select Path");
 
         pChapter->InsertEndChild(pName);
         pChapter->InsertEndChild(pNum);
         pChapter->InsertEndChild(pFileName);
-        pChapter->InsertEndChild(pText);
+        pChapter->InsertEndChild(pContent);
+        pChapter->InsertEndChild(pType);
+        pChapter->InsertEndChild(pHierachy);
 
         pChapters->InsertEndChild(pChapter);
     }
@@ -946,32 +770,42 @@ bool Model::shouldAddCoverSheet()
     return mHasCoverSheet;
 }
 
-bool Model::shouldGenDoxygen()
+
+void Model::setAddTitlePage(bool val)
 {
-    return mDoxygen;
+    mHasTitlePage = val;
 }
 
-bool Model::shouldAddSource()
+
+void Model::setAddTableOfContent(bool val)
 {
-    return mSourceChapter;
+    mHasTableOfContent = val;
 }
 
-std::string Model::getSourceDir()
+
+void Model::setTableOfContentDepth(int depth)
 {
-    return mSourcePath;
+    mTableOfContentDepth = depth;
 }
 
-std::string Model::getCovSheet()
+bool Model::shouldAddTitlePage()
 {
-    return mCoverSheet;
+    return mHasTitlePage;
+}
+
+bool Model::shouldAddTableOfContent()
+{
+    return mHasTableOfContent;
 }
 
-void Model::setSourceDir(std::string path)
+int Model::getTableOfContentDepth()
 {
-    if(!mFSHelp.dirExists(path))
-        throw std::string("Source directory not found!");
+    return mTableOfContentDepth;
+}
 
-    mSourcePath = mFSHelp.addDirLastSlash(path);
+std::string Model::getCovSheet()
+{
+    return mCoverSheet;
 }
 
 void Model::setCovSheet(std::string file)
@@ -989,7 +823,8 @@ std::string Model::getConfDir()
 void Model::saveChaptersToFiles()
 {
     for(auto curChap : mChapters)
-        curChap->WriteFile(mOutPath);
+        if(curChap->GetType() == mChaptFactory.getChapterTypes().at(ChapterFactory::TypeTextChapter))
+            curChap->WriteFile(this);
 }
 
 bool Model::getGenerateEnable()
@@ -997,14 +832,10 @@ bool Model::getGenerateEnable()
     if(getNumChapters() == getNumFinishedChapters())
     {
 
-        if(shouldAddCoverSheet())
+        if(mHasCoverSheet)
             if(!mFSHelp.fileExists(mCoverSheet))
                 return false;
 
-        if(shouldAddSource())
-            if(!mFSHelp.dirExists(mSourcePath))
-                return false;
-
         if(mDocName.empty())
             return false;
 
@@ -1016,41 +847,11 @@ bool Model::getGenerateEnable()
     return false;
 }
 
-std::string Model::getSourceChapterName()
-{
-    return mSourceChapterName;
-}
-
-std::string Model::getDoxygenName()
-{
-    return mDoxygenName;
-}
-
 void Model::setAddCoverSheet(bool val)
 {
     mHasCoverSheet = val;
 }
 
-void Model::setAddSource(bool val)
-{
-    mSourceChapter = val;
-}
-
-void Model::setGenDoxygen(bool val)
-{
-    mDoxygen = val;
-}
-
-void Model::setSourceChapterName(std::string name)
-{
-    mSourceChapterName = name;
-}
-
-void Model::setDoxygenName(std::string name)
-{
-    mDoxygenName = name;
-}
-
 std::string Model::getDocName()
 {
     return mDocName;
@@ -1141,3 +942,8 @@ void Model::setSourceFileExtension(std::string fileExt)
 
     mSourceExtension = fileExt;
 }
+
+std::vector<std::string> Model::getChapterTypes()
+{
+    return mChaptFactory.getChapterTypes();
+}
index b6e6ba8..dbf0367 100644 (file)
@@ -11,7 +11,8 @@
 
 #include "ModelIF.h"
 #include "tinyxml2.h"
-#include "Chapter.h"
+#include "ChapterIF.h"
+#include "ChapterFactory.h"
 #include "Author.h"
 #include "FSHelper.h"
 #include <vector>
@@ -98,8 +99,20 @@ public:
     ///        Kapitelliste hinzu.
     /// \param chaptName Name des Kapitels
     /// \param outFileName name der Ausgabedatei.
+    /// \param type String der Kapiteltyp beschreibt.
+    /// \param hierachy Kapitelhierachietyp
     /////////////////////////////////////////////////
-    void chapterInsertBack(std::string chaptName, std::string outFileName);
+    void chapterInsertBack(std::string chaptName, std::string outFileName, std::string type, int hierachy = 0);
+
+    /////////////////////////////////////////////////
+    /// \brief Füge ein neues Kapitel am Ende der
+    ///        Kapitelliste hinzu.
+    /// \param chaptName Name des Kapitels
+    /// \param outFileName name der Ausgabedatei.
+    /// \param type Enum Konstante die Kapiteltyp beschreibt.
+    /// \param hierachy Kapitelhierachietyp
+    /////////////////////////////////////////////////
+    void chapterInsertBack(std::string chaptName, std::string outFileName, int type, int hierachy = 0);
 
     /////////////////////////////////////////////////
     /// \brief Lösche intern ausgewähltes Kapitel.
@@ -125,39 +138,32 @@ public:
     void saveTemplFile();
 
     /////////////////////////////////////////////////
-    /// \brief Konfiguriere ob Dokument ein Angabeblatt
-    ///        besitzt.
+    /// \brief Konfiguriere ob Dokument ein .pdf Angabeblatt
+    ///        als Deckblatt besitzt.
     /// \param bool true -> ja, false -> nein
     /////////////////////////////////////////////////
     void setAddCoverSheet(bool val);
 
     /////////////////////////////////////////////////
-    /// \brief Konfiguriere ob Dokument ein Quellcode
-    ///        Kapitel besitzt.
+    /// \brief Konfiguriere ob Dokument eine Titelseite
+    ///        besitzt.
     /// \param bool true -> ja, false -> nein
     /////////////////////////////////////////////////
-    void setAddSource(bool val);
+    void setAddTitlePage(bool val);
 
     /////////////////////////////////////////////////
-    /// \brief Konfiguriere ob Dokument ein Doxygen
-    ///        Kapitel besitzt.
+    /// \brief Konfiguriere ob Dokument ein Inhaltsverzeichnis
+    ///        besitzt.
     /// \param bool true -> ja, false -> nein
     /////////////////////////////////////////////////
-    void setGenDoxygen(bool val);
+    void setAddTableOfContent(bool val);
 
     /////////////////////////////////////////////////
-    /// \brief Konfiguriere Kapitelnamen des Quellcode
-    ///        Kapitels.
-    /// \param name Kapitelname
+    /// \brief Configuriert die Nummerierungstiefe
+    ///        des Inhaltsverzeichnis.
+    /// \param depth Nummerierungstiefe
     /////////////////////////////////////////////////
-    void setSourceChapterName(std::string name);
-
-    /////////////////////////////////////////////////
-    /// \brief Konfiguriere Kapitelnamen des Doxygen
-    ///        Kapitels.
-    /// \param name Kapitelname
-    /////////////////////////////////////////////////
-    void setDoxygenName(std::string name);
+    void setTableOfContentDepth(int depth);
 
     /////////////////////////////////////////////////
     /// \brief Setzte die X Deckblattkoordinaten für
@@ -203,8 +209,6 @@ public:
     /////////////////////////////////////////////////
     void saveChaptersToFiles();
 
-    void newTemplate(std::string name);
-
     /////////////////////////////////////////////////
     /// \brief Konfiguriere den Namen des Dokuments
     /// \param name Dokumentname
@@ -228,6 +232,13 @@ public:
     /// \param log Dateiname der Logging Datei.
     /////////////////////////////////////////////////
     void setLogFile(std::string log);
+
+    /////////////////////////////////////////////////
+    /// \brief Starte neues Document ohne eine Tamplate
+    ///        datei zu laden.
+    /// \param name Subject Name des Dokuments.
+    /////////////////////////////////////////////////
+    void newTemplate(std::string name);
     // ---------- Implementierung Interface ---------------
     std::list<std::string> getChapterNames() override;
     std::list<std::string> getAuthorNames() override;
@@ -247,21 +258,19 @@ public:
     int getNumFinishedChapters() override;
     std::string getSubjectName() override;
     bool shouldAddCoverSheet() override;
-    bool shouldAddSource() override;
-    bool shouldGenDoxygen() override;
-    std::string getSourceChapterName() override;
-    std::string getDoxygenName() override;
-    std::string getSourceDir() override;
     std::string getCovSheet() override;
     Author::SPtr getSelAuthor() override;
-    Chapter::SPtr getSelChapter() override;
+    ChapterIF::SPtr getSelChapter() override;
     std::string getLogFile() override;
+    bool shouldAddTitlePage() override;
+    bool shouldAddTableOfContent() override;
+    int getTableOfContentDepth() override;
+    std::vector<std::string> getChapterTypes() override;
 
 private:
     std::string mTemplFileString;
     std::string mOutPath;
     std::string mLogFile;
-    std::string mSourcePath;
     std::string mCoverSheet;
     std::string mConfDir;
     std::string mDocName;
@@ -276,11 +285,10 @@ private:
     std::string mHeaderExtension;
     std::string mSourceExtension;
 
-    bool mDoxygen;
-    std::string mDoxygenName;
-    bool mSourceChapter;
-    std::string mSourceChapterName;
     bool mHasCoverSheet;
+    bool mHasTitlePage;
+    bool mHasTableOfContent;
+    unsigned int mTableOfContentDepth;
 
     // Geladenes Kapitel
     int mChapterNum;
@@ -289,7 +297,8 @@ private:
     int mAuthorNum;
 
     std::vector<Author::SPtr> mAuthors;
-    std::vector<Chapter::SPtr> mChapters;
+    std::vector<ChapterIF::SPtr> mChapters;
+    ChapterFactory mChaptFactory;
 
     tinyxml2::XMLDocument mTemplFile;
 
index 955cde3..cf48d6a 100644 (file)
 #include <memory>
 #include "Subject.h"
 #include "Author.h"
-#include "Chapter.h"
 #include <list>
+#include <vector>
 
+class ChapterIF;
 
 /////////////////////////////////////////////////
 /// \brief Interface für die Model Klasse.
@@ -57,7 +58,7 @@ public:
     ///        Kapitels zurück.
     /// \return Pointer auf Objekt des selektierten Kapitels
     /////////////////////////////////////////////////
-    virtual Chapter::SPtr getSelChapter() = 0;
+    virtual std::shared_ptr<ChapterIF> getSelChapter() = 0;
 
     /////////////////////////////////////////////////
     /// \brief Gibt die nummer des selektierten
@@ -102,40 +103,25 @@ public:
     virtual bool shouldAddCoverSheet() = 0;
 
     /////////////////////////////////////////////////
-    /// \brief Gibt zurück ob ein Quellcode Kapitel
-    ///        hinzugefügt werden soll.
-    /// \return true -> ja, false -> nein
-    /////////////////////////////////////////////////
-    virtual bool shouldAddSource() = 0;
-
-    /////////////////////////////////////////////////
-    /// \brief Gibt gesetzten Namen des Quellcode Kapitels
-    ///        retour.
-    /// \return Name des Quellcode Kapitels
-    /////////////////////////////////////////////////
-    virtual std::string getSourceChapterName() = 0;
-
+    /// \brief Ermittelt ob Dokument eine Titelseite
+    ///        besitzt.
+    /// \return bool true -> ja, false -> nein
     /////////////////////////////////////////////////
-    /// \brief Gibt zurück ob ein
-    ///        Schnittstellendokumentationskapitel
-    ///        hinzugefügt werden soll.
-    /// \return true -> ja, false -> nein
-    /////////////////////////////////////////////////
-    virtual bool shouldGenDoxygen() = 0;
+    virtual bool shouldAddTitlePage() = 0;
 
     /////////////////////////////////////////////////
-    /// \brief Gibt gesetzten Namen des Doxygen Kapitels
-    ///        retour.
-    /// \return Name des Quellcode Kapitels
+    /// \brief Ermittelt ob Dokument ein Inhaltsverzeichnis
+    ///        besitzt.
+    /// \return bool true -> ja, false -> nein
     /////////////////////////////////////////////////
-    virtual std::string getDoxygenName() = 0;
+    virtual bool shouldAddTableOfContent() = 0;
 
     /////////////////////////////////////////////////
-    /// \brief Gibt gesetzten Quellcode Pfad
-    ///        retour.
-    /// \return Quellcode Pfad
+    /// \brief Ermittelt die Nummerierungstiefe
+    ///        des Inhaltsverzeichnis.
+    /// \return depth Nummerierungstiefe
     /////////////////////////////////////////////////
-    virtual std::string getSourceDir() = 0;
+    virtual int getTableOfContentDepth() = 0;
 
     /////////////////////////////////////////////////
     /// \brief Gibt Dateinamen und Pfad des Angabeblattes
@@ -223,6 +209,13 @@ public:
     /////////////////////////////////////////////////
     virtual std::string getLogFile() = 0;
 
+    /////////////////////////////////////////////////
+    /// \brief Gibt eine liste mit allen Kapiteltypen
+    ///        zurück.
+    /// \return Liste mit Kapiteltypen
+    /////////////////////////////////////////////////
+    virtual std::vector<std::string> getChapterTypes() = 0;
+
 
 protected:
     ModelIF() = default;
diff --git a/src/SourceChapter.h b/src/SourceChapter.h
new file mode 100644 (file)
index 0000000..80fbfa7
--- /dev/null
@@ -0,0 +1,99 @@
+///////////////////////////////////////////////////////////////////////////
+// Workfile: SourceChapter.h
+// Author: Daniel Giritzer <daniel@giritzer.eu>
+// Date: 25.03.2018
+// Description: Einfache Klasse zum Speichern Kapiteln.
+// Remarks: Diese Klasse besteht nur aus einer Header Datei.
+///////////////////////////////////////////////////////////////////////////
+#ifndef SOURCECHAPTER_H
+#define SOURCECHAPTER_H
+
+#include <iostream>
+#include "Object.h"
+#include "ChapterIF.h"
+#include <fstream>
+
+/////////////////////////////////////////////////
+/// \brief Klasse zum speichern von
+///        Kapitelinformationen.
+/////////////////////////////////////////////////
+class SourceChapter : public Object, public ChapterIF
+{
+public:
+    SourceChapter(std::string type)
+    {
+        mType = type;
+    }
+    virtual ~SourceChapter() = default;
+
+    std::string GetType() const
+    {
+        return mType;
+    }
+
+    void WriteFile(ModelIF* model)
+    {
+
+        if(!mFSHelp.dirExists(model->getOutPath()))
+            throw std::string("Output directory does not exist: " + model->getOutPath());
+
+        std::string outPath = mFSHelp.addDirLastSlash(model->getOutPath());
+
+        if(!mFSHelp.dirExists(mContent))
+            throw std::string("The source directory entered in Chapter " + mPrettyName + " (" + std::to_string(mNum) + ")" + " does not exist!\n" + mContent);
+
+        std::string srcDir = mFSHelp.addDirLastSlash(outPath + mOutFileName + "_src");
+        mFSHelp.copyDir(mContent, srcDir);
+
+        std::vector<FSHelper::File> sourceFiles;
+        if(!mFSHelp.listFilesRecursive(srcDir, sourceFiles, true))
+            throw std::string("Failed to get filenames of source files!");
+
+
+        // Nach dateiendung filtern
+        auto it = std::remove_if(sourceFiles.begin(),
+                                 sourceFiles.end(),
+                                 [this, model](FSHelper::File x)
+        {
+
+            unsigned int ind = x.second.find_last_of(".");
+            if(ind ==  std::string::npos) return true; //Keine Dateiendung
+
+            // Dateiendung cpp oder h
+            if((x.second.substr(ind) == model->getSourceFileExtension()) ||
+               (x.second.substr(ind) == model->getHeaderFileExtension()))
+                return false;
+
+            // Alle anderen
+            return true;
+        });
+        sourceFiles.erase(it, sourceFiles.end());
+
+        // Nach namen sortieren (header vor cpp)
+        std::sort(sourceFiles.begin(), sourceFiles.end(),
+                  [](FSHelper::File left, FSHelper::File right)
+                    {
+                        return left.second > right.second;
+                    }
+
+                 );
+
+        std::ofstream out;
+        out.open(outPath + mOutFileName, std::ios_base::out);
+        if(out.good())
+            for(auto curElem : sourceFiles)
+            {
+                curElem.first.replace(curElem.first.find(outPath), outPath.length(), ""); //Erzeuge relativen Pfade
+                out << "\\lstinputlisting[language=C++]{" << mFSHelp.convertPathToUnix(curElem.first) << curElem.second <<"}" << std::endl;
+            }
+        else
+            throw std::string("Failed to write sourcefiles chapter.");
+
+        out.close();
+    }
+
+private:
+    std::string mType;
+};
+
+#endif // SOURCECHAPTER_H
diff --git a/src/TextChapter.h b/src/TextChapter.h
new file mode 100644 (file)
index 0000000..5837093
--- /dev/null
@@ -0,0 +1,58 @@
+///////////////////////////////////////////////////////////////////////////
+// Workfile: TextChapter.h
+// Author: Daniel Giritzer <daniel@giritzer.eu>
+// Date: 25.03.2018
+// Description: Einfache Klasse zum Speichern Kapiteln.
+// Remarks: Diese Klasse besteht nur aus einer Header Datei.
+///////////////////////////////////////////////////////////////////////////
+#ifndef TEXTCHAPTER_H
+#define TEXTCHAPTER_H
+
+#include <iostream>
+#include "Object.h"
+#include "ChapterIF.h"
+#include <fstream>
+
+/////////////////////////////////////////////////
+/// \brief Klasse zum speichern von
+///        Kapitelinformationen.
+/////////////////////////////////////////////////
+class TextChapter : public Object, public ChapterIF
+{
+public:
+    TextChapter(std::string type)
+    {
+        mType = type;
+    }
+    virtual ~TextChapter() = default;
+
+    std::string GetType() const
+    {
+        return mType;
+    }
+
+    void WriteFile(ModelIF* model)
+    {
+
+        if(!mFSHelp.dirExists(model->getOutPath()))
+            throw std::string("Output directory does not exist: " + model->getOutPath());
+
+        std::ofstream oFstr;
+        oFstr.open(model->getOutPath() + mOutFileName);
+
+        //Dateistatus Prüfen
+        if(!oFstr.good())
+            throw std::string("Could not create output file: " + model->getOutPath() + mOutFileName);
+
+
+        //Buffer auf oFstr schreiben
+        oFstr << mContent;
+
+        oFstr.close();
+    }
+
+private:
+    std::string mType;
+};
+
+#endif // TEXTCHAPTER_H
index 3dde325..ce27653 100644 (file)
@@ -8,7 +8,8 @@
 ///////////////////////////////////////////////////////////////////////////
 #include "View.h"
 #include "Author.h"
-#include "Chapter.h"
+#include "ChapterIF.h"
+#include "ChapterFactory.h"
 #include "FSHelper.h"
 #include <FL/Fl_File_Chooser.H>
 #include <iostream>
@@ -19,13 +20,14 @@ View::View(ControllerIF::SPtr contr, ModelIF::SPtr model)
     mController = contr;
     mModel = model;
     mEditorChapterLabel = nullptr;
+    mSelectSourceLabel = nullptr;
     subscribeSubject(mModel.get());
 }
 
 View::~View()
 {
     win_doctool->hide();
-    win_chapt_add->hide();
+    win_chapt->hide();
     win_settings->hide();
     win_auth_coord->hide();
     win_depart_coord->hide();
@@ -33,13 +35,14 @@ View::~View()
 
     // Ressourcen freigeben
     Fl::delete_widget(win_doctool);
-    Fl::delete_widget(win_chapt_add);
+    Fl::delete_widget(win_chapt);
     Fl::delete_widget(win_settings);
     Fl::delete_widget(win_auth_coord);
     Fl::delete_widget(win_depart_coord);
     Fl::delete_widget(win_log_view);
     unsubscribeSubject(mModel.get());
     delete[] mEditorChapterLabel;
+    delete[] mSelectSourceLabel;
 }
 
 void View::activate()
@@ -50,6 +53,7 @@ void View::activate()
     ti_name->activate();
     ti_est_time->activate();
     ti_needed_time->activate();
+    ti_ID->activate();
     btn_save_author->activate();
     br_chapters->activate();
 
@@ -85,127 +89,200 @@ void View::activate()
     menu_open_template->deactivate();
 }
 
-void View::updatedBySubject(Subject* s)
+void View::loadChapterList()
 {
-    if(s == nullptr)
-        throw std::string("Nullpointer given as Subject!");
+    if(br_chapters->size() != 0)
+        br_chapters->clear();
 
+    for(auto curChapter : mModel->getChapterNames())
+        br_chapters->add(curChapter.c_str());
+}
 
-    if(mModel->getChapterNames().size() != 0)
-    {
-        try
+void View::loadAuthorList()
+{
+    cb_author->clear();
+    for(auto curAuthor : mModel->getAuthorNames())
+        cb_author->add(curAuthor.c_str());
+    cb_author->value(mModel->getAuthorNum());
+}
+
+void View::loadChapterContent()
+{
+    br_chapters->select(mModel->getChapterNum());
+    chb_finished->value(mModel->getSelChapter()->GetDone());
+
+    // Chapter Einstellungs Fenster
+    add_chapt_chaptname->value(mModel->getSelChapter()->GetPrettyName().c_str());
+    add_chapt_fname->value(mModel->getSelChapter()->GetOutFileName().c_str());
+    spin_hierachy->value(mModel->getSelChapter()->GetHierachyAsNum());
+
+    // Kopiere C String für Label
+    if(mEditorChapterLabel!=nullptr) delete[] mEditorChapterLabel;
+    mEditorChapterLabel = new char [mModel->getSelChapter()->GetPrettyName().length()+1];
+    std::strcpy (mEditorChapterLabel, mModel->getSelChapter()->GetPrettyName().c_str());
+    tb_editor->label(mEditorChapterLabel);
+    win_doctool->label(mModel->getSubjectName().c_str());
+
+    // Quellcode Einstellungen
+    if(mModel->getSelChapter()->GetType() == mModel->getChapterTypes().at(ChapterFactory::TypeSourceChapter) ||
+            mModel->getSelChapter()->GetType() == mModel->getChapterTypes().at(ChapterFactory::TypeDoxygenChapter)
+      )
+    {
+        // Editor Ausblenden
+        tb_editor->hide();
+        menu_editor->hide();
+
+        // Quellcode Einstellungen einblenden
+        ot_src_dir->show();
+        btn_open_src_dir->show();
+        border_src->show();
+
+        if(mSelectSourceLabel!=nullptr) delete[] mSelectSourceLabel;
+        mSelectSourceLabel = new char [mModel->getSelChapter()->GetType().length()+1];
+        std::strcpy (mSelectSourceLabel, mModel->getSelChapter()->GetType().c_str());
+        tb_editor->label(mEditorChapterLabel);
+        lb_type->label(mSelectSourceLabel);
+        lb_type->show();
+
+        // Aktiviere/Deaktiviere
+        // je nachdem ob kapitel als abgeschlossen
+        // markiert wurde
+        if(!mModel->getSelChapter()->GetDone())
+        {
+            ot_src_dir->activate();
+            btn_open_src_dir->activate();
+        }
+        else
         {
+            ot_src_dir->deactivate();
+            btn_open_src_dir->deactivate();
+        }
+        ot_src_dir->value(mModel->getSelChapter()->GetContent().c_str());
+    }
 
-            // Lösche bereits eingetragene Werte
-            br_chapters->clear();
-            cb_author->clear();
+    // Editor
+    if(mModel->getSelChapter()->GetType() == mModel->getChapterTypes().at(ChapterFactory::TypeTextChapter))
+    {
+        // Quellcode Einstellungen ausblenden
+        ot_src_dir->hide();
+        btn_open_src_dir->hide();
+        lb_type->hide();
+        border_src->hide();
 
-            // Author einstellungen
-            for(auto curAuthor : mModel->getAuthorNames())
-                cb_author->add(curAuthor.c_str());
+        // Editor Einblenden
+        tb_editor->show();
+        menu_editor->show();
 
-            cb_author->value(mModel->getAuthorNum());
-            ti_name->value(mModel->getSelAuthor()->GetName().c_str());
-            ti_est_time->value(mModel->getSelAuthor()->GetTimeEstimated().c_str());
-            ti_needed_time->value(mModel->getSelAuthor()->GetTimeSpent().c_str());
+        // Lade text in textbuffer von tb_editor
+        mTextBuf->text(mModel->getSelChapter()->GetContent().c_str());
 
-            // Kapitel
-            for(auto curChapter : mModel->getChapterNames())
-                br_chapters->add(curChapter.c_str());
+        // Aktiviere/Deaktiviere textfeld
+        // je nachdem ob kapitel als abgeschlossen
+        // markiert wurde
+        if(mModel->getSelChapter()->GetDone())
+        {
+            tb_editor->clear_active();
+            menu_editor->deactivate();
+        }
+        else
+        {
+            tb_editor->activate();
+            menu_editor->activate();
+        }
+    }
+}
 
+void View::loadAuthorContent()
+{
+    ti_name->value(mModel->getSelAuthor()->GetName().c_str());
+    ti_est_time->value(mModel->getSelAuthor()->GetTimeEstimated().c_str());
+    ti_needed_time->value(mModel->getSelAuthor()->GetTimeSpent().c_str());
+    ti_ID->value(mModel->getSelAuthor()->GetID().c_str());
+
+    // Koordinaten für in titelblatt eingefügte texte
+    vi_spenttime_x->value(mModel->getSelAuthor()->GetXTimeSpentCoordinate());
+    vi_spenttime_y->value(mModel->getSelAuthor()->GetYTimeSpentCoordinate());
+    vi_authname_x->value(mModel->getSelAuthor()->GetXNameCoordinate());
+    vi_authname_y->value(mModel->getSelAuthor()->GetYNameCoordinate());
+    vi_esttime_x->value(mModel->getSelAuthor()->GetXTimeEstimatedCoordinate());
+    vi_esttime_y->value(mModel->getSelAuthor()->GetYTimeEstimatedCoordinate());
+    vi_id_x->value(mModel->getSelAuthor()->GetXid());
+    vi_id_y->value(mModel->getSelAuthor()->GetYid());
+}
 
-            br_chapters->select(mModel->getChapterNum());
-            chb_finished->value(mModel->getSelChapter()->GetDone());
+void View::loadSettings()
+{
+    // Einstellungen Menü
+    chb_add_covpage->value(mModel->shouldAddCoverSheet());
+    chb_add_titlepage->value(mModel->shouldAddTitlePage());
+    chb_add_toc->value(mModel->shouldAddTableOfContent());
+    spin_toc_depth->value(mModel->getTableOfContentDepth());
+    ti_settings_subject_name->value(mModel->getSubjectName().c_str());
+    ti_location->value(mModel->getLocation().c_str());
+    ti_header_ext->value(mModel->getHeaderFileExtension().c_str());
+    ti_src_ext->value(mModel->getSourceFileExtension().c_str());
+}
 
-            // progressbar
-            pb_progress->maximum(mModel->getNumChapters());
-            pb_progress->value(mModel->getNumFinishedChapters());
+void View::loadGeneralGUIElements()
+{
+    // progressbar
+    pb_progress->maximum(mModel->getNumChapters());
+    pb_progress->value(mModel->getNumFinishedChapters());
 
 
-            // Aktiviere/Deaktiviere textfeld
-            // je nachdem ob kapitel als abgeschlossen
-            // markiert wurde
-            if(mModel->getSelChapter()->GetDone())
-            {
-                tb_editor->clear_active();
-                menu_editor->deactivate();
-            }
-            else
-            {
-                tb_editor->activate();
-                menu_editor->activate();
-            }
+    // Generate Button
+    if(mModel->getGenerateEnable())
+        btn_generate->activate();
+    else
+        btn_generate->clear_active();
 
 
-            // Generate Button
-            if(mModel->getGenerateEnable())
-                btn_generate->activate();
-            else
-                btn_generate->clear_active();
+    // Titelblatt Einstellungen
+    if(mModel->shouldAddCoverSheet())
+    {
+        ot_cov_sheet->activate();
+        btn_open_cov_sheet->activate();
+        ot_cov_sheet->value(mModel->getCovSheet().c_str());
+    }
+    else
+    {
+        ot_cov_sheet->deactivate();
+        btn_open_cov_sheet->deactivate();
+        ot_cov_sheet->value("");
+    }
 
-            // Kopiere C String für Label
-            if(mEditorChapterLabel!=nullptr) delete[] mEditorChapterLabel;
-            mEditorChapterLabel = new char [mModel->getSelChapter()->GetPrettyName().length()+1];
-            std::strcpy (mEditorChapterLabel, mModel->getSelChapter()->GetPrettyName().c_str());
-            tb_editor->label(mEditorChapterLabel);
-            win_doctool->label(mModel->getSubjectName().c_str());
+    // Dokomenten Name
+    ti_doc_name->value(mModel->getDocName().c_str());
+    ti_department->value(mModel->getDepartment().c_str());
 
-            // Quellcode Einstellungen
-            if(mModel->shouldAddSource() || mModel->shouldGenDoxygen())
-            {
-                ot_src_dir->activate();
-                btn_open_src_dir->activate();
-                ot_src_dir->value(mModel->getSourceDir().c_str());
-            }
-            else
-            {
-                ot_src_dir->deactivate();
-                btn_open_src_dir->deactivate();
-                ot_src_dir->value("");
-            }
+    vi_depart_x->value(mModel->getDepartmentX());
+    vi_depart_y->value(mModel->getDepartmentY());
+}
 
-            // Titelblatt Einstellungen
-            if(mModel->shouldAddCoverSheet())
-            {
-                ot_cov_sheet->activate();
-                btn_open_cov_sheet->activate();
-                ot_cov_sheet->value(mModel->getCovSheet().c_str());
-            }
-            else
-            {
-                ot_cov_sheet->deactivate();
-                btn_open_cov_sheet->deactivate();
-                ot_cov_sheet->value("");
-            }
+void View::updatedBySubject(Subject* s)
+{
+    if(s == nullptr)
+        throw std::string("Nullpointer given as Subject!");
 
-            // Dokomenten Name
-            ti_doc_name->value(mModel->getDocName().c_str());
 
-            // Einstellungen Menü
-            chb_add_covpage->value(mModel->shouldAddCoverSheet());
-            chb_add_src->value(mModel->shouldAddSource());
-            chb_gen_doxygen->value(mModel->shouldGenDoxygen());
-            ti_doxy_chapt_name->value(mModel->getDoxygenName().c_str());
-            ti_source_chapt_name->value(mModel->getSourceChapterName().c_str());
-            ti_settings_subject_name->value(mModel->getSubjectName().c_str());
-            ti_location->value(mModel->getLocation().c_str());
+    if(mModel->getChapterNames().size() != 0)
+    {
+        try
+        {
 
-            // Koordinaten für in titelblatt eingefügte texte
-            vi_spenttime_x->value(mModel->getSelAuthor()->GetXTimeSpentCoordinate());
-            vi_spenttime_y->value(mModel->getSelAuthor()->GetYTimeSpentCoordinate());
-            vi_authname_x->value(mModel->getSelAuthor()->GetXNameCoordinate());
-            vi_authname_y->value(mModel->getSelAuthor()->GetYNameCoordinate());
-            vi_esttime_x->value(mModel->getSelAuthor()->GetXTimeEstimatedCoordinate());
-            vi_esttime_y->value(mModel->getSelAuthor()->GetYTimeEstimatedCoordinate());
+            // Autor
+            loadAuthorList();
+            loadAuthorContent();
 
-            vi_depart_x->value(mModel->getDepartmentX());
-            vi_depart_y->value(mModel->getDepartmentY());
+            // Kapitel
+            loadChapterList();
+            loadChapterContent();
 
-            ti_header_ext->value(mModel->getHeaderFileExtension().c_str());
-            ti_src_ext->value(mModel->getSourceFileExtension().c_str());
+            // Einstellungen
+            loadSettings();
 
-            // Lade text in textbuffer von tb_editor
-            mTextBuf->text(mModel->getSelChapter()->GetText().c_str());
+            // Andere GUI Elemente
+            loadGeneralGUIElements();
 
             win_doctool->redraw();
         }
@@ -228,7 +305,7 @@ void View::show()
     btn_next->callback((Fl_Callback*)btn_next_cb, (void*)(this) );
     btn_generate->callback((Fl_Callback*)btn_generate_cb, (void*)(this));
     br_chapters->callback((Fl_Callback*)br_chapters_cb, (void*)(this));
-    menu_open_template->callback( (Fl_Callback*)menu_open_template_cb, (void*)(this));
+    menu_open_template->callback((Fl_Callback*)menu_open_template_cb, (void*)(this));
     menu_editor->callback((Fl_Callback*)menu_editor_cb, (void*)(this));
     menu_chapter->callback((Fl_Callback*)menu_chapter_cb, (void*)(this));
     menu_author->callback((Fl_Callback*)menu_author_cb, (void*)(this));
@@ -237,7 +314,7 @@ void View::show()
     btn_down_chpt->callback((Fl_Callback*)btn_down_chpt_cb, (void*)(this) );
     btn_save_author->callback((Fl_Callback*)btn_save_author_cb, (void*)(this));
     cb_author->callback((Fl_Callback*)cb_author_cb, (void*)(this));
-    btn_chapt_insert->callback((Fl_Callback*)btn_chapt_insert_cb, (void*)(this));
+    btn_chapt_save->callback((Fl_Callback*)btn_chapt_save_cb, (void*)(this));
     menu_out_dir->callback((Fl_Callback*)menu_out_dir_cb, (void*)(this));
     btn_open_src_dir->callback((Fl_Callback*)ot_src_dir_cb, (void*)(this));
     btn_open_cov_sheet->callback((Fl_Callback*)ot_cov_sheet_cb, (void*)(this));
@@ -249,10 +326,17 @@ void View::show()
     menu_new_templ->callback((Fl_Callback*)menu_new_templ_cb, (void*)(this));
     menu_gen_templ->callback((Fl_Callback*)menu_gen_templ_cb, (void*)(this));
     btn_ok_depart->callback((Fl_Callback*)btn_ok_depart_cb, (void*)(this));
-    ti_department->callback((Fl_Callback*)save_texts_cb, (void*)(this));
-    ti_doc_name->callback((Fl_Callback*)save_texts_cb, (void*)(this));
+    ti_department->callback((Fl_Callback*)ti_department_cb, (void*)(this));
+    ti_doc_name->callback((Fl_Callback*)ti_doc_name_cb, (void*)(this));
 
 
+    // Lade Kapiteltypen
+    for(auto curType : mModel->getChapterTypes())
+        choice_chapt_type->add(curType.c_str());
+
+    //Ersten auswählen
+    choice_chapt_type->value(0);
+
     // Textfeld initialisieren
     mTextBuf = new Fl_Text_Buffer();
     tb_editor->buffer(mTextBuf);
@@ -278,11 +362,19 @@ void View::show()
 
 void View::saveBuffer()
 {
-    mController->setDocName(ti_doc_name->value());
-    mController->setDepartment(ti_department->value());
-    char* text = mTextBuf->text();
-    mController->saveWrittenText(text);
-    free(text); // Hier muss free verwendet werde, da mTextBuf->text() speicher mit malloc allokiert
+    if(mModel->getSelChapter()->GetType() == mModel->getChapterTypes().at(ChapterFactory::TypeDoxygenChapter) ||
+            mModel->getSelChapter()->GetType() == mModel->getChapterTypes().at(ChapterFactory::TypeSourceChapter)
+      )
+    {
+        std::string text = ot_src_dir->value();
+        mController->saveContent(text);
+    }
+    if(mModel->getSelChapter()->GetType() == mModel->getChapterTypes().at(ChapterFactory::TypeTextChapter))
+    {
+        char* text = mTextBuf->text();
+        mController->saveContent(text);
+        free(text); // Hier muss free verwendet werde, da mTextBuf->text() speicher mit malloc allokiert
+    }
 }
 
 // -------------------------------------------------
@@ -470,6 +562,100 @@ void View::menu_editor_cb(Fl_Menu_* menu, void* view)
         {
             thisView->tb_editor->insert("\\begin{itemize}\n\\item One\n\\item Two\n\\end{itemize}");
         }
+        if ( strcmp(text, "Page Break") == 0 )
+        {
+            thisView->tb_editor->insert("\\newpage");
+        }
+        if ( strcmp(text, "Line Break") == 0 )
+        {
+            thisView->tb_editor->insert("\\newline");
+        }
+        if ( strcmp(text, "Bold") == 0 )
+        {
+            thisView->tb_editor->insert("\\textbf{Bold Text}");
+        }
+        if ( strcmp(text, "Italic") == 0 )
+        {
+            thisView->tb_editor->insert("\\textit{Italic Text}");
+        }
+        if ( strcmp(text, "Underline") == 0 )
+        {
+            thisView->tb_editor->insert("\\underline{Underlined Text}");
+        }
+        if ( strcmp(text, "Center") == 0 )
+        {
+            thisView->tb_editor->insert("\\begin{center}\nCentered Text\n\\end{center}");
+        }
+        if ( strcmp(text, "Unit") == 0 )
+        {
+            thisView->tb_editor->insert("\\(mA\\)");
+        }
+        if ( strcmp(text, "Equal Sign") == 0 )
+        {
+            thisView->tb_editor->insert("&=");
+        }
+        if ( strcmp(text, "Fraction") == 0 )
+        {
+            thisView->tb_editor->insert("\\frac{numerator}{denominator}");
+        }
+        if ( strcmp(text, "Power") == 0 )
+        {
+            thisView->tb_editor->insert("num^{pow}");
+        }
+        if ( strcmp(text, "Intext Equation") == 0 )
+        {
+            thisView->tb_editor->insert("$ a = b$");
+        }
+        if ( strcmp(text, "Normal Equation") == 0 )
+        {
+        thisView->tb_editor->insert("\\begin{equation*}\n\\begin{split}\n1psi &= \\frac{1 lbf}{sq in}\\\\\n\\end{split}\n\\end{equation*}");
+        }
+        if ( strcmp(text, "Picture") == 0 )
+        {
+            // File browser dialog
+            Fl_File_Chooser chooser(".",
+                                    "Image Files (*.{bmp,gif,jpg,jpeg,png}",
+                                    Fl_File_Chooser::SINGLE,
+                                    "Select image file...");
+            chooser.show();
+
+            // Warte bis benutzer datei ausgewählt hat
+            while(chooser.shown())
+                Fl::wait();
+
+            if ( chooser.value() != nullptr )
+            {
+                std::string file = thisView->mFSHelp.getFileName(chooser.value());
+                thisView->mFSHelp.makeDir(thisView->mModel->getOutPath() + "resources/");
+                thisView->mFSHelp.copyFile(chooser.value(),thisView->mModel->getOutPath() + "resources/" + file);
+                thisView->tb_editor->insert(std::string("\\begin{figure}\n\\centering\n\\includegraphics[width=0.6\\textwidth]{resources/"+file+"}" +
+                                                        "\n\\caption{Short description}\n\\label{fig:PictureLabel}\n\\end{figure}\n"+
+                                                        "% Use ~\\ref{fig:PictureLabel} to reference to this \n% picture within text.").c_str());
+            }
+        }
+        if ( strcmp(text, "Text") == 0 )
+        {
+            // File browser dialog
+            Fl_File_Chooser chooser(".",
+                                    "Text Files (*.{txt,tex,log,info,conf}",
+                                    Fl_File_Chooser::SINGLE,
+                                    "Select input file...");
+            chooser.show();
+
+            // Warte bis benutzer datei ausgewählt hat
+            while(chooser.shown())
+                Fl::wait();
+
+            if ( chooser.value() != nullptr )
+            {
+                std::string file = thisView->mFSHelp.getFileName(chooser.value());
+                thisView->mFSHelp.makeDir(thisView->mModel->getOutPath() + "resources/");
+                thisView->mFSHelp.copyFile(chooser.value(),thisView->mModel->getOutPath() + "resources/" + file);
+                thisView->tb_editor->insert(std::string("\\input{resources/" + file + "}").c_str());
+            }
+        }
+
+
     }
     // ----------- Exception Handling ------------
     catch(std::string& e)
@@ -533,7 +719,19 @@ void View::menu_chapter_cb(Fl_Menu_* menu, void* view)
         if ( !text ) return;
         if ( strcmp(text, "Add chapter") == 0 )
         {
-            thisView->win_chapt_add->show();
+            thisView->add_chapt_chaptname->value("");
+            thisView->add_chapt_fname->value(".tex");
+            thisView->spin_hierachy->value(0);
+            thisView->choice_chapt_type->activate();
+            thisView->choice_chapt_type->show();
+            thisView->win_chapt->show();
+        }
+        if ( strcmp(text, "Edit chapter") == 0 )
+        {
+            thisView->loadChapterContent();
+            thisView->choice_chapt_type->deactivate();
+            thisView->win_chapt->show();
+            thisView->choice_chapt_type->hide();
         }
         if ( strcmp(text, "Remove chapter") == 0 )
         {
@@ -600,10 +798,10 @@ void View::btn_save_author_cb(Fl_Button* btn, void* view)
     try
     {
         View* thisView = static_cast<View*>(view);
-        thisView->mController->saveAuthorName(thisView->ti_name->value());
-        thisView->mController->saveAuthorEstTime(thisView->ti_est_time->value());
-        thisView->mController->saveAuthorSpentTime(thisView->ti_needed_time->value());
-        thisView->mController->forceNotify();
+        thisView->mController->saveAuthor(thisView->ti_name->value(),
+                                          thisView->ti_ID->value(),
+                                          thisView->ti_est_time->value(),
+                                          thisView->ti_needed_time->value());
     }
     // ----------- Exception Handling ------------
     catch(std::string& e)
@@ -638,7 +836,7 @@ void View::cb_author_cb(Fl_Choice* cb, void* view)
     }
 }
 
-void View::btn_chapt_insert_cb(Fl_Button* btn, void* view)
+void View::btn_chapt_save_cb(Fl_Button* btn, void* view)
 {
     try
     {
@@ -647,7 +845,6 @@ void View::btn_chapt_insert_cb(Fl_Button* btn, void* view)
         std::string chaptName = thisView->add_chapt_chaptname->value();
         std::string fileName = thisView->add_chapt_fname->value();
 
-
         if(!thisView->mFSHelp.validFileName(fileName))
             throw std::string("Filename contains illegal characters.");
 
@@ -658,10 +855,12 @@ void View::btn_chapt_insert_cb(Fl_Button* btn, void* view)
             throw std::string("Enter a filename.");
 
 
-        thisView->mController->addChapter(chaptName, fileName);
-        thisView->add_chapt_chaptname->value("");
-        thisView->add_chapt_fname->value("");
-        thisView->win_chapt_add->hide();
+        if(thisView->choice_chapt_type->active())
+            thisView->mController->addChapter(chaptName, fileName, thisView->choice_chapt_type->value(), thisView->spin_hierachy->value());
+        else
+            thisView->mController->updateChapter(chaptName, fileName, thisView->spin_hierachy->value());
+
+        thisView->win_chapt->hide();
     }
     // ----------- Exception Handling ------------
     catch(std::string& e)
@@ -694,8 +893,6 @@ void View::menu_out_dir_cb(Fl_Menu_* menu, void* view)
         while(chooser.shown())
             Fl::wait();
 
-
-
         // Abbruch gedrückt
         if ( chooser.value() != nullptr )
         {
@@ -727,14 +924,14 @@ void View::ot_src_dir_cb(Fl_Output *out, void* view)
                                 "Select source directory...");
         chooser.show();
 
-        // Warte bis benutzer datei ausgewählt hat
+        // Warte bis Benutzer ordner ausgewählt hat
         while(chooser.shown())
             Fl::wait();
 
-        // Abbruch gedrückt
+        // Überpüfe ob Abbruch gedrückt
         if ( chooser.value() != nullptr )
         {
-            thisView->mController->saveSourceDir(chooser.value());
+            thisView->ot_src_dir->value(chooser.value());
         }
     }
     // ----------- Exception Handling ------------
@@ -799,8 +996,16 @@ void View::win_close_cb(Fl_Window* win, void* view)
             ;
             break;
         case 1:
-            thisView->mController->saveAllWrittenTextsToFiles();
-            thisView->win_chapt_add->hide();
+            try
+            {
+                thisView->mController->saveAllWrittenTextsToFiles();
+            }
+            catch(...)
+            {
+                // Speichern fehlgeschlagen
+                std::cerr << "Sorry, could not save written texts to files..." << std::endl;
+                fl_alert("Sorry, could not save written texts to files...");
+            }
             exit(0);
             break;
         default:
@@ -825,9 +1030,11 @@ void View::btn_ok_author_cb(Fl_Button* btn, void* view)
     try
     {
         View* thisView = static_cast<View*>(view);
-        thisView->mController->saveAuthorEstTimeCoordiantes(thisView->vi_esttime_x->value(),thisView->vi_esttime_y->value());
-        thisView->mController->saveAuthorNameCoordinates(thisView->vi_authname_x->value(),thisView->vi_authname_y->value());
-        thisView->mController->saveAuthorSpentTimeCoordinates(thisView->vi_spenttime_x->value(),thisView->vi_spenttime_y->value());
+        thisView->mController->saveAuthorCoordinates(thisView->vi_authname_x->value(),thisView->vi_authname_y->value(),
+                thisView->vi_id_x->value(),thisView->vi_id_y->value(),
+                thisView->vi_esttime_x->value(),thisView->vi_esttime_y->value(),
+                thisView->vi_spenttime_x->value(),thisView->vi_spenttime_y->value()
+                                                    );
         thisView->win_auth_coord->hide();
     }
     // ----------- Exception Handling ------------
@@ -869,19 +1076,11 @@ void View::btn_save_settings_cb(Fl_Button* btn, void* view)
     {
         View* thisView = static_cast<View*>(view);
 
-        std::string sourceChaptName = thisView->ti_source_chapt_name->value();
-        std::string doxyChaptName = thisView->ti_doxy_chapt_name->value();
         std::string subjectName = thisView->ti_settings_subject_name->value();
         std::string location = thisView->ti_location->value();
         std::string header = thisView->ti_header_ext->value();
         std::string source = thisView->ti_src_ext->value();
 
-        if(thisView->chb_add_src->value() && sourceChaptName.empty())
-            throw std::string("Please enter a source chapter name.");
-
-        if(thisView->chb_gen_doxygen->value() && doxyChaptName.empty())
-            throw std::string("Please enter a doxygen documentation chapter name.");
-
         if(header.empty())
             throw std::string("Please enter a header file extension.");
 
@@ -894,21 +1093,13 @@ void View::btn_save_settings_cb(Fl_Button* btn, void* view)
         if(location.empty())
             throw std::string("Please enter a location.");
 
-        thisView->mController->setAddCoverSheet(thisView->chb_add_covpage->value());
-        thisView->mController->setAddSource(thisView->chb_add_src->value());
-        thisView->mController->setGenDoxygen(thisView->chb_gen_doxygen->value());
-
-        thisView->mController->setSourceChapterName(sourceChaptName);
-        thisView->mController->setDoxygenName(doxyChaptName);
-        thisView->mController->setSubjectName(subjectName);
-        thisView->mController->setLocation(location);
-
-        thisView->mController->setFileExtensions(header, source);
-
+        thisView->mController->saveSettings(thisView->chb_add_titlepage->value(), thisView->chb_add_covpage->value(),
+                                            thisView->chb_add_toc->value(), thisView->spin_toc_depth->value(),
+                                            header, source,
+                                            subjectName, location
+                                           );
 
         thisView->win_settings->hide();
-        thisView->mController->forceNotify();
-
     }
     // ----------- Exception Handling ------------
     catch(std::string& e)
@@ -1031,13 +1222,32 @@ void View::btn_ok_depart_cb(Fl_Button* cb, void* view)
     }
 }
 
-void View::save_texts_cb(Fl_Input * in, void* view)
+void View::ti_doc_name_cb(Fl_Input * in, void* view)
 {
     try
     {
         View* thisView = static_cast<View*>(view);
-        thisView->saveBuffer();
-        thisView->mController->forceNotify();
+        thisView->mController->setDocName(thisView->ti_doc_name->value());
+    }
+    // ----------- Exception Handling ------------
+    catch(std::string& e)
+    {
+        std::cerr << e << std::endl;
+        fl_alert(e.c_str()); //Textbox mit fehlermeldung
+    }
+    catch(...)
+    {
+        fl_alert("Unknown error occured!");
+        std::cerr << "Unknown error occured!" << std::endl;
+    }
+}
+
+void View::ti_department_cb(Fl_Input * in, void* view)
+{
+    try
+    {
+        View* thisView = static_cast<View*>(view);
+        thisView->mController->setDepartment(thisView->ti_department->value());
     }
     // ----------- Exception Handling ------------
     catch(std::string& e)
index 03fbfef..a4005ee 100644 (file)
@@ -57,6 +57,42 @@ public:
     /////////////////////////////////////////////////
     void updatedBySubject(Subject* s);
 
+    /////////////////////////////////////////////////
+    /// \brief Lädt die Liste aller Kapitel und befüllt
+    ///        GUI.
+    /////////////////////////////////////////////////
+    void loadChapterList();
+
+    /////////////////////////////////////////////////
+    /// \brief Lädt Daten des ausgewählten Kapitels und
+    ///        befüllt GUI.
+    /////////////////////////////////////////////////
+    void loadChapterContent();
+
+    /////////////////////////////////////////////////
+    /// \brief Lädt die Liste aller Autoren und befüllt
+    ///        GUI.
+    /////////////////////////////////////////////////
+    void loadAuthorList();
+
+    /////////////////////////////////////////////////
+    /// \brief Lädt Daten des ausgewählten Autors und
+    ///        befüllt GUI.
+    /////////////////////////////////////////////////
+    void loadAuthorContent();
+
+    /////////////////////////////////////////////////
+    /// \brief Lädt Daten der Dokumenteinstellungen und
+    ///        befüllt GUI.
+    /////////////////////////////////////////////////
+    void loadSettings();
+
+    /////////////////////////////////////////////////
+    /// \brief Zeichnet generelle GUI Elemente abhängig
+    ///        von allgemeinen Daten.
+    /////////////////////////////////////////////////
+    void loadGeneralGUIElements();
+
 
 private:
     Fl_Text_Buffer* mTextBuf;
@@ -64,6 +100,7 @@ private:
     ControllerIF::SPtr mController;
     ModelIF::SPtr mModel;
     char* mEditorChapterLabel;
+    char* mSelectSourceLabel;
     FSHelper mFSHelp;
 
     /////////////////////////////////////////////////
@@ -83,13 +120,11 @@ private:
     static void menu_author_cb(Fl_Menu_* menu, void* view);
     static void menu_chapter_cb(Fl_Menu_* menu, void* view);
     static void menu_department_cb(Fl_Menu_* menu, void* view);
-    static void btn_add_chpt_cb(Fl_Button* btn, void* view);
-    static void btn_rm_chpt_cb(Fl_Button* btn, void* view);
     static void btn_up_chpt_cb(Fl_Button* btn, void* view);
     static void btn_down_chpt_cb(Fl_Button* btn, void* view);
     static void btn_save_author_cb(Fl_Button* btn, void* view);
     static void cb_author_cb(Fl_Choice* cb, void* view);
-    static void btn_chapt_insert_cb(Fl_Button* cb, void* view);
+    static void btn_chapt_save_cb(Fl_Button* cb, void* view);
     static void menu_out_dir_cb(Fl_Menu_* menu, void* view);
     static void ot_src_dir_cb(Fl_Output *out, void* view);
     static void ot_cov_sheet_cb(Fl_Output *out, void* view);
@@ -100,7 +135,8 @@ private:
     static void menu_new_templ_cb(Fl_Menu_* menu, void* view);
     static void menu_gen_templ_cb(Fl_Menu_* menu, void* view);
     static void btn_ok_depart_cb(Fl_Button* cb, void* view);
-    static void save_texts_cb(Fl_Input * in, void* view);
+    static void ti_doc_name_cb(Fl_Input * in, void* view);
+    static void ti_department_cb(Fl_Input * in, void* view);
 };
 
 #endif //VIEW:H
index 7e9cb55..1f52996 100644 (file)
@@ -8,14 +8,51 @@ Fl_Menu_Item ViewFluid::menu_menu_editor[] = {
  {"h2", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
  {"h3", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
  {0,0,0,0,0,0,0,0,0},
+ {"Format", 0,  0, 0, 64, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {"Bold", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {"Italic", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {"Underline", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {"Center", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {"Unit", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {0,0,0,0,0,0,0,0,0},
+ {"Insert", 0,  0, 0, 64, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {"Picture", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {"Text", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {0,0,0,0,0,0,0,0,0},
+ {"Equation", 0,  0, 0, 64, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {"Normal Equation", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {"Intext Equation", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {"Fraction", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {"Power", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {"Equal Sign", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {0,0,0,0,0,0,0,0,0},
  {"List", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {"Page Break", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {"Line Break", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
  {0,0,0,0,0,0,0,0,0}
 };
 Fl_Menu_Item* ViewFluid::menu_rclck_headl = ViewFluid::menu_menu_editor + 0;
 Fl_Menu_Item* ViewFluid::menu_rclck_headl1 = ViewFluid::menu_menu_editor + 1;
 Fl_Menu_Item* ViewFluid::menu_rclck_headl2 = ViewFluid::menu_menu_editor + 2;
 Fl_Menu_Item* ViewFluid::menu_rclck_headl3 = ViewFluid::menu_menu_editor + 3;
-Fl_Menu_Item* ViewFluid::menu_rclck_list = ViewFluid::menu_menu_editor + 5;
+Fl_Menu_Item* ViewFluid::menu_rclck_format = ViewFluid::menu_menu_editor + 5;
+Fl_Menu_Item* ViewFluid::menu_rclck_bold = ViewFluid::menu_menu_editor + 6;
+Fl_Menu_Item* ViewFluid::menu_rclck_italic = ViewFluid::menu_menu_editor + 7;
+Fl_Menu_Item* ViewFluid::menu_rclck_underline = ViewFluid::menu_menu_editor + 8;
+Fl_Menu_Item* ViewFluid::menu_rclck_center = ViewFluid::menu_menu_editor + 9;
+Fl_Menu_Item* ViewFluid::menu_rclck_unit = ViewFluid::menu_menu_editor + 10;
+Fl_Menu_Item* ViewFluid::menu_rclck_insert = ViewFluid::menu_menu_editor + 12;
+Fl_Menu_Item* ViewFluid::menu_rclck_insert_pic = ViewFluid::menu_menu_editor + 13;
+Fl_Menu_Item* ViewFluid::menu_rclck_insert_txt = ViewFluid::menu_menu_editor + 14;
+Fl_Menu_Item* ViewFluid::menu_rclck_equation = ViewFluid::menu_menu_editor + 16;
+Fl_Menu_Item* ViewFluid::menu_rclck_normal_equ = ViewFluid::menu_menu_editor + 17;
+Fl_Menu_Item* ViewFluid::menu_rclck_intext_equ = ViewFluid::menu_menu_editor + 18;
+Fl_Menu_Item* ViewFluid::menu_rclck_frac = ViewFluid::menu_menu_editor + 19;
+Fl_Menu_Item* ViewFluid::menu_rclck_pow = ViewFluid::menu_menu_editor + 20;
+Fl_Menu_Item* ViewFluid::menu_rclck_equ = ViewFluid::menu_menu_editor + 21;
+Fl_Menu_Item* ViewFluid::menu_rclck_list = ViewFluid::menu_menu_editor + 23;
+Fl_Menu_Item* ViewFluid::menu_rclck_newpage = ViewFluid::menu_menu_editor + 24;
+Fl_Menu_Item* ViewFluid::menu_rclck_newline = ViewFluid::menu_menu_editor + 25;
 
 void ViewFluid::cb_menu_open_about_dialog_i(Fl_Menu_*, void*) {
   Fl_Double_Window win(400,220);
@@ -66,11 +103,13 @@ Fl_Menu_Item* ViewFluid::menu_open_about_dialog = ViewFluid::menu_menu_bar + 11;
 
 Fl_Menu_Item ViewFluid::menu_menu_chapter[] = {
  {"Add chapter", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
+ {"Edit chapter", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
  {"Remove chapter", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
  {0,0,0,0,0,0,0,0,0}
 };
 Fl_Menu_Item* ViewFluid::menu_add_chapter = ViewFluid::menu_menu_chapter + 0;
-Fl_Menu_Item* ViewFluid::menu_rm_chapter = ViewFluid::menu_menu_chapter + 1;
+Fl_Menu_Item* ViewFluid::menu_edit_chapter = ViewFluid::menu_menu_chapter + 1;
+Fl_Menu_Item* ViewFluid::menu_rm_chapter = ViewFluid::menu_menu_chapter + 2;
 
 Fl_Menu_Item ViewFluid::menu_menu_author[] = {
  {"Remove author", 0,  0, 0, 0, (uchar)FL_NORMAL_LABEL, 0, 14, 0},
@@ -94,12 +133,33 @@ ViewFluid::ViewFluid() {
     win_doctool->user_data((void*)(this));
     win_doctool->hotspot(win_doctool);
     { Fl_Group* o = new Fl_Group(200, 45, 365, 575);
-      { btn_next = new Fl_Button(440, 475, 125, 45, "Next");
+      { ot_src_dir = new Fl_Output(205, 190, 355, 25, "Source Directory:");
+        ot_src_dir->tooltip("Directory containing Sourcecode.");
+        ot_src_dir->box(FL_GTK_DOWN_BOX);
+        ot_src_dir->align(Fl_Align(FL_ALIGN_TOP_LEFT));
+        ot_src_dir->hide();
+        ot_src_dir->deactivate();
+      } // Fl_Output* ot_src_dir
+      { btn_open_src_dir = new Fl_Button(325, 220, 115, 25, "Open");
+        btn_open_src_dir->tooltip("Open directory containing source code.");
+        btn_open_src_dir->box(FL_GTK_UP_BOX);
+        btn_open_src_dir->hide();
+        btn_open_src_dir->deactivate();
+      } // Fl_Button* btn_open_src_dir
+      { border_src = new Fl_Box(200, 145, 365, 125);
+        border_src->box(FL_PLASTIC_DOWN_FRAME);
+        border_src->color((Fl_Color)48);
+        border_src->hide();
+      } // Fl_Box* border_src
+      { lb_type = new Fl_Box(200, 115, 365, 30, "Type");
+        lb_type->hide();
+      } // Fl_Box* lb_type
+      { btn_next = new Fl_Button(440, 505, 125, 45, "Next");
         btn_next->tooltip("Edit next chapter.");
         btn_next->box(FL_GTK_UP_BOX);
         btn_next->deactivate();
       } // Fl_Button* btn_next
-      { tb_editor = new Fl_Text_Editor(200, 50, 365, 410, "Text");
+      { tb_editor = new Fl_Text_Editor(200, 50, 365, 440, "Text");
         tb_editor->tooltip("Enter your Latex text here.");
         tb_editor->box(FL_GTK_DOWN_FRAME);
       } // Fl_Text_Editor* tb_editor
@@ -109,22 +169,17 @@ ViewFluid::ViewFluid() {
         btn_generate->user_data((void*)(this));
         btn_generate->deactivate();
       } // Fl_Button* btn_generate
-      { menu_editor = new Fl_Menu_Button(200, 50, 365, 410);
+      { menu_editor = new Fl_Menu_Button(200, 50, 365, 440);
         menu_editor->box(FL_GTK_UP_BOX);
         menu_editor->deactivate();
         menu_editor->menu(menu_menu_editor);
       } // Fl_Menu_Button* menu_editor
-      { btn_open_src_dir = new Fl_Button(440, 530, 125, 25, "Open");
-        btn_open_src_dir->tooltip("Open directory containing source code.");
-        btn_open_src_dir->box(FL_GTK_UP_BOX);
-        btn_open_src_dir->deactivate();
-      } // Fl_Button* btn_open_src_dir
       { btn_open_cov_sheet = new Fl_Button(440, 560, 125, 25, "Open");
         btn_open_cov_sheet->tooltip("Select cover sheet .pdf file.");
         btn_open_cov_sheet->box(FL_GTK_UP_BOX);
         btn_open_cov_sheet->deactivate();
       } // Fl_Button* btn_open_cov_sheet
-      { chb_finished = new Fl_Check_Button(355, 485, 25, 25, "Finished");
+      { chb_finished = new Fl_Check_Button(355, 515, 25, 25, "Finished");
         chb_finished->tooltip("Mark chapter as finished.");
         chb_finished->down_box(FL_GTK_DOWN_BOX);
         chb_finished->user_data((void*)(this));
@@ -161,17 +216,21 @@ ViewFluid::ViewFluid() {
       ti_name->box(FL_GTK_DOWN_BOX);
       ti_name->deactivate();
     } // Fl_Input* ti_name
-    { ti_est_time = new Fl_Input(130, 370, 60, 25, "Estimated time:");
+    { ti_ID = new Fl_Input(75, 370, 115, 25, "ID:");
+      ti_ID->box(FL_GTK_DOWN_BOX);
+      ti_ID->deactivate();
+    } // Fl_Input* ti_ID
+    { ti_est_time = new Fl_Input(130, 400, 60, 25, "Estimated time:");
       ti_est_time->tooltip("Time estimated by the author.");
       ti_est_time->box(FL_GTK_DOWN_BOX);
       ti_est_time->deactivate();
     } // Fl_Input* ti_est_time
-    { ti_needed_time = new Fl_Input(130, 400, 60, 25, "Needed time:");
+    { ti_needed_time = new Fl_Input(130, 430, 60, 25, "Needed time:");
       ti_needed_time->tooltip("Time actually needed.");
       ti_needed_time->box(FL_GTK_DOWN_BOX);
       ti_needed_time->deactivate();
     } // Fl_Input* ti_needed_time
-    { btn_save_author = new Fl_Button(25, 435, 165, 25, "Save Author");
+    { btn_save_author = new Fl_Button(25, 465, 165, 25, "Save Author");
       btn_save_author->box(FL_GTK_UP_BOX);
       btn_save_author->deactivate();
     } // Fl_Button* btn_save_author
@@ -185,11 +244,6 @@ ViewFluid::ViewFluid() {
       btn_down_chpt->box(FL_GTK_UP_BOX);
       btn_down_chpt->deactivate();
     } // Fl_Button* btn_down_chpt
-    { ot_src_dir = new Fl_Output(140, 530, 280, 25, "Source Directory:");
-      ot_src_dir->tooltip("Directory containing Sourcecode.");
-      ot_src_dir->box(FL_GTK_DOWN_BOX);
-      ot_src_dir->deactivate();
-    } // Fl_Output* ot_src_dir
     { ot_cov_sheet = new Fl_Output(140, 560, 280, 25, "Cover Sheet:");
       ot_cov_sheet->tooltip("Cover sheet .pdf file.");
       ot_cov_sheet->box(FL_GTK_DOWN_BOX);
@@ -200,20 +254,20 @@ ViewFluid::ViewFluid() {
       menu_chapter->deactivate();
       menu_chapter->menu(menu_menu_chapter);
     } // Fl_Menu_Button* menu_chapter
-    { menu_author = new Fl_Menu_Button(25, 295, 165, 165);
+    { menu_author = new Fl_Menu_Button(25, 295, 165, 195);
       menu_author->box(FL_GTK_UP_BOX);
       menu_author->deactivate();
       menu_author->menu(menu_menu_author);
     } // Fl_Menu_Button* menu_author
-    { ti_doc_name = new Fl_Input(140, 470, 200, 25, "Document name:");
+    { ti_doc_name = new Fl_Input(140, 500, 200, 25, "Document name:");
       ti_doc_name->box(FL_GTK_DOWN_BOX);
       ti_doc_name->deactivate();
     } // Fl_Input* ti_doc_name
-    { ti_department = new Fl_Input(140, 500, 200, 25, "Department:");
+    { ti_department = new Fl_Input(140, 530, 200, 25, "Department:");
       ti_department->box(FL_GTK_DOWN_BOX);
       ti_department->deactivate();
     } // Fl_Input* ti_department
-    { menu_department = new Fl_Menu_Button(60, 500, 280, 25);
+    { menu_department = new Fl_Menu_Button(30, 530, 310, 25);
       menu_department->box(FL_GTK_UP_BOX);
       menu_department->deactivate();
       menu_department->menu(menu_menu_department);
@@ -221,82 +275,100 @@ ViewFluid::ViewFluid() {
     win_doctool->size_range(585, 555);
     win_doctool->end();
   } // Fl_Double_Window* win_doctool
-  { win_chapt_add = new Fl_Double_Window(415, 125, "Add Chapter");
-    win_chapt_add->box(FL_GTK_DOWN_BOX);
-    win_chapt_add->user_data((void*)(this));
+  { win_chapt = new Fl_Double_Window(415, 150, "Add Chapter");
+    win_chapt->box(FL_GTK_DOWN_BOX);
+    win_chapt->user_data((void*)(this));
     { add_chapt_chaptname = new Fl_Input(150, 15, 225, 25, "Chapter Name:");
       add_chapt_chaptname->box(FL_GTK_DOWN_BOX);
     } // Fl_Input* add_chapt_chaptname
-    { add_chapt_fname = new Fl_Input(150, 50, 225, 25, "Output Filename:");
+    { add_chapt_fname = new Fl_Input(150, 45, 225, 25, "Output Filename:");
       add_chapt_fname->box(FL_GTK_DOWN_BOX);
     } // Fl_Input* add_chapt_fname
-    { btn_chapt_insert = new Fl_Button(120, 85, 175, 30, "Insert Chapter");
-      btn_chapt_insert->box(FL_GTK_UP_BOX);
-    } // Fl_Button* btn_chapt_insert
-    win_chapt_add->end();
-  } // Fl_Double_Window* win_chapt_add
-  { win_settings = new Fl_Double_Window(350, 365, "Settings");
+    { btn_chapt_save = new Fl_Button(120, 110, 175, 30, "Save Chapter");
+      btn_chapt_save->box(FL_GTK_UP_BOX);
+    } // Fl_Button* btn_chapt_save
+    { spin_hierachy = new Fl_Spinner(150, 75, 40, 30, "Chapter Hierachy:");
+      spin_hierachy->tooltip("Set the chapter hierachy type. The lower the number is the higher the chapter\
+ will appear in the hierachy.");
+      spin_hierachy->minimum(0);
+      spin_hierachy->maximum(3);
+      spin_hierachy->value(0);
+    } // Fl_Spinner* spin_hierachy
+    { choice_chapt_type = new Fl_Choice(285, 75, 90, 30, "Chapter Type:");
+      choice_chapt_type->tooltip("Choose the type of the chapter you want to insert..");
+      choice_chapt_type->box(FL_GTK_UP_BOX);
+      choice_chapt_type->down_box(FL_GTK_UP_BOX);
+    } // Fl_Choice* choice_chapt_type
+    win_chapt->end();
+  } // Fl_Double_Window* win_chapt
+  { win_settings = new Fl_Double_Window(350, 350, "Settings");
     win_settings->box(FL_GTK_DOWN_BOX);
     win_settings->user_data((void*)(this));
-    { btn_save_settings = new Fl_Button(220, 325, 90, 25, "Save");
+    { btn_save_settings = new Fl_Button(220, 300, 90, 25, "Save");
       btn_save_settings->tooltip("Save settings.");
       btn_save_settings->box(FL_GTK_UP_BOX);
     } // Fl_Button* btn_save_settings
-    { chb_gen_doxygen = new Fl_Check_Button(120, 70, 115, 25, "Generate Doxygen Chapter");
-      chb_gen_doxygen->tooltip("Add chapter containing doxygen source code documentation to the end of the do\
-cument.");
-      chb_gen_doxygen->down_box(FL_GTK_DOWN_BOX);
-    } // Fl_Check_Button* chb_gen_doxygen
-    { chb_add_src = new Fl_Check_Button(120, 120, 115, 25, "Sourcecode Chapter");
-      chb_add_src->tooltip("Add chapter containing source code to the end of the document.");
-      chb_add_src->down_box(FL_GTK_DOWN_BOX);
-    } // Fl_Check_Button* chb_add_src
-    { chb_add_covpage = new Fl_Check_Button(120, 50, 25, 25, "Cover Sheet");
-      chb_add_covpage->tooltip("Add a coversheet to the document.");
-      chb_add_covpage->down_box(FL_GTK_DOWN_BOX);
-    } // Fl_Check_Button* chb_add_covpage
-    { ti_doxy_chapt_name = new Fl_Input(120, 95, 190, 25, "Chapter Name:");
-      ti_doxy_chapt_name->tooltip("Name of doxygen chapter.");
-      ti_doxy_chapt_name->box(FL_GTK_DOWN_BOX);
-    } // Fl_Input* ti_doxy_chapt_name
-    { ti_source_chapt_name = new Fl_Input(120, 140, 190, 25, "Chapter Name:");
-      ti_source_chapt_name->tooltip("Name of source code chapter.");
-      ti_source_chapt_name->box(FL_GTK_DOWN_BOX);
-    } // Fl_Input* ti_source_chapt_name
-    { ti_settings_subject_name = new Fl_Input(115, 290, 100, 25, "Subject Name:");
-      ti_settings_subject_name->tooltip("Name of the document Subject.");
-      ti_settings_subject_name->box(FL_GTK_DOWN_BOX);
-    } // Fl_Input* ti_settings_subject_name
-    { Fl_Box* o = new Fl_Box(0, 10, 350, 35, "Generation Settings");
+    { chb_add_titlepage = new Fl_Check_Button(120, 70, 115, 25, "Add latex titlepage");
+      chb_add_titlepage->tooltip("Generate a latex titlepage.");
+      chb_add_titlepage->down_box(FL_GTK_DOWN_BOX);
+    } // Fl_Check_Button* chb_add_titlepage
+    { Fl_Box* o = new Fl_Box(0, 5, 350, 35, "Generation Settings");
       o->tooltip("General generation settings used for document generation.");
+      o->labelfont(1);
     } // Fl_Box* o
-    { ti_location = new Fl_Input(115, 325, 100, 25, "Location:");
-      ti_location->tooltip("Location of the Author.");
-      ti_location->box(FL_GTK_DOWN_BOX);
-    } // Fl_Input* ti_location
-    { ti_header_ext = new Fl_Input(115, 220, 70, 25, "Header:");
+    { ti_header_ext = new Fl_Input(115, 195, 70, 25, "Header:");
       ti_header_ext->tooltip("Header file extension (most probably .h)");
       ti_header_ext->box(FL_GTK_DOWN_BOX);
     } // Fl_Input* ti_header_ext
-    { ti_src_ext = new Fl_Input(240, 220, 70, 25, "Source:");
+    { ti_src_ext = new Fl_Input(240, 195, 70, 25, "Source:");
       ti_src_ext->tooltip("Source file extension (most probably .c/.cpp)");
       ti_src_ext->box(FL_GTK_DOWN_BOX);
     } // Fl_Input* ti_src_ext
-    { Fl_Box* o = new Fl_Box(0, 185, 350, 20, "File Extension Settings");
+    { ti_settings_subject_name = new Fl_Input(115, 265, 100, 25, "Subject Name:");
+      ti_settings_subject_name->tooltip("Name of the document Subject.");
+      ti_settings_subject_name->box(FL_GTK_DOWN_BOX);
+    } // Fl_Input* ti_settings_subject_name
+    { ti_location = new Fl_Input(115, 300, 100, 25, "Location:");
+      ti_location->tooltip("Location of the Author.");
+      ti_location->box(FL_GTK_DOWN_BOX);
+    } // Fl_Input* ti_location
+    { Fl_Box* o = new Fl_Box(5, 165, 340, 20, "File Extension Settings");
       o->tooltip("Set file extension used by the C/C++ source files.");
+      o->labelfont(1);
     } // Fl_Box* o
-    { Fl_Box* o = new Fl_Box(0, 250, 350, 35, "Document Settings");
+    { Fl_Box* o = new Fl_Box(5, 230, 340, 35, "Document Settings");
       o->tooltip("Document Settings.");
+      o->labelfont(1);
     } // Fl_Box* o
+    { spin_toc_depth = new Fl_Spinner(95, 125, 40, 25, "Table of content depht");
+      spin_toc_depth->tooltip("Set the numbering depth of the table of content.");
+      spin_toc_depth->maximum(3);
+      spin_toc_depth->value(3);
+      spin_toc_depth->align(Fl_Align(FL_ALIGN_RIGHT));
+    } // Fl_Spinner* spin_toc_depth
+    { chb_add_toc = new Fl_Check_Button(120, 95, 115, 25, "Add Table of content");
+      chb_add_toc->tooltip("Generate table of content.");
+      chb_add_toc->down_box(FL_GTK_DOWN_BOX);
+    } // Fl_Check_Button* chb_add_toc
+    { chb_add_covpage = new Fl_Check_Button(120, 45, 115, 25, "Add cover sheet");
+      chb_add_covpage->tooltip("Add a coversheet .pdf file at the very front of the document.");
+      chb_add_covpage->down_box(FL_GTK_DOWN_BOX);
+    } // Fl_Check_Button* chb_add_covpage
     win_settings->end();
   } // Fl_Double_Window* win_settings
-  { win_auth_coord = new Fl_Double_Window(200, 190, "Author coordinates");
+  { win_auth_coord = new Fl_Double_Window(205, 220, "Author coordinates");
     win_auth_coord->tooltip("Coordinates to enter author information on Cover Sheet.");
     win_auth_coord->box(FL_GTK_DOWN_BOX);
     win_auth_coord->user_data((void*)(this));
-    { btn_ok_author = new Fl_Button(50, 155, 105, 25, "Ok");
+    { btn_ok_author = new Fl_Button(50, 180, 105, 25, "Ok");
       btn_ok_author->box(FL_GTK_UP_BOX);
     } // Fl_Button* btn_ok_author
+    { vi_esttime_x = new Fl_Value_Input(110, 60, 40, 25, "Time estimated:");
+      vi_esttime_x->box(FL_GTK_DOWN_BOX);
+    } // Fl_Value_Input* vi_esttime_x
+    { vi_esttime_y = new Fl_Value_Input(150, 60, 40, 25);
+      vi_esttime_y->box(FL_GTK_DOWN_BOX);
+    } // Fl_Value_Input* vi_esttime_y
     { vi_spenttime_x = new Fl_Value_Input(110, 85, 40, 25, "Time spent:");
       vi_spenttime_x->box(FL_GTK_DOWN_BOX);
     } // Fl_Value_Input* vi_spenttime_x
@@ -309,14 +381,15 @@ cument.");
     { vi_authname_y = new Fl_Value_Input(150, 110, 40, 25);
       vi_authname_y->box(FL_GTK_DOWN_BOX);
     } // Fl_Value_Input* vi_authname_y
-    { vi_esttime_x = new Fl_Value_Input(110, 60, 40, 25, "Time estimated:");
-      vi_esttime_x->box(FL_GTK_DOWN_BOX);
-    } // Fl_Value_Input* vi_esttime_x
-    { vi_esttime_y = new Fl_Value_Input(150, 60, 40, 25);
-      vi_esttime_y->box(FL_GTK_DOWN_BOX);
-    } // Fl_Value_Input* vi_esttime_y
-    { Fl_Box* o = new Fl_Box(20, 5, 175, 25, "Cover Sheet Coordinates");
+    { vi_id_x = new Fl_Value_Input(110, 135, 40, 25, "ID:");
+      vi_id_x->box(FL_GTK_DOWN_BOX);
+    } // Fl_Value_Input* vi_id_x
+    { vi_id_y = new Fl_Value_Input(150, 135, 40, 25);
+      vi_id_y->box(FL_GTK_DOWN_BOX);
+    } // Fl_Value_Input* vi_id_y
+    { Fl_Box* o = new Fl_Box(20, 10, 175, 25, "Cover Sheet Coordinates");
       o->tooltip("These coordinates are used to fill in the values in the cover page .pdf.");
+      o->labelfont(1);
     } // Fl_Box* o
     { new Fl_Box(110, 35, 40, 25, "X");
     } // Fl_Box* o
@@ -342,6 +415,7 @@ cument.");
     } // Fl_Button* btn_ok_depart
     { Fl_Box* o = new Fl_Box(30, 5, 175, 25, "Cover Sheet Coordinates");
       o->tooltip("These coordinates are used to fill in the values in the cover page .pdf.");
+      o->labelfont(1);
     } // Fl_Box* o
     win_depart_coord->end();
   } // Fl_Double_Window* win_depart_coord
index bb50803..fe1d20f 100644 (file)
@@ -8,29 +8,44 @@ class ViewFluid {open
   } {
     Fl_Window win_doctool {
       label {Doc Tool} open
-      protected xywh {319 138 585 630} type Double box GTK_DOWN_BOX resizable hotspot size_range {585 555 0 0} visible
+      protected xywh {381 203 585 630} type Double box GTK_DOWN_BOX hide resizable hotspot size_range {585 555 0 0}
     } {
-      Fl_Group {} {
+      Fl_Group {} {open
         protected xywh {200 45 365 575} resizable
       } {
+        Fl_Output ot_src_dir {
+          label {Source Directory:}
+          protected tooltip {Directory containing Sourcecode.} xywh {205 190 355 25} box GTK_DOWN_BOX align 5 hide deactivate
+        }
+        Fl_Button btn_open_src_dir {
+          label Open
+          protected tooltip {Open directory containing source code.} xywh {325 220 115 25} box GTK_UP_BOX hide deactivate
+        }
+        Fl_Box border_src {
+          protected xywh {200 145 365 125} box PLASTIC_DOWN_FRAME color 48 hide
+        }
+        Fl_Box lb_type {
+          label Type
+          protected xywh {200 115 365 30} hide
+        }
         Fl_Button btn_next {
           label Next
-          protected tooltip {Edit next chapter.} xywh {440 475 125 45} box GTK_UP_BOX deactivate
+          protected tooltip {Edit next chapter.} xywh {440 505 125 45} box GTK_UP_BOX deactivate
         }
         Fl_Text_Editor tb_editor {
           label Text
-          protected tooltip {Enter your Latex text here.} xywh {200 50 365 410} box GTK_DOWN_FRAME
+          protected tooltip {Enter your Latex text here.} xywh {200 50 365 440} box GTK_DOWN_FRAME
         }
         Fl_Button btn_generate {
           label Generate
           user_data this
           protected tooltip {Generate document.} xywh {440 590 125 25} box GTK_UP_BOX deactivate
         }
-        Fl_Menu_Button menu_editor {
-          protected xywh {200 50 365 410} box GTK_UP_BOX deactivate
+        Fl_Menu_Button menu_editor {open
+          protected xywh {200 50 365 440} box GTK_UP_BOX deactivate
         } {
           Submenu menu_rclck_headl {
-            label Headlines open
+            label Headlines
             protected xywh {0 0 100 20}
           } {
             MenuItem menu_rclck_headl1 {
@@ -46,14 +61,81 @@ class ViewFluid {open
               protected xywh {25 25 100 20}
             }
           }
+          Submenu menu_rclck_format {
+            label Format
+            protected xywh {10 10 100 20}
+          } {
+            MenuItem menu_rclck_bold {
+              label Bold
+              protected xywh {15 15 100 20}
+            }
+            MenuItem menu_rclck_italic {
+              label Italic
+              protected xywh {25 25 100 20}
+            }
+            MenuItem menu_rclck_underline {
+              label Underline
+              protected xywh {35 35 100 20}
+            }
+            MenuItem menu_rclck_center {
+              label Center
+              protected xywh {45 45 100 20}
+            }
+            MenuItem menu_rclck_unit {
+              label Unit
+              protected xywh {25 25 100 20}
+            }
+          }
+          Submenu menu_rclck_insert {
+            label Insert
+            protected xywh {20 20 100 20}
+          } {
+            MenuItem menu_rclck_insert_pic {
+              label Picture
+              protected xywh {25 25 100 20}
+            }
+            MenuItem menu_rclck_insert_txt {
+              label Text
+              protected xywh {35 35 100 20}
+            }
+          }
+          Submenu menu_rclck_equation {
+            label Equation open
+            protected xywh {10 10 100 20}
+          } {
+            MenuItem menu_rclck_normal_equ {
+              label {Normal Equation}
+              protected xywh {25 25 100 20}
+            }
+            MenuItem menu_rclck_intext_equ {
+              label {Intext Equation} selected
+              protected xywh {35 35 100 20}
+            }
+            MenuItem menu_rclck_frac {
+              label Fraction
+              protected xywh {15 15 100 20}
+            }
+            MenuItem menu_rclck_pow {
+              label Power
+              protected xywh {25 25 100 20}
+            }
+            MenuItem menu_rclck_equ {
+              label {Equal Sign}
+              protected xywh {35 35 100 20}
+            }
+          }
           MenuItem menu_rclck_list {
             label List
             protected xywh {15 15 100 20}
           }
-        }
-        Fl_Button btn_open_src_dir {
-          label Open
-          protected tooltip {Open directory containing source code.} xywh {440 530 125 25} box GTK_UP_BOX deactivate
+          MenuItem menu_rclck_newpage {
+            label {Page Break}
+            protected xywh {25 25 100 20}
+          }
+          MenuItem menu_rclck_newline {
+            label {Line Break}
+            protected xywh {35 35 100 20}
+          }
         }
         Fl_Button btn_open_cov_sheet {
           label Open
@@ -62,7 +144,7 @@ class ViewFluid {open
         Fl_Check_Button chb_finished {
           label Finished
           user_data this
-          protected tooltip {Mark chapter as finished.} xywh {355 485 25 25} down_box GTK_DOWN_BOX deactivate
+          protected tooltip {Mark chapter as finished.} xywh {355 515 25 25} down_box GTK_DOWN_BOX deactivate
         }
       }
       Fl_Browser br_chapters {
@@ -70,7 +152,7 @@ class ViewFluid {open
         user_data this
         protected tooltip {Choose a chapter to write.} xywh {25 50 165 220} box GTK_UP_BOX align 1 deactivate
       }
-      Fl_Menu_Bar menu_bar {open
+      Fl_Menu_Bar menu_bar {
         protected xywh {0 0 585 20} box GTK_UP_BOX
       } {
         Submenu menu_file {
@@ -126,7 +208,7 @@ output->value("Doc Tool\\n\\nFor a detailed usermanual please visit:"
 win.label("About");
 win.end();
 win.show();
-Fl::run();} selected
+Fl::run();}
             protected tooltip {Shows about text.} xywh {0 0 100 20}
             code0 {\#include <FL/Fl_Multiline_Output.H>}
           }
@@ -138,24 +220,28 @@ Fl::run();} selected
         protected tooltip {Your progress} xywh {25 590 395 25} box GTK_DOWN_BOX deactivate
       }
       Fl_Choice cb_author {
-        label Author open
+        label Author
         protected tooltip {Select author to edit.} xywh {25 310 165 25} box GTK_UP_BOX down_box GTK_DOWN_BOX align 5 deactivate
       } {}
       Fl_Input ti_name {
         label {Name:}
         protected xywh {75 340 115 25} box GTK_DOWN_BOX deactivate
       }
+      Fl_Input ti_ID {
+        label {ID:}
+        protected xywh {75 370 115 25} box GTK_DOWN_BOX deactivate
+      }
       Fl_Input ti_est_time {
         label {Estimated time:}
-        protected tooltip {Time estimated by the author.} xywh {130 370 60 25} box GTK_DOWN_BOX deactivate
+        protected tooltip {Time estimated by the author.} xywh {130 400 60 25} box GTK_DOWN_BOX deactivate
       }
       Fl_Input ti_needed_time {
         label {Needed time:}
-        protected tooltip {Time actually needed.} xywh {130 400 60 25} box GTK_DOWN_BOX deactivate
+        protected tooltip {Time actually needed.} xywh {130 430 60 25} box GTK_DOWN_BOX deactivate
       }
       Fl_Button btn_save_author {
         label {Save Author}
-        protected xywh {25 435 165 25} box GTK_UP_BOX deactivate
+        protected xywh {25 465 165 25} box GTK_UP_BOX deactivate
       }
       Fl_Button btn_up_chpt {
         label Up
@@ -165,10 +251,6 @@ Fl::run();} selected
         label Down
         protected tooltip {Move chapter down..} xywh {105 270 85 25} box GTK_UP_BOX deactivate
       }
-      Fl_Output ot_src_dir {
-        label {Source Directory:}
-        protected tooltip {Directory containing Sourcecode.} xywh {140 530 280 25} box GTK_DOWN_BOX deactivate
-      }
       Fl_Output ot_cov_sheet {
         label {Cover Sheet:}
         protected tooltip {Cover sheet .pdf file.} xywh {140 560 280 25} box GTK_DOWN_BOX deactivate
@@ -178,15 +260,19 @@ Fl::run();} selected
       } {
         MenuItem menu_add_chapter {
           label {Add chapter}
-          protected tooltip {Add new chapter.} xywh {5 5 100 20}
+          protected tooltip {Add a new chapter.} xywh {5 5 100 20}
+        }
+        MenuItem menu_edit_chapter {
+          label {Edit chapter}
+          protected tooltip {Edit selected chapter.} xywh {5 5 100 20}
         }
         MenuItem menu_rm_chapter {
           label {Remove chapter}
-          protected tooltip {Remove selected chapter.} xywh {5 100 20}
+          protected tooltip {Remove selected chapter.} xywh {15 15 100 20}
         }
       }
       Fl_Menu_Button menu_author {
-        protected xywh {25 295 165 165} box GTK_UP_BOX deactivate
+        protected xywh {25 295 165 195} box GTK_UP_BOX deactivate
       } {
         MenuItem menu_add_author {
           label {Remove author}
@@ -203,14 +289,14 @@ Fl::run();} selected
       }
       Fl_Input ti_doc_name {
         label {Document name:}
-        protected xywh {140 470 200 25} box GTK_DOWN_BOX deactivate
+        protected xywh {140 500 200 25} box GTK_DOWN_BOX deactivate
       }
       Fl_Input ti_department {
         label {Department:}
-        protected xywh {140 500 200 25} box GTK_DOWN_BOX deactivate
+        protected xywh {140 530 200 25} box GTK_DOWN_BOX deactivate
       }
       Fl_Menu_Button menu_department {
-        protected xywh {60 500 280 25} box GTK_UP_BOX deactivate
+        protected xywh {30 530 310 25} box GTK_UP_BOX deactivate
       } {
         MenuItem menu_department_coord {
           label {Edit coordinates}
@@ -218,9 +304,9 @@ Fl::run();} selected
         }
       }
     }
-    Fl_Window win_chapt_add {
+    Fl_Window win_chapt {
       label {Add Chapter}
-      protected xywh {1 171 415 125} type Double box GTK_DOWN_BOX visible
+      protected xywh {13 167 415 150} type Double box GTK_DOWN_BOX hide
     } {
       Fl_Input add_chapt_chaptname {
         label {Chapter Name:}
@@ -228,77 +314,88 @@ Fl::run();} selected
       }
       Fl_Input add_chapt_fname {
         label {Output Filename:}
-        protected xywh {150 50 225 25} box GTK_DOWN_BOX
+        protected xywh {150 45 225 25} box GTK_DOWN_BOX
+      }
+      Fl_Button btn_chapt_save {
+        label {Save Chapter}
+        protected xywh {120 110 175 30} box GTK_UP_BOX
       }
-      Fl_Button btn_chapt_insert {
-        label {Insert Chapter}
-        protected xywh {120 85 175 30} box GTK_UP_BOX
+      Fl_Spinner spin_hierachy {
+        label {Chapter Hierachy:}
+        protected tooltip {Set the chapter hierachy type. The lower the number is the higher the chapter will appear in the hierachy.} xywh {150 75 40 30} minimum 0 maximum 3 value 0
       }
+      Fl_Choice choice_chapt_type {
+        label {Chapter Type:} open
+        protected tooltip {Choose the type of the chapter you want to insert..} xywh {285 75 90 30} box GTK_UP_BOX down_box GTK_UP_BOX
+      } {}
     }
     Fl_Window win_settings {
       label Settings
-      protected xywh {652 171 350 365} type Double box GTK_DOWN_BOX visible
+      protected xywh {97 256 350 350} type Double box GTK_DOWN_BOX hide
     } {
       Fl_Button btn_save_settings {
         label Save
-        protected tooltip {Save settings.} xywh {220 325 90 25} box GTK_UP_BOX
-      }
-      Fl_Check_Button chb_gen_doxygen {
-        label {Generate Doxygen Chapter}
-        protected tooltip {Add chapter containing doxygen source code documentation to the end of the document.} xywh {120 70 115 25} down_box GTK_DOWN_BOX
-      }
-      Fl_Check_Button chb_add_src {
-        label {Sourcecode Chapter}
-        protected tooltip {Add chapter containing source code to the end of the document.} xywh {120 120 115 25} down_box GTK_DOWN_BOX
-      }
-      Fl_Check_Button chb_add_covpage {
-        label {Cover Sheet}
-        protected tooltip {Add a coversheet to the document.} xywh {120 50 25 25} down_box GTK_DOWN_BOX
-      }
-      Fl_Input ti_doxy_chapt_name {
-        label {Chapter Name:}
-        protected tooltip {Name of doxygen chapter.} xywh {120 95 190 25} box GTK_DOWN_BOX
+        protected tooltip {Save settings.} xywh {220 300 90 25} box GTK_UP_BOX
       }
-      Fl_Input ti_source_chapt_name {
-        label {Chapter Name:}
-        protected tooltip {Name of source code chapter.} xywh {120 140 190 25} box GTK_DOWN_BOX
-      }
-      Fl_Input ti_settings_subject_name {
-        label {Subject Name:}
-        protected tooltip {Name of the document Subject.} xywh {115 290 100 25} box GTK_DOWN_BOX
+      Fl_Check_Button chb_add_titlepage {
+        label {Add latex titlepage}
+        protected tooltip {Generate a latex titlepage.} xywh {120 70 115 25} down_box GTK_DOWN_BOX
       }
       Fl_Box {} {
         label {Generation Settings}
-        protected tooltip {General generation settings used for document generation.} xywh {0 10 350 35}
-      }
-      Fl_Input ti_location {
-        label {Location:}
-        protected tooltip {Location of the Author.} xywh {115 325 100 25} box GTK_DOWN_BOX
+        protected tooltip {General generation settings used for document generation.} xywh {0 5 350 35} labelfont 1
       }
       Fl_Input ti_header_ext {
         label {Header:}
-        protected tooltip {Header file extension (most probably .h)} xywh {115 220 70 25} box GTK_DOWN_BOX
+        protected tooltip {Header file extension (most probably .h)} xywh {115 195 70 25} box GTK_DOWN_BOX
       }
       Fl_Input ti_src_ext {
         label {Source:}
-        protected tooltip {Source file extension (most probably .c/.cpp)} xywh {240 220 70 25} box GTK_DOWN_BOX
+        protected tooltip {Source file extension (most probably .c/.cpp)} xywh {240 195 70 25} box GTK_DOWN_BOX
+      }
+      Fl_Input ti_settings_subject_name {
+        label {Subject Name:}
+        protected tooltip {Name of the document Subject.} xywh {115 265 100 25} box GTK_DOWN_BOX
+      }
+      Fl_Input ti_location {
+        label {Location:}
+        protected tooltip {Location of the Author.} xywh {115 300 100 25} box GTK_DOWN_BOX
       }
       Fl_Box {} {
         label {File Extension Settings}
-        protected tooltip {Set file extension used by the C/C++ source files.} xywh {0 185 350 20}
+        protected tooltip {Set file extension used by the C/C++ source files.} xywh {5 165 340 20} labelfont 1
       }
       Fl_Box {} {
         label {Document Settings}
-        protected tooltip {Document Settings.} xywh {0 250 350 35}
+        protected tooltip {Document Settings.} xywh {5 230 340 35} labelfont 1
+      }
+      Fl_Spinner spin_toc_depth {
+        label {Table of content depht}
+        protected tooltip {Set the numbering depth of the table of content.} xywh {95 125 40 25} align 8 maximum 3 value 3
+      }
+      Fl_Check_Button chb_add_toc {
+        label {Add Table of content}
+        protected tooltip {Generate table of content.} xywh {120 95 115 25} down_box GTK_DOWN_BOX
+      }
+      Fl_Check_Button chb_add_covpage {
+        label {Add cover sheet}
+        protected tooltip {Add a coversheet .pdf file at the very front of the document.} xywh {120 45 115 25} down_box GTK_DOWN_BOX
       }
     }
     Fl_Window win_auth_coord {
       label {Author coordinates}
-      protected tooltip {Coordinates to enter author information on Cover Sheet.} xywh {64 588 200 190} type Double box GTK_DOWN_BOX visible
+      protected tooltip {Coordinates to enter author information on Cover Sheet.} xywh {48 558 205 220} type Double box GTK_DOWN_BOX hide
     } {
       Fl_Button btn_ok_author {
         label Ok
-        protected xywh {50 155 105 25} box GTK_UP_BOX
+        protected xywh {50 180 105 25} box GTK_UP_BOX
+      }
+      Fl_Value_Input vi_esttime_x {
+        label {Time estimated:}
+        protected xywh {110 60 40 25} box GTK_DOWN_BOX
+      }
+      Fl_Value_Input vi_esttime_y {
+        protected xywh {150 60 40 25} box GTK_DOWN_BOX
       }
       Fl_Value_Input vi_spenttime_x {
         label {Time spent:}
@@ -314,16 +411,16 @@ Fl::run();} selected
       Fl_Value_Input vi_authname_y {
         protected xywh {150 110 40 25} box GTK_DOWN_BOX
       }
-      Fl_Value_Input vi_esttime_x {
-        label {Time estimated:}
-        protected xywh {110 60 40 25} box GTK_DOWN_BOX
+      Fl_Value_Input vi_id_x {
+        label {ID:}
+        protected xywh {110 135 40 25} box GTK_DOWN_BOX
       }
-      Fl_Value_Input vi_esttime_y {
-        protected xywh {150 60 40 25} box GTK_DOWN_BOX
+      Fl_Value_Input vi_id_y {
+        protected xywh {150 135 40 25} box GTK_DOWN_BOX
       }
       Fl_Box {} {
         label {Cover Sheet Coordinates}
-        protected tooltip {These coordinates are used to fill in the values in the cover page .pdf.} xywh {20 5 175 25}
+        protected tooltip {These coordinates are used to fill in the values in the cover page .pdf.} xywh {20 10 175 25} labelfont 1
       }
       Fl_Box {} {
         label X
@@ -336,7 +433,7 @@ Fl::run();} selected
     }
     Fl_Window win_depart_coord {
       label {Department Coordinates}
-      protected xywh {31 394 240 130} type Double box GTK_DOWN_BOX visible
+      protected xywh {24 387 240 130} type Double box GTK_DOWN_BOX hide
     } {
       Fl_Value_Input vi_depart_x {
         label {Coordinates:}
@@ -359,12 +456,12 @@ Fl::run();} selected
       }
       Fl_Box {} {
         label {Cover Sheet Coordinates}
-        protected tooltip {These coordinates are used to fill in the values in the cover page .pdf.} xywh {30 5 175 25}
+        protected tooltip {These coordinates are used to fill in the values in the cover page .pdf.} xywh {30 5 175 25} labelfont 1
       }
     }
     Fl_Window win_log_view {
       label Log
-      protected xywh {816 357 460 395} type Double resizable visible
+      protected xywh {1 472 460 395} type Double hide resizable
     } {
       Fl_Text_Display td_log_view {
         protected xywh {0 5 460 390}
index 6052736..92ad7e2 100644 (file)
@@ -5,7 +5,9 @@
 #include <FL/Fl.H>
 #include <FL/Fl_Double_Window.H>
 #include <FL/Fl_Group.H>
+#include <FL/Fl_Output.H>
 #include <FL/Fl_Button.H>
+#include <FL/Fl_Box.H>
 #include <FL/Fl_Text_Editor.H>
 #include <FL/Fl_Menu_Button.H>
 #include <FL/Fl_Check_Button.H>
@@ -15,8 +17,7 @@
 #include <FL/Fl_Progress.H>
 #include <FL/Fl_Choice.H>
 #include <FL/Fl_Input.H>
-#include <FL/Fl_Output.H>
-#include <FL/Fl_Box.H>
+#include <FL/Fl_Spinner.H>
 #include <FL/Fl_Value_Input.H>
 #include <FL/Fl_Text_Display.H>
 
@@ -24,6 +25,10 @@ class ViewFluid {
 protected:
   ViewFluid();
   Fl_Double_Window *win_doctool;
+  Fl_Output *ot_src_dir;
+  Fl_Button *btn_open_src_dir;
+  Fl_Box *border_src;
+  Fl_Box *lb_type;
   Fl_Button *btn_next;
   Fl_Text_Editor *tb_editor;
   Fl_Button *btn_generate;
@@ -33,8 +38,24 @@ protected:
   static Fl_Menu_Item *menu_rclck_headl1;
   static Fl_Menu_Item *menu_rclck_headl2;
   static Fl_Menu_Item *menu_rclck_headl3;
+  static Fl_Menu_Item *menu_rclck_format;
+  static Fl_Menu_Item *menu_rclck_bold;
+  static Fl_Menu_Item *menu_rclck_italic;
+  static Fl_Menu_Item *menu_rclck_underline;
+  static Fl_Menu_Item *menu_rclck_center;
+  static Fl_Menu_Item *menu_rclck_unit;
+  static Fl_Menu_Item *menu_rclck_insert;
+  static Fl_Menu_Item *menu_rclck_insert_pic;
+  static Fl_Menu_Item *menu_rclck_insert_txt;
+  static Fl_Menu_Item *menu_rclck_equation;
+  static Fl_Menu_Item *menu_rclck_normal_equ;
+  static Fl_Menu_Item *menu_rclck_intext_equ;
+  static Fl_Menu_Item *menu_rclck_frac;
+  static Fl_Menu_Item *menu_rclck_pow;
+  static Fl_Menu_Item *menu_rclck_equ;
   static Fl_Menu_Item *menu_rclck_list;
-  Fl_Button *btn_open_src_dir;
+  static Fl_Menu_Item *menu_rclck_newpage;
+  static Fl_Menu_Item *menu_rclck_newline;
   Fl_Button *btn_open_cov_sheet;
   Fl_Check_Button *chb_finished;
   Fl_Browser *br_chapters;
@@ -57,16 +78,17 @@ protected:
   Fl_Progress *pb_progress;
   Fl_Choice *cb_author;
   Fl_Input *ti_name;
+  Fl_Input *ti_ID;
   Fl_Input *ti_est_time;
   Fl_Input *ti_needed_time;
   Fl_Button *btn_save_author;
   Fl_Button *btn_up_chpt;
   Fl_Button *btn_down_chpt;
-  Fl_Output *ot_src_dir;
   Fl_Output *ot_cov_sheet;
   Fl_Menu_Button *menu_chapter;
   static Fl_Menu_Item menu_menu_chapter[];
   static Fl_Menu_Item *menu_add_chapter;
+  static Fl_Menu_Item *menu_edit_chapter;
   static Fl_Menu_Item *menu_rm_chapter;
   Fl_Menu_Button *menu_author;
   static Fl_Menu_Item menu_menu_author[];
@@ -78,29 +100,32 @@ protected:
   Fl_Menu_Button *menu_department;
   static Fl_Menu_Item menu_menu_department[];
   static Fl_Menu_Item *menu_department_coord;
-  Fl_Double_Window *win_chapt_add;
+  Fl_Double_Window *win_chapt;
   Fl_Input *add_chapt_chaptname;
   Fl_Input *add_chapt_fname;
-  Fl_Button *btn_chapt_insert;
+  Fl_Button *btn_chapt_save;
+  Fl_Spinner *spin_hierachy;
+  Fl_Choice *choice_chapt_type;
   Fl_Double_Window *win_settings;
   Fl_Button *btn_save_settings;
-  Fl_Check_Button *chb_gen_doxygen;
-  Fl_Check_Button *chb_add_src;
-  Fl_Check_Button *chb_add_covpage;
-  Fl_Input *ti_doxy_chapt_name;
-  Fl_Input *ti_source_chapt_name;
-  Fl_Input *ti_settings_subject_name;
-  Fl_Input *ti_location;
+  Fl_Check_Button *chb_add_titlepage;
   Fl_Input *ti_header_ext;
   Fl_Input *ti_src_ext;
+  Fl_Input *ti_settings_subject_name;
+  Fl_Input *ti_location;
+  Fl_Spinner *spin_toc_depth;
+  Fl_Check_Button *chb_add_toc;
+  Fl_Check_Button *chb_add_covpage;
   Fl_Double_Window *win_auth_coord;
   Fl_Button *btn_ok_author;
+  Fl_Value_Input *vi_esttime_x;
+  Fl_Value_Input *vi_esttime_y;
   Fl_Value_Input *vi_spenttime_x;
   Fl_Value_Input *vi_spenttime_y;
   Fl_Value_Input *vi_authname_x;
   Fl_Value_Input *vi_authname_y;
-  Fl_Value_Input *vi_esttime_x;
-  Fl_Value_Input *vi_esttime_y;
+  Fl_Value_Input *vi_id_x;
+  Fl_Value_Input *vi_id_y;
   Fl_Double_Window *win_depart_coord;
   Fl_Value_Input *vi_depart_x;
   Fl_Value_Input *vi_depart_y;
index 6819e87..fbe62dd 100644 (file)
                        <Add directory="../include" />
                </Compiler>
                <Unit filename="Author.h" />
-               <Unit filename="Chapter.h" />
+               <Unit filename="ChapterFactory.cxx" />
+               <Unit filename="ChapterFactory.h" />
+               <Unit filename="ChapterIF.h" />
                <Unit filename="Controller.cxx" />
                <Unit filename="Controller.h" />
                <Unit filename="ControllerIF.h" />
+               <Unit filename="DoxygenChapter.h" />
                <Unit filename="FSHelper.cxx" />
                <Unit filename="FSHelper.h" />
                <Unit filename="Model.cxx" />
                <Unit filename="Object.h" />
                <Unit filename="Observer.cxx" />
                <Unit filename="Observer.h" />
+               <Unit filename="SourceChapter.h" />
                <Unit filename="Subject.cxx" />
                <Unit filename="Subject.h" />
+               <Unit filename="TextChapter.h" />
                <Unit filename="View.cxx" />
                <Unit filename="View.h" />
                <Unit filename="ViewFluid.cxx" />
index dec154f..837a603 100644 (file)
 1524409547 /home/giri/workspace/hsd_doku_tool/include/FL/Fl_Return_Button.H
        "Fl_Button.H"
 
-1525041145 source:/home/giri/workspace/hsd_doku_tool/src/main.cxx
+1526000319 source:/home/giri/workspace/hsd_doku_tool/src/main.cxx
        <cstdlib>
        <iostream>
        "View.h"
        "Controller.h"
        "Model.h"
+       "FSHelper.h"
        <FL/fl_ask.H>
 
 1524409547 /home/giri/workspace/hsd_doku_tool/include/FL/Fl_Output.H
        "ControllerIF.h"
        "ModelIF.h"
 
-1525082511 /home/giri/workspace/hsd_doku_tool/src/Controller.h
+1526231144 /home/giri/workspace/hsd_doku_tool/src/Controller.h
        <list>
        "ControllerIF.h"
        "Subject.h"
        "Model.h"
 
-1525109717 /home/giri/workspace/hsd_doku_tool/src/ControllerIF.h
+1526231154 /home/giri/workspace/hsd_doku_tool/src/ControllerIF.h
        <iostream>
        <memory>
 
-1525100062 /home/giri/workspace/hsd_doku_tool/src/ModelIF.h
+1526176525 /home/giri/workspace/hsd_doku_tool/src/ModelIF.h
        <memory>
        "Subject.h"
        "Author.h"
-       "Chapter.h"
        <list>
+       <vector>
 
-1525108052 source:/home/giri/workspace/hsd_doku_tool/src/Model.cxx
+1526240391 source:/home/giri/workspace/hsd_doku_tool/src/Model.cxx
        "Model.h"
        <iostream>
        <algorithm>
        <fstream>
        <sstream>
 
-1525100080 /home/giri/workspace/hsd_doku_tool/src/Model.h
+1526176558 /home/giri/workspace/hsd_doku_tool/src/Model.h
        "ModelIF.h"
        "tinyxml2.h"
-       "Chapter.h"
+       "ChapterIF.h"
+       "ChapterFactory.h"
        "Author.h"
        "FSHelper.h"
        <vector>
        <android/log.h>
        <assert.h>
 
-1525109103 source:/home/giri/workspace/hsd_doku_tool/src/View.cxx
+1526232364 source:/home/giri/workspace/hsd_doku_tool/src/View.cxx
        "View.h"
        "Author.h"
-       "Chapter.h"
+       "ChapterIF.h"
+       "ChapterFactory.h"
        "FSHelper.h"
        <FL/Fl_File_Chooser.H>
        <iostream>
        <cstring>
 
-1525102686 /home/giri/workspace/hsd_doku_tool/src/View.h
+1526231556 /home/giri/workspace/hsd_doku_tool/src/View.h
        "ViewFluid.h"
        "Observer.h"
        "ModelIF.h"
 1524409547 /home/giri/workspace/hsd_doku_tool/include/FL/Fl_Progress.H
        "Fl_Widget.H"
 
-1524173493 /home/giri/workspace/hsd_doku_tool/src/Object.h
+1525118065 /home/giri/workspace/hsd_doku_tool/src/Object.h
 
 1524517363 /home/giri/workspace/hsd_doku_tool/src/ViewIF.h
        "Observer.h"
 
-1525087356 source:/home/giri/workspace/hsd_doku_tool/src/Controller.cxx
+1526231914 source:/home/giri/workspace/hsd_doku_tool/src/Controller.cxx
        "Controller.h"
        "View.h"
        "Author.h"
        <memory>
        <iostream>
 
-1524398116 /home/giri/workspace/hsd_doku_tool/src/Observer.h
+1525118065 /home/giri/workspace/hsd_doku_tool/src/Observer.h
        <memory>
        <list>
 
-1524397524 /home/giri/workspace/hsd_doku_tool/src/Subject.h
+1525118065 /home/giri/workspace/hsd_doku_tool/src/Subject.h
        <memory>
        <list>
        "Observer.h"
 
-1524397547 source:/home/giri/workspace/hsd_doku_tool/src/Subject.cxx
+1525118065 source:/home/giri/workspace/hsd_doku_tool/src/Subject.cxx
        "Subject.h"
        <algorithm>
 
-1525111451 /home/giri/workspace/hsd_doku_tool/src/ViewFluid.h
+1526251548 /home/giri/workspace/hsd_doku_tool/src/ViewFluid.h
        <FL/Fl.H>
        <FL/Fl_Double_Window.H>
        <FL/Fl_Group.H>
+       <FL/Fl_Box.H>
        <FL/Fl_Button.H>
        <FL/Fl_Text_Editor.H>
        <FL/Fl_Menu_Button.H>
        <FL/Fl_Check_Button.H>
+       <FL/Fl_Output.H>
        <FL/Fl_Browser.H>
        <FL/Fl_Menu_Bar.H>
        <FL/Fl_Multiline_Output.H>
        <FL/Fl_Progress.H>
        <FL/Fl_Choice.H>
        <FL/Fl_Input.H>
-       <FL/Fl_Output.H>
-       <FL/Fl_Box.H>
+       <FL/Fl_Spinner.H>
        <FL/Fl_Value_Input.H>
-       <FL/Fl_Return_Button.H>
-       <string>
        <FL/Fl_Text_Display.H>
 
 1524409548 /home/giri/workspace/hsd_doku_tool/include/FL/fl_ask.H
        <sys/types.h>
        <dirent.h>
 
-1515926384 /usr/include/dirent.h
+1522352849 /usr/include/dirent.h
        <features.h>
        <bits/types.h>
        <bits/dirent.h>
 1524409547 /home/giri/workspace/hsd_doku_tool/include/FL/Fl_File_Input.H
        <FL/Fl_Input.H>
 
-1524398009 source:/home/giri/workspace/hsd_doku_tool/src/Observer.cxx
+1525118065 source:/home/giri/workspace/hsd_doku_tool/src/Observer.cxx
        "Observer.h"
        "Subject.h"
        <algorithm>
 1524409547 /home/giri/workspace/hsd_doku_tool/include/FL/Fl_Multiline_Output.H
        "Fl_Output.H"
 
-1525109292 /home/giri/workspace/hsd_doku_tool/src/Chapter.h
+1525305989 /home/giri/workspace/hsd_doku_tool/src/Chapter.h
        <iostream>
        "Object.h"
        <fstream>
 1524417896 source:/home/giri/workspace/hsd_doku_tool/src/Chapter.cxx
        "Chapter.h"
 
-1525109249 /home/giri/workspace/hsd_doku_tool/src/Author.h
+1526088323 /home/giri/workspace/hsd_doku_tool/src/Author.h
        <iostream>
        "Object.h"
 
-1525100833 source:/home/giri/workspace/hsd_doku_tool/src/FSHelper.cxx
+1526251537 source:/home/giri/workspace/hsd_doku_tool/src/FSHelper.cxx
        "FSHelper.h"
        <fstream>
        <dirent.h>
        <sys/types.h>
+       <unistd.h>
        <sys/stat.h>
        <cstring>
+       <sstream>
        <algorithm>
+       <sys/wait.h>
 
-1525100625 /home/giri/workspace/hsd_doku_tool/src/FSHelper.h
+1526229988 /home/giri/workspace/hsd_doku_tool/src/FSHelper.h
        <iostream>
        <vector>
        "Object.h"
        "Fl_Valuator.H"
        "Fl_Input.H"
 
+1526176471 /home/giri/workspace/hsd_doku_tool/src/ChapterIF.h
+       <iostream>
+       <fstream>
+       <memory>
+       "ModelIF.h"
+       "FSHelper.h"
+
+1526174784 /home/giri/workspace/hsd_doku_tool/src/ChapterFactory.h
+       "TextChapter.h"
+       "DoxygenChapter.h"
+       "SourceChapter.h"
+
+1526176454 /home/giri/workspace/hsd_doku_tool/src/TextChapter.h
+       <iostream>
+       "Object.h"
+       "ChapterIF.h"
+       <fstream>
+
+1526230243 /home/giri/workspace/hsd_doku_tool/src/DoxygenChapter.h
+       <iostream>
+       "Object.h"
+       <algorithm>
+
+1526226678 /home/giri/workspace/hsd_doku_tool/src/SourceChapter.h
+       <iostream>
+       "Object.h"
+       "ChapterIF.h"
+       <fstream>
+
+1524409547 /home/giri/workspace/hsd_doku_tool/include/FL/Fl_Spinner.H
+       <FL/Enumerations.H>
+       <FL/Fl_Group.H>
+       <FL/Fl_Input.H>
+       <FL/Fl_Repeat_Button.H>
+       <stdio.h>
+       <stdlib.h>
+
+1524409547 /home/giri/workspace/hsd_doku_tool/include/FL/Fl_Repeat_Button.H
+       "Fl.H"
+       "Fl_Button.H"
+
+1526164599 source:/home/giri/workspace/hsd_doku_tool/src/ChapterFactory.cpp
+       "ChapterFactory.h"
+
index 67bfe70..f50f58f 100644 (file)
@@ -27,22 +27,21 @@ int main()
 
         try
         {
+            // Benutze eigenen Loader
             FShelp.setLinuxDynLoader(FShelp.addDirLastSlash(curDir) + "lib/ld-linux.so.2");
         }
         catch(std::string& e)
         {
-            // Benutze loader des Linux betriebsystems
+            // Benutze Loader des Linux Betriebsystems
             FShelp.removeLinuxDynLoader();
         }
 
         std::shared_ptr<Model> myModel {std::make_shared<Model>(confDir, FShelp, "Log.txt")};
         Controller::SPtr myController {std::make_shared<Controller>(myModel)};
 
-        Fl::lock(); // Threading unterstützung
         View myView(myController, myModel);
         myView.show();
 
-
         return Fl::run();
     }