/home/sspr/src/www/orocos-1.0/export/build/orocos-ocl-1.4.0/taskbrowser/TaskBrowser.hpp

/***************************************************************************
  tag: Peter Soetens  Tue Dec 21 22:43:08 CET 2004  TaskBrowser.hpp 

                        TaskBrowser.hpp -  description
                           -------------------
    begin                : Tue December 21 2004
    copyright            : (C) 2004 Peter Soetens
    email                : peter.soetens@mech.kuleuven.ac.be
 
 ***************************************************************************
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Lesser General Public            *
 *   License as published by the Free Software Foundation; either          *
 *   version 2.1 of the License, or (at your option) any later version.    *
 *                                                                         *
 *   This library is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place,                                    *
 *   Suite 330, Boston, MA  02111-1307  USA                                *
 *                                                                         *
 ***************************************************************************/
 
 
#ifndef ORO_TASKBROWSER_HPP
#define ORO_TASKBROWSER_HPP
 

#include <rtt/RTT.hpp>
#include <rtt/TaskContext.hpp>
#include "rtt/OperationInterface.hpp"
#include "rtt/DispatchInterface.hpp"
#include <deque>
#include <string>
#include <sstream>
#include <vector>


#include <ocl/OCL.hpp>

namespace OCL
{
    class TaskBrowser
        : public RTT::TaskContext
    {
        // the 'current' task context
        static RTT::TaskContext* taskcontext;
        // the TC we are using for completion.
        static RTT::TaskContext* peer;
        // the TaskBrowser
        static RTT::TaskContext* tb;
        // the current Context: is tb or taskcontext
        static RTT::TaskContext* context;
        static RTT::OperationInterface* taskobject;
        RTT::ConditionInterface* condition;
        RTT::DispatchInterface*   command;
        RTT::DataSource<bool>::shared_ptr   accepted;

        int debug;
        /* A static variable for holding the line. */
        char *line_read;
        int lastc; // last command's number

        std::string storedname; 
        int storedline; 

        std::deque<TaskContext*> taskHistory;

        // store TC + program/state name + line number
        typedef std::map<std::pair<TaskContext*,std::string>,int> PTrace;
        PTrace ptraces;
        PTrace straces;

        /* Read a string, and return a pointer to it.
           Returns NULL on EOF. */
        char *rl_gets ();

        // use this vector to generate candidate strings
        static std::vector<std::string> candidates;
        // Add successful matches of candidate strings to completes.
        static std::vector<std::string> completes;
        static std::vector<std::string>::iterator complete_iter;

        static std::string component;
        static std::string object;
        static std::string peerpath;
        static std::string method;
        static std::string datasource;
        static std::string text;

        // helper function
        static char* dupstr( const char *s );

        static RTT::TaskContext* findPeer( std::string comm );

        static void find_completes();
        
        static void find_ops();
        static void find_peers(std::string::size_type startpos);

        static char ** orocos_hmi_completion ( const char *text, int start, int end );

        static char *command_generator( const char *_text, int state );

    protected:

        void listText(std::stringstream& txtss,int start, int end, int ln, char s);

        void doPrint( RTT::DataSourceBase* ds, bool recurse);

        void enterTask();
        void leaveTask();

        bool macrorecording;
        std::string macrotext;
        std::string macroname;
        void recordMacro(std::string name);
        void cancelMacro();
        void endMacro();

        void checkPorts();
    public:

        enum ColorTheme { nocolors, 
                          darkbg, 
                          whitebg  
        };

        void setColorTheme( ColorTheme t );

        void switchTaskContext(std::string& path);

        void switchTaskContext( RTT::TaskContext* tc, bool store = true);

        void switchBack();

        void browserAction(std::string& act );

        void printResult( RTT::DataSourceBase* ds, bool recurse);

        void printHelp();
        
        void printInfo(const std::string& peerpath);
        
        void printCommand( const std::string c, OperationInterface* ops );
                
        void printSource( const std::string m );
                
        void printMethod( const std::string m, OperationInterface* ops );

        void printEvent( const std::string m, RTT::EventService* ops );

        void printProgram( const std::string& pn, int line = -1, TaskContext* progpeer = 0 );

        void printProgram( int line = -1 );

        TaskBrowser( RTT::TaskContext* c );

        ~TaskBrowser();

        void loop();

        void evaluate(std::string& comm );

        void switchTask( RTT::TaskContext* c);

        static std::string prompt;
        static std::string coloron;
        static std::string underline;
        static std::string coloroff;

        static std::string red;

        static std::string green;

        static std::string blue;

        void evalCommand(std::string& comm );


    };

}

#endif

---