/cygdrive/d/src/svn/vrut/trunk/core/src/iomodule.h

Go to the documentation of this file.

/*
 * $Id: iomodule.h 672 2009-01-16 08:34:17Z misek $
 *
 * Description  : One line description of file.
 * Author       : Vaclav Kyba <mail/Jabber: vaseo1@gmail.com>  <ICQ: 98576293>
 *
 * Purpose      :
 *     Long description of what the file is for.
 */


#ifndef __IOMODULE__H__
#define __IOMODULE__H__

#include <wx/archive.h>
#include <wx/wfstream.h>
#include "scenemodule.h"
#include "common.h"

namespace VRUT
{
       class IOModule : public SceneModule
       {
       protected:
              virtual void processEvent(wxCommandEvent & evt)
              {
                     SceneModule::processEvent(evt);
                     switch (evt.GetEventType())
                     {
                     case Event::EVT_IO_SCENE_IMPORT_DO:
                            {
                                   SCENE_ID _sceneID = SCENE_ID(evt.GetId());
                                   Scene * scene = GetSceneMgr()->GetScene(_sceneID);
                                   if (scene)
                                   {
                                          const SceneNode * root = scene->GetNode(NODE_ID(evt.GetInt()));
                                          if (root)
                                          {
                                                 wxCommandEvent evCache = Event::GET_EVT_RENDER_CACHE_START(_sceneID);
                                                 PostToKernel(evCache);
                                                 ImportScene(evt.GetString(), _sceneID, root->GetUid());
                                          }
                                          else
                                                 LOGERROR(wxT("<IOModule>Invalid root node to start import"));
                                   }
                                   else
                                          LOGERROR(wxT("<IOModule>Invalid scene defined to start import"));
                            }
                            break;
                     default:
                            break;
                     }
              }

       public:
              IOModule(const MODULE_ID & _id, const wxString & _name, unsigned _type, EventHandler * msgSink)
                            : SceneModule(_id, _name, (_type | MODULE_TYPE_IO ), msgSink)
              {
                     REGISTER_LISTENER(Event::EVT_IO_SCENE_IMPORT_DO);
                     wxCommandEvent evt = Event::GET_EVT_PARAM_GUIUNREGISTER(Parameter::ParameterIdentificator(_name, wxT("*"), _id));
                     PostToKernel(evt);
              }
              virtual ~IOModule()     {}

              virtual wxString GetSupportedExts() const = 0;
              static wxInputStream * GetInputStream(const wxString & fname)
              {
                     wxFileName wxFname(fname);
                     if (!wxFname.FileExists())
                     {
                            LOGERROR(wxT("<IOModule>File '") + fname + wxT("' not found"));
                            return (wxInputStream *)NULL;
                     }

                     wxInputStream * sceneStream = new wxFileInputStream(wxFname.GetFullPath());

                     const wxFilterClassFactory * ffactory = wxFilterClassFactory::Find(wxFname.GetFullName(), wxSTREAM_FILEEXT);
                     if (ffactory)
                     {
                            sceneStream = ffactory->NewStream(sceneStream);
                            wxFname.SetFullName(ffactory->PopExtension(wxFname.GetFullName()));
                     }

                     const wxArchiveClassFactory * afactory = wxArchiveClassFactory::Find(wxFname.GetFullName(), wxSTREAM_FILEEXT);
                     if (afactory)
                     {
                            sceneStream = afactory->NewStream(sceneStream);
                            if (sceneStream)
                            {
                                   wxArchiveEntry * entry(((wxArchiveInputStream *)sceneStream)->GetNextEntry());
                                   if (entry)
                                   {
                                          wxFname = wxFileName(entry->GetInternalName());
                                          ((wxArchiveInputStream *)sceneStream)->CloseEntry();
                                          delete entry;
                                   }
                            }
                     }

                     if (!sceneStream || !sceneStream->IsOk())
                     {
                            LOGERROR(wxT("<IOModule>File '") + fname + wxT("' cannot be read"));
                            SAFE_DELETE(sceneStream);
                            return (wxInputStream *)NULL;
                     }

                     return sceneStream;
              }
              virtual bool ImportScene(const wxString & fname, SCENE_ID _sceneID, const wxString & rootUid) = 0;
              virtual bool ExportScene(const wxString & fname, const Scene * scene) = 0;
       };
};


#endif

---