D:/SoftwareEntwicklung/C++/HLC/Tools/SoftPixelEngine/repository/sources/Framework/Tools/spUtilityCommandLine.hpp

Go to the documentation of this file.

/*
 * Command line header
 * 
 * This file is part of the "SoftPixel Engine" (Copyright (c) 2008 by Lukas Hermanns)
 * See "SoftPixelEngine.hpp" for license information.
 */

#ifndef __SP_UTILITY_COMMANDLINE_H__
#define __SP_UTILITY_COMMANDLINE_H__


#include "Base/spStandard.hpp"

#ifdef SP_COMPILE_WITH_COMMANDLINE


#include "Base/spInputOutputControl.hpp"
#include "Base/spTimer.hpp"
#include "Base/spMaterialConfigTypes.hpp"
#include "Base/spInputOutputString.hpp"
#include "Base/spBaseExceptions.hpp"
#include "RenderSystem/spRenderSystemFont.hpp"
#include "Framework/Tools/spUtilityCommandLineTasks.hpp"


namespace sp
{
namespace tool
{


enum ECommandLineFlags
{
    CMDFLAG_SCROLL          = 0x01, 
    CMDFLAG_MEMENTO         = 0x02, 
    CMDFLAG_DISABLE_INPUT   = 0x04, 
    
    CMDFLAG_COMMON =
        CMDFLAG_SCROLL |
        CMDFLAG_MEMENTO,            
};


class SP_EXPORT CommandLineUI
{
    
    public:
        
        CommandLineUI() throw(io::RenderSystemException, io::stringc);
        virtual ~CommandLineUI();
        
        /* === Functions === */
        
        virtual void render(s32 Flags = CMDFLAG_COMMON);
        
        virtual void draw(s32 Flags = CMDFLAG_COMMON);
        
        virtual void updateInput(s32 Flags = CMDFLAG_COMMON);
        
        virtual void updateScrollInput(s32 DefaultScrollSpeed = 3);
        
        virtual void message(const io::stringc &Message, const video::color &Color = 255, u32 NewLineTab = 0);
        virtual void warning(const io::stringc &Message);
        virtual void error(const io::stringc &Message);
        
        virtual void unknown(const io::stringc &Command);
        virtual void confirm(const io::stringc &Output);
        
        virtual void image(video::Texture* Image);
        
        virtual bool executeCommand(const io::stringc &Command);
        
        void setupCursorTimer(u64 IntervalDuration);
        
        bool execute(const io::stringc &Command);
        
        virtual void clear(bool isHelpInfo = true);
        
        bool isScrollingEnabled() const;
        virtual bool scroll(s32 Direction);
        virtual bool scrollPage(s32 Direction);
        virtual void scrollStart();
        virtual void scrollEnd();
        
        void setScrollPosition(s32 Pos);
        s32 getMaxScrollPosition() const;
        s32 getScrollPage() const;
        
        void setFont(video::Font* FontObj);
        
        bool getCmdParam(const io::stringc &Command, io::stringc &Param);
        
        /* === Inline functions === */
        
        inline video::Font* getFont() const
        {
            return ActiveFont_;
        }
        inline video::Font* getOrigFont() const
        {
            return OrigFont_;
        }
        
        inline s32 getScrollPosition() const
        {
            return Scroll_;
        }
        
        inline void setBackgroundColor(const video::color &Color)
        {
            BgColor_ = Color;
        }
        inline video::color getBackgroundColor() const
        {
            return BgColor_;
        }
        
        inline void setForegroundColor(const video::color &Color)
        {
            FgColor_ = Color;
        }
        inline video::color getForegroundColor() const
        {
            return FgColor_;
        }
        
        inline void setRect(const dim::rect2di &Rect)
        {
            Rect_ = Rect;
        }
        inline dim::rect2di getRect() const
        {
            return Rect_;
        }
        
        inline void setLineLimit(u32 Limit)
        {
            MaxLines_ = Limit;
        }
        inline u32 getLineLimit() const
        {
            return MaxLines_;
        }
        
        inline void setMementoLimit(u32 Limit)
        {
            Memento_.Limit = Limit;
        }
        inline u32 getMementoLimit() const
        {
            return Memento_.Limit;
        }
        
        inline void blank()
        {
            message("");
        }
        
    protected:
        
        /* === Macros === */
        
        static const s32 TEXT_DISTANCE;
        static const s32 SCROLLBAR_WIDTH;
        static const s32 SCROLLBAR_DISTANCE;
        
        /* === Structures === */
        
        struct SP_EXPORT STextLine
        {
            STextLine();
            STextLine(video::Font* LineFont, const io::stringc &LineText, const video::color &LineColor = 255);
            STextLine(video::Texture* LineImage);
            ~STextLine();
            
            /* Functions */
            s32 getHeight() const;
            
            void draw(
                const dim::point2di &Origin, const dim::size2di &MaxLineSize,
                s32 &PosVert, f32 TransBgOffset
            ) const;
            
            /* Members */
            video::Font* TextFont;
            video::Texture* Image;
            io::stringc Text;
            video::color Color;
        };
        
        struct SP_EXPORT SCursor
        {
            SCursor();
            ~SCursor();
            
            /* Functions */
            void update();
            
            /* Members */
            io::Timer IntervalTimer;
            bool isVisible;
        };
        
        struct SP_EXPORT SMemento
        {
            SMemento();
            ~SMemento();
            
            /* Functions */
            void push(const io::stringc &Command);
            
            void up(io::stringc &Str);
            void down(io::stringc &Str);
            
            /* Members */
            u32 Limit;
            std::list<io::stringc> Commands;
            std::list<io::stringc>::iterator Current;
        };
        
        struct SP_EXPORT SCommand
        {
            SCommand();
            ~SCommand();
            
            /* Operators */
            bool operator < (const SCommand &Other) const;
            
            /* Members */
            io::stringc Name, Docu;
        };
        
        /* === Functions === */
        
        virtual void drawBackground();
        virtual void drawTextLines();
        virtual void drawCursor();
        virtual void drawScrollbar();
        
        virtual void drawTextLine(s32 &PosVert, const STextLine &Line);
        
        virtual void addHelpLine(const io::stringc &Command, const io::stringc &Description);
        virtual void printHelpLines(c8 SeparationChar = '.', u32 MinSeparationChars = 3);
        
        virtual bool findAutoCompletion(io::stringc &Command);
        
        void registerCommand(const io::stringc &Name, const io::stringc &Docu);
        
        void addNewLine(const STextLine &Line);
        void addNewLine(const io::stringc &Message, const video::color &Color);
        
        /* === Members === */
        
        video::color BgColor_, FgColor_;
        dim::rect2di Rect_;
        
        SCursor Cursor_;
        SMemento Memento_;
        
        u32 MaxLines_;
        s32 Scroll_;
        
        std::vector<STextLine> TextLines_;
        std::vector<SCommand> RegisteredCommands_;
        
        io::stringc CommandLine_;
        
    private:
        
        /* === Structures === */
        
        struct SHelpLine
        {
            io::stringc Command;
            io::stringc Description;
        };
        
        /* === Functions === */
        
        s32 getMaxScrollPosition(s32 TextHeight, s32 VisibleHeight) const;
        
        void clampScrolling(s32 TextHeight, s32 VisibleHeight);
        void clampScrolling();
        
        void getScrollingRange(s32 &TextHeight, s32 &VisibleHeight) const;
        
        void registerDefaultCommands();
        
        /* === Members === */
        
        video::Font* ActiveFont_;
        video::Font* OrigFont_;
        
        s32 TextLineHeight_;
        f32 TransBgOffset_;
        
        std::list<SHelpLine> TempHelpLines_;
        u32 MaxHelpCommand_;
        
};


} // /namespace tool

} // /namespace sp


#endif

#endif



// ================================================================================