Christian Fischer avatar Christian Fischer committed 0c5cd71

added win32 dllexport to allow windows builds with multiple libraries

Comments (0)

Files changed (49)

build/build.cmake

 # load optional config includes
 include(config/local/paths.cmake OPTIONAL)
 
-
-
+
+
+# on win32 we may need to copy all SDL DLL's to our binary directory
+if (WIN32)
+	if (DEFINED EXTRALIBS_PATH)
+		file(GLOB DLLS_TO_COPY ${EXTRALIBS_PATH}/bin/*.dll)
+		file(COPY ${DLLS_TO_COPY} DESTINATION .)
+	endif()
+endif()

src/base/wiesel/geometry.h

 #ifndef __WIESEL_GEOMETRY_H__
 #define __WIESEL_GEOMETRY_H__
 
+#include <wiesel/wiesel-base.def>
 
 #include "math/vector2d.h"
 
 
 namespace wiesel {
 
-	struct dimension
+	class WIESEL_BASE_EXPORT dimension
 	{
 	// constructors
 	public:
 	/**
 	 * @brief A basic class covering the boundings of a rectangle.
 	 */
-	class rectangle
+	class WIESEL_BASE_EXPORT rectangle
 	{
 	public:
 		/// creates a new rectangle with zero position and size.
 	/**
 	 * @brief Create a new rectangle, which contains both parameter rectangles.
 	 */
-	rectangle createUnion(const rectangle &a, const rectangle &b);
+	WIESEL_BASE_EXPORT rectangle createUnion(const rectangle &a, const rectangle &b);
 
 
 	/**
 	 * @brief Create the intersection of two rectangles.
 	 */
-	rectangle createIntersection(const rectangle &a, const rectangle &b);
+	WIESEL_BASE_EXPORT rectangle createIntersection(const rectangle &a, const rectangle &b);
 
 
 
-	std::ostream& operator <<(std::ostream &o, const dimension &dim);
-	std::ostream& operator <<(std::ostream &o, const rectangle &r);
-	
+	WIESEL_BASE_EXPORT std::ostream& operator <<(std::ostream &o, const dimension &dim);
+	WIESEL_BASE_EXPORT std::ostream& operator <<(std::ostream &o, const rectangle &r);
+
 }
 
 #endif

src/base/wiesel/math/matrix.h

 #ifndef __WIESEL_MATH_MATRIX_H__
 #define	__WIESEL_MATH_MATRIX_H__
 
+#include <wiesel/wiesel-base.def>
+
 #include <ostream>
 
 
 	/**
 	 * @brief A class covering a 4x4 matrix for 3D transformation.
 	 */
-	class matrix4x4
+	class WIESEL_BASE_EXPORT matrix4x4
 	{
 	public:
 		/// creates a new uninitialised matrix.
 
 	public:
 		/// the identity matrix
-		static const matrix4x4 identity;
+		static WIESEL_BASE_EXPORT const matrix4x4 identity;
 
 		/// the zero matrix
-		static const matrix4x4 zero;
+		static WIESEL_BASE_EXPORT const matrix4x4 zero;
 	};
 
 
 
 
-	matrix4x4 operator *(const matrix4x4 &a, const matrix4x4 &b);
-	matrix4x4 operator /(const matrix4x4 &a, const matrix4x4 &b);
+	WIESEL_BASE_EXPORT matrix4x4 operator *(const matrix4x4 &a, const matrix4x4 &b);
+	WIESEL_BASE_EXPORT matrix4x4 operator /(const matrix4x4 &a, const matrix4x4 &b);
 
 
-	std::ostream& operator <<(std::ostream &o, const matrix4x4 &m);
+	WIESEL_BASE_EXPORT std::ostream& operator <<(std::ostream &o, const matrix4x4 &m);
 
 }
 #endif	/* __WIESEL_MATH_MATRIX_H__ */

src/base/wiesel/math/vector2d.h

 #ifndef __WIESEL_MATH_VECTOR2D_H__
 #define	__WIESEL_MATH_VECTOR2D_H__
 
+#include <wiesel/wiesel-base.def>
+
 #include "matrix.h"
 
 #include <ostream>
 	/**
 	 * @brief A class handling a two dimensional vector.
 	 */
-	class vector2d
+	class WIESEL_BASE_EXPORT vector2d
 	{
 	public:
 		/// creates a new uninitialised vector
 
 	public:
 		/// a null-vector
-		static vector2d zero;
+		static WIESEL_BASE_EXPORT vector2d zero;
 	};
 
 
 
-	vector2d operator +(const vector2d &a, const vector2d &b);
-	vector2d operator -(const vector2d &a, const vector2d &b);
-	vector2d operator *(const vector2d &a, const vector2d &b);
-	vector2d operator /(const vector2d &a, const vector2d &b);
-	vector2d operator *(const vector2d &a, float s);
-	vector2d operator /(const vector2d &a, float s);
+	WIESEL_BASE_EXPORT vector2d operator +(const vector2d &a, const vector2d &b);
+	WIESEL_BASE_EXPORT vector2d operator -(const vector2d &a, const vector2d &b);
+	WIESEL_BASE_EXPORT vector2d operator *(const vector2d &a, const vector2d &b);
+	WIESEL_BASE_EXPORT vector2d operator /(const vector2d &a, const vector2d &b);
+	WIESEL_BASE_EXPORT vector2d operator *(const vector2d &a, float s);
+	WIESEL_BASE_EXPORT vector2d operator /(const vector2d &a, float s);
 
-	const vector2d& operator +=(vector2d &a, const vector2d &b);
-	const vector2d& operator -=(vector2d &a, const vector2d &b);
-	const vector2d& operator *=(vector2d &a, const vector2d &b);
-	const vector2d& operator /=(vector2d &a, const vector2d &b);
-	const vector2d& operator *=(vector2d &a, float s);
-	const vector2d& operator /=(vector2d &a, float s);
+	WIESEL_BASE_EXPORT const vector2d& operator +=(vector2d &a, const vector2d &b);
+	WIESEL_BASE_EXPORT const vector2d& operator -=(vector2d &a, const vector2d &b);
+	WIESEL_BASE_EXPORT const vector2d& operator *=(vector2d &a, const vector2d &b);
+	WIESEL_BASE_EXPORT const vector2d& operator /=(vector2d &a, const vector2d &b);
+	WIESEL_BASE_EXPORT const vector2d& operator *=(vector2d &a, float s);
+	WIESEL_BASE_EXPORT const vector2d& operator /=(vector2d &a, float s);
 
 
-	vector2d operator *(const vector2d &v, const matrix4x4 &m);
-	vector2d operator /(const vector2d &v, const matrix4x4 &m);
+	WIESEL_BASE_EXPORT vector2d operator *(const vector2d &v, const matrix4x4 &m);
+	WIESEL_BASE_EXPORT vector2d operator /(const vector2d &v, const matrix4x4 &m);
 
-	const vector2d& operator *=(vector2d &v, const matrix4x4 &m);
-	const vector2d& operator /=(vector2d &v, const matrix4x4 &m);
+	WIESEL_BASE_EXPORT const vector2d& operator *=(vector2d &v, const matrix4x4 &m);
+	WIESEL_BASE_EXPORT const vector2d& operator /=(vector2d &v, const matrix4x4 &m);
 
 
-	std::ostream& operator <<(std::ostream &o, const vector2d &v);
+	WIESEL_BASE_EXPORT std::ostream& operator <<(std::ostream &o, const vector2d &v);
 
 }
 #endif	/* __WIESEL_MATH_VECTOR2D_H__ */

src/base/wiesel/math/vector3d.h

 #ifndef __WIESEL_MATH_VECTOR3D_H__
 #define	__WIESEL_MATH_VECTOR3D_H__
 
+#include <wiesel/wiesel-base.def>
+
 #include "vector2d.h"
 #include "matrix.h"
 
 	/**
 	 * @brief A class handling a three dimensional vector.
 	 */
-	class vector3d
+	class WIESEL_BASE_EXPORT vector3d
 	{
 	public:
 		/// creates a new uninitialised vector
 
 	public:
 		/// a null-vector
-		static vector3d zero;
+		static WIESEL_BASE_EXPORT vector3d zero;
 	};
 
 
 	/**
 	 * @brief Compute the dot-product or scalar-product of two vectors.
 	 */
-	float dot(const vector3d &a, const vector3d &b);
+	WIESEL_BASE_EXPORT float dot(const vector3d &a, const vector3d &b);
 
 	/**
 	 * @brief Compute the cross-product of two vectors.
 	 */
-	vector3d cross(const vector3d &a, const vector3d &b);
+	WIESEL_BASE_EXPORT vector3d cross(const vector3d &a, const vector3d &b);
 
 
 
-	vector3d operator +(const vector3d &a, const vector3d &b);
-	vector3d operator -(const vector3d &a, const vector3d &b);
-	vector3d operator *(const vector3d &a, const vector3d &b);
-	vector3d operator /(const vector3d &a, const vector3d &b);
-	vector3d operator *(const vector3d &a, float s);
-	vector3d operator /(const vector3d &a, float s);
+	WIESEL_BASE_EXPORT vector3d operator +(const vector3d &a, const vector3d &b);
+	WIESEL_BASE_EXPORT vector3d operator -(const vector3d &a, const vector3d &b);
+	WIESEL_BASE_EXPORT vector3d operator *(const vector3d &a, const vector3d &b);
+	WIESEL_BASE_EXPORT vector3d operator /(const vector3d &a, const vector3d &b);
+	WIESEL_BASE_EXPORT vector3d operator *(const vector3d &a, float s);
+	WIESEL_BASE_EXPORT vector3d operator /(const vector3d &a, float s);
 
-	const vector3d& operator +=(vector3d &a, const vector3d &b);
-	const vector3d& operator -=(vector3d &a, const vector3d &b);
-	const vector3d& operator *=(vector3d &a, const vector3d &b);
-	const vector3d& operator /=(vector3d &a, const vector3d &b);
-	const vector3d& operator *=(vector3d &a, float s);
-	const vector3d& operator /=(vector3d &a, float s);
+	WIESEL_BASE_EXPORT const vector3d& operator +=(vector3d &a, const vector3d &b);
+	WIESEL_BASE_EXPORT const vector3d& operator -=(vector3d &a, const vector3d &b);
+	WIESEL_BASE_EXPORT const vector3d& operator *=(vector3d &a, const vector3d &b);
+	WIESEL_BASE_EXPORT const vector3d& operator /=(vector3d &a, const vector3d &b);
+	WIESEL_BASE_EXPORT const vector3d& operator *=(vector3d &a, float s);
+	WIESEL_BASE_EXPORT const vector3d& operator /=(vector3d &a, float s);
 
 
-	vector3d operator *(const vector3d &v, const matrix4x4 &m);
-	vector3d operator /(const vector3d &v, const matrix4x4 &m);
+	WIESEL_BASE_EXPORT vector3d operator *(const vector3d &v, const matrix4x4 &m);
+	WIESEL_BASE_EXPORT vector3d operator /(const vector3d &v, const matrix4x4 &m);
 
-	const vector3d& operator *=(vector3d &v, const matrix4x4 &m);
-	const vector3d& operator /=(vector3d &v, const matrix4x4 &m);
+	WIESEL_BASE_EXPORT const vector3d& operator *=(vector3d &v, const matrix4x4 &m);
+	WIESEL_BASE_EXPORT const vector3d& operator /=(vector3d &v, const matrix4x4 &m);
 
 
-	std::ostream& operator <<(std::ostream &o, const vector3d &v);
+	WIESEL_BASE_EXPORT std::ostream& operator <<(std::ostream &o, const vector3d &v);
 
 }
 #endif	/* __WIESEL_MATH_VECTOR3D_H__ */

src/base/wiesel/util/shared_object.h

 #ifndef __WIESEL_UTIL_MANAGED_OBJECT_H__
 #define __WIESEL_UTIL_MANAGED_OBJECT_H__
 
+#include <wiesel/wiesel-base.def>
+
 #include <assert.h>
 #include <stddef.h>
 #include <vector>
 	 *
 	 * By design, this class should be used as a virtual base class only.
 	 */
-	class SharedObject
+	class WIESEL_BASE_EXPORT SharedObject
 	{
 	protected:
 		SharedObject();

src/base/wiesel/wiesel-base.def

+/**
+ * Copyright (C) 2012
+ * Christian Fischer
+ *
+ * https://bitbucket.org/baldur/wiesel/
+ *
+ * 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 3 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA
+ */
+#ifndef __WIESEL_BASE_DEF_H__
+#define __WIESEL_BASE_DEF_H__
+
+/**
+ * some defines and flags specially for the wiesel-base library
+ */
+
+#if defined(_WIN32)
+	#if defined(wiesel_base_EXPORTS)
+		#define WIESEL_BASE_EXPORT		__declspec(dllexport)
+	#else
+		#define WIESEL_BASE_EXPORT		__declspec(dllimport)
+	#endif
+#else
+		#define WIESEL_BASE_EXPORT		
+#endif
+
+
+#endif // __WIESEL_BASE_DEF_H__

src/common/wiesel/application.h

 #ifndef __WIESEL_APPLICATION_H__
 #define __WIESEL_APPLICATION_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "graph/scene.h"
 #include <vector>
 
 	/**
 	 * @brief An abstract class implementing the application logic.
 	 */
-	class Application {
+	class WIESEL_COMMON_EXPORT Application {
 	public:
 		Application();
 		virtual ~Application();

src/common/wiesel/engine.h

 #ifndef __WIESEL_ENGINE_H__
 #define __WIESEL_ENGINE_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "screen.h"
 #include "application.h"
 #include "engine_interfaces.h"
 	/**
 	 * @brief An interface to the game engine.
 	 */
-	class Engine {
+	class WIESEL_COMMON_EXPORT Engine {
 	protected:
 		Engine();
 		virtual ~Engine();
 		/**
 		 * @brief starts the main loop with the currently installed engine.
 		 */
-		static void run(Application *application);
+		static WIESEL_COMMON_EXPORT void run(Application *application);
 
 		/**
 		 * @brief requests to stop the main loop after the current frame.
 
 	// static members
 	private:
-		static Engine*			current_instance;
-		static Application*		current_app;
-		static bool				exit_requested;
+		static WIESEL_COMMON_EXPORT Engine*			    current_instance;
+		static WIESEL_COMMON_EXPORT Application*		current_app;
+		static WIESEL_COMMON_EXPORT bool				exit_requested;
 
 	// instance members
 	protected:

src/common/wiesel/engine_interfaces.h

 #ifndef __WIESEL_ENGINE_INTERFACES_H__
 #define __WIESEL_ENGINE_INTERFACES_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include <wiesel/util/shared_object.h>
 
 
 	 * To receive updates, the object has to be received on the engine object.
 	 * The update will be invoked each frame by the engine.
 	 */
-	class IUpdateable : public virtual SharedObject
+	class WIESEL_COMMON_EXPORT IUpdateable : public virtual SharedObject
 	{
 	public:
 		IUpdateable();

src/common/wiesel/gl/gl.h

 #ifndef __WIESEL_GL_GLUTILS_H__
 #define __WIESEL_GL_GLUTILS_H__
 
+#include <wiesel/wiesel-common.def>
+
 // include platform specific OpenGL headers
 #include "wiesel/platform/gl_import.h"
 
 	 * @param file	The current source code file.
 	 * @param line	The current source code line.
 	 */
-	void checkGlError(const char *file, int line);
+	WIESEL_COMMON_EXPORT void checkGlError(const char *file, int line);
 }
 
 

src/common/wiesel/gl/shader/shader.h

 	/**
 	 * @brief A class handling a single shader object.
 	 */
-	class Shader : public virtual SharedObject
+	class WIESEL_COMMON_EXPORT Shader : public virtual SharedObject
 	{
 	private:
 		Shader();
 		 * @brief compile a shader from source code.
 		 * @return the created shader on success, \c NULL when compiling failed.
 		 */
-		static Shader *compile(const std::string &source, ShaderType type);
+		static WIESEL_COMMON_EXPORT Shader *compile(const std::string &source, ShaderType type);
 
 		/**
 		 * @brief compile a shader from source code.
 		 * @return the created shader on success, \c NULL when compiling failed.
 		 */
-		static Shader *compile(DataSource *source, ShaderType type);
+		static WIESEL_COMMON_EXPORT Shader *compile(DataSource *source, ShaderType type);
 
 		/**
 		 * 
 	/**
 	 * @brief Handles a shader program with mulitple shaders linked.
 	 */
-	class ShaderProgram : public virtual SharedObject
+	class WIESEL_COMMON_EXPORT ShaderProgram : public virtual SharedObject
 	{
 	public:
 		/**

src/common/wiesel/gl/shader/shaders.h

 #ifndef __WIESEL_GL_SHADER_SHADERS_H__
 #define	__WIESEL_GL_SHADER_SHADERS_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "shader.h"
 
 #include "wiesel/gl/vbo/vertexbuffer.h"
 	 * @brief An utility class to create new shaders
 	 * and cache existing shaders.
 	 */
-	class Shaders
+	class WIESEL_COMMON_EXPORT Shaders
 	{
 	private:
 		Shaders();
 	// singleton
 	public:
 		/// get the singleton instance
-		static Shaders *instance();
+		static WIESEL_COMMON_EXPORT Shaders *instance();
 
 	// shader variable names
 	public:
-		static const char *ATTRIBUTE_VERTEX_POSITION;
-		static const char *ATTRIBUTE_VERTEX_NORMAL;
-		static const char *ATTRIBUTE_VERTEX_COLOR;
-		static const char *ATTRIBUTE_VERTEX_TEXTURE_COORDINATE;
-		static const char *UNIFORM_PROJECTION_MATRIX;
-		static const char *UNIFORM_MODELVIEW_MATRIX;
-		static const char *UNIFORM_TEXTURE;
-		static const char *VARYING_COLOR;
-		static const char *VARYING_NORMAL;
-		static const char *VARYING_TEXTURE_COORDINATE;
+		WIESEL_COMMON_EXPORT static const char *ATTRIBUTE_VERTEX_POSITION;
+		WIESEL_COMMON_EXPORT static const char *ATTRIBUTE_VERTEX_NORMAL;
+		WIESEL_COMMON_EXPORT static const char *ATTRIBUTE_VERTEX_COLOR;
+		WIESEL_COMMON_EXPORT static const char *ATTRIBUTE_VERTEX_TEXTURE_COORDINATE;
+		WIESEL_COMMON_EXPORT static const char *UNIFORM_PROJECTION_MATRIX;
+		WIESEL_COMMON_EXPORT static const char *UNIFORM_MODELVIEW_MATRIX;
+		WIESEL_COMMON_EXPORT static const char *UNIFORM_TEXTURE;
+		WIESEL_COMMON_EXPORT static const char *VARYING_COLOR;
+		WIESEL_COMMON_EXPORT static const char *VARYING_NORMAL;
+		WIESEL_COMMON_EXPORT static const char *VARYING_TEXTURE_COORDINATE;
 
 	// public types
 	public:

src/common/wiesel/gl/texture/spriteframe.h

 #ifndef __WIESEL_GL_TEXTURE_SPRITEFRAME_H__
 #define __WIESEL_GL_TEXTURE_SPRITEFRAME_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include <wiesel/gl/gl.h>
 #include <wiesel/gl/texture/texture.h>
 #include <wiesel/geometry.h>
 	/**
 	 * @brief An object which contains a specific part of a texture.
 	 */
-	class SpriteFrame : public virtual SharedObject
+	class WIESEL_COMMON_EXPORT SpriteFrame : public virtual SharedObject
 	{
 	private:
 		SpriteFrame();
 
 
 
-	std::ostream& operator <<(std::ostream&, const SpriteFrame *sprite_frame);
+	WIESEL_COMMON_EXPORT std::ostream& operator <<(std::ostream&, const SpriteFrame *sprite_frame);
 
 
 } /* namespace wiesel */

src/common/wiesel/gl/texture/spritesheet.h

 #ifndef __WIESEL_GL_TEXTURE_SPRITESHEET_H__
 #define __WIESEL_GL_TEXTURE_SPRITESHEET_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "spriteframe.h"
 
 #include <wiesel/gl/gl.h>
 	/**
 	 * @brief A SpriteSheet contains multiple sprites which belongs to a single texture.
 	 */
-	class SpriteSheet : public virtual SharedObject
+	class WIESEL_COMMON_EXPORT SpriteSheet : public virtual SharedObject
 	{
 	public:
 		typedef std::vector<SpriteFrame*>			List;
 		 * @brief Load a spritesheet from a file.
 		 * @param file	A file containing the spritesheet.
 		 */
-		static SpriteSheet* fromFile(File *file);
+		static WIESEL_COMMON_EXPORT SpriteSheet* fromFile(File *file);
 
 		virtual ~SpriteSheet();
 

src/common/wiesel/gl/texture/texture.h

 #ifndef __WIESEL_GL_TEXTURE_TEXTURE_H__
 #define __WIESEL_GL_TEXTURE_TEXTURE_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include <wiesel/gl/gl.h>
 #include <wiesel/geometry.h>
 #include <wiesel/util/shared_object.h>
 
 namespace wiesel {
 
-	class Texture : public virtual SharedObject
+	class WIESEL_COMMON_EXPORT Texture : public virtual SharedObject
 	{
 	private:
 		Texture();
 		/**
 		 * @brief load a texture from a \ref File.
 		 */
-		static Texture *fromFile(File *filename);
+		static WIESEL_COMMON_EXPORT Texture *fromFile(File *filename);
 
 		/**
 		 * @brief load a texture from a \ref DataSource.
 		 */
-		static Texture *fromDataSource(DataSource *data);
+		static WIESEL_COMMON_EXPORT Texture *fromDataSource(DataSource *data);
 
 		/**
 		 * @brief get the texture's size.

src/common/wiesel/gl/vbo/indexbuffer.h

 #ifndef __WIESEL_GL_VBO_INDEXBUFFER_H__
 #define __WIESEL_GL_VBO_INDEXBUFFER_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include <wiesel/gl/gl.h>
 #include <wiesel/util/shared_object.h>
 #include <wiesel/gl/shader/shader.h>
 	/**
 	 * @brief 
 	 */
-	class IndexBuffer : public virtual SharedObject
+	class WIESEL_COMMON_EXPORT IndexBuffer : public virtual SharedObject
 	{
 	public:
 		/// alias type for the index of each vertex.

src/common/wiesel/gl/vbo/vertexbuffer.h

 #ifndef __WIESEL_GL_VBO_VERTEXBUFFER_H__
 #define __WIESEL_GL_VBO_VERTEXBUFFER_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include <wiesel/gl/gl.h>
 #include <wiesel/util/shared_object.h>
 #include <wiesel/gl/shader/shader.h>
 	 * A vertex can contain 2D or 3D coordinates, normal, color,
 	 * and multiple texture coordinates.
 	 */
-	class VertexBuffer : public virtual SharedObject
+	class WIESEL_COMMON_EXPORT VertexBuffer : public virtual SharedObject
 	{
 	public:
 		/// alias type for the index of each vertex.

src/common/wiesel/graph/2d/multisprite_node.h

 #ifndef __WIESEL_GRAPH_2D_MULTISPRITENODE_H__
 #define	__WIESEL_GRAPH_2D_MULTISPRITENODE_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "node2d.h"
 #include "sprite_node.h"
 #include "wiesel/gl/texture/texture.h"
 	 * This Node is designed to provide a very basic functionality, so each sprite can
 	 * have an individual offset, but no custom transformations like scaling or rotation.
 	 */
-	class MultiSpriteNode : public Node2D
+	class WIESEL_COMMON_EXPORT MultiSpriteNode : public Node2D
 	{
 	public:
 		/**

src/common/wiesel/graph/2d/node2d.h

 #ifndef __WIESEL_GRAPH_2D_NODE2D_H__
 #define	__WIESEL_GRAPH_2D_NODE2D_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "wiesel/graph/node.h"
 #include "wiesel/math/vector2d.h"
 #include "wiesel/geometry.h"
 
 namespace wiesel {
 
-	class Node2D : public Node
+	class WIESEL_COMMON_EXPORT Node2D : public Node
 	{
 	public:
 		Node2D();

src/common/wiesel/graph/2d/sprite_node.h

 #ifndef __WIESEL_GRAPH_2D_SPRITENODE_H__
 #define	__WIESEL_GRAPH_2D_SPRITENODE_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "node2d.h"
 #include "wiesel/gl/texture/texture.h"
 #include "wiesel/gl/vbo/vertexbuffer.h"
 	/**
 	 * @brief A Node for displaying a single sprite.
 	 */
-	class SpriteNode : public Node2D
+	class WIESEL_COMMON_EXPORT SpriteNode : public Node2D
 	{
 	public:
 		/**

src/common/wiesel/graph/node.h

 #ifndef __WIESEL_GRAPH_NODE_H__
 #define	__WIESEL_GRAPH_NODE_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include <wiesel/util/shared_object.h>
 #include <wiesel/math/matrix.h>
 #include <wiesel/math/vector2d.h>
 	 * for your custom objects.
 	 * Instead, you should be consider Node2D or Node3D.
 	 */
-	class Node : public virtual SharedObject
+	class WIESEL_COMMON_EXPORT Node : public virtual SharedObject
 	{
 	public:
 		Node();

src/common/wiesel/graph/scene.h

 #ifndef __WIESEL_GRAPH_SCENE_H__
 #define	__WIESEL_GRAPH_SCENE_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "node.h"
 
 namespace wiesel {
 	/**
 	 * @brief Base-class for scenes.
 	 */
-	class Scene : public Node
+	class WIESEL_COMMON_EXPORT Scene : public Node
 	{
 	public:
 		Scene();

src/common/wiesel/io/databuffer.h

 #ifndef __WIESEL_IO_DATABUFFER_H__
 #define __WIESEL_IO_DATABUFFER_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "wiesel/util/shared_object.h"
 #include <string>
 
 	/**
 	 * @brief Wrapper object for any kind of data buffers.
 	 */
-	class DataBuffer : public virtual SharedObject
+	class WIESEL_COMMON_EXPORT DataBuffer : public virtual SharedObject
 	{
 	protected:
 		DataBuffer();
 	 * @brief A \ref DataBuffer implementation, which stores a simple data pointer.
 	 * When the object is released, the buffer will be destroyed.
 	 */
-	class ExclusiveDataBuffer : public DataBuffer
+	class WIESEL_COMMON_EXPORT ExclusiveDataBuffer : public DataBuffer
 	{
 	private:
 		ExclusiveDataBuffer() : data(NULL), size(0) {}
 	 * @brief A \ref DataBuffer implementation, which stores a simple data pointer.
 	 * The buffer will NOT be destroyed, when the object is released.
 	 */
-	class SharedDataBuffer : public DataBuffer
+	class WIESEL_COMMON_EXPORT SharedDataBuffer : public DataBuffer
 	{
 	private:
 		SharedDataBuffer() : data(NULL), size(0) {}

src/common/wiesel/io/datasource.h

 #ifndef __WIESEL_IO_DATASOURCE_H__
 #define __WIESEL_IO_DATASOURCE_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "databuffer.h"
 #include "wiesel/util/shared_object.h"
 
 	/**
 	 * @brief Wrapper object for any kind of data source, like files or buffers.
 	 */
-	class DataSource : public virtual SharedObject
+	class WIESEL_COMMON_EXPORT DataSource : public virtual SharedObject
 	{
 	protected:
 		DataSource();
 	/**
 	 * @brief A DataSource which provides data of a \ref DataBuffer object.
 	 */
-	class BufferDataSource : public DataSource
+	class WIESEL_COMMON_EXPORT BufferDataSource : public DataSource
 	{
 	private:
 		BufferDataSource() : buffer(NULL) {}

src/common/wiesel/io/directory.h

 #ifndef __WIESEL_IO_DIRECTORY_H__
 #define __WIESEL_IO_DIRECTORY_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "wiesel/util/shared_object.h"
 #include "file.h"
 
 	/**
 	 * @brief A class representing a directory within a \ref FileSystem.
 	 */
-	class Directory : public virtual SharedObject
+	class WIESEL_COMMON_EXPORT Directory : public virtual SharedObject
 	{
 	private:
 		Directory() {}

src/common/wiesel/io/directory_filesystem.h

 #ifndef __WIESEL_IO_DIRECTORY_FILESYSTEM_H__
 #define __WIESEL_IO_DIRECTORY_FILESYSTEM_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "wiesel/io/filesystem.h"
 
 
 	 * as it's root directory. Each directory of this filesystem corresponds to a
 	 * directory of the enclosed filesystem.
 	 */
-	class DirectoryFileSystem : public FileSystem
+	class WIESEL_COMMON_EXPORT DirectoryFileSystem : public FileSystem
 	{
 	private:
 		DirectoryFileSystem() {};
 	/**
 	 * @brief A virtual \ref Directory object, which wraps a directory of an other filesystem.
 	 */
-	class DirectoryFileSystemDirectory : public Directory
+	class WIESEL_COMMON_EXPORT DirectoryFileSystemDirectory : public Directory
 	{
 	public:
 		DirectoryFileSystemDirectory(DirectoryFileSystem *fs, DirectoryFileSystemDirectory *parent, Directory *enclosed_directory);
-		~DirectoryFileSystemDirectory();
+		virtual ~DirectoryFileSystemDirectory();
 
 		/**
 		 * @brief get the enclosed directory object of this virtual directory.
 	/**
 	 * @brief A virtual \ref Directory object, which wraps the root directory of a \ref DirectoryFileSystem.
 	 */
-	class DirectoryFileSystemRootDirectory : public DirectoryFileSystemDirectory
+	class WIESEL_COMMON_EXPORT DirectoryFileSystemRootDirectory : public DirectoryFileSystemDirectory
 	{
 	public:
 		DirectoryFileSystemRootDirectory(DirectoryFileSystem *fs, Directory *enclosed_directory);
-		~DirectoryFileSystemRootDirectory();
+		virtual ~DirectoryFileSystemRootDirectory();
 
 		virtual std::string getName() const;
 	};
 	/**
 	 * @brief A virtual \ref File object, which wraps a directory of an other filesystem.
 	 */
-	class DirectoryFileSystemFile : public File
+	class WIESEL_COMMON_EXPORT DirectoryFileSystemFile : public File
 	{
 	public:
 		DirectoryFileSystemFile(DirectoryFileSystemDirectory *parent, File *enclosed_file);
-		~DirectoryFileSystemFile();
+		virtual ~DirectoryFileSystemFile();
 
 		/**
 		 * @brief get the enclosed file object of this virtual file.

src/common/wiesel/io/file.h

 #ifndef __WIESEL_IO_FILE_H__
 #define __WIESEL_IO_FILE_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "wiesel/util/shared_object.h"
 #include "datasource.h"
 
 	/**
 	 * @brief A class representing a file within a \ref FileSystem.
 	 */
-	class File : public virtual SharedObject
+	class WIESEL_COMMON_EXPORT File : public virtual SharedObject
 	{
 	private:
 		File() {}
 		/**
 		 * @brief Sort a list of files by their names.
 		 */
-		static void sortByName(FileList &list, bool asc=true);
+		static WIESEL_COMMON_EXPORT void sortByName(FileList &list, bool asc=true);
 
 	private:
 		Directory*	parent;
 	/**
 	 * @brief A \ref DataSource object which provides access to a \ref FileObject.
 	 */
-	class FileDataSource : public DataSource
+	class WIESEL_COMMON_EXPORT FileDataSource : public DataSource
 	{
 	private:
 		FileDataSource() : file(NULL) {};

src/common/wiesel/io/filesystem.h

 #ifndef __WIESEL_IO_FILESYSTEM_H__
 #define __WIESEL_IO_FILESYSTEM_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "directory.h"
 #include "file.h"
 
 	/**
 	 * @brief A class representing a filesystem to provide access to files and directories of a platform.
 	 */
-	class FileSystem
+	class WIESEL_COMMON_EXPORT FileSystem
 	{
 	protected:
 		FileSystem();

src/common/wiesel/platform/android/android_engine.h

 #ifndef __WIESEL_PLATFORM_ANDROID_ENGINE_H__
 #define __WIESEL_PLATFORM_ANDROID_ENGINE_H__
 
+#include <wiesel/wiesel-common.def>
+
 #ifdef __ANDROID__
 
 #include "../../../wiesel/engine.h"
 	/**
 	 * @brief The android engine implementation.
 	 */
-	class AndroidEngine
+	class WIESEL_COMMON_EXPORT AndroidEngine
 	: public Engine
 	{
 	public:

src/common/wiesel/platform/android/android_screen.h

 #ifndef __WIESEL_PLATFORM_ANDROID_SCREEN_H__
 #define __WIESEL_PLATFORM_ANDROID_SCREEN_H__
 
+#include <wiesel/wiesel-common.def>
+
 #ifdef __ANDROID__
 
 #include "../../screen.h"
 	/**
 	 * @brief The android Screen implementation.
 	 */
-	class AndroidScreen
+	class WIESEL_COMMON_EXPORT AndroidScreen
 	: public Screen
 	{
 	private:

src/common/wiesel/platform/android/file_support/android_asset_fs.h

 #ifndef __WIESEL_PLATFORM_ANDROID_FILESUPPORT_ANDROID_ASSET_FS_H__
 #define __WIESEL_PLATFORM_ANDROID_FILESUPPORT_ANDROID_ASSET_FS_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "wiesel/io/filesystem.h"
 
 #include <android/asset_manager.h>
 
 
 
-	class AndroidAssetFileSystem : public FileSystem
+	class WIESEL_COMMON_EXPORT AndroidAssetFileSystem : public FileSystem
 	{
 	private:
 		AndroidAssetFileSystem() {};
 
 
 
-	class AndroidAssetFileSystemDirectory : public Directory
+	class WIESEL_COMMON_EXPORT AndroidAssetFileSystemDirectory : public Directory
 	{
 	public:
 		AndroidAssetFileSystemDirectory(AndroidAssetFileSystem *fs, Directory *parent, const std::string &name);
 
 
 
-	class AndroidAssetFileSystemFile : public File
+	class WIESEL_COMMON_EXPORT AndroidAssetFileSystemFile : public File
 	{
 	public:
 		AndroidAssetFileSystemFile(AndroidAssetFileSystemDirectory *parent, const std::string &name);

src/common/wiesel/platform/android/platform_main.h

 #ifndef __WIESEL_PLATFORM_ANDROID_PLATFORM_MAIN_H__
 #define __WIESEL_PLATFORM_ANDROID_PLATFORM_MAIN_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "../../application.h"
 
 #if defined(__ANDROID__)
 	}
 
 /// delegate for the application entry point
-void __internal_android_main(wiesel::Application *application, struct android_app* state);
+void WIESEL_COMMON_EXPORT __internal_android_main(wiesel::Application *application, struct android_app* state);
 
 #endif // defined(__ANDROID__)
 

src/common/wiesel/platform/generic/generic_root_fs.h

 #ifndef __WIESEL_PLATFORM_GENERIC_FILESUPPORT_GENERIC_ROOT_FS_H__
 #define __WIESEL_PLATFORM_GENERIC_FILESUPPORT_GENERIC_ROOT_FS_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "wiesel/io/filesystem.h"
 
 
 
 
 
-	class GenericFileSystem : public FileSystem
+	class WIESEL_COMMON_EXPORT GenericFileSystem : public FileSystem
 	{
 	public:
 		GenericFileSystem();
 
 
 
-	class GenericFileSystemDirectory : public Directory
+	class WIESEL_COMMON_EXPORT GenericFileSystemDirectory : public Directory
 	{
 	public:
 		GenericFileSystemDirectory(GenericFileSystem *fs, Directory *parent, const std::string &name);
 
 
 
-	class GenericFileSystemFile : public File
+	class WIESEL_COMMON_EXPORT GenericFileSystemFile : public File
 	{
 	public:
 		GenericFileSystemFile(GenericFileSystemDirectory *parent, const std::string &name);

src/common/wiesel/platform/sdl/sdl_engine.cpp

 #include "wiesel/util/log.h"
 #include "wiesel/ui/touchhandler.h"
 
-#include <SDL/SDL_image.h>
+#include <SDL_image.h>
 
 #include <assert.h>
 #include <inttypes.h>

src/common/wiesel/platform/sdl/sdl_engine.h

 #ifndef __WIESEL_PLATFORM_SDL_ENGINE_H__
 #define __WIESEL_PLATFORM_SDL_ENGINE_H__
 
+#include <wiesel/wiesel-common.def>
+
 #ifdef WIESEL_USE_LIBSDL
 
 #include "../../../wiesel/engine.h"
 	/**
 	 * @brief The SDL engine implementation.
 	 */
-	class SdlEngine
+	class WIESEL_COMMON_EXPORT SdlEngine
 	: public Engine
 	{
 	public:

src/common/wiesel/platform/sdl/sdl_platform.h

 #ifndef __WIESEL_PLATFORM_SDL_PLATFORM_MAIN_H__
 #define __WIESEL_PLATFORM_SDL_PLATFORM_MAIN_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "../../application.h"
 
 #if WIESEL_USE_LIBSDL
 	}
 
 /// delegate for the application entry point
-void __internal_sdl_app_main(wiesel::Application *app, int argc, char* argv[]);
+WIESEL_COMMON_EXPORT void __internal_sdl_app_main(wiesel::Application *app, int argc, char* argv[]);
 
 #endif // WIESEL_USE_LIBSDL
 

src/common/wiesel/platform/sdl/sdl_screen.cpp

 #include <wiesel/gl/gl.h>
 #include <assert.h>
 
-#include <SDL/SDL.h>
+#include <SDL.h>
 
 
 using namespace wiesel;

src/common/wiesel/platform/sdl/sdl_screen.h

 #ifndef __WIESEL_PLATFORM_SDL_SCREEN_H__
 #define __WIESEL_PLATFORM_SDL_SCREEN_H__
 
+#include <wiesel/wiesel-common.def>
+
 #if WIESEL_USE_LIBSDL
 
 #include "../../screen.h"
 	/**
 	 * @brief The SDL Screen implementation.
 	 */
-	class SdlScreen
+	class WIESEL_COMMON_EXPORT SdlScreen
 	: public Screen
 	{
 	private:

src/common/wiesel/screen.h

 #ifndef __WIESEL_SCREEN_H__
 #define __WIESEL_SCREEN_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include <wiesel/geometry.h>
 #include <wiesel/math/matrix.h>
 
 	/**
 	 * @brief An abstract interface to the current screen.
 	 */
-	class Screen {
+	class WIESEL_COMMON_EXPORT Screen {
 	public:
 		Screen();
 		virtual ~Screen();

src/common/wiesel/ui/bitmapfont.h

 #ifndef __WIESEL_UI_BITMAPFONT_H__
 #define __WIESEL_UI_BITMAPFONT_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "font.h"
 
 namespace wiesel {
 	/**
 	 * @brief A font class implementing a bitmap font, provided from a spritesheet.
 	 */
-	class BitmapFont : public Font
+	class WIESEL_COMMON_EXPORT BitmapFont : public Font
 	{
 	public:
 		/**

src/common/wiesel/ui/font.h

 #ifndef __WIESEL_UI_FONT_H__
 #define	__WIESEL_UI_FONT_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "wiesel/util/shared_object.h"
 
 #include <string>
 	/**
 	 * @brief A class used by \ref LabelNode
 	 */
-	class Font : public virtual SharedObject
+	class WIESEL_COMMON_EXPORT Font : public virtual SharedObject
 	{
 	protected:
 		Font();

src/common/wiesel/ui/label_node.h

 #ifndef __WIESEL_UI_LABELNODE_H__
 #define	__WIESEL_UI_LABELNODE_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include "wiesel/graph/2d/multisprite_node.h"
 
 #include <string>
 	/**
 	 * @brief A node which can display multiline texts.
 	 */
-	class LabelNode : public MultiSpriteNode
+	class WIESEL_COMMON_EXPORT LabelNode : public MultiSpriteNode
 	{
 	public:
 		LabelNode();

src/common/wiesel/ui/touch.h

 #ifndef __WIESEL_UI_TOUCH_H__
 #define	__WIESEL_UI_TOUCH_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include <wiesel/util/shared_object.h>
 #include <wiesel/math/vector2d.h>
 #include <wiesel/math/vector3d.h>
 
 
 
-	class Touch
+	class WIESEL_COMMON_EXPORT Touch
 	{
 	friend class TouchHandler;
 
 
 
 
-	class TouchReceiver : public virtual SharedObject
+	class WIESEL_COMMON_EXPORT TouchReceiver : public virtual SharedObject
 	{
 	public:
 		TouchReceiver();

src/common/wiesel/ui/touchhandler.h

 #ifndef __WIESEL_UI_TOUCHHANDLER_H__
 #define	__WIESEL_UI_TOUCHHANDLER_H__
 
+#include <wiesel/wiesel-common.def>
+#include <wiesel/engine_interfaces.h>
+
 #include "touch.h"
 
-#include <wiesel/engine_interfaces.h>
-
 #include <vector>
 
 
 	/**
 	 * @brief Manager class for handling touch events.
 	 */
-	class TouchHandler :
+	class WIESEL_COMMON_EXPORT TouchHandler :
 		public IUpdateable
 	{
 	public:

src/common/wiesel/util/imageutils.h

 #ifndef __WIESEL_UTIL_IMAGEUTILS_H__
 #define __WIESEL_UTIL_IMAGEUTILS_H__
 
+#include <wiesel/wiesel-common.def>
+
 namespace wiesel {
 namespace imageutils {
 
 	/**
 	 * @brief compute the next power-of-two size, which is equal or greater than the input number.
 	 */
-	unsigned int getNextPowerOfTwo(unsigned int number);
+	WIESEL_COMMON_EXPORT unsigned int getNextPowerOfTwo(unsigned int number);
 
 	/**
 	 * @brief increase or decrease the size of the image.
 	 * @return the buffer of the resized image, which may be the same as the original input.
 	 */
-	unsigned char* resizeImage(
+	WIESEL_COMMON_EXPORT unsigned char* resizeImage(
 			unsigned char *buffer,			unsigned char bytesPerPixel,
 			unsigned int original_width,	unsigned int original_height,
 			unsigned int new_width,			unsigned int new_height

src/common/wiesel/util/log.h

 #ifndef __WIESEL_UTIL_LOG_H__
 #define __WIESEL_UTIL_LOG_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include <ostream>
 #include <string>
 
 	 * @brief write a single log message to the output console, if the current log level is high enough.
 	 * @param level		The current log level.
 	 */
-	int logmsg(LogLevel level, const char *tag, const char *message, ...)
+	WIESEL_COMMON_EXPORT int logmsg(LogLevel level, const char *tag, const char *message, ...)
 	#if defined(__GNUC__)
 		__attribute__ ((format(printf, 3, 4)))
 	#endif
 	/**
 	 * @brief A Log class for logging messages using a std::ostream derived class.
 	 */
-	class Log : public std::basic_ostream< char, std::char_traits<char> >
+	class WIESEL_COMMON_EXPORT Log : public std::basic_ostream< char, std::char_traits<char> >
 	{
 	public:
 		Log(std::basic_streambuf<char, std::char_traits<char> > *buffer);
 		virtual ~Log();
 
 	public:
-		static Log err;			//!< error log level for critical error messages.
-		static Log warn;		//!< warning log level for minor errors and warnings.
-		static Log info;		//!< info log level for simple program information.
-		static Log debug;		//!< detailed log level for detailed program information, not relevant for productive usage.
+		static WIESEL_COMMON_EXPORT Log err;		//!< error log level for critical error messages.
+		static WIESEL_COMMON_EXPORT Log warn;		//!< warning log level for minor errors and warnings.
+		static WIESEL_COMMON_EXPORT Log info;		//!< info log level for simple program information.
+		static WIESEL_COMMON_EXPORT Log debug;		//!< detailed log level for detailed program information, not relevant for productive usage.
 
 
 		/**
 		 * @brief set the current \ref LogLevel.
 		 * All messages with a higher level than the currently configured level will be discarded.
 		 */
-		static void setLevel(LogLevel level);
+		static WIESEL_COMMON_EXPORT void setLevel(LogLevel level);
 
 		/**
 		 * @brief get the current \ref LogLevel.
 		/**
 		 * @brief checks, if a specific combination of log tag and \ref LogLevel will be included in the log messages.
 		 */
-		static bool isLogged(LogLevel level, const char *tag);
+		static WIESEL_COMMON_EXPORT bool isLogged(LogLevel level, const char *tag);
 
 		/**
 		 * @brief checks, if a specific combination of log tag and \ref LogLevel will be included in the log messages.
 		}
 
 	private:
-		static LogLevel		current_log_level;
+		static WIESEL_COMMON_EXPORT LogLevel		current_log_level;
 	};
 
 } /* namespace wiesel */

src/common/wiesel/util/xml_parser.h

 #ifndef __WIESEL_UTIL_XML_PARSER_H__
 #define __WIESEL_UTIL_XML_PARSER_H__
 
+#include <wiesel/wiesel-common.def>
+
 #include <map>
 #include <string>
 #include <vector>
 	 * An implementation will extend this class and use the callback methods
 	 * to read the XML content.
 	 */
-	class XmlSaxParser
+	class WIESEL_COMMON_EXPORT XmlSaxParser
 	{
 	public:
 		/**

src/common/wiesel/wiesel-common.def

+/**
+ * Copyright (C) 2012
+ * Christian Fischer
+ *
+ * https://bitbucket.org/baldur/wiesel/
+ *
+ * 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 3 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA
+ */
+#ifndef __WIESEL_COMMON_DEF_H__
+#define __WIESEL_COMMON_DEF_H__
+
+/**
+ * some defines and flags specially for the wiesel-common library
+ */
+
+#if defined(_WIN32)
+	#if defined(wiesel_common_EXPORTS)
+		#define WIESEL_COMMON_EXPORT		__declspec(dllexport)
+	#else
+		#define WIESEL_COMMON_EXPORT		__declspec(dllimport)
+	#endif
+#else
+		#define WIESEL_COMMON_EXPORT		
+#endif
+
+
+#endif // __WIESEL_COMMON_DEF_H__
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.