Ryzom

IF(WITH_QT)

  ADD_SUBDIRECTORY(georges_editor_qt)

ENDIF(WITH_QT)

#-----------------------------------------------------------------------------

#

#   Georges Editor Qt

#   Copyright (C) 2010 Adrian J?kel <aj at elane2k dot com>

#

#-----------------------------------------------------------------------------

# This tells the application(s) where to find the installed data.

ADD_DEFINITIONS(-DDATA_DIR="\\"${NL_SHARE_PREFIX}/georges_editor_qt/\\"")

ADD_SUBDIRECTORY(src)

INSTALL(DIRECTORY data/

        DESTINATION share/georges_editor_qt/data

        COMPONENT data

        PATTERN "CVS" EXCLUDE

        PATTERN ".svn" EXCLUDE

        PATTERN "Makefile*" EXCLUDE)

RootConfigFilename   = "georges_editor_default.cfg";

SearchPaths          = {

	"G:/ryzom_assets/ryzom_assets/Stuff/Matis", "G:/ryzom_assets/bnps/characters_shapes" 

};

GraphicsDriver       = "OpenGL";

BackgroundColor      = {

	173, 205, 234 

};

LeveldesignPath      = "D:/Dev/Ryzom/code/ryzom/common/data_leveldesign/leveldesign";

QtWindowState        = "%00%00%00%FF%00%00%00%00%FD%00%00%00%03%00%00%00%00%00%00%02%A6%00%00%00%E9%FC%02%00%00%00%01%FB%00%00%00%2A%00C%00G%00e%00o%00r%00g%00e%00s%00D%00i%00r%00T%00r%00e%00e%00D%00i%00a%00l%00o%00g%01%00%00%00%3B%00%00%00%E9%00%00%00t%00%FF%FF%FF%00%00%00%02%00%00%00%00%00%00%00%00%FC%01%00%00%00%01%FB%00%00%00%26%00C%00O%00b%00j%00e%00c%00t%00V%00i%00e%00w%00e%00r%00D%00i%00a%00l%00o%00g%00%00%00%00%00%FF%FF%FF%FF%00%00%00N%00%FF%FF%FF%00%00%00%03%00%00%02%A6%00%00%01c%FC%01%00%00%00%01%FB%00%00%00%22%00C%00G%00e%00o%00r%00g%00e%00s%00L%00o%00g%00D%00i%00a%00l%00o%00g%01%00%00%00%00%00%00%02%A6%00%00%00%5D%00%FF%FF%FF%00%00%00%00%00%00%00%E9%00%00%00%04%00%00%00%04%00%00%00%08%00%00%00%08%FC%00%00%00%01%00%00%00%02%00%00%00%01%FF%FF%FF%FF%01%00%00%00%00%FF%FF%FF%FF%00%00%00%00%00%00%00%00";

QtWindowGeometry     = "%01%D9%D0%CB%00%01%00%00%00%00%00%D6%00%00%00%C0%00%00%03%83%00%00%03%82%00%00%00%DA%00%00%00%DE%00%00%03%7F%00%00%03~%00%00%00%00%00%00";

//////////////////////////////////////////////////////////////////////////////

// Config file for Georges Editor Qt ////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////

//

// This file is used to setup the georges editor tool.

//

//////////////////////////////////////////////////////////////////////////////

// NeL Qt ////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////

// Root directory where we can find the client datas (zones, tiles, maps, ...)

// You must uncomment this line on GNU/Linux and comment the next one

//SearchPaths = { "/usr/local/share/games/nel_qt/" };

SearchPaths = { "data" };

LeveldesignPath = "";

// Which extensions to remap to what if needed (pairs of 2)

RemapExtensions = { "png", "tga" };

// The language code of the client

LanguageCode = "en";

// If changes to the config should be saved on exit

SaveConfig = 1;

//////////////////////////////////////////////////////////////////////////////

// Qt ////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////

QtStyle = "Cleanlooks";

QtPalette = 0;

QtWindowState        = "";

QtWindowGeometry     = "";

//////////////////////////////////////////////////////////////////////////////

// Graphics //////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////

// Use OpenGL or Direct3D (Windows)

GraphicsEnabled = 1;

GraphicsDrivers = { "OpenGL", "Direct3D" };

GraphicsDriver = "OpenGL";

// Font name used for all text in the client (it can be a .ttf, .fon, .pfb)

FontName = "andbasr.ttf";

FontShadow = 1;

// Background color

BackgroundColor = { 151, 156, 182 };

SunDirection = { -2.935, +0.107, -1.22 };

SunAmbient = { 190, 170, 150 };

SunDiffuse = { 255, 248, 255 };

SunSpecular = { 255, 255, 255};

//////////////////////////////////////////////////////////////////////////////

// Time //////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////

FpsSmoothing = 64;

//////////////////////////////////////////////////////////////////////////////

// Interface /////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////

// This setting is used to bind keys to actions.

//  "key_handler", "args", "***", "Key1|Key2", 

//                          *** -> CTRL, SHIFT, ALT don't matter

//                          --- -> CTRL, SHIFT, ALT must all be disabled

//                          -+- -> only SHIFT must be down

KeySettings = {

	"screenshot", "", "***", "KeyF5", 

	"command", "set_state Exit", "-+-", "KeyESCAPE", 

	"command", "set_state Login", "+--", "KeyESCAPE", 

	"command", "set_state Unload", "***", "KeyF8", 

	"command", "set_state Demo", "***", "KeyF7", 

	"move_forward", "", "***", "KeyUP|KeyZ|KeyW", 

	"move_backward", "", "***", "KeyDOWN|KeyS", 

	"move_left", "", "***", "KeyLEFT|KeyQ|KeyA", 

	"move_right", "", "***", "KeyRIGHT|KeyD", 

	"move_forward", "", "***", "KeyZ|KeyW", 

	"move_backward", "", "***", "KeyS", 

	"move_left", "", "***", "KeyQ|KeyA", 

	"move_right", "", "***", "KeyD", 

	"chat_begin", "", "***", "KeyT", 

	"chat_send", "", "***", "KeyENTER", 

	"chat_leave", "", "***", "KeyESCAPE", 

	"display_test", "", "***", "KeyTAB", 

	"send_action", "0", "---", "Key1", 

	"send_action", "1", "---", "Key2", 

	"send_action", "2", "---", "Key3", 

	"send_action", "3", "---", "Key4", 

	"send_action", "4", "---", "Key5", 

	"send_action", "5", "---", "Key6", 

	"send_action", "6", "---", "Key7", 

	"send_action", "7", "---", "Key8", 

	"send_action", "8", "---", "Key9", 

	"send_action", "9", "---", "Key0", 

	"demo_crystal_spawn", "", "---", "KeyO", 

	"demo_crystal_explode", "", "---", "KeyP", 

	"free_camera_forward", "", "---", "KeyNUMPAD8", 

	"free_camera_backward", "", "---", "KeyNUMPAD2", 

	"free_camera_left", "", "---", "KeyNUMPAD4", 

	"free_camera_right", "", "---", "KeyNUMPAD6", 

	"switch_camera", "", "---", "KeyF4", 

	"switch_ui_visible" ,"", "---", "KeyF6", 

};

// end of file

INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_SOURCE_DIR} ${LIBXML2_INCLUDE_DIR} ${NEL_INCLUDE_DIR} ${QT_INCLUDES})

INCLUDE( ${QT_USE_FILE} )

FILE(GLOB GEORGES_EDITOR_SRC *.cpp)

SET(GEORGES_EDITOR_HDR georges_dirtree_dialog.h georges_treeview_dialog.h georgesform_model.h main_window.h

	log_dialog.h objectviewer_dialog.h settings_dialog.h)

SET(GEORGES_EDITOR_UIS settings_form.ui objectviewer_form.ui log_form.ui georges_treeview_form.ui georges_dirtree_form.ui)

SET(GEORGES_EDITOR_RCS georges_editor_qt.qrc)

SET(QT_USE_QTGUI TRUE)

SET(QT_USE_QTOPENGL TRUE)

QT4_ADD_RESOURCES( GEORGES_EDITOR_RC_SRCS ${GEORGES_EDITOR_RCS} )

QT4_WRAP_CPP( GEORGES_EDITOR_MOC_SRCS ${GEORGES_EDITOR_HDR} )

QT4_WRAP_UI( GEORGES_EDITOR_UI_HDRS ${GEORGES_EDITOR_UIS} )

ADD_EXECUTABLE(georges_editor_qt WIN32 ${GEORGES_EDITOR_SRC} ${GEORGES_EDITOR_MOC_SRCS} ${GEORGES_EDITOR_RC_SRCS} ${GEORGES_EDITOR_UI_HDRS})

TARGET_LINK_LIBRARIES(georges_editor_qt

		nelmisc 

		nel3d

		nelgeorges

		${QT_LIBRARIES}

		${QT_QTOPENGL_LIBRARY}

		${QT_QTMAIN_LIBRARY})

ADD_DEFINITIONS(-DQT_NO_KEYWORDS ${LIBXML2_DEFINITIONS} ${QT_DEFINITIONS})

NL_DEFAULT_PROPS(georges_editor_qt "Ryzom, Tools, World: Georges Editor Qt")

NL_ADD_RUNTIME_FLAGS(georges_editor_qt)

IF(WITH_PCH)

  ADD_NATIVE_PRECOMPILED_HEADER(georges_editor_qt ${CMAKE_CURRENT_SOURCE_DIR}/stdpch.h ${CMAKE_CURRENT_SOURCE_DIR}/stdpch.cpp)

ENDIF(WITH_PCH)

INSTALL(TARGETS georges_editor_qt RUNTIME DESTINATION bin COMPONENT runtime)

/* 

 * Copyright (C) 2010  by authors

 * 

 * This file is part of NEL QT.

 * NEL QT is free software: you can redistribute it and/or modify it

 * under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 2 of the License, or

 * (at your option) any later version.

 * 

 * NEL QT 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

 * General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with NEL QT; see the file COPYING.  If not, see

 * <http://www.gnu.org/licenses/>.

 */

#include <nel/misc/types_nl.h>

#include "callback.h"

namespace NLQT {

} /* namespace NLQT */

/* end of file */

/* 

 * Copyright (C) 2010  by authors

 * 

 * This file is part of NEL QT.

 * NEL QT is free software: you can redistribute it and/or modify it

 * under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 2 of the License, or

 * (at your option) any later version.

 * 

 * NEL QT 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

 * General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with NEL QT; see the file COPYING.  If not, see

 * <http://www.gnu.org/licenses/>.

 */

#ifndef NLQT_CALLBACK_H

#define NLQT_CALLBACK_H

#include <nel/misc/types_nl.h>

// STL includes

// NeL includes

#include <nel/misc/debug.h>

// Project includes

namespace NLQT {

#define NLQT_CALLBACK_TEMPLATE \

/** \

 * \brief NLQT_CALLBACK_ARGS_CLASS \

 * \date 2009-03-03 18:09GMT \

 * \author Jan Boon (Kaetemi) \

 * Awesome callback template \

 */ \

template<typename TReturn NLQT_CALLBACK_ARGS_TYPENAME> \

class NLQT_CALLBACK_ARGS_CLASS \

{ \

	/* Very simple reference counting callback base */ \

	class CCallbackBase \

	{ \

	public: \

		CCallbackBase() : m_RefCount(0) \

		{ \

			 \

		} \

		 \

		virtual ~CCallbackBase() \

		{ \

			nlassert(!m_RefCount); \

		} \

		 \

		void refAdd() \

		{ \

			++m_RefCount; \

		} \

		 \

		void refRemove() \

		{ \

			--m_RefCount; \

			if (!m_RefCount) \

				delete this; \

		} \

		 \

		virtual TReturn callback(NLQT_CALLBACK_ARGS_DECL) = 0; \

		 \

		virtual bool equals(const CCallbackBase *callbackBase) = 0; \

		 \

		/* disable copy */ \

		CCallbackBase(const CCallbackBase &); \

		CCallbackBase &operator=(const CCallbackBase &); \

		 \

	private: \

		uint m_RefCount; \

	}; \

	 \

	typedef TReturn TCallbackFunction(NLQT_CALLBACK_ARGS_DECL); \

	class CCallbackFunction : public CCallbackBase \

	{ \

	public: \

		CCallbackFunction(TCallbackFunction *callbackFunction) : m_CallbackFunction(callbackFunction) \

		{ \

			nlassert(m_CallbackFunction); \

		} \

		 \

		virtual ~CCallbackFunction() \

		{ \

			m_CallbackFunction = NULL; \

		} \

		 \

		virtual TReturn callback(NLQT_CALLBACK_ARGS_DECL) \

		{ \

			return m_CallbackFunction(NLQT_CALLBACK_ARGS_IMPL); \

		} \

		 \

		virtual bool equals(const CCallbackBase *callbackBase) \

		{ \

			const CCallbackFunction *callbackFunction = \

				dynamic_cast<const CCallbackFunction *>(callbackBase); \

			if (!callbackFunction) return false; \

			return m_CallbackFunction == callbackFunction->m_CallbackFunction; \

		} \

		 \

	private: \

		TCallbackFunction *m_CallbackFunction; \

	}; \

	 \

	template<typename TClass> \

	class CCallbackMethod : public CCallbackBase \

	{ \

		typedef TReturn (TClass::*TCallbackMethod)(NLQT_CALLBACK_ARGS_DECL); \

	public: \

		CCallbackMethod(TClass *callbackObject, TCallbackMethod callbackMethod) : m_CallbackObject(callbackObject), m_CallbackMethod(callbackMethod) \

		{ \

			nlassert(m_CallbackObject); \

			nlassert(m_CallbackMethod); \

		} \

		 \

		virtual ~CCallbackMethod() \

		{ \

			m_CallbackObject = NULL; \

			m_CallbackMethod = NULL; \

		} \

		 \

		virtual TReturn callback(NLQT_CALLBACK_ARGS_DECL) \

		{ \

			return (m_CallbackObject->*m_CallbackMethod)(NLQT_CALLBACK_ARGS_IMPL); \

		} \

		 \

		virtual bool equals(const CCallbackBase *callbackBase) \

		{ \

			const CCallbackMethod *callbackMethod = \

				dynamic_cast<const CCallbackMethod *>(callbackBase); \

			if (!callbackMethod) return false; \

			return m_CallbackObject == callbackMethod->m_CallbackObject \

				&& m_CallbackMethod == callbackMethod->m_CallbackMethod; \

		} \

		 \

	private: \

		TClass *m_CallbackObject; \

		TCallbackMethod m_CallbackMethod; \

	}; \

	 \

public: \

	CCallback() : m_CallbackBase(NULL) \

	{ \

		 \

	} \

	 \

	CCallback(TCallbackFunction *callbackFunction) : m_CallbackBase(new CCallbackFunction(callbackFunction)) \

	{ \

		nlassert(m_CallbackBase); \

		m_CallbackBase->refAdd(); \

	} \

	 \

	template<typename TClass> \

	CCallback(TClass *callbackObject, TReturn (TClass::*callbackMethod)(NLQT_CALLBACK_ARGS_DECL)) : m_CallbackBase(new CCallbackMethod<TClass>(callbackObject, callbackMethod)) \

	{ \

		nlassert(m_CallbackBase); \

		m_CallbackBase->refAdd(); \

	} \

	 \

	CCallback(const CCallback &callback) \

	{ \

		m_CallbackBase = callback.m_CallbackBase; \

		if (m_CallbackBase) \

			m_CallbackBase->refAdd(); \

	} \

	 \

	CCallback &operator=(const CCallback &callback) \

	{ \

		if (m_CallbackBase != callback.m_CallbackBase) \

		{ \

			if (m_CallbackBase) \

				m_CallbackBase->refRemove(); \

			m_CallbackBase = callback.m_CallbackBase; \

			if (m_CallbackBase) \

				m_CallbackBase->refAdd(); \

		} \

		return *this; \

	} \

	 \

	~CCallback() \

	{ \

		if (m_CallbackBase) \

		{ \

			m_CallbackBase->refRemove(); \

			m_CallbackBase = NULL; \

		} \

	} \

	 \

	TReturn callback(NLQT_CALLBACK_ARGS_DECL) \

	{ \

		nlassert(m_CallbackBase); \

		return m_CallbackBase->callback(NLQT_CALLBACK_ARGS_IMPL); \

	} \

	 \

	TReturn operator()(NLQT_CALLBACK_ARGS_DECL) \

	{ \

		nlassert(m_CallbackBase); \

		return m_CallbackBase->callback(NLQT_CALLBACK_ARGS_IMPL); \

	} \

	 \

	bool valid() const \

	{ \

		return m_CallbackBase != NULL; \

	} \

	 \

	operator bool() const \

	{ \

		return m_CallbackBase != NULL; \

	} \

	 \

	bool operator==(const CCallback &callback) \

	{ \

		return m_CallbackBase->equals(callback.m_CallbackBase); \

	} \

	 \

private: \

	CCallbackBase *m_CallbackBase; \

	 \

}; /* class CCallback */ \

template<typename TReturn, typename TArgsA = void, typename TArgsB = void, typename TArgsC = void, typename TArgsD = void, typename TArgsE = void, typename TArgsF = void, typename TArgsG = void, typename TDummy = void>

class CCallback;

#define NLQT_CALLBACK_ARGS_CLASS CCallback<TReturn, void, void, void, void, void, void, void, void>

#define NLQT_CALLBACK_ARGS_TYPENAME 

#define NLQT_CALLBACK_ARGS_DECL 

#define NLQT_CALLBACK_ARGS_IMPL 

NLQT_CALLBACK_TEMPLATE

#undef NLQT_CALLBACK_ARGS_CLASS

#undef NLQT_CALLBACK_ARGS_TYPENAME

#undef NLQT_CALLBACK_ARGS_DECL

#undef NLQT_CALLBACK_ARGS_IMPL

#define NLQT_CALLBACK_ARGS_CLASS CCallback<TReturn, TArgsA, void, void, void, void, void, void, void>

#define NLQT_CALLBACK_ARGS_TYPENAME , typename TArgsA

#define NLQT_CALLBACK_ARGS_DECL TArgsA argsA

#define NLQT_CALLBACK_ARGS_IMPL argsA

NLQT_CALLBACK_TEMPLATE

#undef NLQT_CALLBACK_ARGS_CLASS

#undef NLQT_CALLBACK_ARGS_TYPENAME

#undef NLQT_CALLBACK_ARGS_DECL

#undef NLQT_CALLBACK_ARGS_IMPL

#define NLQT_CALLBACK_ARGS_CLASS CCallback<TReturn, TArgsA, TArgsB, void, void, void, void, void, void>

#define NLQT_CALLBACK_ARGS_TYPENAME , typename TArgsA, typename TArgsB

#define NLQT_CALLBACK_ARGS_DECL TArgsA argsA, TArgsB argsB

#define NLQT_CALLBACK_ARGS_IMPL argsA, argsB

NLQT_CALLBACK_TEMPLATE

#undef NLQT_CALLBACK_ARGS_CLASS

#undef NLQT_CALLBACK_ARGS_TYPENAME

#undef NLQT_CALLBACK_ARGS_DECL

#undef NLQT_CALLBACK_ARGS_IMPL

#define NLQT_CALLBACK_ARGS_CLASS CCallback<TReturn, TArgsA, TArgsB, TArgsC, void, void, void, void, void>

#define NLQT_CALLBACK_ARGS_TYPENAME , typename TArgsA, typename TArgsB, typename TArgsC

#define NLQT_CALLBACK_ARGS_DECL TArgsA argsA, TArgsB argsB, TArgsC argsC

#define NLQT_CALLBACK_ARGS_IMPL argsA, argsB, argsC

NLQT_CALLBACK_TEMPLATE

#undef NLQT_CALLBACK_ARGS_CLASS

#undef NLQT_CALLBACK_ARGS_TYPENAME

#undef NLQT_CALLBACK_ARGS_DECL

#undef NLQT_CALLBACK_ARGS_IMPL

#define NLQT_CALLBACK_ARGS_CLASS CCallback<TReturn, TArgsA, TArgsB, TArgsC, TArgsD, void, void, void, void>

#define NLQT_CALLBACK_ARGS_TYPENAME , typename TArgsA, typename TArgsB, typename TArgsC, typename TArgsD

#define NLQT_CALLBACK_ARGS_DECL TArgsA argsA, TArgsB argsB, TArgsC argsC, TArgsD argsD

#define NLQT_CALLBACK_ARGS_IMPL argsA, argsB, argsC, argsD

NLQT_CALLBACK_TEMPLATE

#undef NLQT_CALLBACK_ARGS_CLASS

#undef NLQT_CALLBACK_ARGS_TYPENAME

#undef NLQT_CALLBACK_ARGS_DECL

#undef NLQT_CALLBACK_ARGS_IMPL

#define NLQT_CALLBACK_ARGS_CLASS CCallback<TReturn, TArgsA, TArgsB, TArgsC, TArgsD, TArgsE, void, void, void>

#define NLQT_CALLBACK_ARGS_TYPENAME , typename TArgsA, typename TArgsB, typename TArgsC, typename TArgsD, typename TArgsE

#define NLQT_CALLBACK_ARGS_DECL TArgsA argsA, TArgsB argsB, TArgsC argsC, TArgsD argsD, TArgsE argsE

#define NLQT_CALLBACK_ARGS_IMPL argsA, argsB, argsC, argsD, argsE

NLQT_CALLBACK_TEMPLATE

#undef NLQT_CALLBACK_ARGS_CLASS

#undef NLQT_CALLBACK_ARGS_TYPENAME

#undef NLQT_CALLBACK_ARGS_DECL

#undef NLQT_CALLBACK_ARGS_IMPL

#define NLQT_CALLBACK_ARGS_CLASS CCallback<TReturn, TArgsA, TArgsB, TArgsC, TArgsD, TArgsE, TArgsF, void, void>

#define NLQT_CALLBACK_ARGS_TYPENAME , typename TArgsA, typename TArgsB, typename TArgsC, typename TArgsD, typename TArgsE, typename TArgsF

#define NLQT_CALLBACK_ARGS_DECL TArgsA argsA, TArgsB argsB, TArgsC argsC, TArgsD argsD, TArgsE argsE, TArgsF argsF

#define NLQT_CALLBACK_ARGS_IMPL argsA, argsB, argsC, argsD, argsE, argsF

NLQT_CALLBACK_TEMPLATE

#undef NLQT_CALLBACK_ARGS_CLASS

#undef NLQT_CALLBACK_ARGS_TYPENAME

#undef NLQT_CALLBACK_ARGS_DECL

#undef NLQT_CALLBACK_ARGS_IMPL

#define NLQT_CALLBACK_ARGS_CLASS CCallback<TReturn, TArgsA, TArgsB, TArgsC, TArgsD, TArgsE, TArgsF, TArgsG, void>

#define NLQT_CALLBACK_ARGS_TYPENAME , typename TArgsA, typename TArgsB, typename TArgsC, typename TArgsD, typename TArgsE, typename TArgsF, typename TArgsG

#define NLQT_CALLBACK_ARGS_DECL TArgsA argsA, TArgsB argsB, TArgsC argsC, TArgsD argsD, TArgsE argsE, TArgsF argsF, TArgsG argsG

#define NLQT_CALLBACK_ARGS_IMPL argsA, argsB, argsC, argsD, argsE, argsF, argsG

NLQT_CALLBACK_TEMPLATE

#undef NLQT_CALLBACK_ARGS_CLASS

#undef NLQT_CALLBACK_ARGS_TYPENAME

#undef NLQT_CALLBACK_ARGS_DECL

#undef NLQT_CALLBACK_ARGS_IMPL

#undef NLQT_CALLBACK_ARGS_CLASSNAME

#undef NLQT_CALLBACK_TEMPLATE

typedef CCallback<void> CEmptyCallback;

} /* namespace NLQT */

#endif /* #ifndef NLQT_CALLBACK_H */

/* end of file */

/*

    Georges Editor Qt

	Copyright (C) 2010 Adrian Jaekel <aj at elane2k dot com>

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "configuration.h"

// STL includes

// Qt includes

#include <QFile>

// NeL includes

#include <nel/misc/debug.h>

#include <nel/misc/hierarchical_timer.h>

#include <nel/misc/config_file.h>

#include <nel/misc/path.h>

#include "modules.h"

#include <QFile>

using namespace std;

using namespace NLMISC;

namespace NLQT {

CConfiguration::CConfiguration()

{

}

CConfiguration::~CConfiguration()

{

}

void CConfiguration::init()

{	

	// verify data

	nlassert(!ConfigCallbacks.size());

	// load config

	QFile file(NLQT_CONFIG_FILE);

	if (!file.exists()) {

		file.open( QIODevice::WriteOnly | QIODevice::Text );

		file.write("GraphicsDrivers = { \"OpenGL\", \"Direct3D\" };");

		file.write("\nSearchPaths = {\"\"};");

		file.write("\nRemapExtensions = { \"png\", \"tga\" };");

		file.write("\nBackgroundColor = { 0, 0, 0 };");

		file.write("\nQtStyle = \"\";");

		file.write("\nQtPalette = \"\";");

		file.close();

	}

	try {

	ConfigFile.load(NLQT_CONFIG_FILE);

	} catch(...) {

	}

	// setup config file callback

	Modules::config().setCallback("SearchPaths", CConfigCallback(this, &CConfiguration::cfcbSearchPaths));

}

void CConfiguration::release()

{

	Modules::config().dropCallback("SearchPaths");

	 // save and release the config file

	if (ConfigFile.exists("SaveConfig") && ConfigFile.getVarPtr("SaveConfig")->asBool()) 

	{

		ConfigFile.save();

	}

	ConfigFile.clear();

	// release the search paths etc

	CPath::releaseInstance();

	// verify data

	nlassert(!ConfigCallbacks.size());

}

void CConfiguration::updateUtilities()

{

	//H_AUTO2

	CConfigFile::checkConfigFiles();

}

void CConfiguration::configSearchPaths()

{

	cfcbSearchPaths(Modules::config().getConfigFile().getVar("SearchPaths"));

}

std::string CConfiguration::configLeveldesignPath()

{

	std::string path = Modules::config().getValue("LeveldesignPath", QString("").toStdString());

	cfcbSearchPaths(Modules::config().getConfigFile().getVar("LeveldesignPath"));

	return path;

}

void CConfiguration::configRemapExtensions()

{

	CConfigFile::CVar *var;

	var = ConfigFile.getVarPtr("RemapExtensions");

	uint varsize = var->size();

	for (uint i = 0; i < varsize; i += 2)

	CPath::remapExtension(var->asString(i), var->asString(i + 1), true);

}

void CConfiguration::setAndCallback(const std::string &varName, CConfigCallback configCallback)

{

	ConfigCallbacks[varName] = configCallback;

	ConfigFile.setCallback(varName, cbConfigCallback);

	configCallback(*ConfigFile.getVarPtr(varName));

}

void CConfiguration::setCallback(const std::string &varName, CConfigCallback configCallback)

{

	ConfigCallbacks[varName] = configCallback;

	ConfigFile.setCallback(varName, cbConfigCallback);

}

void CConfiguration::dropCallback(const std::string &varName)

{

	ConfigFile.setCallback(varName, NULL);

	ConfigCallbacks.erase(varName);

}

float CConfiguration::getValue(const string &varName, float defaultValue)

{

	if (ConfigFile.exists(varName)) return ConfigFile.getVar(varName).asFloat();

	CConfigFile::CVar varToCopy;

	varToCopy.forceAsDouble((double)defaultValue);	

	ConfigFile.insertVar(varName, varToCopy);

	return defaultValue;

}

double CConfiguration::getValue(const string &varName, double defaultValue)

{

	if (ConfigFile.exists(varName)) return ConfigFile.getVar(varName).asDouble();

	CConfigFile::CVar varToCopy;

	varToCopy.forceAsDouble(defaultValue);	

	ConfigFile.insertVar(varName, varToCopy);

	return defaultValue;

}

int CConfiguration::getValue(const string &varName, int defaultValue)

{

	if (ConfigFile.exists(varName)) return ConfigFile.getVar(varName).asInt();

	CConfigFile::CVar varToCopy;

	varToCopy.forceAsInt(defaultValue);	

	ConfigFile.insertVar(varName, varToCopy);

	return defaultValue;

}

string CConfiguration::getValue(const string &varName, const string &defaultValue)

{

	if (ConfigFile.exists(varName)) return ConfigFile.getVar(varName).asString();

	CConfigFile::CVar varToCopy;

	varToCopy.forceAsString(defaultValue);

	ConfigFile.insertVar(varName, varToCopy);

	return defaultValue;

}

ucstring CConfiguration::getValue(const string &varName, const ucstring &defaultValue)

{

	if (ConfigFile.exists(varName)) return ucstring::makeFromUtf8(ConfigFile.getVar(varName).asString());

	CConfigFile::CVar varToCopy;

	varToCopy.forceAsString(defaultValue.toUtf8());

	ConfigFile.insertVar(varName, varToCopy);

	return defaultValue;

}

bool CConfiguration::getValue(const string &varName, bool defaultValue)

{

	if (ConfigFile.exists(varName)) return ConfigFile.getVar(varName).asBool();

	CConfigFile::CVar varToCopy;

	varToCopy.forceAsInt(defaultValue ? 1 : 0);	

	ConfigFile.insertVar(varName, varToCopy);

	return defaultValue;

}

CRGBA CConfiguration::getValue(const string &varName, const CRGBA &defaultValue)

{

	if (ConfigFile.exists(varName)) 

	{

		return getValue(ConfigFile.getVar(varName), defaultValue);

	}

	else

	{

		// create a new value only if one doesn't exist

		CConfigFile::CVar varToCopy;

		varToCopy.forceAsInt(defaultValue.R);

		varToCopy.setAsInt(defaultValue.G, 1);

		varToCopy.setAsInt(defaultValue.B, 2);

		varToCopy.setAsInt(defaultValue.A, 3);

		ConfigFile.insertVar(varName, varToCopy);

	}

	return defaultValue;

}

CRGBA CConfiguration::getValue(const CConfigFile::CVar &var, const CRGBA &defaultValue)

{

	if (var.size() >= 3)

	{

		if (var.size() > 4) nlwarning("RGBA value in config value '%s' is too long, ignoring unused values");

		return CRGBA((uint8)var.asInt(0), (uint8)var.asInt(1), (uint8)var.asInt(2), var.size() >= 4 ? (uint8)var.asInt(3) : 255);

	}

	nlwarning("Invalid RGBA value in config value '%s', reverting to default { %i, %i, %i, %i }", var.Name.c_str(), (sint)defaultValue.R, (sint)defaultValue.G, (sint)defaultValue.B, (sint)defaultValue.A);	

	return defaultValue;

}

void CConfiguration::cbConfigCallback(NLMISC::CConfigFile::CVar &var)

{

	Modules::config().ConfigCallbacks[var.Name](var);

}

void CConfiguration::cfcbSearchPaths(NLMISC::CConfigFile::CVar &var)

{

	uint varsize = var.size();

	//CPath::clearMap();

	for (uint i = 0; i < varsize; ++i)

		CPath::addSearchPath(var.asString(i), true, false);

}

} /* namespace NLQT */

/*

    Georges Editor Qt

	Copyright (C) 2010 Adrian Jaekel <aj at elane2k dot com>

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef CONFIGURATION_H

#define CONFIGURATION_H

#include <nel/misc/types_nl.h>

// STL includes

#include <map>

// NeL includes

#include <nel/misc/config_file.h>

#include <nel/misc/rgba.h>

#include <nel/misc/ucstring.h>

// Project includes

#include "callback.h"

#define NLQT_CONFIG_FILE "georges_editor.cfg"

namespace NLQT {

typedef CCallback<void, NLMISC::CConfigFile::CVar &> CConfigCallback;

/**

 * CConfiguration

 * \brief CConfiguration

 * \date 2010-02-05 15:44GMT

 * \author Jan Boon (Kaetemi)

 */

class CConfiguration

{

public:

	CConfiguration();

	virtual ~CConfiguration();

	void init();

	void release();

	void updateUtilities();

	void configSearchPaths();

	std::string configLeveldesignPath();

	void configRemapExtensions();

	void setAndCallback(const std::string &varName, CConfigCallback configCallback);

	void setCallback(const std::string &varName, CConfigCallback configCallback);

	void dropCallback(const std::string &varName);

	float getValue(const std::string &varName, float defaultValue);

	double getValue(const std::string &varName, double defaultValue);

	int getValue(const std::string &varName, int defaultValue);

	std::string getValue(const std::string &varName, const std::string &defaultValue);

	ucstring getValue(const std::string &varName, const ucstring &defaultValue);

	bool getValue(const std::string &varName, bool defaultValue);

	NLMISC::CRGBA getValue(const std::string &varName, const NLMISC::CRGBA &defaultValue);

	NLMISC::CRGBA getValue(const NLMISC::CConfigFile::CVar &var, const NLMISC::CRGBA &defaultValue);

	inline NLMISC::CConfigFile &getConfigFile() { return ConfigFile; }

private:

	static void cbConfigCallback(NLMISC::CConfigFile::CVar &var);

	void cfcbSearchPaths(NLMISC::CConfigFile::CVar &var);

	CConfiguration(const CConfiguration &);

	CConfiguration &operator=(const CConfiguration &);

	NLMISC::CConfigFile ConfigFile;

	std::map<std::string, CConfigCallback> ConfigCallbacks;

};/* class CConfiguration */

} /* namespace NLQT */

#endif // CONFIGURATION_H

/*

    Georges Editor Qt

	Copyright (C) 2010 Adrian Jaekel <aj at elane2k dot com>

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "entity.h"

// NeL includes

#include <nel/misc/path.h>

#include <nel/3d/u_camera.h>

#include <nel/3d/u_driver.h>

#include <nel/3d/u_text_context.h>

#include <nel/3d/u_instance.h>

#include <nel/3d/u_scene.h>

#include <nel/3d/u_material.h>

#include <nel/3d/u_landscape.h>

#include <nel/3d/u_skeleton.h>

#include <nel/3d/u_animation_set.h>

#include <nel/3d/u_animation.h>

#include <nel/3d/u_play_list_manager.h>

#include <nel/3d/u_play_list.h>

#include <nel/3d/u_track.h>

// Project includes

#include "modules.h"

using namespace NLMISC;

using namespace NL3D;

namespace NLQT {

CSlotInfo& CSlotInfo::operator=(const CSlotInfo & slotInfo)

{

	if ( this != &slotInfo)

	{

		Animation = slotInfo.Animation;

		ClampMode = slotInfo.ClampMode;

		Enable = slotInfo.Enable;

		EndBlend = slotInfo.EndBlend;

		EndTime = slotInfo.EndTime;

		Offset = slotInfo.Offset;

		Skeleton = slotInfo.Skeleton;

		SkeletonInverted = slotInfo.SkeletonInverted;

		Smoothness = slotInfo.Smoothness;

		SpeedFactor = slotInfo.SpeedFactor;

		StartBlend = slotInfo.StartBlend;

		StartTime = slotInfo.StartTime;

	}

	return *this;

}

CEntity::CEntity(void):

		_Name("<Unknown>"),

		_Instance(NULL), _Skeleton(NULL), 

		_PlayList(NULL), _AnimationSet(NULL)

{

}

CEntity::~CEntity(void)

{

}

void CEntity::loadAnimation(std::string &fileName)

{

	uint id = _AnimationSet->addAnimation(fileName.c_str(),CFile::getFilenameWithoutExtension(fileName).c_str());	

	_AnimationList.push_back(_AnimationSet->getAnimationName(id));

	_AnimationSet->build();

	if (!_Skeleton.empty()) _PlayList->registerTransform(_Skeleton);

	else _PlayList->registerTransform(_Instance);

}

void CEntity::loadSWT(std::string &fileName)

{

	uint id = _AnimationSet->addSkeletonWeight(fileName.c_str(),CFile::getFilenameWithoutExtension(fileName).c_str());

	_SWTList.push_back(_AnimationSet->getSkeletonWeightName(id));

}

void CEntity::addAnimToPlayList(std::string &name)

{

	_PlayListAnimation.push_back(name);

	_AnimationStatus.EndAnim = this->getPlayListLength();

}

void CEntity::removeAnimToPlayList(uint row)

{

	if (row < _PlayListAnimation.size())

	 _PlayListAnimation.erase(_PlayListAnimation.begin() + row);

	_AnimationStatus.EndAnim = this->getPlayListLength();

}

void CEntity::swapAnimToPlayList(uint row1, uint row2)

{

	if ((row1 < _PlayListAnimation.size()) && (row2 < _PlayListAnimation.size()))

	 std::swap(_PlayListAnimation[row1], _PlayListAnimation[row2]);

}

void CEntity::playbackAnim(bool play)

{

	_AnimationStatus.PlayAnim = play;

}

void CEntity::reset()

{

	_PlayListAnimation.clear();

	_AnimationList.clear();

	_SWTList.clear();

	_PlayList->resetAllChannels();

}

float CEntity::getPlayListLength()

{

	// Accumul all the time

	float time = 0;

	for(size_t i = 0; i < _PlayListAnimation.size(); ++i)

		time += getAnimLength(_PlayListAnimation[i]);

	return time;

}

float CEntity::getAnimLength(std::string name)

{

	uint id = _AnimationSet->getAnimationIdByName(name.c_str());

	NL3D::UAnimation *anim = _AnimationSet->getAnimation(id);

	return anim->getEndTime() - anim->getBeginTime();

}

void CEntity::update(NL3D::TAnimationTime time)

{

	this->resetChannel();

	switch (_AnimationStatus.Mode) 

	{

	case Mode::PlayList:  

		animatePlayList(time);

		break;

	case Mode::Mixer:

		animateChannelMixer();

		break;

	}

}

void CEntity::resetChannel()

{

	for(size_t i = 0; i < NL3D::CChannelMixer::NumAnimationSlot; i++)

	 _PlayList->setAnimation(i, UPlayList::empty);

}

void CEntity::animatePlayList(NL3D::TAnimationTime time)

{

	if (!_PlayListAnimation.empty())

	{

		// Animation index

		uint id = _AnimationSet->getAnimationIdByName(_PlayListAnimation[0].c_str());

		// Try channel AnimationSet

		NL3D::UAnimation *anim = _AnimationSet->getAnimation(id);

		// Accumul time

		float startTime = 0;

		float endTime = anim->getEndTime() - anim->getBeginTime();

		uint index = 0;

		while (time >= endTime)

		{

			index++;

			if (index < _PlayListAnimation.size())

			{

				id = _AnimationSet->getAnimationIdByName(_PlayListAnimation[index].c_str());

				anim = _AnimationSet->getAnimation(id);

				// Add start time

				startTime = endTime;

				endTime = startTime + (anim->getEndTime() - anim->getBeginTime());

			}

			else 

			  break;

		}

		// Time cropped ?

		if (index >= _PlayListAnimation.size())

		{

			// Yes

			index--;

			id = _AnimationSet->getAnimationIdByName(_PlayListAnimation[index].c_str());

			anim = _AnimationSet->getAnimation(id);

			// End time for last anim

			startTime = anim->getEndTime() - time;

		}

		else

		{

			// No 

			id = _AnimationSet->getAnimationIdByName(_PlayListAnimation[index].c_str());

			anim = _AnimationSet->getAnimation(id);

			// Final time

			startTime -= anim->getBeginTime();

		}

		// Set the slot

		_PlayList->setAnimation(0, id);

		_PlayList->setTimeOrigin(0, startTime);

		_PlayList->setWeightSmoothness(0, 1.0f);

		_PlayList->setStartWeight(0, 1, 0);

		_PlayList->setEndWeight(0, 1, 1);

		_PlayList->setWrapMode(0, UPlayList::Clamp);

	}

}

void CEntity::animateChannelMixer()

{

	for (uint i = 0; i < NL3D::CChannelMixer::NumAnimationSlot; i++)

	{

		if (_SlotInfo[i].Enable)

		{

			// Set the animation

			uint animId =  _AnimationSet->getAnimationIdByName(_SlotInfo[i].Animation);

			if (animId == UAnimationSet::NotFound) 

				_PlayList->setAnimation(i, UPlayList::empty);

			else 

				_PlayList->setAnimation(i, animId);

			// Set the skeleton weight

			uint skelId = _AnimationSet->getSkeletonWeightIdByName(_SlotInfo[i].Skeleton);

			if (skelId == UAnimationSet::NotFound)

				_PlayList->setSkeletonWeight(i, UPlayList::empty, false);

			else

				_PlayList->setSkeletonWeight(i, skelId, _SlotInfo[i].SkeletonInverted);

			// Set others values

			_PlayList->setTimeOrigin(i, _SlotInfo[i].Offset);

			_PlayList->setSpeedFactor(i, _SlotInfo[i].SpeedFactor);

			_PlayList->setStartWeight(i, _SlotInfo[i].StartBlend, _SlotInfo[i].StartTime);

			_PlayList->setEndWeight(i, _SlotInfo[i].EndBlend, _SlotInfo[i].EndTime);

			_PlayList->setWeightSmoothness(i, _SlotInfo[i].Smoothness);

			// Switch between wrap modes

			switch (_SlotInfo[i].ClampMode)

			{

			case 0:

				_PlayList->setWrapMode (i, UPlayList::Clamp);

				break;

			case 1:

				_PlayList->setWrapMode (i, UPlayList::Repeat);

				break;

			case 2:

				_PlayList->setWrapMode (i, UPlayList::Disable);

				break;

			}

		}

	}

}

} /* namespace NLQT */

/*

    Georges Editor Qt

	Copyright (C) 2010 Adrian Jaekel <aj at elane2k dot com>

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef ENTITY_H

#define ENTITY_H

// STL includes

#include <map>

#include <string>

#include <vector>

// NeL includes

#include "nel/3d/animation_time.h"

#include <nel/3d/u_instance.h>

#include <nel/3d/u_skeleton.h>

#include "nel/3d/channel_mixer.h"

namespace NL3D {

	class UPlayList;

	class UAnimationSet;

}

namespace NLQT {

class CSlotInfo

{

public:

	CSlotInfo (): 	

		Animation("empty"), Skeleton("empty"),

		Offset(0), StartTime(0), EndTime(0),

		StartBlend(1),	EndBlend (1), Smoothness(1),

		SpeedFactor(1),	ClampMode(0),

		SkeletonInverted(false), 

		Enable(true)	{} ;

	std::string		Animation;

	std::string		Skeleton;

	float			Offset;

	float			StartTime;

	float			EndTime;

	float			StartBlend;

	float			EndBlend;

	float			Smoothness;

	float			SpeedFactor;

	sint32			ClampMode;

	bool			SkeletonInverted;

	bool			Enable;

	CSlotInfo &operator=(const CSlotInfo &);

};

/**

@class CEntity

Animated object. Allows you to upload animations for the shape. 

Contains a built-in playlist. Has management and playback Playlists or Mixer.

*/

class CEntity

{

public:

  	struct Mode

	{

		enum List

		{

			PlayList = 1,

			Mixer

		};

	};

	// will need for a single or multiple reproduction

	struct SAnimationStatus

	{

		bool	LoopAnim;

		bool	PlayAnim;

		float	CurrentTimeAnim;

		float	StartAnim;

		float	EndAnim;

		float	SpeedAnim;

		int	Mode;

		SAnimationStatus():

			LoopAnim(false), PlayAnim(false),

			CurrentTimeAnim(0), StartAnim(0),

			EndAnim(0), SpeedAnim(1), Mode(Mode::PlayList) {}

	};

	/// Constructor

	CEntity(void);

	/// Destructor

	~CEntity(void);

	/// Loads a file animations

	/// @param fileName - name animation file

	void loadAnimation(std::string &fileName);

	/// Loads a file skeleton weight

	void loadSWT(std::string &fileName);

	/// Adds an animation to a playlist

	/// @param name - name loaded animations

	void addAnimToPlayList(std::string &name);

	/// Removes the animation from a playlist

	/// @param row - number of animations in the playlist

	void removeAnimToPlayList(uint row);

	/// Swaps animations to a playlist

	/// @param row1 - first number of animations in the playlist

	/// @param row2 - second number of animations in the playlist

	void swapAnimToPlayList(uint row1, uint row2); 

	/// Playback animation 

	void playbackAnim(bool play);

	/// Reset playlist and animation

	void reset();

	/// Get the total time of animation playlist

	/// @return total time of animation

	float getPlayListLength();

	/// get time length single animation

	float getAnimLength(std::string name);

	/// Get slot infomation

	void setSlotInfo(uint num, CSlotInfo& slotInfo) { _SlotInfo[num] = slotInfo; }

	/// Set use mode playlist or mixer

	void setMode(int mode)	{ _AnimationStatus.Mode = mode; }

	/// Get information about the current status of playing a playlist

	/// @return struct containing current information playback

	SAnimationStatus& getStatus() { return _AnimationStatus; }

	/// Get name entity

	/// @return name entity

	std::string &getName() { return _Name; }

	/// Get slot information

	CSlotInfo& getSlotInfo(uint num) { return _SlotInfo[num]; }

	/// Get list loaded animations files

	std::vector<std::string>& getAnimationList() { return _AnimationList; }

	/// Get playlist animations

	std::vector<std::string>& getPlayListAnimation() { return _PlayListAnimation; }

	/// Get list loaded skeleton weight template files

	std::vector<std::string>& getSWTList() { return _SWTList; }

private:

	/// Update the animate from the playlist or channel mixer

	/// @param time - current time in second

	void update(NL3D::TAnimationTime time);

	void resetChannel();

	/// Update the animate from the playlist

	void animatePlayList(NL3D::TAnimationTime time);

	/// Update the animate from the mixer

	void animateChannelMixer();

	// The name of the entity

	std::string			_Name;

	SAnimationStatus		_AnimationStatus;

	// The mesh instance associated to this entity

	NL3D::UInstance			_Instance;

	// The skeleton binded to the instance

	NL3D::USkeleton			_Skeleton;

	NL3D::UPlayList			*_PlayList;

	NL3D::UAnimationSet		*_AnimationSet;

	// Animation input file

	std::vector<std::string>	_AnimationList;

	// Skeleton weight input file

	std::vector<std::string>	_SWTList;

	// Play list animation

	std::vector<std::string >	_PlayListAnimation;

	// Slot info for this object

	CSlotInfo			_SlotInfo[NL3D::CChannelMixer::NumAnimationSlot];

	friend class CObjectViewer;

}; /* class CEntity */

typedef std::map<std::string, CEntity>	CEntities;

typedef CEntities::iterator		EIT;

} /* namespace NLQT */

#endif // ENTITY_H

/*

    Georges Editor Qt

	Copyright (C) 2010 Adrian Jaekel <aj at elane2k dot com>

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "filesystem_model.h"

#include <QtGui/QApplication>

#include <QtGui/QStyle>

namespace NLQT {

	CFileSystemModel::CFileSystemModel(QString ldPath, QObject *parent)

		: QFileSystemModel(parent),

		_ldPath(ldPath){

	}

	CFileSystemModel::~CFileSystemModel() {

	}

	QVariant CFileSystemModel::data(const QModelIndex& index, int role) const {

		if (role == Qt::DecorationRole) {

			if (_ldPath.isEmpty())

				return QVariant();

			if (isDir(index))

				return QApplication::style()->standardIcon(QStyle::SP_DirIcon);

		}

		if (_ldPath.isEmpty() && role == Qt::DisplayRole) {

			if (index.parent().isValid())

				return QVariant();

			return QString("Set a correct leveldesign path ...");

		}

		return QFileSystemModel::data(index, role);

	}

	int CFileSystemModel::columnCount(const QModelIndex &/*parent*/) const

	{

		return 1;

	}

	int CFileSystemModel::rowCount(const QModelIndex &parent) const

	{

		if (_ldPath.isEmpty()) {

			if(parent.isValid()) {

				return 0;

			} else {

				return qMin(QFileSystemModel::rowCount(parent),1);

			}

		}

		return QFileSystemModel::rowCount(parent);

	}

} /* namespace NLQT */

/* end of file */

/*

    Georges Editor Qt

	Copyright (C) 2010 Adrian Jaekel <aj at elane2k dot com>

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <http://www.gnu.org/licenses/>.