Changeset 6015

Timestamp:

Nov 2, 2009, 5:54:13 PM (15 years ago)

Author:

rgrieder

Message:

IOConsole cleanup and added ConsoleWriter to the OutputHandler so that we get std::cout output before the creation of the IOConsole.

Location:

code/branches/console/src

Files:

• libraries/core/Core.cc (modified) (2 diffs)
• libraries/core/Core.h (modified) (1 diff)
• libraries/core/IOConsole.cc (modified) (10 diffs)
• libraries/core/IOConsole.h (modified) (4 diffs)
• libraries/util/OutputHandler.cc (modified) (3 diffs)
• libraries/util/OutputHandler.h (modified) (3 diffs)
• orxonox/overlays/InGameConsole.cc (modified) (1 diff)
• orxonox/overlays/InGameConsole.h (modified) (1 diff)

code/branches/console/src/libraries/core/Core.cc

@@ -218 +218 @@
         this->languageInstance_.reset(new Language());
 
+        // create persistent io console
+        this->ioConsole_.reset(new IOConsole());
+
         // creates the class hierarchy for all classes with factories
         Identifier::createClassHierarchy();
@@ -231 +234 @@
         this->tclBind_.reset(new TclBind(PathConfig::getDataPathString()));
         this->tclThreadManager_.reset(new TclThreadManager(tclBind_->getTclInterpreter()));
-
-        // create persistent io console
-        this->ioConsole_.reset(new IOConsole());
 
         // Create singletons that always exist (in other libraries)

code/branches/console/src/libraries/core/Core.h

@@ -91 +91 @@
             scoped_ptr<ConfigFileManager> configFileManager_;
             scoped_ptr<Language>          languageInstance_;
+            scoped_ptr<IOConsole>         ioConsole_;
             scoped_ptr<CoreConfiguration> configuration_;
             scoped_ptr<TclBind>           tclBind_;
             scoped_ptr<TclThreadManager>  tclThreadManager_;
-            scoped_ptr<IOConsole>         ioConsole_;
             // graphical
             scoped_ptr<GraphicsManager>   graphicsManager_;     //!< Interface to OGRE

code/branches/console/src/libraries/core/IOConsole.cc

@@ -30 +30 @@
 #include "IOConsole.h"
 
-#include <cstring>
 #include <iomanip>
 #include <iostream>
-
-#include "util/Clock.h"
-#include "util/Debug.h"
-#include "util/Sleep.h"
-#include "core/CommandExecutor.h"
 #include "core/Game.h"
-#include "core/GameMode.h"
-#include "core/Shell.h"
 #include "core/input/InputBuffer.h"
 
+// ##########################
+// ###   Mutual methods   ###
+// ##########################
+namespace orxonox
+{
+    IOConsole* IOConsole::singletonPtr_s = NULL;
+
+    int IOConsole::extractLogLevel(std::string* text)
+    {
+        // Handle line colouring by inspecting the first letter
+        char level = 0;
+        if (!text->empty())
+        {
+            level = (*text)[0];
+            if (level == -1 || level >= 1 && level <= 6)
+            {
+                *text = text->substr(1);
+                if (level != -1)
+                    return level;
+            }
+        }
+        return 0;
+    }
+
+    inline bool IOConsole::willPrintStatusLines()
+    {
+        return !this->statusLineWidths_.empty()
+             && this->terminalWidth_  >= this->statusLineMaxWidth_
+             && this->terminalHeight_ >= (this->minOutputLines_ + this->statusLineWidths_.size());
+    }
+
+    // ###############################
+    // ###  ShellListener methods  ###
+    // ###############################
+
+    //! Called if all output-lines have to be reprinted
+    void IOConsole::linesChanged()
+    {
+        // Method only gets called upon start to draw all the lines
+        // or when scrolling. But scrolling is disable and the output
+        // is already in std::cout when we start the IOConsole
+    }
+
+    //! Called if the text in the input-line has changed
+    void IOConsole::inputChanged()
+    {
+        this->printInputLine();
+        std::cout.flush();
+    }
+
+    //! Called if the position of the cursor in the input-line has changed
+    void IOConsole::cursorChanged()
+    {
+        this->printInputLine();
+        std::cout.flush();
+    }
+
+    //! Called if a command is about to be executed
+    void IOConsole::executed()
+    {
+        this->shell_->addOutputLine(this->promptString_ + this->shell_->getInput());
+    }
+
+    //! Called if the console gets closed
+    void IOConsole::exit()
+    {
+        // Exit is not an option, just do nothing (Shell doesn't really exit too)
+    }
+}
+
 #ifdef ORXONOX_PLATFORM_UNIX
+// ###############################
+// ###   Unix Implementation   ###
+// ###############################
+
 #include <termios.h>
 #include <sys/ioctl.h>
 #include <sys/stat.h>
-#endif
 
 namespace orxonox
 {
-    IOConsole* IOConsole::singletonPtr_s = NULL;
-
-#ifdef ORXONOX_PLATFORM_UNIX
-
     namespace EscapeMode
     {
@@ -82 +143 @@
         this->lastTerminalWidth_ = this->terminalWidth_;
         this->lastTerminalHeight_ = this->terminalHeight_;
+
+        // Disable standard std::cout logging
+        OutputHandler::getInstance().disableCout();
     }
 
     IOConsole::~IOConsole()
     {
-        // Goto last line and erase it
+        // Goto last line and create a new one
         if (this->bStatusPrinted_)
             std::cout << "\033[" << this->statusLineWidths_.size() << 'E';
-        std::cout << "\033[1G\033[K";
-        std::cout.flush();
+        std::cout << std::endl;
+
         resetTerminalMode();
         delete this->originalTerminalSettings_;
         this->shell_->destroy();
-    }
-
-    void IOConsole::setTerminalMode()
-    {
-        termios new_settings;
-
-        tcgetattr(0, this->originalTerminalSettings_);
-        new_settings = *this->originalTerminalSettings_;
-        new_settings.c_lflag &= ~(ICANON | ECHO);
-        //         new_settings.c_lflag |= ( ISIG | IEXTEN );
-        new_settings.c_cc[VTIME] = 0;
-        new_settings.c_cc[VMIN]  = 0;
-        tcsetattr(0, TCSANOW, &new_settings);
-        COUT(0) << endl;
-        //       atexit(&IOConsole::resetTerminalMode);
-    }
-
-    void IOConsole::resetTerminalMode()
-    {
-        tcsetattr(0, TCSANOW, IOConsole::originalTerminalSettings_);
+
+        // Enable standard std::cout logging again
+        OutputHandler::getInstance().enableCout();
     }
 
@@ -121 +168 @@
         std::string escapeSequence;
         EscapeMode::Value escapeMode = EscapeMode::None;
-        while (read(STDIN_FILENO, &c, 1) == 1)
-        {
+        while (std::cin.good())
+        {
+            c = std::cin.get();
+            if (std::cin.bad())
+                break;
+
             if (escapeMode == EscapeMode::First && (c == '[' || c=='O') )
                 escapeMode = EscapeMode::Second;
@@ -191 +242 @@
             }
         }
+        // Reset error flags in std::cin
+        std::cin.clear();
 
         // If there is still an escape key pending (escape key ONLY), then
@@ -205 +258 @@
         if (this->bStatusPrinted_ && heightDiff < 0)
         {
-            // Terminal width has shrinked. The cursor will still be on the input line,
+            // Terminal width has shrunk. The cursor will still be on the input line,
             // but that line might very well be the last
             int newLines = std::min((int)this->statusLineWidths_.size(), -heightDiff);
@@ -230 +283 @@
     void IOConsole::printLogText(const std::string& text)
     {
-        std::string output;
-
-        // Handle line colouring by inspecting the first letter
-        char level = 0;
-        if (!text.empty())
-            level = text[0];
-        if (level >= -1 && level <= 6)
-            output = text.substr(1);
-        else
-            output = text;
+        std::string output = text;
+        int level = this->extractLogLevel(&output);
 
         // Colour line
@@ -297 +342 @@
     }
 
-    inline bool IOConsole::willPrintStatusLines()
-    {
-        return !this->statusLineWidths_.empty()
-             && this->terminalWidth_  >= this->statusLineMaxWidth_
-             && this->terminalHeight_ >= (this->minOutputLines_ + this->statusLineWidths_.size());
+    void IOConsole::setTerminalMode()
+    {
+        termios new_settings;
+
+        tcgetattr(0, this->originalTerminalSettings_);
+        new_settings = *this->originalTerminalSettings_;
+        new_settings.c_lflag &= ~(ICANON | ECHO);
+        //new_settings.c_lflag |= (ISIG | IEXTEN);
+        new_settings.c_cc[VTIME] = 0;
+        new_settings.c_cc[VMIN]  = 0;
+        tcsetattr(0, TCSANOW, &new_settings);
+    }
+
+    void IOConsole::resetTerminalMode()
+    {
+        tcsetattr(0, TCSANOW, IOConsole::originalTerminalSettings_);
     }
 
@@ -333 +389 @@
     }
 
-#elif defined(ORXONOX_PLATFORM_WINDOWS)
-
-    IOConsole::IOConsole()
-        : shell_(new Shell("IOConsole", false))
-        , buffer_(shell_->getInputBuffer())
-    {
-        this->setTerminalMode();
-    }
-
-    IOConsole::~IOConsole()
-    {
-    }
-
-    void IOConsole::setTerminalMode()
-    {
-    }
-
-    void IOConsole::resetTerminalMode()
-    {
-    }
-
-    void IOConsole::update(const Clock& time)
-    {
-    }
-
-    void IOConsole::printLogText(const std::string& text)
-    {
-    }
-
-    void IOConsole::printInputLine()
-    {
-    }
-
-    void IOConsole::printStatusLines()
-    {
-    }
-
-#endif /* ORXONOX_PLATFORM_UNIX */
-
     // ###############################
     // ###  ShellListener methods  ###
     // ###############################
 
-    /**
-    @brief
-        Called if all output-lines have to be redrawn.
-    */
-    void IOConsole::linesChanged()
-    {
-        // Method only gets called upon start to draw all the lines
-        // But we are using std::cout anyway, so do nothing here
-    }
-
-    /**
-    @brief
-        Called if only the last output-line has changed.
-    */
+    //! Called if only the last output-line has changed
     void IOConsole::onlyLastLineChanged()
     {
@@ -403 +407 @@
     }
 
-    /**
-    @brief
-        Called if a new output-line was added.
-    */
+    //! Called if a new output-line was added
     void IOConsole::lineAdded()
     {
@@ -429 +430 @@
         std::cout.flush();
     }
-
-    /**
-    @brief
-        Called if the text in the input-line has changed.
-    */
-    void IOConsole::inputChanged()
-    {
-        this->printInputLine();
-        std::cout.flush();
-    }
-
-    /**
-    @brief
-        Called if the position of the cursor in the input-line has changed.
-    */
-    void IOConsole::cursorChanged()
-    {
-        this->printInputLine();
-        std::cout.flush();
-    }
-
-    /**
-    @brief
-        Called if a command is about to be executed
-    */
-    void IOConsole::executed()
-    {
-        this->shell_->addOutputLine(this->promptString_ + this->shell_->getInput());
-    }
-
-
-    /**
-    @brief
-        Called if the console gets closed.
-    */
-    void IOConsole::exit()
-    {
-        // Exit is not an option, IOConsole always exists
-    }
-
 }
+
+#elif defined(ORXONOX_PLATFORM_WINDOWS)
+// ##################################
+// ###   Windows Implementation   ###
+// ##################################
+
+namespace orxonox
+{
+    IOConsole::IOConsole()
+        : shell_(new Shell("IOConsole", false, true))
+        , buffer_(shell_->getInputBuffer())
+        , bStatusPrinted_(false)
+        , promptString_("orxonox # ")
+    {
+/*
+        this->setTerminalMode();
+        this->shell_->registerListener(this);
+
+        // Manually set the widths of the individual status lines
+        this->statusLineWidths_.push_back(29);
+        this->statusLineMaxWidth_ = 29;
+
+        this->getTerminalSize();
+        this->lastTerminalWidth_ = this->terminalWidth_;
+        this->lastTerminalHeight_ = this->terminalHeight_;
+
+        // Disable standard std::cout logging
+        OutputHandler::getInstance().disableCout();
+*/
+    }
+
+    IOConsole::~IOConsole()
+    {
+/*
+        resetTerminalMode();
+        this->shell_->destroy();
+
+        // Enable standard std::cout logging again
+        OutputHandler::getInstance().enableCout();
+*/
+    }
+
+    void IOConsole::update(const Clock& time)
+    {
+/*
+        unsigned char c = 0;
+        while (std::cin.good())
+        {
+            c = std::cin.get();
+            if (std::cin.bad())
+                break;
+        }
+        // Reset error flags in std::cin
+        std::cin.clear();
+
+        // Determine terminal width and height
+        this->lastTerminalWidth_ = this->terminalWidth_;
+        this->lastTerminalHeight_ = this->terminalHeight_;
+        this->getTerminalSize();
+*/
+    }
+
+    void IOConsole::printLogText(const std::string& text)
+    {
+    }
+
+    void IOConsole::printInputLine()
+    {
+    }
+
+    void IOConsole::printStatusLines()
+    {
+/*
+        if (this->willPrintStatusLines())
+        {
+            this->bStatusPrinted_ = true;
+        }
+        else
+            this->bStatusPrinted_ = false;
+*/
+    }
+
+    void IOConsole::setTerminalMode()
+    {
+    }
+
+    void IOConsole::resetTerminalMode()
+    {
+    }
+
+    void IOConsole::getTerminalSize()
+    {
+    }
+
+    // ###############################
+    // ###  ShellListener methods  ###
+    // ###############################
+
+    //! Called if only the last output-line has changed
+    void IOConsole::onlyLastLineChanged()
+    {
+    }
+
+    //! Called if a new output-line was added
+    void IOConsole::lineAdded()
+    {
+    }
+}
+
+#endif /* ORXONOX_PLATFORM_UNIX */

code/branches/console/src/libraries/core/IOConsole.h

@@ -33 +33 @@
 #include "CorePrereqs.h"
 
-#include <queue>
-#include <boost/scoped_ptr.hpp>
+#include <string>
+#include <vector>
 #include "util/Singleton.h"
 #include "core/Shell.h"
 
+#ifdef ORXONOX_PLATFORM_UNIX
 struct termios;
+#endif
 
 namespace orxonox
@@ -53 +55 @@
 
     private:
-
         void setTerminalMode();
         void resetTerminalMode();
         void getTerminalSize();
         bool willPrintStatusLines();
+        int extractLogLevel(std::string* text);
 
         void printLogText(const std::string& line);
@@ -71 +73 @@
         void executed();
         void exit();
-
         Shell*                  shell_;
         InputBuffer*            buffer_;
-        termios*                originalTerminalSettings_;
         unsigned int            terminalWidth_;
         unsigned int            terminalHeight_;
@@ -86 +86 @@
         static const unsigned   minOutputLines_ = 3;
 
+#ifdef ORXONOX_PLATFORM_UNIX
+        termios*                originalTerminalSettings_;
+#endif
+
         static IOConsole* singletonPtr_s;
     };

code/branches/console/src/libraries/util/OutputHandler.cc

@@ -118 +118 @@
         std::ofstream logFile_;     //! File handle for the log file
         std::string   logFilename_; //! Filename of the log file
+    };
+
+
+    /////////////////////////
+    ///// ConsoleWriter /////
+    /////////////////////////
+    /**
+    @brief
+        Writes the output to std::cout.
+    @note
+        This listener will usually be disable once an actual shell with console is instantiated.
+    */
+    class ConsoleWriter : public OutputListener
+    {
+    public:
+        //! Only assigns the output stream with std::cout
+        ConsoleWriter()
+            : OutputListener("consoleLog")
+        {
+            this->outputStream_ = &std::cout;
+        }
     };
 
@@ -176 +197 @@
         : outputLevel_(OutputLevel::Verbose)
     {
+#ifdef ORXONOX_RELEASE
+        const OutputLevel::Value defaultLevelConsole = OutputLevel::Error;
+        const OutputLevel::Value defaultLevelLogFile = OutputLevel::Info;
+#else
+        const OutputLevel::Value defaultLevelConsole = OutputLevel::Info;
+        const OutputLevel::Value defaultLevelLogFile = OutputLevel::Debug;
+#endif
+
         this->logFile_ = new LogFileWriter();
         // Use default level until we get the configValue from the Core
-        this->logFile_->softDebugLevel_ = OutputLevel::Debug;
+        this->logFile_->softDebugLevel_ = defaultLevelLogFile;
         this->registerOutputListener(this->logFile_);
+
+        this->consoleWriter_ = new ConsoleWriter();
+        this->consoleWriter_->softDebugLevel_ = defaultLevelConsole;
+        this->registerOutputListener(this->consoleWriter_);
 
         this->output_  = new MemoryLogWriter();
@@ -225 +258 @@
     }
 
+    void OutputHandler::disableCout()
+    {
+        this->unregisterOutputListener(this->consoleWriter_);
+    }
+
+    void OutputHandler::enableCout()
+    {
+        this->registerOutputListener(this->consoleWriter_);
+    }
+
     OutputHandler::OutputVectorIterator OutputHandler::getOutputVectorBegin() const
     {

code/branches/console/src/libraries/util/OutputHandler.h

@@ -74 +74 @@
     // Forward declarations for classes in the source file
     class LogFileWriter;
+    class ConsoleWriter;
     class MemoryLogWriter;
 
@@ -129 +130 @@
             //! Set the log path once the program has been properly initialised
             void setLogPath(const std::string& path);
+            //! Disables the std::cout stream for output
+            void disableCout();
+            //! Enables the std::cout stream for output (startup behaviour)
+            void enableCout();
 
             //! Sets the level of the incoming output and returns the OutputHandler
@@ -210 +215 @@
             OutputHandler(const OutputHandler& rhs); //! Unused and undefined
 
-            std::list<OutputListener*> listeners_; //!< Array with all registered output listeners
-            int outputLevel_;                      //!< The level of the incoming output
-            LogFileWriter* logFile_;               //!< Listener that writes to the log file
-            MemoryLogWriter* output_;              //!< Listener that Stores ALL output below the current soft debug level
-            static int softDebugLevel_s;           //!< Maximum of all soft debug levels. @note This is only static for faster access
+            std::list<OutputListener*> listeners_;        //!< Array with all registered output listeners
+            int                        outputLevel_;      //!< The level of the incoming output
+            LogFileWriter*             logFile_;          //!< Listener that writes to the log file
+            ConsoleWriter*             consoleWriter_;    //!< Listener for std::cout (just program beginning)
+            MemoryLogWriter*           output_;           //!< Listener that Stores ALL output below the current soft debug level
+            static int                 softDebugLevel_s;  //!< Maximum of all soft debug levels. @note This is only static for faster access
     };
 

code/branches/console/src/orxonox/overlays/InGameConsole.cc

@@ -336 +336 @@
 
     /**
+        @brief Called if a command is about to be executed
+    */
+    void InGameConsole::executed()
+    {
+        this->shell_->addOutputLine(this->shell_->getInput());
+    }
+
+    /**
         @brief Called if the console gets closed.
     */

code/branches/console/src/orxonox/overlays/InGameConsole.h

@@ -68 +68 @@
         void inputChanged();
         void cursorChanged();
+        void executed();
         void exit();