Move to gitHub the edn project (remove history keep it on my nas)

Sources/tools/AL/AL_Mutex.cpp

@@ -0,0 +1,179 @@
+/**
+ *******************************************************************************
+ * @file AL_Mutex.c
+ * @brief Editeur De N'ours : Abstraction Layer Mutex
+ * @author Edouard DUPIN
+ * @date 04/12/2010
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+
+#include "tools_debug.h"
+#include "AL_Mutex.h"
+// /usr/include/pthread.h
+
+
+/**
+ * @brief initialize the curent Mutex
+ *
+ * @param[in,out]  pointerMutex    Pointer on the mutex that might be init
+ * @param[in]      recursive       Enable the possibility that one thread can lock multiple time the same Mutex
+ *
+ * @return an standard Error Code (ERR_NONE / ERR_FAIL)
+ *
+ */
+erreurCode_te AL_mutex_init(AL_MUTEX * pointerMutex,bool recursive)
+{
+	int systemRet;
+	pthread_mutexattr_t mutexattr;
+	erreurCode_te myError= ERR_NONE;
+	EDN_CHECK_INOUT(pointerMutex);
+	// init mutex attributes
+	systemRet = pthread_mutexattr_init(&mutexattr);
+	if (0 == systemRet) {
+		if (true == recursive) {
+			systemRet = pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_RECURSIVE_NP);
+			EDN_ASSERT(!systemRet, "pthread_mutexattr_settype Error");
+		}
+		else {
+			systemRet = pthread_mutexattr_settype(&mutexattr, PTHREAD_MUTEX_ERRORCHECK_NP);
+			EDN_ASSERT(!systemRet, "pthread_mutexattr_settype Error");
+		}
+	}
+	if (0 == systemRet) {
+		systemRet = pthread_mutex_init(pointerMutex, &mutexattr);
+		EDN_ASSERT(!systemRet, "pthread_mutex_init Error Mutex Init");
+		if (systemRet) {
+			myError = ERR_FAIL;
+		}
+	}
+	systemRet = pthread_mutexattr_destroy(&mutexattr);
+	EDN_ASSERT(0 == systemRet, "pthread_mutexattr_destroy Error");
+	return myError;
+}
+
+
+/**
+ * @brief Destroy the current Mutex
+ *
+ * @param[in,out]  pointerMutex    Pointer on the mutex that might be init
+ *
+ * @return an standard Error Code (ERR_NONE / ERR_FAIL)
+ *
+ */
+erreurCode_te AL_mutex_destroy(AL_MUTEX * pointerMutex)
+{
+	int systemRet;
+	EDN_CHECK_INOUT(pointerMutex);
+	systemRet = pthread_mutex_destroy(pointerMutex);
+	EDN_ASSERT(!systemRet, "pthread_mutex_destroy Error Mutex Destroy");
+	if (systemRet) {
+		return ERR_FAIL;
+	}
+	return ERR_NONE;
+}
+
+
+/**
+ * @brief Lock the curent Mutex. Lock call
+ *
+ * @param[in,out]  pointerMutex    Pointer on the mutex that might be init
+ *
+ * @return ---
+ *
+ */
+void AL_mutex_lock(AL_MUTEX * pointerMutex)
+{
+	int systemRet;
+	EDN_CHECK_INOUT(pointerMutex);
+	systemRet = pthread_mutex_lock(pointerMutex);
+	EDN_ASSERT(!systemRet, "pthread_mutex_lock Error Mutex lock");
+}
+
+
+/**
+ * @brief Unlock the current Mutex
+ *
+ * @param[in,out]  pointerMutex    Pointer on the mutex that might be init
+ *
+ * @return ---
+ *
+ */
+void AL_mutex_unlock(AL_MUTEX * pointerMutex)
+{
+	int systemRet;
+	EDN_CHECK_INOUT(pointerMutex);
+	systemRet = pthread_mutex_unlock(pointerMutex);
+	EDN_ASSERT(!systemRet, "pthread_mutex_unlock Error Mutex unlock");
+}
+
+
+/**
+ * @brief Try the lock of the curent Mutex
+ *
+ * @param[in,out]  pointerMutex    Pointer on the mutex that might be init
+ *
+ * @return an standard Error Code (ERR_NONE / ERR_BUSY)
+ *
+ */
+erreurCode_te AL_mutex_trylock(AL_MUTEX * pointerMutex)
+{
+	int systemRet;
+	EDN_CHECK_INOUT(pointerMutex);
+	systemRet = pthread_mutex_trylock(pointerMutex);
+	EDN_ASSERT(0==systemRet || EBUSY==systemRet, "pthread_mutex_trylock Error Mutex unlock");
+	if (EBUSY==systemRet) {
+		return ERR_BUSY;
+	}
+	return ERR_NONE;
+}
+
+
+/**
+ * @brief try lock in a periode of time
+ *
+ * @param[in,out]  pointerMutex    Pointer on the mutex that might be init
+ *
+ * @return an standard Error Code (ERR_NONE / ERR_TIMEOUT)
+ *
+ */
+erreurCode_te AL_mutex_timedlock(AL_MUTEX * pointerMutex, int32_t delay)
+{
+/*
+	int systemRet;
+	EDN_CHECK_INOUT(pointerMutex);
+	if (0 == delay) {
+		return ERR_NONE;
+	}
+	// TODO ... check is it OK...
+	systemRet = pthread_mutex_timedlock(pointerMutex, delay);
+	EDN_ASSERT(0 == systemRet || ETIMEDOUT == systemRet, "pthread_mutex_timedlock Error");
+	if (ETIMEDOUT == systemRet) {
+		return ERR_TIMEOUT;
+	}
+*/
+	return ERR_NONE;
+}
+
+
+
+
+
+
+

Sources/tools/AL/AL_Mutex.h

@@ -0,0 +1,45 @@
+/**
+ *******************************************************************************
+ * @file AL_Mutex.h
+ * @brief Editeur De N'ours : Abstraction Layer Mutex
+ * @author Edouard DUPIN
+ * @date 04/12/2010
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+ 
+#ifndef __AL_MUTEX_H__
+#define __AL_MUTEX_H__
+
+//basic mutex with pthread system
+#include <pthread.h>
+#include <errno.h>
+
+
+typedef pthread_mutex_t     AL_MUTEX;
+
+erreurCode_te AL_mutex_init(AL_MUTEX * pointerMutex,bool recursive);
+erreurCode_te AL_mutex_destroy(AL_MUTEX * pointerMutex);
+void          AL_mutex_lock(AL_MUTEX * pointerMutex);
+void          AL_mutex_unlock(AL_MUTEX * pointerMutex);
+erreurCode_te AL_mutex_trylock(AL_MUTEX * pointerMutex);
+//erreurCode_te AL_mutex_timedlock(AL_MUTEX * pointerMutex, int32_t delay);
+
+#endif
+
+

Sources/tools/ClipBoard/ClipBoard.cpp

@@ -0,0 +1,95 @@
+/**
+ *******************************************************************************
+ * @file ClipBoard.cpp
+ * @brief Editeur De N'ours : copy / past main system
+ * @author Edouard DUPIN
+ * @date 05/12/2010
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+#include "tools_globals.h"
+#include "ClipBoard.h"
+
+#undef __class__
+#define __class__	"ClipBoard"
+
+/*
+note: la copy dans le :
+        0 : copy standard
+   [1..9] : copy interne
+       10 : bouton du milieux
+*/
+static EdnVectorBin<int8_t> mesCopy[TOTAL_OF_CLICKBOARD];
+
+
+void ClipBoard::Init(void)
+{
+	EDN_INFO("Initialyse ClipBoards");
+	for(int32_t i=0; i<TOTAL_OF_CLICKBOARD; i++) {
+		mesCopy[i].Clear();
+	}
+}
+
+
+void ClipBoard::Set(uint8_t clipboardID, EdnVectorBin<int8_t> &data)
+{
+	// check if ID is correct
+	if(clipboardID >= TOTAL_OF_CLICKBOARD) {
+		EDN_WARNING("request ClickBoard id error");
+	} else if(0 == data.Size()) {
+		EDN_WARNING("request a copy of nothing");
+	} else if (COPY_STD == clipboardID) {
+		GtkClipboard * clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
+		gtk_clipboard_set_text(clipboard, (const gchar*)&data[0], data.Size() );
+	} else if (COPY_MIDDLE_BUTTON == clipboardID) {
+		GtkClipboard * clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
+		gtk_clipboard_set_text(clipboard, (const gchar*)&data[0], data.Size() );
+	}
+	// Copy datas ...
+	mesCopy[clipboardID] = data;
+}
+
+
+void ClipBoard::Get(uint8_t clipboardID, EdnVectorBin<int8_t> &data)
+{
+	if(clipboardID >= TOTAL_OF_CLICKBOARD) {
+		EDN_WARNING("request ClickBoard id error");
+	} else if (COPY_STD == clipboardID) {
+		GtkClipboard * clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD );
+		gchar *text = gtk_clipboard_wait_for_text(clipboard);
+		if (text != NULL) {
+			mesCopy[COPY_STD].Clear();
+			mesCopy[COPY_STD].PushBack((int8_t*)text, strlen(text) );
+		}
+	} else if (COPY_MIDDLE_BUTTON == clipboardID) {
+		GtkClipboard * clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY );
+		gchar *text = gtk_clipboard_wait_for_text(clipboard);
+		if (text != NULL) {
+			mesCopy[COPY_MIDDLE_BUTTON].Clear();
+			mesCopy[COPY_MIDDLE_BUTTON].PushBack((int8_t*)text, strlen(text) );
+		}
+	}
+	// Copy datas ...
+	data = mesCopy[clipboardID];
+}
+
+
+
+
+

Sources/tools/ClipBoard/ClipBoard.h

@@ -0,0 +1,45 @@
+/**
+ *******************************************************************************
+ * @file ClipBoard.h
+ * @brief Editeur De N'ours : copy / past main system (header)
+ * @author Edouard DUPIN
+ * @date 30/12/2010
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+ 
+#ifndef __CLIP_BOARD_H__
+#define __CLIP_BOARD_H__
+
+	#include "tools_debug.h"
+	#include "EdnVectorBin.h"
+
+	#define TOTAL_OF_CLICKBOARD			(11)
+	#define COPY_MIDDLE_BUTTON			(10)
+	#define COPY_STD					(0)
+
+	namespace ClipBoard
+	{
+		void	Init(void);
+		void	Set(uint8_t clipboardID, EdnVectorBin<int8_t> &data);
+		void	Get(uint8_t clipboardID, EdnVectorBin<int8_t> &data);
+	}
+
+#endif
+
+

Sources/tools/Display/Display.cpp

@@ -0,0 +1,623 @@
+/**
+ *******************************************************************************
+ * @file Display.cpp
+ * @brief Editeur De N'ours : Basic Pixbuf display function
+ * @author Edouard DUPIN
+ * @date 21/01/2010
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+#include "tools_debug.h"
+#include "tools_globals.h"
+#include "Display.h"
+#include "ColorizeManager.h"
+#include "charset.h"
+#include <string>
+
+#undef __class__
+#define __class__	"Display"
+
+
+#define FONT_BOLD_NO	(0)
+#define FONT_BOLD_YES	(1)
+#define FONT_ITALIC_NO	(0)
+#define FONT_ITALIC_YES	(1)
+
+
+// Variables privé du namespace
+#define		POLICE_NAME		"Monospace"
+
+#ifdef USE_GTK_VERSION_3_0
+	#define		POLICE_SIZE		15
+	static int32_t				m_pangoFontWidth  = 9;
+	static int32_t				m_pangoFontHeight = 19;
+#elif USE_GTK_VERSION_2_0
+	#define		POLICE_SIZE		12
+	static int32_t				m_pangoFontWidth  = 7;
+	static int32_t				m_pangoFontHeight = 15;
+#endif
+/*
+	#define		POLICE_SIZE		11
+	static int32_t				  m_pangoFontWidth  = 7;
+	static int32_t				  m_pangoFontHeight = 11;
+static cairo_font_face_t	* m_cairoFont[2][2] = {{NULL, NULL},{ NULL, NULL}};
+*/
+static cairo_font_face_t	* m_cairoFont[2][2] = {{NULL, NULL},{ NULL, NULL}};
+void Display::Init(void)
+{
+	/*
+	charWidth = gdk_char_width(myFont[FONT_ITALIC_YES][FONT_BOLD_NO], 'Z');
+	EDN_INFO("Font Width = %d", charWidth);
+	charHeignt = gdk_char_height(myFont[FONT_ITALIC_YES][FONT_BOLD_NO], 'Z');
+	EDN_INFO("Font Height = %d", charHeignt);
+	*/
+	
+	m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_NO]		= cairo_toy_font_face_create(POLICE_NAME, CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
+	m_cairoFont[FONT_ITALIC_YES][FONT_BOLD_NO]		= cairo_toy_font_face_create(POLICE_NAME, CAIRO_FONT_SLANT_ITALIC, CAIRO_FONT_WEIGHT_NORMAL);
+	m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_YES]		= cairo_toy_font_face_create(POLICE_NAME, CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
+	m_cairoFont[FONT_ITALIC_YES][FONT_BOLD_YES]		= cairo_toy_font_face_create(POLICE_NAME, CAIRO_FONT_SLANT_ITALIC, CAIRO_FONT_WEIGHT_BOLD);
+	if ( NULL == m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_NO]) {
+		EDN_ASSERT(FALSE, "basic font ERROR");
+	}
+	if ( NULL == m_cairoFont[FONT_ITALIC_YES][FONT_BOLD_NO]) {
+		EDN_ERROR("Italic font error ... link with basic font");
+		m_cairoFont[FONT_ITALIC_YES][FONT_BOLD_NO] = m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_NO];
+	}
+	if ( NULL == m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_YES]) {
+		EDN_ERROR("Bold font error ... link with basic font");
+		m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_YES] = m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_NO];
+	}
+	if ( NULL == m_cairoFont[FONT_ITALIC_YES][FONT_BOLD_YES]) {
+		EDN_ERROR("Italic & Bold font error ... link with basic font");
+		m_cairoFont[FONT_ITALIC_YES][FONT_BOLD_YES] = m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_NO];
+	}
+}
+
+
+
+
+
+void Display::UnInit(void)
+{
+	// clean the builder...
+	free(m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_NO]);
+	free(m_cairoFont[FONT_ITALIC_YES][FONT_BOLD_NO]);
+	free(m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_YES]);
+	free(m_cairoFont[FONT_ITALIC_YES][FONT_BOLD_YES]);
+}
+
+
+int32_t Display::GetFontHeight(void)
+{
+	return m_pangoFontHeight;
+}
+
+int32_t Display::GetFontWidth(void)
+{
+	return m_pangoFontWidth;
+}
+
+
+
+cairo_font_face_t * Display::GetFont(bool bold, bool italic)
+{
+    if(    false == bold
+        && false == italic) {
+        return m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_NO];
+    } else if(    true  == bold
+               && false == italic) {
+        return m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_YES];
+    } else if (   false == bold
+               && true  == italic) {
+        return m_cairoFont[FONT_ITALIC_YES][FONT_BOLD_NO];
+    }
+    return m_cairoFont[FONT_ITALIC_YES][FONT_BOLD_YES];
+}
+
+
+#undef __class__
+#define __class__	"DrawerManager"
+
+/**
+ * @brief DrawerManager constructor : generate a memoryDC where we can draw everything...
+ *
+ * @param [in]		window			Current windows where the memoryDC must be paint
+ * @param [in]		x				Current width of the Display
+ * @param [in]		y				Current Height of the Display
+ *
+ * @note : No exeption
+ *
+ * @return ---
+ *
+ */
+DrawerManager::DrawerManager(GtkWidget * widget, int32_t x, int32_t y)
+{
+
+	m_size.x = x;
+	m_size.y = y;
+	m_haveWork = false;
+	// Create the Cairo Element
+#   if USE_GTK_VERSION_3_0
+	m_cairo = gdk_cairo_create(gtk_widget_get_window(widget));
+#   elif USE_GTK_VERSION_2_0
+	m_cairo = gdk_cairo_create(widget->window);
+#   endif
+	//cairo_translate(m_cairo, 0, 7);
+	cairo_set_source_rgb(m_cairo, 0, 0, 0);
+	cairo_paint(m_cairo);
+	cairo_set_font_size(m_cairo, POLICE_SIZE);
+	m_dataToDisplay[0] = '\0';
+	
+	cairo_scale(m_cairo, 1.0, 1.0);
+	
+}
+
+
+/**
+ * @brief main DrawerManager destructor : Copy data on the curent screen
+ *
+ * @param ---
+ *
+ * @note : No exeption
+ *
+ * @return ---
+ *
+ */
+DrawerManager::~DrawerManager()
+{
+	cairo_destroy(m_cairo);
+}
+
+
+/**
+ * @brief Draw Text with the specify color
+ *
+ *		This function does not display the text directly, it save it while a flush appare or the y position differ, or the color differ.
+ *		This is for the char by char writing ==> more efficient when we write multiple char.
+ *
+ * @param [in]		SelectColor		Color that is used to display data
+ * @param [in]		x				Horizontal position to display data
+ * @param [in]		y				Vertical position to display data
+ * @param [in]		myText			Text to write in UTF8 ...
+ * @param [in]		displayBG		unused
+ *
+ * @return ---
+ *
+ */
+void DrawerManager::Text(Colorize *SelectColor, int32_t x, int32_t y,const char *myUTF8Text, int32_t len)
+{
+	EDN_CHECK_INOUT(NULL!=SelectColor);
+	// check if flush is needed : 
+	if (true == m_haveWork) {
+		if(		m_pos.y != y
+			||	m_selectColor != SelectColor)
+		{
+			Flush();
+		}
+	}
+	
+	// check change
+	if (false == m_haveWork) {
+		m_pos.x = x;
+		m_pos.y = y;
+		m_selectColor = SelectColor;
+	}
+	//EDN_WARNING("add data : \"" << myText << "\" x=" << x << " y=" << y );
+	// process : 
+	m_haveWork = true;
+	strcat(m_dataToDisplay, myUTF8Text);
+	if (len != -1 ) {
+		m_nbElement+=len;
+	} else {
+		m_nbElement+=strUtf8Len(myUTF8Text);
+	}
+}
+
+void DrawerManager::Text(color_ts & SelectColorFg, color_ts & SelectColorBg, int32_t x, int32_t y,const char *myText)
+{
+	Flush();
+	cairo_set_font_face(m_cairo, Display::GetFont(false, false));
+	int32_t letterHeight = Display::GetFontHeight();
+	int32_t letterWidth = Display::GetFontWidth();
+	int32_t stringLen = strUtf8Len(myText);
+	DirectRectangle(SelectColorBg, x, y, letterWidth*strlen(myText), letterHeight);
+	cairo_fill(m_cairo);
+	cairo_move_to(m_cairo, x, y+letterHeight-4);
+	cairo_set_source_rgb(m_cairo, SelectColorFg.red, SelectColorFg.green, SelectColorFg.blue);
+	cairo_show_text(m_cairo, myText);
+	cairo_fill(m_cairo);
+}
+
+void DrawerManager::Text(color_ts & SelectColorFg, int32_t x, int32_t y,const char *myText)
+{
+	Flush();
+	cairo_set_font_face(m_cairo, Display::GetFont(false, false));
+	int32_t letterHeight = Display::GetFontHeight();
+	cairo_move_to(m_cairo, x, y+letterHeight-4);
+	cairo_set_source_rgb(m_cairo, SelectColorFg.red, SelectColorFg.green, SelectColorFg.blue);
+	cairo_show_text(m_cairo, myText);
+	cairo_fill(m_cairo);
+	
+}
+
+void DrawerManager::SpaceText(color_ts & SelectColor, int32_t x, int32_t y,int32_t nbChar)
+{
+	Flush();
+	int32_t letterHeight = Display::GetFontHeight();
+	int32_t letterWidth = Display::GetFontWidth();
+	DirectRectangle(SelectColor, x, y, letterWidth*nbChar, letterHeight);
+	cairo_fill(m_cairo);
+}
+
+
+/**
+ * @brief Force de display of the curent Text
+ *
+ *		The flush is to be more performent with the Pango display methode...
+ *
+ * @param ---
+ *
+ * @return ---
+ *
+ */
+void DrawerManager::Flush(void)
+{
+	if (true == m_haveWork) {
+		//EDN_WARNING("flush : \"" << m_dataToDisplay << "\"");
+		m_haveWork = false;
+
+		cairo_set_font_face(m_cairo, Display::GetFont(m_selectColor->GetBold(), m_selectColor->GetItalic()));
+		int32_t letterHeight = Display::GetFontHeight();
+		if (true == m_selectColor->HaveBg() ) {
+			int32_t letterWidth = Display::GetFontWidth();
+			int32_t stringLen = m_nbElement;
+			// generate Clean BG:
+			DirectRectangle(m_selectColor, m_pos.x, m_pos.y, letterWidth*stringLen, letterHeight);
+		}
+		cairo_move_to(m_cairo, m_pos.x, m_pos.y+letterHeight-4);
+		m_selectColor->ApplyFG(m_cairo);
+		cairo_show_text(m_cairo, m_dataToDisplay);
+		cairo_fill(m_cairo);
+		
+		m_dataToDisplay[0] = '\0';
+		m_nbElement = 0;
+	}
+}
+
+
+/**
+ * @brief display a rectangle with the curent bgColor and no border
+ *
+ *		This function in the open API to drow the rectangle, it flush the curent Text in the buffer
+ *
+ * @param [in]		SelectColor		Color that is used to display rectangle
+ * @param [in]		x				Horizontal position to display rectangle
+ * @param [in]		y				Vertical position to display rectangle
+ * @param [in]		width			Width of the rectangle
+ * @param [in]		height			Height of the rectangle
+ *
+ * @return ---
+ *
+ */
+void DrawerManager::Rectangle(Colorize *SelectColor, int32_t x, int32_t y, int32_t width, int32_t height)
+{
+	Flush();
+	DirectRectangle(SelectColor, x, y, width, height);
+}
+
+
+/**
+ * @brief Real function to display the rectangle (no flush done (expectially for the Background display)
+ *
+ * @param [in]		SelectColor		Color that is used to display rectangle
+ * @param [in]		x				Horizontal position to display rectangle
+ * @param [in]		y				Vertical position to display rectangle
+ * @param [in]		width			Width of the rectangle
+ * @param [in]		height			Height of the rectangle
+ *
+ * @return ---
+ *
+ */
+void DrawerManager::DirectRectangle(Colorize *SelectColor, int32_t x, int32_t y, int32_t width, int32_t height)
+{
+	EDN_CHECK_INOUT(NULL!=SelectColor);
+	//EDN_INFO("x="<< x <<" y="<< y <<" width="<< width <<" height="<< height);
+	//gdk_draw_rectangle(	p_pixmap, SelectColor->GetColorBG(), TRUE, x, y, width, height);
+	// set color
+	SelectColor->ApplyBG(m_cairo);
+	// set postion
+	cairo_rectangle(m_cairo, x, y, width, height);
+	//cairo_stroke(m_cairo);
+	// flush
+	cairo_fill(m_cairo);
+}
+void DrawerManager::DirectRectangle(color_ts &SelectColor, int32_t x, int32_t y, int32_t width, int32_t height)
+{
+
+	cairo_set_source_rgb(m_cairo, SelectColor.red, SelectColor.green, SelectColor.blue);
+	// set postion
+	cairo_rectangle(m_cairo, x, y, width, height);
+	//cairo_stroke(m_cairo);
+	// flush
+	cairo_fill(m_cairo);
+}
+
+
+/**
+ * @brief Clean the curent Windows with the curent color
+ *
+ * @param [in]		SelectColor		Color that is used to display background
+ *
+ * @return ---
+ *
+ */
+void DrawerManager::Clean(Colorize *SelectColor)
+{
+	m_haveWork = false;
+	DirectRectangle(SelectColor, 0, 0, m_size.x, m_size.y);
+}
+
+/**
+ * @brief Clean the curent Windows with the curent color
+ *
+ * @param [in]		SelectColor		Color that is used to display background
+ *
+ * @return ---
+ *
+ */
+void DrawerManager::Clean(color_ts & SelectColor)
+{
+	m_haveWork = false;
+	DirectRectangle(SelectColor, 0, 0, m_size.x, m_size.y);
+}
+
+/**
+ * @brief Display a cursor with the cortect form.
+ *
+ *		Automatic selection of the XML color "cursorColor"
+ *
+ * @param [in]		x				Horizontal position to display cursor
+ * @param [in]		y				Vertical position to display cursor
+ *
+ * @return ---
+ *
+ */
+#define CURSOR_WIDTH	(4)
+void DrawerManager::Cursor(int32_t x, int32_t y)
+{
+	Flush();
+	// get the cursor Color : 
+	color_ts myColor = ColorizeManager::getInstance()->Get(COLOR_CODE_CURSOR);
+	cairo_set_source_rgb(m_cairo, myColor.red, myColor.green, myColor.blue);
+
+	// draw cursor
+	int32_t letterHeight = Display::GetFontHeight();
+	int32_t letterWidth = Display::GetFontWidth();
+	// depending on the inserting mode
+	if (false == globals::IsSetInsert()) {
+		cairo_set_line_width(m_cairo, 2);
+		cairo_move_to(m_cairo, x-CURSOR_WIDTH, y - letterHeight+1);
+		cairo_rel_line_to(m_cairo, CURSOR_WIDTH*2, 0);
+		cairo_rel_move_to(m_cairo, -CURSOR_WIDTH, 0);
+		cairo_rel_line_to(m_cairo, 0, letterHeight-2);
+		cairo_rel_move_to(m_cairo, -CURSOR_WIDTH, 0);
+		cairo_rel_line_to(m_cairo, CURSOR_WIDTH*2, 0);
+	} else {
+		cairo_set_line_width(m_cairo, 1);
+		cairo_move_to(m_cairo, x, y - letterHeight  + 1);
+		cairo_rel_line_to(m_cairo, letterWidth, 0);
+		cairo_rel_line_to(m_cairo, 0, letterHeight);
+		cairo_rel_line_to(m_cairo, -letterWidth, 0);
+		cairo_rel_line_to(m_cairo, 0, -letterHeight);
+	}
+	cairo_stroke(m_cairo);
+	cairo_fill(m_cairo);
+}
+
+/**
+ * @brief Display a end of the curent line ...
+ *
+ *		Automatic draw the end of line with the curent XML color "cursorColor"
+ *
+ * @param [in]		x				Horizontal position to display cursor
+ * @param [in]		y				Vertical position to display cursor
+ *
+ * @return ---
+ *
+ */
+void DrawerManager::EndOfLine(int32_t x, int32_t y)
+{
+	if (true == globals::IsSetDisplayEndOfLine() ) {
+		Flush();
+		// get the cursor Color : 
+		color_ts myColor = ColorizeManager::getInstance()->Get(COLOR_CODE_CURSOR);
+		cairo_set_source_rgb(m_cairo, myColor.red, myColor.green, myColor.blue);
+		// draw cursor
+		int32_t letterHeight = Display::GetFontHeight();
+		// depending on the inserting mode
+		/*
+				x1		x2
+			y1	| |-----
+				| |-----
+				| |
+			y2	| |
+		*/
+		cairo_set_line_width(m_cairo, 2);
+		cairo_move_to(m_cairo, x, y - letterHeight+1);
+		cairo_rel_line_to(m_cairo, 0, letterHeight);
+		cairo_move_to(m_cairo, x+2, y - letterHeight+1);
+		cairo_rel_line_to(m_cairo, 0, letterHeight);
+		cairo_arc(m_cairo, x+3, y - letterHeight/4*3, 3.0, -3.149/2, 3.149/2);
+		cairo_stroke(m_cairo);
+		cairo_fill(m_cairo);
+	}
+}
+
+
+
+/**
+ * @brief Display a Tabulation with the user form selection.
+ *
+ * @param [in]		SelectColor		Color that is used to display Tabulation
+ * @param [in]		x				Horizontal position to display cursor
+ * @param [in]		y				Vertical position to display cursor
+ * @param [in]		mbColomn		Width of the current Tabulation caracter (in number of Char)
+ *
+ * @return ---
+ *
+ */
+void DrawerManager::Tabulation(Colorize *SelectColor, int32_t x, int32_t y, int32_t mbColomn)
+{
+	Flush();
+	int32_t letterWidth = Display::GetFontWidth();
+	int32_t letterHeight = Display::GetFontHeight();
+	
+	// generate Clean BG:
+	DirectRectangle(SelectColor, x, y-letterHeight, letterWidth*mbColomn, letterHeight);
+	
+	// set the pen for the display
+	SelectColor->ApplyFG(m_cairo);
+	
+	uint32_t yCalc = y - (letterHeight+1)/2;
+	
+	cairo_move_to(m_cairo, x + 3, yCalc);
+	cairo_line_to(m_cairo, x + letterWidth*mbColomn - 2 , yCalc);
+	cairo_rel_line_to(m_cairo, -6 , -2);
+	cairo_move_to(m_cairo, x + letterWidth*mbColomn - 2 , yCalc);
+	cairo_rel_line_to(m_cairo, -6 , +2);
+	
+	cairo_stroke(m_cairo);
+	cairo_fill(m_cairo);
+}
+
+
+/**
+ * @brief Display an unknow UTF8 character (a special rectangle)
+ *
+ * @param [in]		SelectColor			Color that is used to display Tabulation
+ * @param [in]		x					Horizontal position to display cursor
+ * @param [in]		y					Vertical position to display cursor
+ * @param [in]		utf8Size			number of char used by the UTF8 character
+ * @param [in]		ValidUtf8			true if the character UTF8 is well encoded
+ *
+ * @return ---
+ *
+ */
+void DrawerManager::UTF8UnknownElement(Colorize *SelectColor, int32_t x, int32_t y, int8_t utf8Size, bool ValidUtf8)
+{
+	Flush();
+	int32_t letterWidth = Display::GetFontWidth();
+	int32_t letterHeight = Display::GetFontHeight();
+	
+	// generate Clean BG:
+	DirectRectangle(SelectColor, x, y-letterHeight, letterWidth*2, letterHeight);
+	
+	SelectColor->ApplyFG(m_cairo);
+	
+	/*
+			y1		y2
+		x1	|-------|
+			|		|
+			|		|
+		x2	|-------|
+	*/
+	uint32_t x1 = x                 + 2;
+	uint32_t x2 = x + letterWidth*2 - 2;
+	uint32_t y1 = y - letterHeight  + 2;
+	uint32_t y2 = y                 - 2;
+	// Box
+	cairo_move_to(m_cairo, x1 , y1);
+	cairo_line_to(m_cairo, x2 , y1);
+	cairo_line_to(m_cairo, x2 , y2);
+	cairo_line_to(m_cairo, x1 , y2);
+	cairo_line_to(m_cairo, x1 , y1);
+	// croix in the middle
+	switch(utf8Size)
+	{
+		case 1:
+			break;
+		case 2:
+			cairo_line_to(m_cairo, x2 , y2);
+			break;
+		case 3:
+			cairo_move_to(m_cairo, x1 , y2);
+			cairo_line_to(m_cairo, x2 , y1);
+			break;
+		default:
+			cairo_line_to(m_cairo, x2 , y2);
+			cairo_move_to(m_cairo, x1 , y2);
+			cairo_line_to(m_cairo, x2 , y1);
+			break;
+	}
+	if (false == ValidUtf8) {
+		cairo_move_to(m_cairo, x1 , y2-2);
+		cairo_line_to(m_cairo, x2 , y2-2);
+	}
+	cairo_stroke(m_cairo);
+	cairo_fill(m_cairo);
+}
+
+
+
+
+/* Basic axample with cairo and pango...
+	cairo_t *cr;
+
+	cr = gdk_cairo_create(widget->window);
+
+	cairo_translate(cr, 0, 7);
+
+	cairo_set_source_rgb(cr, 0, 0, 0);
+	cairo_paint(cr);
+
+	gint pos = 18;//GTK_CPU(widget)->sel;
+	gint rect = pos / 5;
+
+	cairo_set_source_rgb(cr, 0.2, 0.4, 0);
+
+	gint i;
+	for ( i = 1; i <= 20; i++) {
+		if (i > 20 - rect) {
+			cairo_set_source_rgb(cr, 0.6, 1.0, 0);
+		} else {
+			cairo_set_source_rgb(cr, 0.2, 0.4, 0);
+		}
+		cairo_rectangle(cr, 8, i*4, 30, 3);
+		cairo_rectangle(cr, 42, i*4, 30, 3);
+		cairo_fill(cr);
+	}
+//----
+	PangoLayout *layout;
+	PangoFontDescription *desc;
+
+	cairo_translate(cr, 10, 20);
+	layout = pango_cairo_create_layout(cr);
+	pango_layout_set_text(layout, "Hello World!", -1);
+	desc = pango_font_description_from_string("Sans Bold 12");
+	pango_layout_set_font_description(layout, desc);
+	pango_font_description_free(desc);
+
+	cairo_set_source_rgb(cr, 0.0, 0.0, 1.0);
+	pango_cairo_update_layout(cr, layout);
+	pango_cairo_show_layout(cr, layout);
+
+	g_object_unref(layout);
+//-----
+	cairo_destroy(cr);
+*/

Sources/tools/Display/Display.h

@@ -0,0 +1,95 @@
+/**
+ *******************************************************************************
+ * @file Display.h
+ * @brief Editeur De N'ours : Basic Pixbuf display function (header)
+ * @author Edouard DUPIN
+ * @date 21/01/2010
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+ 
+#ifndef __TOOLS_DISPLAY_H__
+#define __TOOLS_DISPLAY_H__
+
+	#include "tools_debug.h"
+	#include "Colorize.h"
+	#include "ColorizeManager.h"
+	#include <string>
+	#include <vector>
+
+
+/**
+ *  Basic namespace for the font display system
+ */
+namespace Display
+{
+	void                    Init(void);
+	void                    UnInit(void);
+	cairo_font_face_t *     GetFont(bool bold, bool italic);
+	int32_t                 GetFontHeight(void);
+	int32_t                 GetFontWidth(void);
+};
+
+#define MAX_CARACTER_CYCLE		(512)
+/**
+ * class to abstrate the writing on the curent GUI (INTEFACE to be no dependent of the one chosen)
+ */
+class DrawerManager;
+
+class DrawerManager {
+	public:
+		// Constructeur
+		DrawerManager(GtkWidget * widget, int32_t x, int32_t y);
+		~DrawerManager();
+
+		void    Rectangle(Colorize *SelectColor, int32_t x, int32_t y, int32_t width, int32_t height);
+		void    Rectangle(color_ts & SelectColor, int32_t x, int32_t y, int32_t width, int32_t height) {
+			DirectRectangle(SelectColor, x, y, width, height);
+		}
+		void    Clean(Colorize *SelectColor);
+		void    Clean(color_ts & SelectColor);
+		void    Text(Colorize *SelectColor, int32_t x, int32_t y,const char *myUTF8Text, int32_t len = -1);
+		void    Text(color_ts & SelectColorFg, color_ts & SelectColorBg, int32_t x, int32_t y,const char *myText);
+		void    Text(color_ts & SelectColorFg, int32_t x, int32_t y,const char *myText);
+		void    SpaceText(color_ts & SelectColor, int32_t x, int32_t y,int32_t nbChar);
+		void    Cursor(int32_t x, int32_t y);
+		void    EndOfLine(int32_t x, int32_t y);
+		void    Tabulation(Colorize *SelectColor, int32_t x, int32_t y, int32_t mbColomn);
+		void    UTF8UnknownElement(Colorize *SelectColor, int32_t x, int32_t y, int8_t utf8Size, bool ValidUtf8);
+		void    Flush(void);
+		int32_t GetWidth(void) { return m_size.x; };
+		int32_t GetHeight(void) { return m_size.y; };
+
+	private:
+		void    DirectRectangle(Colorize *SelectColor, int32_t x, int32_t y, int32_t width, int32_t height);
+		void    DirectRectangle(color_ts & SelectColor, int32_t x, int32_t y, int32_t width, int32_t height);
+
+		bool            m_haveWork;                             //!< if data might be print (true)
+		char            m_dataToDisplay[MAX_CARACTER_CYCLE];    //!< curent string to display
+		uint32_t        m_nbElement;                            //!< nb element in the string
+		position_ts     m_pos;                                  //!< position where start the string display (X,Y)
+		Colorize *      m_selectColor;                          //!< curent color to display
+
+		position_ts     m_size;                                 //!< Total size
+		cairo_t *       m_cairo;                                //!< Cairo Layout pointer
+		
+};
+
+
+#endif
+

Sources/tools/EdnBuf/EdnBuf.h

@@ -0,0 +1,212 @@
+/**
+ *******************************************************************************
+ * @file EdnBuf.h
+ * @brief Editeur De N'ours : Buffer for internal Data (header)
+ * @author Edouard DUPIN
+ * @date 23/03/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+#ifndef __EDN_BUF_H__
+#define __EDN_BUF_H__
+
+/* Maximum length in characters of a tab or control character expansion
+   of a single buffer character */
+#define MAX_EXP_CHAR_LEN 20*4
+
+class EdnBuf;
+
+#include "EdnVectorBuf.h"
+#include "EdnBufHistory.h"
+#include "HighlightManager.h"
+#include "charset.h"
+
+/*
+                                                                                                    
+               rectStart                       rectStart                                            
+start          *************                   *************                                        
+      **********           *               xxxx*xxxxxx     *                                        
+      *             ********               xxxx*xxxxxxxxxxx*xxxxx                                   
+end   ***************                          *************                                        
+                    rectEnd                                rectEnd                                  
+                                                                                                    
+                                                                                                    
+                                                                                                    
+*/
+typedef struct {
+	bool selected;			//!< True if the selection is active
+	bool rectangular;		//!< True if the selection is rectangular
+	bool zeroWidth;			//!< Width 0 selections aren't "real" selections, but they can be useful when creating rectangular selections from the keyboard.
+	int32_t start;			//!< Pos. of start of selection, or if rectangular start of line containing it.
+	int32_t end;			//!< Pos. of end of selection, or if rectangular end of line containing it.
+	int32_t rectStart;		//!< Indent of left edge of rect. selection
+	int32_t rectEnd;		//!< Indent of right edge of rect. selection
+} selection;
+
+typedef enum{
+	SELECTION_PRIMARY,
+	SELECTION_SECONDARY,
+	SELECTION_HIGHTLIGHT,
+	SELECTION_SIZE
+}selectionType_te;
+
+
+typedef struct {
+	std::vector<colorInformation_ts>    HLData;
+	int32_t                             idSequence;
+	int32_t                             posHLPass1;
+	int32_t                             posHLPass2;
+}displayHLData_ts;
+
+
+
+class EdnBuf {
+	public:
+		// constructer
+		EdnBuf(void);
+		// destructer
+		~EdnBuf(void);
+		// public function :
+		void    GetAll(                 EdnVectorBin<int8_t> &text);
+		void    SetAll(                 EdnVectorBin<int8_t> &text);
+		void    GetRange(               int32_t start, int32_t end, EdnVectorBin<int8_t> &output);
+		bool    DumpIn(                 FILE *myFile);
+		bool    DumpFrom(               FILE *myFile);
+		// replace with operator [] ...
+		int8_t  operator[] (int32_t);
+		void    Insert(                 int32_t pos, EdnVectorBin<int8_t> &insertText);
+		void    Replace(                int32_t start, int32_t end, EdnVectorBin<int8_t> &insertText);
+		void    Remove(                 int32_t start, int32_t end);
+		int32_t Indent(                 selectionType_te select);
+		int32_t UnIndent(               selectionType_te select);
+		
+		
+		void    GetLineText(            int32_t pos, EdnVectorBin<int8_t> &text);
+		int32_t StartOfLine(            int32_t pos);
+		int32_t EndOfLine(              int32_t pos);
+		
+		int32_t GetExpandedChar(        int32_t &pos, int32_t indent, char outUTF8[MAX_EXP_CHAR_LEN], uint32_t &currentChar);
+		int32_t ExpandCharacter(        char c,      int32_t indent, char outUTF8[MAX_EXP_CHAR_LEN]); 	// TODO : rework this
+		int32_t CharWidth(              char c,      int32_t indent); 	// TODO : rework this
+		int32_t CountDispChars(         int32_t lineStartPos, int32_t targetPos);
+		int32_t CountForwardDispChars(  int32_t lineStartPos, int32_t nChars);
+		int32_t CountLines(             int32_t startPos, int32_t endPos);
+		int32_t CountLines(             void);
+		int32_t CountLines(             EdnVectorBin<int8_t> &data);
+		int32_t CountForwardNLines(     int32_t startPos, int32_t nLines);
+		int32_t CountBackwardNLines(    int32_t startPos, int32_t nLines);
+		
+		bool    SearchForward(          int32_t startPos, EdnVectorBin<int8_t> &searchVect, int32_t *foundPos, bool caseSensitive = true);
+		bool    SearchBackward(         int32_t startPos, EdnVectorBin<int8_t> &searchVect, int32_t *foundPos, bool caseSensitive = true);
+		bool    SearchForward(          int32_t startPos, char searchChar, int32_t *foundPos);
+		bool    SearchBackward(         int32_t startPos, char searchChar, int32_t *foundPos);
+		bool    SelectAround(           int32_t startPos, int32_t &beginPos, int32_t &endPos);
+
+		// Buffer Size system :
+		int32_t Size(void)              { return m_data.Size(); };
+		int32_t NumberOfLines(void)     {return m_nbLine;};
+
+	// -----------------------------------------
+	// selection remember...
+	// -----------------------------------------
+	public:
+		bool	SelectHasSelection(		selectionType_te select);
+		void	Select(					selectionType_te select, int32_t start, int32_t end);
+		void	Unselect(				selectionType_te select);
+		void	RectSelect(				selectionType_te select, int32_t start, int32_t end, int32_t rectStart, int32_t rectEnd);
+		bool	GetSelectionPos(		selectionType_te select, int32_t &start, int32_t &end, bool &isRect, int32_t &rectStart, int32_t &rectEnd);
+		void	GetSelectionText(		selectionType_te select, EdnVectorBin<int8_t> &text);
+		void	RemoveSelected(			selectionType_te select);
+		void	ReplaceSelected(		selectionType_te select, EdnVectorBin<int8_t> &text);
+	private:
+		// current selection of the buffer
+		selection m_selectionList[SELECTION_SIZE];		//!< Selection area of the buffer
+		void	UpdateSelection(		selectionType_te select, int32_t pos, int32_t nDeleted, int32_t nInserted);
+		void	UpdateSelections(		int32_t pos, int32_t nDeleted, int32_t nInserted);
+
+	// -----------------------------------------
+	// History section : 
+	// -----------------------------------------
+	public:
+		int32_t	Undo(					void);
+		int32_t	Redo(					void);
+	private:
+		bool							m_isUndoProcessing;
+		bool							m_isRedoProcessing;
+		EdnVectorBin<EdnBufHistory*>	m_historyUndo;
+		EdnVectorBin<EdnBufHistory*>	m_historyRedo;
+
+	// -----------------------------------------
+	// hightlight section : 
+	// -----------------------------------------
+	private:
+		Highlight *							m_Highlight;					//!< internal link with the Highlight system
+		std::vector<colorInformation_ts>	m_HLDataPass1;					//!< colorisation position in the current buffer pass 1
+		int32_t								m_HLDataSequence;				//!< position of the start of line requested by the screen viewer
+		void								RegenerateHighLightAt(int32_t pos, int32_t nbDeleted, int32_t nbAdded);
+		void								GenerateHighLightAt(int32_t pos, int32_t endPos, int32_t addinPos=0);
+		void								CleanHighLight(void);
+		void								FindMainHighLightPosition(int32_t startPos, int32_t endPos, int32_t &startId, int32_t &stopId, bool backPreviousNotEnded);
+	public:
+		void                                SetHLSystem(  Highlight * newHLSystem);
+		void								HightlightGenerateLines(displayHLData_ts & MData, int32_t startPos, int32_t nbLines);
+		colorInformation_ts *				GetElementColorAtPosition(displayHLData_ts & MData, int32_t pos);
+	private:
+		colorInformation_ts *				GetElementColorAtPosition(int32_t pos, int32_t &starPos);
+
+	private:
+		EdnVectorBuf						m_data;			//!< buffer of the data in the mode int8_t
+		void								CountNumberOfLines(void);
+		int32_t								m_nbLine;		//!< Number of line in the biffer
+
+	// -----------------------------------------
+	// Display property and charset ...
+	// -----------------------------------------
+	public:
+		int32_t     GetTabDistance(void)              { return m_tabDist; } ;
+		void        SetTabDistance(int32_t tabDist)   { m_tabDist = tabDist; };
+		charset_te  GetCharsetType(void)              { return m_charsetType; };
+		void        SetCharsetType(charset_te newOne) { m_charsetType = newOne; if (EDN_CHARSET_UTF8==newOne){m_isUtf8=true;} else {m_isUtf8=false;} };
+		bool        GetUTF8Mode(void)                 { return m_isUtf8; };
+		void        SetUTF8Mode(bool newOne)          { m_isUtf8 = newOne; m_charsetType=EDN_CHARSET_UTF8; };
+	private:
+		// Special mode of the buffer :
+		bool		m_isUtf8;								//!< true if we are in UTF8 mode ==> if true the size of a char is 0, otherwise .. 1->4 ( TODO : not now)
+		charset_te	m_charsetType;							//!< if UTF8 mode is at false : the charset type of the buffer
+		// Local Tabulation policies
+		int32_t		m_tabDist;								//!< equiv. number of characters in a tab
+		bool		m_useTabs;								//!< True if buffer routines are allowed to use tabs for padding in rectangular operations
+	
+	// -----------------------------------------
+	// Local function : 
+	// -----------------------------------------
+	private:
+		void	findRectSelBoundariesForCopy(	int32_t lineStartPos, int32_t rectStart, int32_t rectEnd, int32_t *selStart, int32_t *selEnd);
+		char	*getSelectionText(				selection &sel);
+		void	removeSelected(					selection &sel);
+		void	replaceSelected(				selection &sel, const char *text);
+
+		void	eventModification(				int32_t pos, int32_t nInserted, EdnVectorBin<int8_t> &deletedText);
+
+
+		int32_t insert(							int32_t pos, EdnVectorBin<int8_t> &insertText);
+		
+		bool	charMatch(						char first, char second, bool caseSensitive = true);
+};
+
+#endif

Sources/tools/EdnBuf/EdnBufHistory.cpp

@@ -0,0 +1,82 @@
+/**
+ *******************************************************************************
+ * @file EdnBufHistory.cpp
+ * @brief Editeur De N'ours : history of buffer modification (sources)
+ * @author Edouard DUPIN
+ * @date 24/03/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+
+#include "tools_debug.h"
+#include "tools_globals.h"
+#include "EdnBufHistory.h"
+
+
+#undef __class__
+#define __class__	"EdnBufHistory"
+
+EdnBufHistory::EdnBufHistory(void)
+{
+	//EDN_INFO("EdnBufHistory new");
+	m_pos = 0;
+	m_nInserted = 0;
+}
+
+EdnBufHistory::EdnBufHistory(int32_t pos, int32_t nInserted, EdnVectorBin<int8_t> &deletedText)
+{
+	//EDN_INFO("EdnBufHistory new + data");
+	m_pos = pos;
+	m_nInserted = nInserted;
+	m_deletedText = deletedText;
+}
+
+void EdnBufHistory::Set(int32_t pos, int32_t nInserted, EdnVectorBin<int8_t> &deletedText)
+{
+	//EDN_INFO("EdnBufHistory new + data");
+	m_pos = pos;
+	m_nInserted = nInserted;
+	m_deletedText = deletedText;
+}
+
+EdnBufHistory::~EdnBufHistory(void)
+{
+	// nothing to do ...
+}
+
+int32_t EdnBufHistory::getPos(void)
+{
+	return m_pos;
+}
+
+int32_t EdnBufHistory::getnbDeleted(void)
+{
+	return m_deletedText.Size();
+}
+
+int32_t EdnBufHistory::getnbInserted(void)
+{
+	return m_nInserted;
+}
+
+void EdnBufHistory::getData(EdnVectorBin<int8_t> &deletedText)
+{
+	deletedText = m_deletedText;
+}
+

Sources/tools/EdnBuf/EdnBufHistory.h

@@ -0,0 +1,49 @@
+/**
+ *******************************************************************************
+ * @file EdnBufHistory.h
+ * @brief Editeur De N'ours : history of buffer modification (header)
+ * @author Edouard DUPIN
+ * @date 24/03/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+ 
+#ifndef __EDN_BUFFER_HISTORY_H__
+#define __EDN_BUFFER_HISTORY_H__
+
+
+#include "EdnVectorBin.h"
+
+class EdnBufHistory{
+	public:
+					 EdnBufHistory(void);
+					 EdnBufHistory(int32_t pos, int32_t nInserted, EdnVectorBin<int8_t> &deletedText);
+					~EdnBufHistory(void);
+		void		 Set(int32_t pos, int32_t nInserted, EdnVectorBin<int8_t> &deletedText);
+		int32_t		 getPos(void);
+		int32_t		 getnbDeleted(void);
+		int32_t		 getnbInserted(void);
+		void		 getData(EdnVectorBin<int8_t> &deletedText);
+	private:
+		int32_t m_pos;
+		int32_t m_nInserted;
+		EdnVectorBin<int8_t> m_deletedText;
+};
+
+#endif
+

Sources/tools/EdnBuf/EdnBuf_HighLight.cpp

@@ -0,0 +1,348 @@
+/**
+ *******************************************************************************
+ * @file EdnBuf_HighLight.cpp
+ * @brief Editeur De N'ours : Buffer for internal Data - section highlight (Sources)
+ * @author Edouard DUPIN
+ * @date 23/03/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+#include "tools_debug.h"
+#include "tools_globals.h"
+#include "EdnBuf.h"
+
+
+#undef __class__
+#define __class__	"EdnBuf{HighLight}"
+
+void EdnBuf::SetHLSystem(Highlight * newHLSystem)
+{
+	if (m_Highlight != newHLSystem) {
+		m_Highlight = newHLSystem;
+		m_HLDataPass1.clear();
+		RegenerateHighLightAt(0, 0, m_data.Size());
+	}
+}
+
+
+void EdnBuf::RegenerateHighLightAt(int32_t pos, int32_t nbDeleted, int32_t nbAdded)
+{
+	GTimeVal timeStart;
+	g_get_current_time(&timeStart);
+	
+	// remove display HL...
+	m_HLDataSequence++;
+	
+	// prevent ERROR...
+	if (NULL == m_Highlight) {
+		return;
+	}
+	// prevent No data Call
+	if(		0 == nbDeleted
+		&&	0 == nbAdded)
+	{
+		return;
+	}
+	// normal case
+	EDN_INFO("(pos="<<pos<<", nbDeleted="<<nbDeleted<<", nbAdded=" << nbAdded << "\");");
+	int32_t i;
+	int32_t posEnd = pos + nbDeleted;
+	// search position of the old element to reparse IT...
+	int32_t startId;
+	int32_t stopId;
+	// clean data if needed
+	if (0 != m_HLDataPass1.size()) {
+		// find element previous
+		FindMainHighLightPosition(pos, posEnd, startId, stopId, true);
+
+		// Remove deprecated element
+		if(		-1 == startId
+			&&	-1 == stopId)
+		{
+			m_HLDataPass1.clear();
+		} else if(-1 == startId) {
+			if (0 == stopId){
+				m_HLDataPass1.erase(m_HLDataPass1.begin());
+			} else {
+				m_HLDataPass1.erase(m_HLDataPass1.begin(),m_HLDataPass1.begin()+stopId);
+			}
+		} else if(-1 == stopId) {
+			m_HLDataPass1.erase(m_HLDataPass1.begin()+startId+1,m_HLDataPass1.end());
+		} else {
+			m_HLDataPass1.erase(m_HLDataPass1.begin()+startId+1,m_HLDataPass1.begin()+stopId);
+		}
+		EDN_DEBUG("new size=" << (int32_t)m_HLDataPass1.size()-1);
+		// update position after the range position : 
+		int32_t elemStart;
+		if(-1 == startId) {
+			elemStart = 0;
+		} else {
+			elemStart = startId+1;
+		}
+		for (i=elemStart; i< (int32_t)m_HLDataPass1.size(); i++) {
+			//EDN_DEBUG("move element=" << i);
+			m_HLDataPass1[i].beginStart += nbAdded - nbDeleted;
+			m_HLDataPass1[i].beginStop  += nbAdded - nbDeleted;
+			m_HLDataPass1[i].endStart   += nbAdded - nbDeleted;
+			m_HLDataPass1[i].endStop    += nbAdded - nbDeleted;
+		}
+		//Regenerate Element inside range
+		if(		-1 == startId
+			&&	-1 == stopId)
+		{
+			//EDN_DEBUG("*******  Regenerate ALL");
+			GenerateHighLightAt(0, m_data.Size());
+		} else if(-1 == startId) {
+			//EDN_DEBUG("*******  Regenerate START");
+			GenerateHighLightAt(0, m_HLDataPass1[0].beginStart, 0);
+		} else if(-1 == stopId) {
+			//EDN_DEBUG("*******  Regenerate STOP");
+			GenerateHighLightAt(m_HLDataPass1[m_HLDataPass1.size() -1].endStop, m_data.Size(), m_HLDataPass1.size());
+		} else {
+			//EDN_DEBUG("*******  Regenerate RANGE");
+			GenerateHighLightAt(m_HLDataPass1[startId].endStop, m_HLDataPass1[startId+1].beginStart, startId+1);
+		}
+	} else {
+		// Parse the new element ...
+		//GenerateHighLightAt(pos, nbAdded);
+		GenerateHighLightAt(0, m_data.Size());
+	}
+	for (i=0; i< (int32_t)m_HLDataPass1.size(); i++) {
+		Edn::String ploppp;
+		if (NULL != m_HLDataPass1[i].patern ) {
+			ploppp = ((HighlightPattern*)m_HLDataPass1[i].patern)->GetName();
+		}
+		//EDN_DEBUG("HighLight element id=" << i << " S=" << m_HLDataPass1[i].beginStart << " E=" << m_HLDataPass1[i].endStop << " patern name=" << ploppp.c_str() );
+	}
+	GTimeVal timeStop;
+	g_get_current_time(&timeStop);
+	EDN_DEBUG("HL General = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s");
+}
+
+void EdnBuf::FindMainHighLightPosition(int32_t startPos, int32_t endPos, int32_t &startId, int32_t &stopId, bool backPreviousNotEnded)
+{
+	startId = -1;
+	stopId = -1;
+	/* rules to start stop:
+		HighLight data ----
+		Remove area    ****
+		Start pos      S
+		End pos        E
+
+	Some Case :
+		-----------          ------------          -------------            ----------
+			      S              ****              E                                  
+
+		-----------          ------------          -------------            ----------
+			      S                **********      E                                  
+
+		-----------          ------------          -------------            ----------
+			                            S   ****   E                                  
+
+		-----------          ------------          -------------            ----------
+			      S     *********                  E                                  
+
+		-----------          ------------          -------------            ----------
+			      S     *********************      E                                  
+
+		-----------          ------------          -------------            ----------
+			      S               ************************                  E         
+
+		-----------          ------------          -------------            ----------
+			      S     *****************          E                                  
+
+		-----------          ------------          -------------            ----------
+			      S          ***************       E                                  
+
+		-----------          ------------       
+			      S          ***************       E=-1
+
+			                 ------------          -------------            ----------
+			      S=-1      ***************        E                                  
+	*/
+	int32_t i;
+	for (i=0; i< (int32_t)m_HLDataPass1.size(); i++) {
+		if (m_HLDataPass1[i].endStop > startPos) {
+			break;
+		}
+		startId = i;
+	}
+	// go back while the previous element is not eneded
+	if (true == backPreviousNotEnded) {
+		for (i=startId; i>=0; i--) {
+			if (m_HLDataPass1[i].notEnded == false) {
+				break;
+			}
+			startId = i-1;
+		}
+	}
+	int32_t elemStart;
+	if(-1 == startId) {
+		elemStart = 0;
+	} else {
+		elemStart = startId+1;
+	}
+	for (i=elemStart; i< (int32_t)m_HLDataPass1.size(); i++) {
+		if (m_HLDataPass1[i].beginStart > endPos)
+		{
+			stopId = i;
+			break;
+		}
+	}
+	/*
+	if (-1 != startId && startId < (int32_t)m_HLDataPass1.size()) {
+		EDN_DEBUG("==> BEGIN : start="<<m_HLDataPass1[startId].beginStart<<", stop="<<m_HLDataPass1[startId].endStop<<" id=" << startId << "/" << (int32_t)m_HLDataPass1.size()-1);
+	} else {
+		EDN_DEBUG("==> BEGIN : start=???, stop=??? id=" << startId);
+	}
+	if (-1 != stopId && stopId < (int32_t)m_HLDataPass1.size()) {
+		EDN_DEBUG("==> END   : start="<<m_HLDataPass1[stopId].beginStart<<", stop="<<m_HLDataPass1[stopId].endStop<<" id=" << stopId<< "/" << (int32_t)m_HLDataPass1.size()-1);
+	} else {
+		EDN_DEBUG("==> END   : start=???, stop=??? id=" << stopId);
+	}
+	*/
+}
+
+
+
+
+void EdnBuf::GenerateHighLightAt(int32_t pos, int32_t endPos, int32_t addinPos)
+{
+	if (NULL == m_Highlight) {
+		return;
+	}
+	//EDN_DEBUG("area : ("<<pos<<","<<endPos<<") insert at : " << addinPos);
+	m_Highlight->Parse(pos, endPos, m_HLDataPass1, addinPos, m_data);
+}
+
+
+
+void EdnBuf::CleanHighLight(void)
+{
+	// Remove all element in the list...
+	m_HLDataPass1.clear();
+}
+
+
+colorInformation_ts *EdnBuf::GetElementColorAtPosition(int32_t pos, int32_t &starPos)
+{
+	int32_t i;
+	int32_t start = edn_max(0, starPos-1);
+	for (i=start; i<(int32_t)m_HLDataPass1.size(); i++) {
+		starPos = i;
+		if(		m_HLDataPass1[i].beginStart <= pos
+			&&	m_HLDataPass1[i].endStop    > pos)
+		{
+			return &m_HLDataPass1[i];
+		}
+		if(m_HLDataPass1[i].beginStart > pos) {
+			return NULL;
+		}
+	}
+	return NULL;
+}
+
+
+
+void EdnBuf::HightlightGenerateLines(displayHLData_ts & MData, int32_t HLStart, int32_t nbLines)
+{
+	MData.posHLPass1 = 0;
+	MData.posHLPass2 = 0;
+	if (NULL == m_Highlight) {
+		return;
+	}
+	if (MData.idSequence != m_HLDataSequence) {
+		GTimeVal timeStart;
+		g_get_current_time(&timeStart);
+		MData.idSequence = m_HLDataSequence;
+		HLStart = StartOfLine(HLStart);
+		MData.HLData.clear();
+		int32_t HLStop = CountForwardNLines(HLStart, nbLines);
+		int32_t startId, stopId;
+		// find element previous
+		FindMainHighLightPosition(HLStart, HLStop, startId, stopId, true);
+
+		int32_t k;
+		//EDN_DEBUG("List of section between : "<< startId << " & " << stopId);
+		int32_t endSearch = stopId+1;
+		if (-1 == stopId) {
+			endSearch = m_HLDataPass1.size();
+		}
+		for (k=edn_max(startId, 0); k<endSearch; k++) {
+			// empty section :
+			if (0==k) {
+				if (HLStart < m_HLDataPass1[k].beginStart) {
+					//EDN_DEBUG("  ==> (empty section 1 ) k="<<k<<" start="<<HLStart<<" stop="<<m_HLDataPass1[k].beginStart );
+					m_Highlight->Parse2(HLStart,
+										m_HLDataPass1[k].beginStart,
+										MData.HLData,
+										m_data);
+				} // else : nothing to do ...
+			} else {
+				//EDN_DEBUG("  ==> (empty section 2 ) k="<<k<<" start="<<m_HLDataPass1[k-1].endStop<<" stop="<<m_HLDataPass1[k].beginStart );
+				m_Highlight->Parse2(m_HLDataPass1[k-1].endStop,
+									m_HLDataPass1[k].beginStart,
+									MData.HLData,
+									m_data);
+			}
+			// under section :
+			//EDN_DEBUG("  ==> (under section   ) k="<<k<<" start="<<m_HLDataPass1[k].beginStart<<" stop="<<m_HLDataPass1[k].endStop << "subSectionOfID=" << 99999999);
+			// TODO ...
+		}
+		if (endSearch == (int32_t)m_HLDataPass1.size() ){
+			if(		k < (int32_t)m_HLDataPass1.size()) {
+				//EDN_DEBUG("  ==> (empty section 3 ) k="<<k<<" start="<<m_HLDataPass1[k-1].endStop<<" stop="<<HLStop );
+				m_Highlight->Parse2(m_HLDataPass1[k-1].endStop,
+									HLStop,
+									MData.HLData,
+									m_data);
+			} else {
+				//EDN_DEBUG("  ==> (empty section 4 ) k="<<k<<" start=0 stop="<<HLStop );
+				m_Highlight->Parse2(0,
+									HLStop,
+									MData.HLData,
+									m_data);
+			}
+		}
+		
+		GTimeVal timeStop;
+		g_get_current_time(&timeStop);
+		EDN_DEBUG("Display reAnnalyse = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s");
+	}
+
+}
+
+
+colorInformation_ts * EdnBuf::GetElementColorAtPosition(displayHLData_ts & MData, int32_t pos)
+{
+	int32_t i;
+	int32_t start = edn_max(0, MData.posHLPass2-1);
+	for (i=start; i<(int32_t)MData.HLData.size(); i++) {
+		MData.posHLPass2 = i;
+		if(		MData.HLData[i].beginStart <= pos
+			&&	MData.HLData[i].endStop    > pos)
+		{
+			return &MData.HLData[i];
+		}
+		if(MData.HLData[i].beginStart > pos) {
+			return GetElementColorAtPosition(pos, MData.posHLPass1);
+		}
+	}
+	return GetElementColorAtPosition(pos, MData.posHLPass1);
+}

Sources/tools/EdnBuf/EdnBuf_History.cpp

@@ -0,0 +1,133 @@
+/**
+ *******************************************************************************
+ * @file EdnBuf_History.cpp
+ * @brief Editeur De N'ours : Buffer for internal Data - section history (Sources)
+ * @author Edouard DUPIN
+ * @date 23/03/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+#include "tools_debug.h"
+#include "tools_globals.h"
+#include "EdnBuf.h"
+
+
+#undef __class__
+#define __class__	"EdnBuf{History}"
+
+
+
+
+int32_t EdnBuf::Undo(void)
+{
+	int32_t nbElement = m_historyUndo.Size();
+	//EDN_DEBUG("EdnBuf::Undo Request id="<<nbElement);
+	int32_t posDest = -1;
+	if (0 == nbElement) {
+		// nothing to do ...
+		EDN_ERROR("EdnBuf::Undo No more History");
+		return -1;
+	}
+	nbElement--;
+	if (m_historyUndo[nbElement] == NULL) {
+		EDN_ERROR("EdnBuf::Undo Find empty history ==> remove it");
+		m_historyUndo.PopBack();
+		return -1;
+	}
+	int32_t pos        = m_historyUndo[nbElement]->getPos();
+	int32_t nbDeleted  = m_historyUndo[nbElement]->getnbDeleted();
+	int32_t nbInserted = m_historyUndo[nbElement]->getnbInserted();
+	EdnVectorBin<int8_t> deletedText;
+	m_historyUndo[nbElement]->getData(deletedText);
+	m_isUndoProcessing = true;
+	if (0 == nbInserted) {
+		// just add data at position ...
+		if (0 == nbDeleted) {
+			EDN_ERROR("EdnBuf::Undo nothing to do in UNDO");
+		} else {
+			Insert(pos, deletedText);
+			posDest = pos + nbDeleted;
+		}
+	} else {
+		if (0 == nbDeleted) {
+			// only remove data
+			Remove(pos, pos+nbInserted);
+			posDest = pos;
+		} else {
+			// replace data
+			Replace(pos, pos+nbInserted, deletedText);
+			posDest = pos + nbDeleted;
+		}
+	}
+	// remove element in the list :
+	delete(m_historyUndo[nbElement]);
+	m_historyUndo.PopBack();
+	m_isUndoProcessing = false;
+	return posDest;
+}
+
+int32_t EdnBuf::Redo(void)
+{
+	int32_t nbElement = m_historyRedo.Size();
+	//EDN_DEBUG("EdnBuf::Redo Request id="<<nbElement);
+	int32_t posDest = -1;
+	if (0 == nbElement) {
+		// nothing to do ...
+		EDN_ERROR("EdnBuf::Redo No more History");
+		return -1;
+	}
+	nbElement--;
+	if (m_historyRedo[nbElement] == NULL) {
+		EDN_ERROR("EdnBuf::Redo Find empty history ==> remove it");
+		m_historyRedo.PopBack();
+		return -1;
+	}
+	int32_t pos        = m_historyRedo[nbElement]->getPos();
+	int32_t nbDeleted  = m_historyRedo[nbElement]->getnbDeleted();
+	int32_t nbInserted = m_historyRedo[nbElement]->getnbInserted();
+	EdnVectorBin<int8_t> deletedText;
+	m_historyRedo[nbElement]->getData(deletedText);
+	m_isRedoProcessing = true;
+	if (0 == nbInserted) {
+		// just add data at position ...
+		if (0 == nbDeleted) {
+			EDN_ERROR("EdnBuf::Redo nothing to do in REDO");
+		} else {
+			Insert(pos, deletedText);
+			posDest = pos + nbDeleted;
+		}
+	} else {
+		if (0 == nbDeleted) {
+			// only remove data
+			Remove(pos, pos+nbInserted);
+			posDest = pos;
+		} else {
+			// replace data
+			Replace(pos, pos+nbInserted, deletedText);
+			posDest = pos + nbDeleted;
+		}
+	}
+	// remove element in the list :
+	delete(m_historyRedo[nbElement]);
+	m_historyRedo.PopBack();
+	m_isRedoProcessing = false;
+	return posDest;
+}
+
+

Sources/tools/EdnBuf/EdnBuf_Selection.cpp

@@ -0,0 +1,284 @@
+/**
+ *******************************************************************************
+ * @file EdnBuf_Selection.cpp
+ * @brief Editeur De N'ours : Buffer for internal Data - section selection (Sources)
+ * @author Edouard DUPIN
+ * @date 23/03/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+#include "tools_debug.h"
+#include "tools_globals.h"
+#include "EdnBuf.h"
+
+
+#undef __class__
+#define __class__	"EdnBuf{Selection}"
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+bool EdnBuf::SelectHasSelection(selectionType_te select)
+{
+	return m_selectionList[select].selected;
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnBuf::Select(selectionType_te select, int32_t start, int32_t end)
+{
+	selection oldSelection = m_selectionList[select];
+	m_selectionList[select].selected = start != end;
+	m_selectionList[select].zeroWidth = (start == end) ? true : false;
+	m_selectionList[select].rectangular = false;
+	m_selectionList[select].start = edn_min(start, end);
+	m_selectionList[select].end = edn_max(start, end);
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnBuf::Unselect(selectionType_te select)
+{
+	selection oldSelection = m_selectionList[select];
+	m_selectionList[select].selected = false;
+	m_selectionList[select].zeroWidth = false;
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * @param[in,out] ---
+ * @param[in,out] ---
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnBuf::RectSelect(selectionType_te select, int32_t start, int32_t end, int32_t rectStart, int32_t rectEnd)
+{
+	m_selectionList[select].selected = rectStart < rectEnd;
+	m_selectionList[select].zeroWidth = (rectStart == rectEnd) ? false : true;
+	m_selectionList[select].rectangular = true;
+	m_selectionList[select].start = start;
+	m_selectionList[select].end = end;
+	m_selectionList[select].rectStart = rectStart;
+	m_selectionList[select].rectEnd = rectEnd;
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+bool EdnBuf::GetSelectionPos(selectionType_te select, int32_t &start, int32_t &end, bool &isRect, int32_t &rectStart, int32_t &rectEnd)
+{
+	/* Always fill in the parameters (zero-width can be requested too). */
+	isRect = m_selectionList[select].rectangular;
+	start = m_selectionList[select].start;
+	end = m_selectionList[select].end;
+	if (m_selectionList[select].rectangular) {
+		rectStart = m_selectionList[select].rectStart;
+		rectEnd = m_selectionList[select].rectEnd;
+	}
+	return m_selectionList[select].selected;
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnBuf::GetSelectionText(selectionType_te select, EdnVectorBin<int8_t> &text)
+{
+	int32_t start, end, rectStart, rectEnd;
+	bool isRect;
+	// remove output data
+	text.Clear();
+	
+	bool isSelected = GetSelectionPos(select, start, end, isRect, rectStart, rectEnd);
+	
+	// No data selected ...
+	if (false == isSelected) {
+		return;
+	}
+	
+	// Rectangular selection
+	if (true == isRect) {
+		//GetTextInRect(start, end, rectStart, rectEnd, text);
+		// TODO : ...
+	} else {
+		GetRange(start, end, text);
+	}
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnBuf::RemoveSelected(selectionType_te select)
+{
+	int32_t start, end;
+	int32_t rectStart, rectEnd;
+	bool isRect;
+	bool isSelected = GetSelectionPos(select, start, end, isRect, rectStart, rectEnd);
+	
+	// No data selected ...
+	if (false == isSelected) {
+		return;
+	}
+	// Rectangular selection
+	if (true == isRect) {
+		//RemoveRect(start, end, rectStart, rectEnd);
+		// TODO : ...
+	} else {
+		Remove(start, end);
+	}
+	Unselect(select);
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnBuf::ReplaceSelected(selectionType_te select, EdnVectorBin<int8_t> &text)
+{
+	int32_t start, end, rectStart, rectEnd;
+	bool isRect;
+	bool isSelected = GetSelectionPos(select, start, end, isRect, rectStart, rectEnd);
+	
+	// No data selected ...
+	if (false == isSelected) {
+		return;
+	}
+	// Rectangular selection
+	if (true == isRect) {
+		//ReplaceRect(start, end, rectStart, rectEnd, text);
+		// TODO : ...
+	} else {
+		Replace(start, end, text);
+	}
+	// Clean selection
+	m_selectionList[select].selected = false;
+}
+
+
+
+/*
+** Update all of the selections in "buf" for changes in the buffer's text
+*/
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnBuf::UpdateSelections(int32_t pos, int32_t nDeleted, int32_t nInserted)
+{
+	UpdateSelection(SELECTION_PRIMARY   , pos, nDeleted, nInserted);
+	UpdateSelection(SELECTION_SECONDARY , pos, nDeleted, nInserted);
+	UpdateSelection(SELECTION_HIGHTLIGHT, pos, nDeleted, nInserted);
+}
+
+
+/*
+** Update an individual selection for changes in the corresponding text
+*/
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnBuf::UpdateSelection(selectionType_te select, int32_t pos, int32_t nDeleted, int32_t nInserted)
+{
+	if(		(		false == m_selectionList[select].selected
+				&&	false == m_selectionList[select].zeroWidth)
+		||	pos > m_selectionList[select].end )
+	{
+		return;
+	}
+	if (pos+nDeleted <= m_selectionList[select].start) {
+		m_selectionList[select].start += nInserted - nDeleted;
+		m_selectionList[select].end += nInserted - nDeleted;
+	} else if(		pos <= m_selectionList[select].start
+				&&	pos+nDeleted >= m_selectionList[select].end)
+	{
+		m_selectionList[select].start = pos;
+		m_selectionList[select].end = pos;
+		m_selectionList[select].selected = false;
+		m_selectionList[select].zeroWidth = false;
+	} else if(		pos <= m_selectionList[select].start
+				&&	pos+nDeleted < m_selectionList[select].end)
+	{
+		m_selectionList[select].start = pos;
+		m_selectionList[select].end = nInserted + m_selectionList[select].end - nDeleted;
+	} else if(pos < m_selectionList[select].end) {
+		m_selectionList[select].end += nInserted - nDeleted;
+		if (m_selectionList[select].end <= m_selectionList[select].start) {
+			m_selectionList[select].selected = false;
+		}
+	}
+}
+

Sources/tools/EdnRegExp/EdnRegExp.h

@@ -0,0 +1,261 @@
+/**
+ *******************************************************************************
+ * @file EdnRegExp.h
+ * @brief Editeur De N'ours : Regular expression annalyser (header)
+ * @author Edouard DUPIN
+ * @date 04/04/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+#ifndef __EDN_REG_EXP_H__
+#define __EDN_REG_EXP_H__
+
+class EdnRegExp;
+
+#include "EdnTree.h"
+#include "EdnBuf.h"
+#include "EdnVectorBin.h"
+#include "EdnVectorBuf.h"
+
+
+/*
+normal mode :
+	(...)				sub element is separate with |
+	\d					Digits									[0-9]
+	\D					NOT a digit								[^0-9]
+	\l					Letters									[a-zA-Z]
+	\L					NOT a Letter							[^a-zA-Z]
+	\s					Whitespace								[ \t\n\r\f\v]
+	\S					NOT Whitespace							[^ \t\n\r\f\v]
+	\w					"Word" character						[a-zA-Z0-9_]
+	\W					NOT a "Word" character					[^a-zA-Z0-9_]
+	\@					at the start or the end					not in the parsing of element ==> check if \w is not present   (other regExp will be <> ...)
+	[anjdi] or [a-gt-j]	range
+	.					dot										[^\x00-\x08\x0A-\x1F\x7F]
+==> TODO :
+	$					End / Start of line of line 			==> ce sera un truc supl<70>mentaire comme le \@
+	^in the []			invertion of the range element
+
+multiplicity :
+	*     ==> {0, 2147483647}
+	?     ==> {0, 1}
+	+     ==> {1, 2147483647}
+	{x}   ==> {x, x}
+	{x,y} ==> {x, y}
+*/
+
+class RegExpNode;
+
+/**
+ *	@brief Node Elements for every-one
+ */
+class RegExpNode{
+	public :
+		                        RegExpNode(void);
+		virtual                 ~RegExpNode(void) { };
+		virtual int32_t         Generate(EdnVectorBin<int16_t> &data, int32_t startPos, int32_t nbElement);
+		virtual bool            Parse(EdnVectorBuf &data, int32_t currentPos, int32_t lenMax, int32_t &findLen);
+		virtual void            Display(int32_t level);
+		void                    SetMult(int32_t min, int32_t max);
+	protected:
+		int32_t                 GetMultMin(void) { return m_multipleMin; };
+		int32_t                 GetMultMax(void) { return m_multipleMax; };
+	protected :
+		int32_t                 m_multipleMin;      //!< minimum repetition (included)
+		int32_t                 m_multipleMax;      //!< maximum repetition (included)
+		// Data Section ... (can have no data...)
+		EdnVectorBin<int16_t>   m_RegExpData;       //!< data to parse and compare in some case ...
+};
+
+
+class RegExpNodePThese : public RegExpNode {
+	public :
+		        RegExpNodePThese(void) { };
+		        ~RegExpNodePThese(void);
+		int32_t Generate(EdnVectorBin<int16_t> &data);
+		bool    Parse(EdnVectorBuf &data, int32_t currentPos, int32_t lenMax, int32_t &findLen);
+		void    Display(int32_t level);
+	protected :
+		// SubNodes :
+		EdnVectorBin<RegExpNode*> m_subNode;
+		//int32_t						m_posPthese;		//!< position of the element is detected in the output element
+};
+
+class RegExpNodePTheseElem : public RegExpNode {
+	public :
+		        RegExpNodePTheseElem(void) { };
+		        ~RegExpNodePTheseElem(void);
+		int32_t Generate(EdnVectorBin<int16_t> &data);
+		bool    Parse(EdnVectorBuf &data, int32_t currentPos, int32_t lenMax, int32_t &findLen);
+		void    Display(int32_t level);
+	protected :
+		// SubNodes :
+		EdnVectorBin<RegExpNode*> m_subNode;
+	private :
+		bool    SetMultiplicityOnLastNode(int32_t min, int32_t max);
+};
+
+
+class RegExpNodeValue : public RegExpNode {
+	public :
+		        RegExpNodeValue(void) { };
+		        ~RegExpNodeValue(void) { };
+		int32_t Generate(EdnVectorBin<int16_t> &data);
+		bool    Parse(EdnVectorBuf &data, int32_t currentPos, int32_t lenMax, int32_t &findLen);
+		void    Display(int32_t level);
+	protected :
+		// SubNodes :
+		EdnVectorBin<char> m_data;
+};
+
+class RegExpNodeBracket : public RegExpNode {
+	public :
+		        RegExpNodeBracket(void) { };
+		        ~RegExpNodeBracket(void) { };
+		int32_t Generate(EdnVectorBin<int16_t> &data);
+		bool    Parse(EdnVectorBuf &data, int32_t currentPos, int32_t lenMax, int32_t &findLen);
+		void    Display(int32_t level);
+	protected :
+		// SubNodes :
+		EdnVectorBin<char> m_data;
+};
+
+class RegExpNodeDigit : public RegExpNode {
+	public :
+		        RegExpNodeDigit(void) { };
+		        ~RegExpNodeDigit(void) { };
+		bool    Parse(EdnVectorBuf &data, int32_t currentPos, int32_t lenMax, int32_t &findLen);
+		void    Display(int32_t level);
+};
+class RegExpNodeDigitNot : public RegExpNode {
+	public :
+		        RegExpNodeDigitNot(void) { };
+		        ~RegExpNodeDigitNot(void) { };
+		bool    Parse(EdnVectorBuf &data, int32_t currentPos, int32_t lenMax, int32_t &findLen);
+		void    Display(int32_t level);
+};
+class RegExpNodeLetter : public RegExpNode {
+	public :
+		        RegExpNodeLetter(void) { };
+		        ~RegExpNodeLetter(void) { };
+		bool    Parse(EdnVectorBuf &data, int32_t currentPos, int32_t lenMax, int32_t &findLen);
+		void    Display(int32_t level);
+};
+class RegExpNodeLetterNot : public RegExpNode {
+	public :
+		        RegExpNodeLetterNot(void) { };
+		        ~RegExpNodeLetterNot(void) { };
+		bool    Parse(EdnVectorBuf &data, int32_t currentPos, int32_t lenMax, int32_t &findLen);
+		void    Display(int32_t level);
+};
+class RegExpNodeWhiteSpace : public RegExpNode {
+	public :
+		        RegExpNodeWhiteSpace(void) { };
+		        ~RegExpNodeWhiteSpace(void) { };
+		bool    Parse(EdnVectorBuf &data, int32_t currentPos, int32_t lenMax, int32_t &findLen);
+		void    Display(int32_t level);
+};
+class RegExpNodeWhiteSpaceNot : public RegExpNode {
+	public :
+		        RegExpNodeWhiteSpaceNot(void) { };
+		        ~RegExpNodeWhiteSpaceNot(void) { };
+		bool    Parse(EdnVectorBuf &data, int32_t currentPos, int32_t lenMax, int32_t &findLen);
+		void    Display(int32_t level);
+};
+class RegExpNodeWordChar : public RegExpNode {
+	public :
+		        RegExpNodeWordChar(void) { };
+		        ~RegExpNodeWordChar(void) { };
+		bool    Parse(EdnVectorBuf &data, int32_t currentPos, int32_t lenMax, int32_t &findLen);
+		void    Display(int32_t level);
+};
+class RegExpNodeWordCharNot : public RegExpNode {
+	public :
+		        RegExpNodeWordCharNot(void) { };
+		        ~RegExpNodeWordCharNot(void) { };
+		bool    Parse(EdnVectorBuf &data, int32_t currentPos, int32_t lenMax, int32_t &findLen);
+		void    Display(int32_t level);
+};
+class RegExpNodeDot : public RegExpNode {
+	public :
+		        RegExpNodeDot(void) { };
+		        ~RegExpNodeDot(void) { };
+		bool    Parse(EdnVectorBuf &data, int32_t currentPos, int32_t lenMax, int32_t &findLen);
+		void    Display(int32_t level);
+};
+
+class RegExpNodeSOL : public RegExpNode {
+	public :
+		        RegExpNodeSOL(void) { };
+		        ~RegExpNodeSOL(void) { };
+		bool    Parse(EdnVectorBuf &data, int32_t currentPos, int32_t lenMax, int32_t &findLen);
+		void    Display(int32_t level);
+};
+
+class RegExpNodeEOL : public RegExpNode {
+	public :
+		        RegExpNodeEOL(void) { };
+		        ~RegExpNodeEOL(void) { };
+		bool    Parse(EdnVectorBuf &data, int32_t currentPos, int32_t lenMax, int32_t &findLen);
+		void    Display(int32_t level);
+};
+
+typedef struct {
+	int32_t start;
+	int32_t stop;
+}elementPos_ts;
+
+
+// Regular expression manager
+class EdnRegExp {
+	// public API : 
+	public:
+		// create the regular expression
+		EdnRegExp(const char *exp);
+		EdnRegExp(Edn::String &exp);
+		EdnRegExp(void);
+		~EdnRegExp(void);
+		void		SetRegExp(const char *exp);
+		void		SetRegExp(Edn::String &exp);
+		Edn::String	GetRegExp(void) { return m_expressionRequested;};
+		bool		GetStatus(void)  { return m_isOk;};
+		// process the regular expression
+		bool	Process(	EdnVectorBuf			&SearchIn,
+							int32_t					startPos,
+							int32_t					endPos,
+							char					escapeChar=0);
+		int32_t	Start(void)	{ return m_areaFind.start; };
+		int32_t	Stop(void)	{ return m_areaFind.stop; };
+		void	Display(void);
+	// internal parameters
+	private:
+		Edn::String					m_expressionRequested;	// TODO : Remove ...
+		elementPos_ts				m_areaFind;					//!< position around selection
+		RegExpNodePThese			m_exprRootNode;				//!< The tree where data is set
+		bool						m_isOk;						//!< Known if we can process with this regExp
+		bool						m_notBeginWithChar;			//!< The regular expression must not have previously a char [a-zA-Z0-9_]
+		bool						m_notEndWithChar;			//!< The regular expression must not have after the end a char [a-zA-Z0-9_]
+	// internal access
+	private:
+		bool CheckGoodPosition(EdnVectorBin<int16_t> tmpExp, int32_t &pos);
+		bool CheckGoodPosition(EdnVectorBin<int16_t> tmpExp);
+
+
+};
+
+#endif

Sources/tools/EdnTemplate/EdnTemplateTest.cpp

@@ -0,0 +1,29 @@
+
+#include "tools_debug.h"
+#include "tools_globals.h"
+
+#include "EdnVectorBin.h"
+
+void TestTemplate(void)
+{
+	
+	EDN_WARNING("Start Template Test ...");
+	EdnVectorBin<int32_t> plop;
+	EdnVectorBin<int8_t> plop2;
+	
+	plop.PushBack(15365);
+	plop.PushBack(1);
+	plop.PushBack(2);
+	plop.PushBack(3);
+	plop.PushBack(4);
+	
+	EDN_INFO("data is : " << plop[0]);
+	EDN_INFO("data is : " << plop[1]);
+	EDN_INFO("data is : " << plop[2]);
+	EDN_INFO("data is : " << plop[3]);
+	
+	plop2.PushBack(65);
+	
+	EDN_INFO("data is : " << plop2[0]);
+	
+}

Sources/tools/EdnTemplate/EdnTree.h

@@ -0,0 +1,186 @@
+/**
+ *******************************************************************************
+ * @file EdnTree.h
+ * @brief Editeur De N'ours : Basic tree in a vector For none expensive tree (template)
+ * @author Edouard DUPIN
+ * @date 04/04/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+#ifndef __EDN_TREE_H__
+#define __EDN_TREE_H__
+
+#undef __class__
+#define __class__	"EdnTreeElement"
+
+template < class T > class EdnTreeElement
+{
+	public:
+		EdnTreeElement(int32_t parent, int32_t id, T &maNouvelleClass) : elementPtr(NULL), m_parent(parent), m_id(id)
+		{
+			elementPtr = new T(maNouvelleClass);
+		};
+		~EdnTreeElement(void)
+		{
+			delete(elementPtr);
+		};
+		EdnTreeElement(const EdnTreeElement &mustCopy ) : elementPtr(NULL), m_parent(mustCopy.m_parent), m_id(mustCopy.m_id)
+		{
+			elementPtr = new T(*mustCopy.elementPtr);
+		}
+		int32_t	GetParrent(void) { return m_parent;};
+		int32_t	GetId(void) { return m_id;};
+		T*		GetPtr() const 
+		{
+			return elementPtr;
+		};
+
+	private:
+		T* elementPtr;		// pointer on the curent element
+		int32_t m_parent;
+		int32_t m_id;
+};
+
+#undef __class__
+#define __class__	"EdnTree"
+
+#define ROOT_NODE_ID	(-1)
+
+template < class T > class EdnTree 
+{
+	public: 
+		// constructeur et destructeur
+		EdnTree(void)
+		{
+			m_LastId = 0;
+		};
+		
+		~EdnTree(void)
+		{
+			
+		};
+		// Common function ...
+		int32_t GetNumberNode(void)
+		{
+			return m_listElement.size();
+		};
+		
+		int32_t GetDepth(void)
+		{
+			// TODO : ...
+			return 0;
+		};
+		//!< add an element in the tree
+		int32_t Add(T &maNouvelleClass, int32_t parent=-1)
+		{
+			if (true == CheckPresenceParrent(parent)) {
+				// create the local element
+				EdnTreeElement<T> nouvelElement(parent, m_LastId, maNouvelleClass);
+				// add it in the list
+				m_listElement.push_back(nouvelElement);
+				// increment the ID of the element
+				m_LastId++;
+				// Add is Ok, in theory ...
+				return m_LastId-1;
+			}
+			return -2;
+		};
+		
+		bool Remove(int32_t id)
+		{
+			return false;
+		};
+		
+		bool Clear(void)
+		{
+			return false;
+		};
+		
+		T* Get(int32_t id)
+		{
+			// try to find ID
+			int32_t realID = FindElementWithId(id);
+			// when we find it, check it
+			if (0 > realID || realID >= m_LastId) {
+				return NULL;
+			}
+			// Return the element :
+			return m_listElement[realID].GetPtr();
+		};
+		
+		std::vector<int32_t> GetListSubNode( int32_t parentId = ROOT_NODE_ID)
+		{
+			std::vector<int32_t> res;
+			int32_t i;
+			for (i=0; i<(int32_t)m_listElement.size(); i++) {
+				if (m_listElement[i].GetParrent() == parentId) {
+					// Add the element ID in the list ...
+					res.push_back(m_listElement[i].GetId());
+				}
+			}
+			return res;
+		};
+		
+		std::vector<int32_t> Root(void)
+		{
+			return GetListSubNode(ROOT_NODE_ID);
+		};
+		
+		
+	private:
+		int32_t								m_LastId;
+		std::vector< EdnTreeElement<T> >	m_listElement;		//!< list of element...
+		
+		bool CheckPresence(int32_t id)
+		{
+			int32_t i;
+			for (i=0; i<(int32_t)m_listElement.size(); i++) {
+				if (m_listElement[i].GetId() == id) {
+					return true;
+				}
+			}
+			return false;
+		};
+		
+		bool CheckPresenceParrent(int32_t parrentId)
+		{
+			if (ROOT_NODE_ID == parrentId) {
+				return true;
+			}
+			return CheckPresence(parrentId);
+		};
+		
+		int32_t	FindElementWithId(int32_t id)
+		{
+			int32_t i;
+			for (i=0; i<(int32_t)m_listElement.size(); i++) {
+				if (m_listElement[i].GetId() == id) {
+					return i;
+				}
+			}
+			return ROOT_NODE_ID;
+		};
+};
+
+
+
+#undef __class__
+#define __class__	NULL
+
+#endif
+

Sources/tools/EdnTemplate/EdnVector.h

@@ -0,0 +1,497 @@
+/**
+ *******************************************************************************
+ * @file EdnEdnVector.h
+ * @brief Editeur De N'ours : Basic EdnVector (template)
+ * @author Edouard DUPIN
+ * @date 07/04/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+#ifndef __EDN_EdnVector_H__
+#define __EDN_EdnVector_H__
+
+#undef __class__
+#define __class__	"EdnEdnVector"
+
+/**
+ * @brief EdnVector classes ...
+ *
+ * @tparam[in] T The type of objects to store.
+ * @tparam[in] INC Incrementation mode (0 : Exponential to 200 and increment by stemp of 200)
+ *
+ * @todo : Need to add : popBack / Assign / Insert / Erase / Swap / Clear
+ *
+ *          m_data
+ *         ----------         |-----------------------|                             
+ *         |    0   |-------->|  Class Data           |                             
+ *         |--------|         |-----------------------|                             
+ *         |    1   |----|                                                          
+ *         |--------|    |                                                          
+ *         |    2   |====|==============|   |-----------------------|               
+ *         |--------|    |              --->|  Class Data           |               
+ * m_count |    3   |-|  |                  |-----------------------|               
+ *         |--------| |  |                                                          
+ *         |    x   | |  |        |-----------------------|                         
+ *         |--------| |  -------->|  Class Data           |                         
+ *         |    x   | |           |-----------------------|                         
+ *         |--------| |                                                             
+ *         |    x   | |                                                             
+ *         |--------| |                     |-----------------------|               
+ *         |    x   | --------------------->|  Class Data           |               
+ *         |--------|                       |-----------------------|               
+ *         |    x   |                                                               
+ *         |--------|                                                               
+ *         |    x   |                                                               
+ *         |--------|                                                               
+ * m_size  |    x   |                                                               
+ *         ----------                                                               
+ *
+ */
+template<class T, int32_t INC=0> class EdnVector:
+{
+	public:
+		class Iterator:
+		{
+			// Private data : 
+			private:
+				int32_t			  m_current;		// curent Id on the vector
+				EdnVector<T>	* m_EdnVector;		// Pointer on the curent element of the vector
+			public:
+				/**
+				 * @brief Basic itarator constructor with no link with an EdnVector
+				 */
+				Iterator():
+					m_current(-1),
+					m_EdnVector(NULL)
+				{
+					// nothing to do ...
+				}
+				/**
+				 * @brief Recopy constructor on a specific EdnVector.
+				 * @param[in] otherIterator		The Iterator that might be copy
+				 */
+				Iterator(const Iterator & otherIterator):
+					m_current(otherIterator.m_current),
+					m_EdnVector(otherIterator.m_EdnVector)
+				{
+					// nothing to do ...
+				}
+				/**
+				 * @brief Asignation operator.
+				 * @param[in] otherIterator		The Iterator that might be copy
+				 * @return reference on the curent Iterator
+				 */
+				Iterator& operator=(const Iterator & otherIterator)
+				{
+					m_current = otherIterator.m_current;
+					m_EdnVector = otherIterator.m_EdnVector;
+					return *this;
+				}
+				/**
+				 * @brief Basic destructor
+				 */
+				~Iterator()
+				{
+					m_current = -1;
+					m_EdnVector = NULL;
+				}
+				/**
+				 * @brief basic boolean cast
+				 * @return true if the element is present in the EdnVector size
+				 */
+				operator bool ()
+				{
+					if(		0 <= m_current
+						&&	m_current < m_EdnVector->Size() )
+					{
+						return true;
+					} else {
+						return false;
+					}
+				}
+				/**
+				 * @brief Incremental operator
+				 * @return Reference on the current iterator incremented
+				 */
+				Iterator& operator++ ()
+				{
+					if(		NULL != m_EdnVector
+						&&	m_current < m_EdnVector->Size() )
+					{
+						m_current++;
+					}
+					return *this;
+				}
+				/**
+				 * @brief Decremental operator
+				 * @return Reference on the current iterator decremented
+				 */
+				Iterator& operator-- ()
+				{
+					if (m_current >= 0) {
+						m_current--;
+					}
+					return *this;
+				}
+				/**
+				 * @brief Incremental operator
+				 * @return Reference on a new iterator and increment the other one
+				 */
+				Iterator operator++ (int32_t)
+				{
+					Iterator it(*this);
+					++(*this);
+					return it;
+				}
+				/**
+				 * @brief Decremental operator
+				 * @return Reference on a new iterator and decrement the other one
+				 *
+				 */
+				Iterator operator-- (int32_t)
+				{
+					Iterator it(*this);
+					--(*this);
+					return it;
+				}
+				/**
+				 * @brief 
+				 *
+				 * @param[in,out] ---
+				 *
+				 * @return ---
+				 *
+				 */
+				T * operator-> () const
+				{
+					EDN_CHECK_INOUT(m_current >= 0 && m_current < m_EdnVector->Size());
+					return &m_EdnVector->Get(m_current);
+				}
+				/**
+				 * @brief 
+				 *
+				 * @param[in,out] ---
+				 *
+				 * @return ---
+				 *
+				 */
+				T & operator* () const
+				{
+					EDN_CHECK_INOUT(m_current >= 0 && m_current < m_EdnVector->Size());
+					return m_EdnVector->Get(m_current);
+				}
+			private:
+				/**
+				 * @brief 
+				 *
+				 * @param[in,out] ---
+				 *
+				 * @return ---
+				 *
+				 */
+				Iterator(EdnVector<T> * EdnVector, int pos):
+					m_current(pos),
+					m_EdnVector(EdnVector)
+				{
+					// nothing to do ...
+				}
+				friend class EdnVector;
+		};
+
+	/**
+	 * @brief 
+	 *
+	 * @param[in,out] ---
+	 *
+	 * @return ---
+	 *
+	 */
+	EdnVector(int count = 0):
+		m_data(NULL),
+		m_count(0),
+		m_size(0)
+	{
+		Resize(count);
+	}
+	
+	/**
+	 * @brief 
+	 *
+	 * @param[in,out] ---
+	 *
+	 * @return ---
+	 *
+	 */
+	EdnVector(const EdnVector<T> & EdnVector):
+		m_size(EdnVector.m_size),
+		m_count(EdnVector.m_count),
+		m_data(NULL)
+	{
+		int32_t i;
+		EDN_MALLOC_CAST(m_data, m_size, T, reinterpret_cast<T*>);
+		for(i=0; i<m_count; i++) {
+			new (&m_data[i]) T(EdnVector[i]);
+		}
+	}
+	
+	/**
+	 * @brief 
+	 *
+	 * @param[in,out] ---
+	 *
+	 * @return ---
+	 *
+	 */
+	~EdnVector()
+	{
+		Destroy();
+	}
+	
+	/**
+	 * @brief 
+	 *
+	 * @param[in,out] ---
+	 *
+	 * @return ---
+	 *
+	 */
+	EdnVector& operator=(const EdnVector<T> & EdnVector)
+	{
+		int32_t i;
+		this->~EdnVector(); 
+		m_size = EdnVector.m_size;
+		m_count = EdnVector.m_count;
+		EDN_MALLOC_CAST(m_data, m_size, T, reinterpret_cast<T*>);
+		for(i=0; i<m_count; i++) {
+			new (&m_data[i]) T(EdnVector[i]);
+		}
+		return *this;
+	}
+	
+	/**
+	 * @brief 
+	 *
+	 * @param[in,out] ---
+	 *
+	 * @return ---
+	 *
+	 */
+	int32_t Size()
+	{
+		return m_count;
+	}
+	
+	/**
+	 * @brief 
+	 *
+	 * @param[in,out] ---
+	 *
+	 * @return ---
+	 *
+	 */
+	T& Get(int32_t pos)
+	{
+		return m_data[pos];
+	}
+	
+	/**
+	 * @brief 
+	 *
+	 * @param[in,out] ---
+	 *
+	 * @return ---
+	 *
+	 */
+	T& operator[] (int32_t pos)
+	{
+		return Get(pos);
+	}
+	
+	/**
+	 * @brief 
+	 *
+	 * @param[in,out] ---
+	 *
+	 * @return ---
+	 *
+	 */
+	const T& operator[] (int32_t pos) const
+	{
+		return m_data[pos];
+	}
+	
+	/**
+	 * @brief 
+	 *
+	 * @param[in,out] ---
+	 *
+	 * @return ---
+	 *
+	 */
+	int IndexOf(const T * item) const
+	{
+		int32_t res = item - m_data;
+		if(		0 > res
+			||	res >= Size())
+		{
+			return -1
+		} else {
+			return res;
+		}
+	}
+
+	/**
+	 * @brief 
+	 *
+	 * @param[in,out] ---
+	 *
+	 * @return ---
+	 *
+	 */
+	void PushBack(const T& item)
+	{
+		int32_t idx = Size();
+		Resize(idx+1);
+		Get(idx) = item;
+	}
+
+	/**
+	 * @brief 
+	 *
+	 * @param[in,out] ---
+	 *
+	 * @return ---
+	 *
+	 */
+	Iterator Get(int pos)
+	{
+		return Iterator(this, pos);
+	}
+	
+	/**
+	 * @brief 
+	 *
+	 * @param[in,out] ---
+	 *
+	 * @return ---
+	 *
+	 */
+	Iterator Begin()
+	{
+		return Get(0);
+	}
+	
+	/**
+	 * @brief 
+	 *
+	 * @param[in,out] ---
+	 *
+	 * @return ---
+	 *
+	 */
+	Iterator End()
+	{
+		return Get( Size()-1 );
+	}
+
+	/**
+	 * @brief 
+	 *
+	 * @param[in,out] ---
+	 *
+	 * @return ---
+	 *
+	 */
+	void Resize(int32_t count)
+	{
+		int32_t i;
+		// Reallocate memory
+		if (count > m_size) {
+			ChangeAllocation(count);
+		}
+
+		// Remove deprecated element
+		for(i=count; i<m_count; i++) {
+			m_data[i].~T();
+		}
+
+		// Create nex item
+		for(i=m_count;i<count;i++) {
+			new (&m_data[i]) T();
+		}
+
+		m_count = count;
+	}
+
+	/**
+	 * @brief 
+	 *
+	 * @param[in,out] ---
+	 *
+	 * @return ---
+	 *
+	 */
+	void ChangeAllocation(int count)
+	{
+		if (count > m_size) {
+			// generate new size
+			while(count > m_size) {
+				if (INC) {
+					m_size = (m_size + INC)
+				} else if (m_size==0) {
+					m_size = 1;
+				} else {
+					m_size = m_size * 2;
+				}
+			}
+			// Allocate the curent element
+			T * data = NULL;
+			EDN_MALLOC_CAST(data, m_size, T, reinterpret_cast<T*>);
+			for(int i=0; i<m_count; i++) {
+				new (&data[i]) T(m_data[i]);
+			}
+			Destroy();
+			m_data = data;
+		}
+	}
+
+private:
+	T		* m_data;		//!< pointer on the current Data
+	int32_t	  m_count;		//!< number of element
+	int32_t	  m_size;		//!< current allocated size
+
+	/**
+	 * @brief 
+	 *
+	 * @param[in,out] ---
+	 *
+	 * @return ---
+	 *
+	 */
+	void Destroy()
+	{
+		for(int i=0; i<m_count; i++) {
+			m_data[i].~T();
+		}
+		if (m_data) {
+			EDN_FREE(m_data);
+		}
+	}
+};
+#undef __class__
+#define __class__	NULL

Sources/tools/EdnTemplate/EdnVectorBin.h

@@ -0,0 +1,642 @@
+/**
+ *******************************************************************************
+ * @file EdnEdnVectorBin.h
+ * @brief Editeur De N'ours : Basic EdnVectorBin for direct data insertion (template)
+ * @author Edouard DUPIN
+ * @date 07/04/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+#ifndef __EDN_VECTOR_BIN_H__
+#define __EDN_VECTOR_BIN_H__
+
+#include "toolsMemory.h"
+
+#undef __class__
+#define __class__	"EdnEdnVectorBin"
+
+/**
+ * @brief EdnVectorBin classes ...
+ *
+ * @tparam[in] SIZE Size of the current element.
+ *
+ * @todo : Need to add : popBack / Assign / Insert / Erase / Swap / Clear
+ *
+ *              m_data
+ *               <------------ m_dataSize ------------>
+ *              ----------------------------------------
+ *              |    0                                 |
+ *              |--------------------------------------|
+ *              |    1                                 |
+ *              |--------------------------------------|
+ *              |    2                                 |
+ *              |--------------------------------------|
+ * m_size       |    3                                 |
+ *              |--------------------------------------|
+ *              |    x                                 |
+ *              |--------------------------------------|
+ *              |    x                                 |
+ *              |--------------------------------------|
+ *              |    x                                 |
+ *              |--------------------------------------|
+ *              |    x                                 |
+ *              |--------------------------------------|
+ *              |    x                                 |
+ *              |--------------------------------------|
+ *              |    x                                 |
+ *              |--------------------------------------|
+ * m_allocated  |    x                                 |
+ *              ----------------------------------------
+ *
+ */
+template<typename MY_TYPE=int32_t> class EdnVectorBin
+{
+	public:
+		class Iterator
+		{
+			// Private data : 
+			private:
+				int32_t						  m_current;		// curent Id on the vector
+				EdnVectorBin<MY_TYPE>		* m_EdnVectorBin;	// Pointer on the curent element of the vectorBin
+			public:
+				/**
+				 * @brief Basic itarator constructor with no link with an EdnVector
+				 */
+				Iterator():
+					m_current(-1),
+					m_EdnVectorBin(NULL)
+				{
+					// nothing to do ...
+				}
+				/**
+				 * @brief Recopy constructor on a specific EdnVector.
+				 * @param[in] otherIterator		The Iterator that might be copy
+				 */
+				Iterator(const Iterator & otherIterator):
+					m_current(otherIterator.m_current),
+					m_EdnVectorBin(otherIterator.m_EdnVectorBin)
+				{
+					// nothing to do ...
+				}
+				/**
+				 * @brief Asignation operator.
+				 * @param[in] otherIterator		The Iterator that might be copy
+				 * @return reference on the curent Iterator
+				 */
+				Iterator& operator=(const Iterator & otherIterator)
+				{
+					m_current = otherIterator.m_current;
+					m_EdnVectorBin = otherIterator.m_EdnVectorBin;
+					return *this;
+				}
+				/**
+				 * @brief Basic destructor
+				 */
+				~Iterator()
+				{
+					m_current = -1;
+					m_EdnVectorBin = NULL;
+				}
+				/**
+				 * @brief basic boolean cast
+				 * @return true if the element is present in the EdnVector size
+				 */
+				operator bool ()
+				{
+					if(		0 <= m_current
+						&&	m_current < m_EdnVectorBin->Size() )
+					{
+						return true;
+					} else {
+						return false;
+					}
+				}
+				/**
+				 * @brief Incremental operator
+				 * @return Reference on the current iterator incremented
+				 */
+				Iterator& operator++ ()
+				{
+					if(		NULL != m_EdnVectorBin
+						&&	m_current < m_EdnVectorBin->Size() )
+					{
+						m_current++;
+					}
+					return *this;
+				}
+				/**
+				 * @brief Decremental operator
+				 * @return Reference on the current iterator decremented
+				 */
+				Iterator& operator-- ()
+				{
+					if (m_current >= 0) {
+						m_current--;
+					}
+					return *this;
+				}
+				/**
+				 * @brief Incremental operator
+				 * @return Reference on a new iterator and increment the other one
+				 */
+				Iterator operator++ (int32_t)
+				{
+					Iterator it(*this);
+					++(*this);
+					return it;
+				}
+				/**
+				 * @brief Decremental operator
+				 * @return Reference on a new iterator and decrement the other one
+				 */
+				Iterator operator-- (int32_t)
+				{
+					Iterator it(*this);
+					--(*this);
+					return it;
+				}
+				/**
+				 * @brief Get reference on the current Element
+				 * @return the reference on the current Element 
+				 */
+				MY_TYPE & operator-> () const
+				{
+					EDN_CHECK_INOUT(m_current >= 0 && m_current < m_EdnVectorBin->Size());
+					return &m_EdnVectorBin->Get(m_current);
+				}
+				/**
+				 * @brief Get reference on the current Element
+				 * @return the reference on the current Element 
+				 */
+				MY_TYPE & operator* () const
+				{
+					EDN_CHECK_INOUT(m_current >= 0 && m_current < m_EdnVectorBin->Size());
+					return m_EdnVectorBin->Get(m_current);
+				}
+			private:
+				/**
+				 * @brief 
+				 *
+				 * @param[in,out] ---
+				 *
+				 * @return ---
+				 *
+				 */
+				Iterator(EdnVectorBin<MY_TYPE> * Evb, int32_t pos):
+					m_current(pos),
+					m_EdnVectorBin(Evb)
+				{
+					// nothing to do ...
+				}
+				friend class EdnVectorBin;
+		};
+
+	private:
+		MY_TYPE		* m_data;		//!< pointer on the curetn table of Data
+		int32_t		  m_size;		//!< nb Element in the buffer
+		int32_t		  m_allocated;	//!< Current allocated size
+		int32_t		  m_increment;	//!< methode of increment
+	public:
+		/**
+		 * @brief Create an empty vector
+		 * @param[in] count		Minimum request size of the Buffer
+		 */
+		EdnVectorBin(int32_t count = 0):
+			m_data(NULL),
+			m_size(0),
+			m_allocated(0),
+			m_increment(1)
+		{
+			ChangeAllocation(count);
+		}
+
+		/**
+		 * @brief Re-copy constructor (copy all needed data)
+		 * @param[in] Evb	Vector that might be copy
+		 */
+		EdnVectorBin(const EdnVectorBin<MY_TYPE> & Evb)
+		{
+			m_allocated = Evb.m_allocated;
+			m_size = Evb.m_size;
+			m_increment = Evb.m_increment;
+			m_data = NULL;
+			//EDN_DEBUG("USE Specific vector allocator ... Evb.m_size=" << Evb.m_size << " Evb.m_increment=" << Evb.m_increment);
+			// allocate all same data
+			EDN_MALLOC(m_data, m_allocated, MY_TYPE);
+			EDN_ASSERT(NULL!=m_data, "Error in data allocation");
+			// Copy all data ...
+			memcpy(m_data, Evb.m_data, m_allocated * sizeof(MY_TYPE) );
+		}
+
+		/**
+		 * @brief Destructor of the current Class
+		 */
+		~EdnVectorBin()
+		{
+			if (NULL!=m_data) {
+				EDN_FREE(m_data);
+				m_data = NULL;
+				m_allocated = 0;
+				m_size = 0;
+				m_increment = 0;
+			}
+		}
+
+		/**
+		 * @brief Re-copy operator
+		 * @param[in] Evb	Vector that might be copy
+		 * @return reference on the curent re-copy vector
+		 */
+		EdnVectorBin& operator=(const EdnVectorBin<MY_TYPE> & Evb)
+		{
+			//EDN_DEBUG("USE RECOPY vector ... Evb.m_size=" << Evb.m_size << " Evb.m_increment=" << Evb.m_increment);
+			if( this != &Evb ) // avoid copy to itself
+			{
+				if (NULL!=m_data) {
+					EDN_FREE(m_data);
+					m_data = NULL;
+				}
+				// Set the new value
+				m_allocated = Evb.m_allocated;
+				m_size      = Evb.m_size;
+				m_increment = Evb.m_increment;
+				// allocate all same data
+				EDN_MALLOC(m_data, m_allocated, MY_TYPE);
+				EDN_ASSERT(NULL!=m_data, "Error in data allocation");
+				// Copy all data ...
+				memcpy(m_data, Evb.m_data, m_allocated * sizeof(MY_TYPE) );
+			}
+			// Return the curent pointer
+			return *this;
+		}
+
+		/**
+		 * @brief Add at the Last position of the Vector
+		 * @param[in] item	Element to add at the end of vector
+		 */
+		EdnVectorBin& operator+= (const EdnVectorBin<MY_TYPE> & Evb)	// += operator
+		{
+			int32_t nbElememt = Evb.Size();
+			int32_t idx = m_size;
+			Resize(m_size+nbElememt);
+			memcpy(&m_data[idx], &Evb.m_data[0], nbElememt*sizeof(MY_TYPE) );
+			// Return the curent pointer
+			return *this;
+		}
+
+		/**
+		 * @brief Set increment mode of this vector (default it match corectly with the number of element inside)
+		 * @param[in] newIncrementNumber methode requested
+		 */
+		void SetIncrement(int32_t newIncrementNumber)
+		{
+			m_increment = newIncrementNumber;
+		}
+
+		/**
+		 * @brief Get the number of element in the vector
+		 * @return The number requested
+		 */
+		int32_t Size() const
+		{
+			return m_size;
+		}
+
+		/**
+		 * @brief Get the Allocated size in the vector
+		 * @return The size of allocation
+		 */
+		int32_t AllocatedSize() const
+		{
+			return m_allocated;
+		}
+
+		/**
+		 * @brief Get a current element in the vector
+		 * @param[in] pos Desired position read
+		 * @return Reference on the Element
+		 */
+		MY_TYPE& Get(int32_t pos)
+		{
+			return m_data[pos];
+		}
+
+		/**
+		 * @brief Get an copy Element an a special position
+		 * @param[in] pos	Position in the vector that might be get [0..Size()]
+		 * @return An reference on the copy of selected element
+		 */
+		MY_TYPE& operator[] (int32_t pos)
+		{
+			return Get(pos);
+		}
+
+		/**
+		 * @brief Get an Element an a special position
+		 * @param[in] pos	Position in the vector that might be get [0..Size()]
+		 * @return An reference on the selected element
+		 */
+		const MY_TYPE& operator[] (int32_t pos) const
+		{
+			return m_data[pos];
+		}
+
+		/**
+		 * @brief Add at the Last position of the Vector
+		 * @param[in] item	Element to add at the end of vector
+		 */
+		void PushBack(const MY_TYPE& item)
+		{
+			int32_t idx = m_size;
+			Resize(m_size+1);
+			m_data[idx] = item;
+		}
+
+		/**
+		 * @brief Add at the Last position of the Vector
+		 * @param[in] item	Element to add at the end of vector
+		 */
+		void PushBack(const MY_TYPE * item, int32_t nbElement)
+		{
+			if (NULL == item) {
+				return;
+			}
+			int32_t idx = m_size;
+			Resize(m_size+nbElement);
+			memcpy(&m_data[idx], item, nbElement*sizeof(MY_TYPE) );
+		}
+
+		/**
+		 * @brief Remove the last element of the vector
+		 */
+		void PopBack(void)
+		{
+			if(m_size>0) {
+				Resize(m_size-1);
+			}
+		}
+
+		/**
+		 * @brief Remove all alement in the current vector
+		 */
+		void Clear(void)
+		{
+			if(m_size>0) {
+				Resize(0);
+			}
+		}
+
+		/**
+		 * @brief 
+		 *
+		 * @param[in,out] ---
+		 *
+		 * @return ---
+		 *
+		 */
+		void Insert(int32_t pos, const MY_TYPE& item)
+		{
+			if (pos>m_size) {
+				EDN_ERROR(" can not insert Element at this position : " << pos << " > " << m_size<< " add it at the end ... ");
+				PushBack(item);
+				return;
+			}
+			int32_t tmpSize = m_size;
+			// Request resize of the current buffer
+			Resize(m_size+1);
+			// move curent data
+			memmove((m_data + pos + 1), (m_data + pos), (tmpSize - pos)*sizeof(MY_TYPE) );
+			// affectation of the current element
+			m_data[pos] = item;
+		}
+
+		/**
+		 * @brief 
+		 *
+		 * @param[in,out] ---
+		 *
+		 * @return ---
+		 *
+		 */
+		void Insert(int32_t pos, const MY_TYPE * item, int32_t nbElement)
+		{
+			if (pos>m_size) {
+				EDN_WARNING(" can not insert Element at this position : " << pos << " > " << m_size << " add it at the end ... ");
+				PushBack(item, nbElement);
+				return;
+			}
+			int32_t tmpSize = m_size;
+			// Request resize of the current buffer
+			Resize(m_size+nbElement);
+			// move curent data (after the position)
+			memmove((m_data + pos + nbElement), (m_data + pos), (tmpSize - pos)*sizeof(MY_TYPE) );
+			// affectation of all input element
+			memcpy(&m_data[pos], item, nbElement*sizeof(MY_TYPE) );
+		}
+
+		/**
+		 * @brief Remove one element
+		 *
+		 * @param[in] pos Position to remove the data
+		 *
+		 * @return ---
+		 *
+		 */
+		void Erase(int32_t pos)
+		{
+			if (pos>m_size) {
+				EDN_ERROR(" can not Erase Element at this position : " << pos << " > " << m_size);
+				return;
+			}
+			int32_t tmpSize = m_size;
+			// move curent data
+			memmove((m_data + pos), (m_data + pos + 1), (tmpSize - (pos+1))*sizeof(MY_TYPE) );
+			// Request resize of the current buffer
+			Resize(m_size-1);
+		}
+
+		/**
+		 * @brief Remove one element
+		 *
+		 * @param[in] pos Position to remove the data
+		 * @param[in] nbElement number of element to remove
+		 *
+		 * @return ---
+		 *
+		 */
+		void Erase(int32_t pos, int32_t nbElement)
+		{
+			if (pos>m_size) {
+				EDN_ERROR(" can not Erase Element at this position : " << pos << " > " << m_size);
+				return;
+			}
+			if (pos+nbElement>m_size) {
+				nbElement = m_size - pos;
+			}
+			int32_t tmpSize = m_size;
+			// move curent data
+			memmove((m_data + pos), (m_data + pos + nbElement), (tmpSize - (pos+nbElement))*sizeof(MY_TYPE) );
+			// Request resize of the current buffer
+			Resize(m_size-nbElement);
+		}
+
+		/**
+		 * @brief extract data between two point : 
+		 * @param[in] posStart start position to extract data
+		 * @param[in] posEnd End position to extract data
+		 * @return the extracted vector
+		 */
+		EdnVectorBin Extract(int32_t posStart = 0, int32_t posEnd=0x7FFFFFFF)
+		{
+			EdnVectorBin<MY_TYPE> out;
+			if (posStart < 0) {
+				posStart = 0;
+			} else if (posStart >= Size() ) {
+				return out;
+			}
+			if (posEnd < 0) {
+				return out;
+			} else if (posEnd >= Size() ) {
+				posEnd = Size();
+			}
+			out.PushBack(&m_data[posStart], posEnd-posStart);
+			return out;
+		}
+
+		/**
+		 * @brief Set the minimum allocation in memory for the curent vector ==> reallocate the 
+		 *     buffer to fit exactly the mumber of element needed
+		 */
+		void Fit(void)
+		{
+			if (m_size > m_allocated) {
+				// Reallocate the curent data to the correct size ...
+				EDN_REALLOC(m_data, m_size, MY_TYPE);
+			}
+			// Check result with assert : 
+			EDN_ASSERT(NULL!=m_data, "Error in data Fitting");
+			m_allocated = m_size;
+		}
+
+		/**
+		 * @brief Get an iterator an an specific position
+		 * @param[in] pos Requested position of the iterator in the vector
+		 * @return The Iterator
+		 */
+		Iterator Position(int32_t pos)
+		{
+			return Iterator(this, pos);
+		}
+
+		/**
+		 * @brief Get an Iterator on the start position of the Vector
+		 * @return The Iterator
+		 */
+		Iterator Begin(void)
+		{
+			return Position(0);
+		}
+
+		/**
+		 * @brief Get an Iterator on the end position of the Vector
+		 * @return The Iterator
+		 */
+		Iterator End(void)
+		{
+			return Position( Size()-1 );
+		}
+
+	private:
+		/**
+		 * @brief Change the current size of the vector
+		 * @param[in] newSize New requested size of element in the vector
+		 */
+		void Resize(int32_t newSize)
+		{
+			// Reallocate memory
+			if (newSize > m_allocated) {
+				ChangeAllocation(newSize);
+			}
+			m_size = newSize;
+		}
+		
+		/**
+		 * @brief Change the current allocation to the corect one (depend on the current size)
+		 * @param[in] newSize Minimum number of element needed
+		 */
+		void ChangeAllocation(int32_t newSize)
+		{
+			// set the minimal size to 1
+			if(newSize <= 0) {
+				newSize = 1;
+			}
+			int32_t requestSize = m_allocated;
+			// set the size with the corect chose type : 
+			if (newSize == m_allocated) {
+				return;
+			} else if (newSize < requestSize) {
+				// down the size of the vector:
+				if (0==m_increment) {
+					// never down size...
+				} else {
+					int32_t devide = m_increment;
+					if (devide == 0) {
+						devide = 1;
+					}
+					int32_t numberOfStep = m_allocated / devide;
+					if (newSize< ((numberOfStep-2)*devide + devide/2) ) {
+						//Allow Reallocation of a new size shoerter
+						requestSize = ((newSize / devide)+1) * devide;
+					}
+				}
+			} else {
+				while(newSize > requestSize) {
+					if (0 == requestSize) {
+						requestSize = 1;
+					} else if (0==m_increment) {
+						requestSize = requestSize * 2;
+					} else {
+						requestSize = (requestSize + m_increment);
+					}
+				}
+			}
+			// No reallocation needed :
+			if (requestSize == m_allocated) {
+				return;
+			}
+			// check if something is allocated : 
+			if (NULL == m_data) {
+				// no data allocated ==> request an allocation (might be the first)
+				EDN_MALLOC(m_data, requestSize, MY_TYPE);
+			} else {
+				// move datas
+				EDN_REALLOC(m_data, requestSize, MY_TYPE);
+			}
+			// Check result with assert : 
+			EDN_ASSERT(NULL!=m_data, "Error in data allocation");
+			// set the new allocation size
+			m_allocated = requestSize;
+		}
+
+};
+
+#undef __class__
+#define __class__	NULL
+
+#endif

Sources/tools/EdnTemplate/EdnVectorBuf.cpp

@@ -0,0 +1,706 @@
+/**
+ *******************************************************************************
+ * @file EdnEdnVectorBuf.cpp
+ * @brief Editeur De N'ours : Basic EdnVectorBuf Basic binary vector for all type of storage
+ * @author Edouard DUPIN
+ * @date 07/04/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+
+#include "tools_debug.h"
+#include "tools_globals.h"
+#include "toolsMemory.h"
+#include "EdnVectorBuf.h"
+
+#undef __class__
+#define __class__	"EdnEdnVectorBuf"
+
+
+/**
+ * @brief Create an empty vector
+ * 
+ * @param[in] count		Minimum request size of the Buffer
+ * 
+ * @return ---
+ * 
+ */
+EdnVectorBuf::EdnVectorBuf(int32_t count)
+{
+	m_data = NULL;
+	m_allocated = 0;
+	m_gapStart = 0;
+	m_gapEnd = GAP_SIZE_MIN;
+	ChangeAllocation(count+GAP_SIZE_MIN);
+}
+
+
+/**
+ * @brief Re-copy constructor (copy all needed data)
+ * 
+ * @param[in] Evb	Vector that might be copy
+ * 
+ * @return ---
+ * 
+ */
+EdnVectorBuf::EdnVectorBuf(const EdnVectorBuf & Evb)
+{
+	m_allocated = Evb.m_allocated;
+	m_data = NULL;
+	m_gapStart = Evb.m_gapStart;
+	m_gapEnd = Evb.m_gapEnd;
+	
+	// allocate all same data
+	EDN_MALLOC(m_data, m_allocated, int8_t);
+	EDN_ASSERT(NULL!=m_data, "Error in data allocation");
+	// Copy all data ...
+	memcpy(m_data, Evb.m_data, m_allocated * sizeof(int8_t) );
+}
+
+
+/**
+ * @brief Destructor of the current Class
+ * 
+ * @param ---
+ * 
+ * @return ---
+ * 
+ */
+EdnVectorBuf::~EdnVectorBuf()
+{
+	if (NULL!=m_data) {
+		EDN_FREE(m_data);
+		m_data = NULL;
+		m_allocated = 0;
+		m_gapStart = 0;
+		m_gapEnd = 0;
+	}
+}
+
+
+static int32_t getFileSize(FILE *myFile)
+{
+	if (NULL == myFile) {
+		return 0;
+	}
+	int32_t size = 0;
+
+	fseek(myFile, 0, SEEK_END);
+	size = ftell(myFile);
+	fseek(myFile, 0, SEEK_SET);
+	return size;
+}
+
+
+/**
+ * @brief Save in the current file open
+ * 
+ * @param[in,out] myFile	pointer on the file where data might be writed
+ *
+ * @return true if OK / false if an error occured
+ *
+ */
+bool EdnVectorBuf::DumpIn(FILE *myFile)
+{
+	bool ret = true;
+	// write Data
+	(void)fwrite(m_data,            sizeof(int8_t), m_gapStart, myFile);
+	(void)fwrite(&m_data[m_gapEnd], sizeof(int8_t), m_allocated - m_gapEnd, myFile);
+	return ret;
+}
+
+
+/**
+ * @brief Load in the current file open
+ * 
+ * @param[in,out] myFile	pointer on the file where data might be read
+ *
+ * @return true if OK / false if an error occured
+ *
+ */
+bool EdnVectorBuf::DumpFrom(FILE *myFile)
+{
+	bool ret = true;
+	int32_t length = getFileSize(myFile);
+	// error case ...
+	if (length < 0) {
+		length = 0;
+	}
+	// allocate the current buffer : 
+	ChangeAllocation(length + GAP_SIZE_MIN);
+	
+	// insert Data
+	int32_t nbReadData = fread(&m_data[GAP_SIZE_MIN], sizeof(int8_t), length, myFile);
+	EDN_INFO("load data : filesize=" << length << ", readData=" << nbReadData);
+	// check ERROR
+	if (nbReadData != length) {
+		EDN_ERROR("load data pb : filesize=" << length << ", readData=" << nbReadData);
+		ret = false;
+	}
+	// set the gapsize at the end ...
+	m_gapStart = 0;
+	m_gapEnd = GAP_SIZE_MIN;
+	return ret;
+}
+
+
+
+/**
+ * @brief Re-copy operator
+ * 
+ * @param[in] Evb	Vector that might be copy
+ * 
+ * @return reference on the curent re-copy vector
+ * 
+ */
+EdnVectorBuf& EdnVectorBuf::operator=(const EdnVectorBuf & Evb)
+{
+	if( this != &Evb ) // avoid copy to itself
+	{
+		if (NULL!=m_data) {
+			EDN_FREE(m_data);
+			m_data = NULL;
+		}
+		// Set the new value
+		m_allocated = Evb.m_allocated;
+		m_gapStart  = Evb.m_gapStart;
+		m_gapEnd    = Evb.m_gapEnd;
+		// allocate all same data
+		EDN_MALLOC(m_data, m_allocated, int8_t);
+		EDN_ASSERT(NULL!=m_data, "Error in data allocation");
+		// Copy all data ...
+		memcpy(m_data, Evb.m_data, m_allocated * sizeof(int8_t) );
+	}
+	// Return the curent pointer
+	return *this;
+}
+
+int8_t EdnVectorBuf::operator[] (int32_t pos)
+{
+	EDN_ASSERT(0 <= pos || pos < Size(), "try to read an element non existing");
+	if (pos < m_gapStart) {
+		return m_data[pos];
+	}
+	return m_data[pos + m_gapEnd-m_gapStart];
+}
+
+
+/**
+ * @brief Get a current element in the vector
+ * 
+ * @param[in] pos Desired position read
+ * 
+ * @return Reference on the Element
+ * 
+ */
+int8_t& EdnVectorBuf::Get(int32_t pos)
+{
+	EDN_ASSERT(0 <= pos || pos < Size(), "try to read an element non existing");
+	if (pos < m_gapStart) {
+		return m_data[pos];
+	}
+	return m_data[pos + m_gapEnd-m_gapStart];
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnVectorBuf::Get(int32_t pos, int32_t nbElement, EdnVectorBin<int8_t> &tmpBuffer)
+{
+	tmpBuffer.Clear();
+	if (pos < m_gapStart) {
+		if (pos + nbElement < m_gapStart) {
+			tmpBuffer.PushBack(&m_data[pos], nbElement);
+		} else {
+			tmpBuffer.PushBack(&m_data[pos], m_gapStart - pos);
+			tmpBuffer.PushBack(&m_data[m_gapEnd], nbElement - (m_gapStart - pos) );
+		}
+	} else {
+		tmpBuffer.PushBack(&m_data[pos+(m_gapEnd-m_gapStart)], nbElement);
+	}
+}
+
+
+/**
+ * @brief Add at the Last position of the Vector
+ * 
+ * @param[in] item	Element to add at the end of vector
+ * 
+ * @return ---
+ * 
+ */
+void EdnVectorBuf::PushBack(const int8_t& item)
+{
+	Insert( Size(), item);
+}
+
+/**
+ * @brief Remove the last element of the vector
+ * 
+ * @param ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnVectorBuf::PopBack(void)
+{
+	if (Size()>0) {
+		Remove( Size() );
+	}
+}
+
+
+/**
+ * @brief Remove data in the buffer
+ * 
+ * @param[in] 
+ * 
+ * @return ---
+ * 
+ */
+void EdnVectorBuf::Remove(int32_t pos, int32_t nbRemoveElement)
+{
+	if(		pos > Size()
+		||	pos < 0 ) {
+		EDN_ERROR("Request higher than buffer size : pos="<<pos<< " bufferSize="<<Size());
+		return;
+	}
+	if( pos+nbRemoveElement > Size() ) {
+		EDN_ERROR("Request remove more element than expected in the buffer pos+nbRemoveElement="<<pos+nbRemoveElement<< " bufferSize="<<Size());
+		return;
+	}
+	if (false == GapMove(pos) ) {
+		return;
+	}
+	// Remove elements :
+	if (m_allocated==m_gapEnd) {
+		m_gapStart -= nbRemoveElement;
+	} else {
+		m_gapEnd += nbRemoveElement;
+	}
+	// Resize buffer if needed...
+	GapCheckMaxSize();
+}
+
+/**
+ * @brief Change the current allocation to the corect one (depend on the current size)
+ * 
+ * @param[in] newSize Minimum number of element needed
+ * 
+ * @return ---
+ * 
+ */
+void EdnVectorBuf::Clear(void)
+{
+	// Remove all element in the buffer
+	Remove(0, Size() );
+}
+
+
+/**
+ * @brief Change the current allocation to the corect one (depend on the current size)
+ * 
+ * @param[in] newSize Minimum number of element needed
+ * 
+ * @return ---
+ * 
+ */
+void EdnVectorBuf::ChangeAllocation(int32_t newSize)
+{
+	// set the minimal size to 1
+	if(newSize <= 0) {
+		newSize = 1;
+	}
+	// set the size with the corect chose type : 
+	if (newSize == m_allocated) {
+		return;
+	}
+	EDN_DEBUG("Change Allocation : " << m_allocated << " ==> " << newSize);
+	// check if something is allocated : 
+	if (NULL == m_data) {
+		// no data allocated ==> request an allocation (might be the first)
+		EDN_MALLOC(m_data, newSize, int8_t);
+	} else {
+		// move datas
+		EDN_REALLOC(m_data, newSize, int8_t);
+	}
+	// Check result with assert : 
+	EDN_ASSERT(NULL!=m_data, "Error in data allocation");
+	// set the new allocation size
+	m_allocated = newSize;
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnVectorBuf::Insert(int32_t pos, const int8_t& item)
+{
+	if(		pos > Size()
+		||	pos < 0 ) {
+		EDN_ERROR("Request higher than buffer size : pos="<<pos<< " bufferSize="<<Size());
+		return;
+	}
+	if( 0 == GapSize() ) {
+		if (false == GapResize(pos, GAP_SIZE_MIN + 1) ) {
+			return;
+		}
+	} else if(		pos == m_gapStart
+				&&	pos == m_gapEnd-1 )
+	{
+		// mothing to do ...
+	} else {
+		if (false == GapMove(pos)) {
+			return;
+		}
+	}
+	if(pos == m_gapStart) {
+		m_data[m_gapStart] = item;
+		m_gapStart++;
+	} else {
+		m_data[m_gapEnd-1] = item;
+		m_gapEnd--;
+	}
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnVectorBuf::Insert(int32_t pos, EdnVectorBin<int8_t>& items)
+{
+	if(		pos > Size()
+		||	pos < 0 ) {
+		EDN_ERROR("Request higher than buffer size : pos="<<pos<< " bufferSize="<<Size());
+		return;
+	}
+	if( items.Size() > GapSize() ) {
+		if (false == GapResize(pos, GAP_SIZE_MIN + items.Size()) ) {
+			return;
+		}
+	} else {
+		if (false == GapMove(pos) ) {
+			return;
+		}
+	}
+	int32_t i;
+	for(i=0; i<items.Size(); i++) {
+		m_data[m_gapStart+i] = items[i];
+	}
+	m_gapStart += items.Size();
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnVectorBuf::Replace(int32_t pos, const int8_t& item)
+{
+	if(		pos > Size()
+		||	pos < 0 ) {
+		EDN_ERROR("Request higher than buffer size : pos="<<pos<< " bufferSize="<<Size());
+		return;
+	}
+	// just replace the element, not update Gap position
+	if (pos < m_gapStart) {
+		m_data[pos] = item;
+	} else {
+		m_data[pos+GapSize()] = item;
+	}
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnVectorBuf::Replace(int32_t pos, int32_t nbRemoveElement, EdnVectorBin<int8_t>& items)
+{
+	if(		pos > Size()
+		||	pos < 0 ) {
+		EDN_ERROR("Request higher than buffer size : pos="<<pos<< " bufferSize="<<Size());
+		return;
+	}
+	if( pos+nbRemoveElement > Size() ) {
+		EDN_ERROR("Request remove more element than expected in the buffer pos+nbRemoveElement="<<pos+nbRemoveElement<< " bufferSize="<<Size());
+		return;
+	}
+	if (false == GapMove(pos)) {
+		return;
+	}
+	// Remove elements :
+	m_gapEnd += nbRemoveElement;
+	//Display();
+	// insert elements
+	Insert(pos, items);
+	// Resize buffer if needed...
+	GapCheckMaxSize();
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+bool EdnVectorBuf::GapMove(int32_t pos)
+{
+	if(		pos > Size()
+		||	pos < 0 ) {
+		EDN_ERROR("Request higher than buffer size : pos="<<pos<< " bufferSize="<<Size());
+		return false;
+	}
+	int32_t gapLen = m_gapEnd - m_gapStart;
+	if (pos > m_gapStart) {
+		memmove(&m_data[m_gapStart], &m_data[m_gapEnd], pos - m_gapStart);
+	} else {
+		memmove(&m_data[pos + gapLen], &m_data[pos], m_gapStart - pos);
+	}
+	m_gapEnd += pos - m_gapStart;
+	m_gapStart += pos - m_gapStart;
+	return true;
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+bool EdnVectorBuf::GapResize(int32_t pos, int32_t newGapLen)
+{
+	if(		pos > Size()
+		||	pos < 0 ) {
+		EDN_ERROR("Request higher than buffer size : pos="<<pos<< " bufferSize="<<Size());
+		return false;
+	}
+	int32_t previousSize = Size();
+	if (newGapLen == GapSize() ) {
+		// nothing to do ...
+		return true;
+	} else {
+		if (newGapLen > GapSize() ) {
+			// reallocation
+			ChangeAllocation( previousSize + newGapLen);
+		}
+		// move Data
+		if (pos <= m_gapStart) {
+			// just move the end of the gap
+			memmove(&m_data[m_gapStart + newGapLen], &m_data[m_gapEnd], previousSize - m_gapStart);
+			// update gap end position
+			m_gapEnd = m_gapStart + newGapLen;
+			if (pos < m_gapStart) {
+				if (false == GapMove(pos)) {
+					return false;
+				}
+			}
+			// no else
+		} else {
+			if (false == GapMove(pos) ) {
+				return false;
+			}
+			memmove(&m_data[m_gapStart + newGapLen], &m_data[m_gapEnd], previousSize - m_gapStart);
+		}
+		if (newGapLen < GapSize() ) {
+			// rellocation
+			ChangeAllocation(previousSize + newGapLen);
+		}
+	}
+	// update gap position
+	m_gapStart = pos;
+	m_gapEnd = pos + newGapLen;
+	return true;
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnVectorBuf::GapCheckMaxSize(void)
+{
+	if(GapSize() > GAP_SIZE_MAX) {
+		int32_t currentSize = Size();
+		// Change the gap Size
+		if (false == GapResize(m_gapStart, GAP_SIZE_MAX) ) {
+			return;
+		}
+		// remove deprecated elements at the end of the buffer ...
+		ChangeAllocation(currentSize + GAP_SIZE_MAX);
+	}
+}
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnVectorBuf::Display(void)
+{
+	EDN_INFO(" Display Buffer : Size="<<Size()<<" m_allocated="<<m_allocated<<" m_gapStart="<<m_gapStart<<" m_gapEnd="<<m_gapEnd);
+	for(int32_t i=0; i<m_allocated; i++) {
+		if (i>= m_gapStart && i< m_gapEnd) {
+			EDN_INFO( "Element " << i << " : GAP");
+		} else {
+			EDN_INFO( "Element " << i << " : " << m_data[i]);
+		}
+	}
+}
+
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void TestEdnVectorBuf(void)
+{
+	EdnVectorBuf myBufferTmp;
+	int32_t i;
+	
+	//invert data
+	for (i=0; i<50; i++) {
+		myBufferTmp.Insert(0, 'a' + i%26);
+	}
+	myBufferTmp.Display();
+	myBufferTmp.Clear();
+	myBufferTmp.Display();
+	
+	myBufferTmp.Remove(2, 300);
+	/*
+	char plop='a';
+	myBufferTmp.Insert(0, plop);
+	myBufferTmp.Display();
+	plop='b';
+	myBufferTmp.Insert(0, plop);
+	myBufferTmp.Display();
+	plop='c';
+	myBufferTmp.Insert(0, plop);
+	myBufferTmp.Display();
+	plop='d';
+	myBufferTmp.Insert(0, plop);
+	myBufferTmp.Display();
+	plop='e';
+	myBufferTmp.Insert(0, plop);
+	myBufferTmp.Display();
+	plop='f';
+	myBufferTmp.Insert(0, plop);
+	myBufferTmp.Display();
+	plop='g';
+	myBufferTmp.Insert(0, plop);
+	myBufferTmp.Display();
+	plop='h';
+	myBufferTmp.Insert(0, plop);
+	myBufferTmp.Display();
+	plop='m';
+	
+	EdnVectorBin<int8_t> items;
+	items.PushBack('i');
+	items.PushBack('j');
+	items.PushBack('k');
+	items.PushBack('l');
+	items.PushBack('m');
+	items.PushBack('n');
+	items.PushBack('o');
+	items.PushBack('p');
+	
+	
+	
+	myBufferTmp.Insert(3, items);
+	myBufferTmp.Display();
+	
+	
+	
+	plop='7';
+	myBufferTmp.Insert(7, plop);
+	myBufferTmp.Display();
+	
+	myBufferTmp.Replace(8, 'z');
+	myBufferTmp.Display();
+	
+	items.Clear();
+	items.PushBack('1');
+	items.PushBack('2');
+	items.PushBack('3');
+	myBufferTmp.Replace(10, 4, items);
+	myBufferTmp.Display();
+
+	
+	myBufferTmp.PushBack('a');
+	myBufferTmp.PushBack('a');
+	myBufferTmp.PushBack('a');
+	myBufferTmp.PushBack('a');
+	myBufferTmp.Display();
+	
+	
+	myBufferTmp.PopBack();
+	myBufferTmp.PopBack();
+	myBufferTmp.PopBack();
+	myBufferTmp.PopBack();
+	myBufferTmp.Display();
+	
+	myBufferTmp.Remove(2, 3);
+	myBufferTmp.Display();
+	*/
+	
+}
+
+

Sources/tools/EdnTemplate/EdnVectorBuf.h

@@ -0,0 +1,342 @@
+/**
+ *******************************************************************************
+ * @file EdnEdnVectorBuf.h
+ * @brief Editeur De N'ours : Basic EdnVectorBuf for direct data insertion (template)
+ * @author Edouard DUPIN
+ * @date 07/04/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+#ifndef __EDN_VECTOR_BUF_H__
+#define __EDN_VECTOR_BUF_H__
+
+#include "toolsMemory.h"
+#include "EdnVectorBin.h"
+
+#undef __class__
+#define __class__	"EdnVectorBuf"
+
+// minimum gapSize when allocated
+#define GAP_SIZE_MIN		(80)
+// maximum gap that is automaticly resize
+#define GAP_SIZE_MAX		(GAP_SIZE_MIN*4)
+
+
+/*
+                                                                                                                                      
+                                                                                                                                      
+                                                                                                                                      
+              ______________________________________________________________________________________                                  
+              | 																				   |								  
+              | 																				   |								  
+              | 				<GapStart														   |								  
+              | 				*******************************************************************|								  
+              |******************************************										   |								  
+              | 								Gap Stop >                                         |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              | 																				   |								  
+              |____________________________________________________________________________________|								  
+                                                                                                                                      
+                                                                                                                                      
+                                                                                                                                      
+                                                                                                                                      
+                                                                                                                                      
+                                                                                                                                      
+                                                                                                                                      
+                                                                                                                                      
+                                                                                                                                      
+                                                                                                                                      
+*/
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * @brief EdnVectorBuf classes ...
+ */
+class EdnVectorBuf
+{
+	public:
+		class Iterator
+		{
+			// Private data : 
+			private:
+				int32_t				  m_current;		// curent Id on the vector
+				EdnVectorBuf		* m_EdnVectorBuf;	// Pointer on the curent element of the vectorBin
+			public:
+				/**
+				 * @brief Basic itarator constructor with no link with an EdnVector
+				 */
+				Iterator(void):
+					m_current(-1),
+					m_EdnVectorBuf(NULL)
+				{
+					// nothing to do ...
+				}
+				/**
+				 * @brief Recopy constructor on a specific EdnVector.
+				 * @param[in] otherIterator		The Iterator that might be copy
+				 */
+				Iterator(const Iterator & otherIterator):
+					m_current(otherIterator.m_current),
+					m_EdnVectorBuf(otherIterator.m_EdnVectorBuf)
+				{
+					// nothing to do ...
+				}
+				/**
+				 * @brief Asignation operator.
+				 * @param[in] otherIterator		The Iterator that might be copy
+				 * @return reference on the curent Iterator
+				 */
+				Iterator& operator=(const Iterator & otherIterator)
+				{
+					m_current = otherIterator.m_current;
+					m_EdnVectorBuf = otherIterator.m_EdnVectorBuf;
+					return *this;
+				}
+				/**
+				 * @brief Basic destructor
+				 */
+				~Iterator(void)
+				{
+					m_current = -1;
+					m_EdnVectorBuf = NULL;
+				}
+				/**
+				 * @brief gaet element position in the system
+				 */
+				int32_t Position(void)
+				{
+					if(0 > m_current) {
+						return 0;
+					} else if (m_EdnVectorBuf->Size() <= m_current) {
+						return m_EdnVectorBuf->Size();
+					} else {
+						return m_current;
+					}
+				}
+				/**
+				 * @brief basic boolean cast
+				 * @return true if the element is present in the EdnVector size
+				 */
+				operator bool ()
+				{
+					if(		0 <= m_current
+						&&	m_current < m_EdnVectorBuf->Size() )
+					{
+						return true;
+					} else {
+						return false;
+					}
+				}
+				/**
+				 * @brief Incremental operator
+				 * @return Reference on the current iterator incremented
+				 */
+				Iterator& operator++ ()
+				{
+					if(		NULL != m_EdnVectorBuf
+						&&	m_current < m_EdnVectorBuf->Size() )
+					{
+						m_current++;
+					}
+					return *this;
+				}
+				/**
+				 * @brief Decremental operator
+				 * @return Reference on the current iterator decremented
+				 */
+				Iterator& operator-- ()
+				{
+					if (m_current >= 0) {
+						m_current--;
+					}
+					return *this;
+				}
+				/**
+				 * @brief Incremental operator
+				 * @return Reference on a new iterator and increment the other one
+				 */
+				Iterator operator++ (int32_t)
+				{
+					Iterator it(*this);
+					++(*this);
+					return it;
+				}
+				/**
+				 * @brief Decremental operator
+				 * @return Reference on a new iterator and decrement the other one
+				 */
+				Iterator operator-- (int32_t)
+				{
+					Iterator it(*this);
+					--(*this);
+					return it;
+				}
+				/**
+				 * @brief Get reference on the current Element
+				 * @return the reference on the current Element 
+				 */
+				int8_t & operator-> () const
+				{
+					EDN_CHECK_INOUT(m_current >= 0 && m_current < m_EdnVectorBuf->Size());
+					return m_EdnVectorBuf->Get(m_current);
+				}
+				/**
+				 * @brief Get reference on the current Element
+				 * @return the reference on the current Element 
+				 */
+				int8_t & operator* () const
+				{
+					EDN_CHECK_INOUT(m_current >= 0 && m_current < m_EdnVectorBuf->Size());
+					return m_EdnVectorBuf->Get(m_current);
+				}
+			private:
+				/**
+				 * @brief 
+				 *
+				 * @param[in,out] ---
+				 *
+				 * @return ---
+				 *
+				 */
+				Iterator(EdnVectorBuf * Evb, int32_t pos):
+					m_current(pos),
+					m_EdnVectorBuf(Evb)
+				{
+					// nothing to do ...
+				}
+				friend class EdnVectorBuf;
+		};
+	private:
+		int8_t		* m_data;		//!< pointer on the curetn table of Data
+		int32_t		  m_allocated;	//!< Current allocated size
+		// empty part of the buffer data
+		int32_t		  m_gapStart;	//!< points to the first character of the gap
+		int32_t		  m_gapEnd;		//!< points to the first char after the gap
+	public:
+										EdnVectorBuf(int32_t count = 0);
+										EdnVectorBuf(const EdnVectorBuf & Evb);
+										~EdnVectorBuf();
+		
+		bool	 DumpIn(				FILE *myFile);
+		bool	 DumpFrom(				FILE *myFile);
+		
+		EdnVectorBuf &					operator=(	const EdnVectorBuf & Evb);
+		int8_t							operator[] (int32_t pos);
+		int8_t &						Get(		int32_t pos);
+		void							Get(		int32_t pos, int32_t nbElement, EdnVectorBin<int8_t> &tmpBuffer);
+		// insert functions
+		void							PushBack(	const int8_t& item);
+		void							Insert(		int32_t pos, const int8_t& item);
+		void							Insert(		int32_t pos, EdnVectorBin<int8_t>& items);
+		// Remove and insert functions
+		void							Replace(	int32_t pos, const int8_t& item);
+		void							Replace(	int32_t pos, int32_t nbRemoveElement, EdnVectorBin<int8_t>& items);
+		// Revove fonctions
+		void							Remove(		int32_t pos, int32_t nbRemoveElement = 1);
+		void							PopBack(	void);
+		void							Clear(		void);
+		
+		
+		void							Fit(void);
+		
+		void							Display(void);
+		
+		/**
+		 * @brief Get a current element in the vector (iterator system)
+		 * @param[in] RealElementPosition Real position in the buffer (only use in the ITERATOR)
+		 * @return Reference on the Element
+		 */
+		int8_t &	GetDirect(int32_t RealElementPosition){	return m_data[RealElementPosition];	};
+		/**
+		 * @brief Get the number of element in the vector
+		 * @return The number requested
+		 */
+		int32_t		Size(void) { return m_allocated - GapSize(); };
+
+		Iterator Position(int32_t pos)
+		{
+			return Iterator(this, pos);
+		}
+
+		/**
+		 * @brief Get an Iterator on the start position of the Vector
+		 * @return The Iterator
+		 */
+		Iterator Begin()
+		{
+			return Position(0);
+		}
+
+		/**
+		 * @brief Get an Iterator on the end position of the Vector
+		 * @return The Iterator
+		 */
+		Iterator End()
+		{
+			return Position( Size()-1 );
+		}
+	private:
+		// TODO : Set a boolean at the return value to prevent internal error ...
+		void				ChangeAllocation(	int32_t newSize);
+		bool				GapMove(			int32_t pos);
+		bool				GapResize(			int32_t pos, int32_t newGapLen);
+		// get current gap Size
+		int32_t				GapSize(			void) { return m_gapEnd - m_gapStart; };
+		void				GapCheckMaxSize(	void);
+};
+
+#undef __class__
+#define __class__	NULL
+
+void TestEdnVectorBuf(void);
+
+#endif

Sources/tools/EdnTemplate/Singleton.h

@@ -0,0 +1,85 @@
+/**
+ *******************************************************************************
+ * @file Singleton.h
+ * @brief Editeur De N'ours : singleton system class
+ * @author Edouard DUPIN
+ * @date 04/12/2010
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+#ifndef __SINGLETON_H__
+#define __SINGLETON_H__
+
+#include <iostream>
+using namespace std;
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Singleton - modèle Singleton applicable à n'importe quelle classe.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+class Singleton
+{
+	protected:
+		// Constructeur/destructeur
+		Singleton() { }
+		~Singleton() { /*std::cout << "destroying singleton." << std::endl;*/ }
+
+	public:
+		// Interface publique
+		static T *getInstance()
+		{
+			if (NULL == _singleton)
+			{
+				/*std::cout << "C: Singleton	 | creating singleton." << std::endl;*/
+				_singleton = new T;
+			}
+			/*
+			else
+			{
+				std::cout << "C: Singleton	 | singleton already created!" << std::endl;
+			}
+			*/
+
+			return (static_cast<T*> (_singleton));
+		}
+
+		static void kill()
+		{
+			if (NULL != _singleton)
+			{
+				delete _singleton;
+				_singleton = NULL;
+			}
+		}
+
+	private:
+	// Unique instance
+		static T *_singleton;
+};
+
+template <typename T>
+		T *Singleton<T>::_singleton = NULL;
+
+#endif
+
+

Sources/tools/MsgBroadcast/AccelKey.cpp

@@ -0,0 +1,97 @@
+/**
+ *******************************************************************************
+ * @file AccelKey.cpp
+ * @brief Editeur De N'ours : Basic Gui Accelerator Key (common for ALL) or nearly (Sources)
+ * @author Edouard DUPIN
+ * @date 17/06/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+#include "tools_debug.h"
+#include "AccelKey.h"
+
+AccelKey::AccelKey(void)
+{
+	m_accelGroup = gtk_accel_group_new();
+}
+
+AccelKey::~AccelKey(void)
+{
+	
+}
+
+void AccelKey::SetAccel(GtkWidget * widget, char * accelKey)
+{
+	SetAccel(widget, m_accelGroup, accelKey);
+}
+
+void AccelKey::SetAccel(GtkWidget * widget, GtkAccelGroup * accel, char * accelKey)
+{
+	guint accel_key = 0;
+	int32_t accel_mods = 0;
+	if(		NULL==accelKey
+		||	0==strlen(accelKey))
+	{
+		return;
+	}
+	// parsing of the string :
+	//"ctrl+shift+alt+pomme+s"
+	//EDN_DEBUG("Parse acxel string : \"" << accelKey << "\"");
+	char * tmp = strstr(accelKey, "ctrl");
+	if(NULL != tmp) {
+		accel_mods |= GDK_CONTROL_MASK;
+		//EDN_DEBUG("   => find CTRL");
+	}
+	tmp = strstr(accelKey, "shift");
+	if(NULL != tmp) {
+		accel_mods |= GDK_SHIFT_MASK;
+		//EDN_DEBUG("   => find SHIFT");
+	}
+	tmp = strstr(accelKey, "alt");
+	if(NULL != tmp) {
+		accel_mods |= GDK_MOD1_MASK;
+		//EDN_DEBUG("   => find ALT");
+	}
+	tmp = strstr(accelKey, "pomme");
+	if(NULL != tmp) {
+		accel_mods |= GDK_MOD2_MASK;
+		//EDN_DEBUG("   => find POMME");
+	}
+	accel_key = accelKey[strlen(accelKey) -1];
+	//char plop = accel_key;
+	//EDN_DEBUG("   => find letter : '" << plop << "'");
+
+	// Ajout du racourcis clavier :
+	gtk_widget_add_accelerator(	widget, "activate", accel,
+									accel_key, // key
+									(GdkModifierType)accel_mods, // modifier keys
+									GTK_ACCEL_VISIBLE);
+}
+
+void AccelKey::LinkCommonAccel(GtkWidget * widget)
+{
+	gtk_window_add_accel_group(GTK_WINDOW(widget), m_accelGroup);
+}
+
+void AccelKey::LinkCommonAccel(GtkWindow * widget)
+{
+	gtk_window_add_accel_group(GTK_WINDOW(widget), m_accelGroup);
+}
+
+

Sources/tools/MsgBroadcast/AccelKey.h

@@ -0,0 +1,56 @@
+/**
+ *******************************************************************************
+ * @file AccelKey.h
+ * @brief Editeur De N'ours : Basic Gui Accelerator Key (common for ALL) or nearly (header)
+ * @author Edouard DUPIN
+ * @date 17/06/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+ 
+#ifndef __ACCEL_KEY_H__
+#define __ACCEL_KEY_H__
+
+#include "tools_debug.h"
+#include "Singleton.h"
+
+// need to create a syngleton ...
+class AccelKey: public Singleton<AccelKey>
+{
+	friend class Singleton<AccelKey>;
+	// specific for sigleton system...
+	private:
+		// Constructeur
+		AccelKey(void);
+		~AccelKey(void);
+	public:
+		// for internal Parsing
+		void SetAccel(GtkWidget * widget, char * accelKey);
+		// For external parsing
+		void SetAccel(GtkWidget * widget, GtkAccelGroup * accel, char * accelKey);
+		void LinkCommonAccel(GtkWidget * widget);
+		void LinkCommonAccel(GtkWindow * widget);
+		GtkAccelGroup * GetAccel(void) { return m_accelGroup; };
+
+	private:
+		GtkAccelGroup * m_accelGroup;
+};
+
+
+#endif
+

Sources/tools/MsgBroadcast/MsgBroadcast.cpp

@@ -0,0 +1,260 @@
+/**
+ *******************************************************************************
+ * @file MsgBroadcast.cpp
+ * @brief Editeur De N'ours : message beetween thread and GUI elements ... (Souces)
+ * @author Edouard DUPIN
+ * @date 04/02/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+#include "tools_debug.h"
+#include "tools_globals.h"
+#include "MsgBroadcast.h"
+
+#undef __class__
+#define __class__	"MsgBroadcast"
+
+
+MsgBroadcast::MsgBroadcast(const char * className, messageCat_te cat)
+{
+	m_messageSystem = MsgBroadcastCore::getInstance();
+	m_className = className;
+	m_cat = cat;
+	// add on listner
+	m_messageSystem->AddReceiver(this);
+}
+
+MsgBroadcast::~MsgBroadcast(void)
+{
+	m_messageSystem->RmReceiver(this);
+	m_messageSystem = NULL;
+}
+
+void MsgBroadcast::OnMessage(int32_t id, int32_t dataID)
+{
+	// nothing to do here
+}
+
+void MsgBroadcast::SendMessage(messageType_te id, int32_t dataID)
+{
+	m_messageSystem->SendMessage(this, id, dataID);
+}
+
+
+#undef __class__
+#define __class__	"MsgBroadcastCore"
+
+
+// need to create a syngleton ...
+MsgBroadcastCore::MsgBroadcastCore(void)
+{
+	EDN_INFO("Init broadcast message System : ");
+	m_messageID = 0;
+}
+
+MsgBroadcastCore::~MsgBroadcastCore(void)
+{
+	EDN_INFO("Un-Init broadcast message System : ");
+}
+
+#define MACRO_DISPLAY_MSG(data)         case data: return (char*)#data ; break;
+
+static char * GetMessageChar(messageType_te Id)
+{
+	switch(Id)
+	{
+		MACRO_DISPLAY_MSG(EDN_MSG__QUIT)
+		MACRO_DISPLAY_MSG(EDN_MSG__BUFFER_CHANGE_CURRENT)
+
+		MACRO_DISPLAY_MSG(EDN_MSG__GUI_SHOW_MAIN_WINDOWS)
+		MACRO_DISPLAY_MSG(EDN_MSG__GUI_SHOW_SEARCH)
+		MACRO_DISPLAY_MSG(EDN_MSG__GUI_SHOW_PREFERENCE)
+		MACRO_DISPLAY_MSG(EDN_MSG__GUI_SHOW_REPLACE)
+		MACRO_DISPLAY_MSG(EDN_MSG__GUI_SHOW_OPEN_FILE)
+		MACRO_DISPLAY_MSG(EDN_MSG__GUI_SHOW_SAVE_AS)
+		MACRO_DISPLAY_MSG(EDN_MSG__GUI_SHOW_GOTO_LINE)
+	
+		MACRO_DISPLAY_MSG(EDN_MSG__BUFFER_REMOVE)
+		MACRO_DISPLAY_MSG(EDN_MSG__BUFFER_REMOVE_ALL)
+		MACRO_DISPLAY_MSG(EDN_MSG__BUFFER_ADD)
+		MACRO_DISPLAY_MSG(EDN_MSG__BUFFER_CHANGE_STATE)
+		MACRO_DISPLAY_MSG(EDN_MSG__BUFFER_CHANGE_NAME)
+		MACRO_DISPLAY_MSG(EDN_MSG__BUFFER_CHANGE_MODIFY)
+		MACRO_DISPLAY_MSG(EDN_MSG__BUFFER_CHANGE_HAS_HISTORY)
+		MACRO_DISPLAY_MSG(EDN_MSG__BUFFER_CHANGE_HAS_NOT_HISTORY)
+		MACRO_DISPLAY_MSG(EDN_MSG__BUFFER_CHANGE_HAS_FUTURE_HISTORY)
+		MACRO_DISPLAY_MSG(EDN_MSG__BUFFER_CHANGE_HAS_NOT_FUTURE_HISTORY)
+	
+		// create a new buffer
+		MACRO_DISPLAY_MSG(EDN_MSG__NEW)
+		MACRO_DISPLAY_MSG(EDN_MSG__BUFF_ALL_SAVE)
+		MACRO_DISPLAY_MSG(EDN_MSG__BUFF_ALL_CLOSE)
+		MACRO_DISPLAY_MSG(EDN_MSG__BUFF_ID_CLOSE)
+		MACRO_DISPLAY_MSG(EDN_MSG__BUFF_ID_SAVE)
+	
+		// GUI event for the selected buffer
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_CHANGE_BUFFER_ID)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_SAVE)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_SAVE_AS)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_REMOVE_LINE)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_SELECT_ALL)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_UN_SELECT)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_COPY)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_CUT)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_PASTE)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_FIND_PREVIOUS)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_FIND_OLD_PREVIOUS)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_FIND_NEXT)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_FIND_OLD_NEXT)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_REPLACE)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_REPLACE_ALL)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_CLOSE)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_UNDO)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_REDO)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_GOTO_LINE)
+		MACRO_DISPLAY_MSG(EDN_MSG__REFRESH_DISPLAY)
+		MACRO_DISPLAY_MSG(EDN_MSG__CURRENT_SET_CHARSET)
+	
+		// Ctags MESSAGE : 
+		MACRO_DISPLAY_MSG(EDN_MSG__OPEN_CTAGS)
+		MACRO_DISPLAY_MSG(EDN_MSG__RELOAD_CTAGS)
+		MACRO_DISPLAY_MSG(EDN_MSG__JUMP_TO_CURRENT_SELECTION)
+		MACRO_DISPLAY_MSG(EDN_MSG__JUMP_BACK)
+	
+		default:
+			return (char*)"??";
+	}
+}
+
+static char * GetMessageTypeChar(messageCat_te Id)
+{
+	switch(Id)
+	{
+		case EDN_CAT_NONE:
+			return (char*)"NONE";
+		case EDN_CAT_GUI:
+			return (char*)"GUI";
+		case EDN_CAT_WORK_AREA:
+			return (char*)"WORK_AREA";
+		case EDN_CAT_SYSTEM:
+			return (char*)"SYSTEM";
+		case EDN_CAT_BUFFER_MANAGER:
+			return (char*)"BUFFER_MANAGER";
+		case EDN_CAT_GUI_MANAGER:
+			return (char*)"GUI_MANAGER";
+		case EDN_CAT_CTAGS:
+			return (char*)"C-TAGS_MANAGER";
+		default:
+			return (char*)"??";
+	}
+}
+
+void MsgBroadcastCore::SendMessage(MsgBroadcast * pointerOnSender, messageType_te id, int32_t dataID)
+{
+	// Add message on the list :
+	messageElement_ts myStructMessage;
+	messageCat_te catDest = EDN_CAT_NONE;
+	
+	
+	// DESTINATION : GUI_MANAGER
+	if(    MSG_TO_GUI_MANAGER__START <= id
+	    && MSG_TO_GUI_MANAGER__STOP  >= id )
+	{
+		catDest = EDN_CAT_GUI_MANAGER;
+	} else if(    MSG_TO_GUI__START <= id
+	           && MSG_TO_GUI__STOP  >= id )
+	{
+		catDest = EDN_CAT_GUI;
+	} else if(    MSG_TO_BUFFER_MANAGER__START <= id
+	           && MSG_TO_BUFFER_MANAGER__STOP  >= id )
+	{
+		catDest = EDN_CAT_BUFFER_MANAGER;
+	} else if(    MSG_TO_WORKING_AREA__START <= id
+	           && MSG_TO_WORKING_AREA__STOP  >= id )
+	{
+		catDest = EDN_CAT_WORK_AREA;
+	} else if(    MSG_TO_SYSTEM__START <= id
+	           && MSG_TO_SYSTEM__STOP  >= id )
+	{
+		catDest = EDN_CAT_SYSTEM;
+	} else if(    MSG_TO_CTAGS__START <= id
+	           && MSG_TO_CTAGS__STOP  >= id )
+	{
+		catDest = EDN_CAT_CTAGS;
+	}
+	
+	myStructMessage.localMessageID = m_messageID++;
+	if (NULL == pointerOnSender) {
+		EDN_INFO("#" << myStructMessage.localMessageID << " From \"NULL\" CAT="                                         << GetMessageTypeChar(catDest) << " id=" << id << "=\"" << GetMessageChar(id) << "\" dataID=" << dataID);
+	} else {
+		EDN_INFO("#" << myStructMessage.localMessageID << " From \"" << pointerOnSender->GetName().c_str() << "\" CAT=" << GetMessageTypeChar(catDest) << " id=" << id << "=\"" << GetMessageChar(id) << "\" dataID=" << dataID);
+	}
+	myStructMessage.msgCatDest = catDest;
+	myStructMessage.msgId      = id;
+	myStructMessage.data       = dataID;
+	m_listOfMessage.PushBack(myStructMessage);
+	
+	
+	if (m_listOfMessage.Size() > 1 ) {
+		// we are curently in message processing ==> wait end to process this message
+		return;
+	}
+	// send message on system :
+	while (m_listOfMessage.Size() > 0) {
+		for (int32_t i=0 ; i<m_listMessage.Size() ; i++) {
+			if(		EDN_CAT_NONE == m_listOfMessage[0].msgCatDest
+				||	m_listOfMessage[0].msgCatDest == m_listMessage[i]->GetCat())
+			{
+				EDN_INFO("        #" << m_listOfMessage[0].localMessageID << " ==> process In :\"" << m_listMessage[i]->GetName().c_str() << "\" ");
+				m_listMessage[i]->OnMessage(m_listOfMessage[0].msgId, m_listOfMessage[0].data);
+			}
+		}
+		m_listOfMessage.Erase(0);
+	}
+}
+
+void MsgBroadcastCore::AddReceiver(MsgBroadcast * pointerOnReceiver)
+{
+	for (int32_t i=0 ; i<m_listMessage.Size() ; i++) {
+		if (m_listMessage[i] == pointerOnReceiver) {
+			// nothing to do ...
+			return;
+		}
+	}
+	m_listMessage.PushBack(pointerOnReceiver);
+	EDN_INFO("Add a listner for the broadCast messages : \"" << pointerOnReceiver->GetName().c_str() << "\"");
+}
+
+
+void MsgBroadcastCore::RmReceiver(MsgBroadcast * pointerOnReceiver)
+{
+	for (int32_t i=0 ; i<m_listMessage.Size() ; i++) {
+		if (m_listMessage[i] == pointerOnReceiver) {
+			m_listMessage.Erase(i);
+			return;
+		}
+	}
+}
+
+
+
+void GeneralSendMessage(messageType_te id, int32_t dataID)
+{
+	MsgBroadcastCore::getInstance()->SendMessage(NULL, id, dataID);
+}

Sources/tools/MsgBroadcast/MsgBroadcast.h

@@ -0,0 +1,198 @@
+/**
+ *******************************************************************************
+ * @file MsgBroadcast.h
+ * @brief Editeur De N'ours : message beetween thread and GUI elements ... (header)
+ * @author Edouard DUPIN
+ * @date 04/02/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+ 
+#ifndef __MSG_BROADCAST_H__
+#define __MSG_BROADCAST_H__
+
+#include "tools_debug.h"
+#include "Edn.h"
+#include "Singleton.h"
+
+
+
+// broadCast Message
+
+// Message to prevent the curent thread that Buffer has changed
+// the ID we'll use to identify our event
+typedef enum {
+	EDN_MSG__NONE = 0,
+	// Programm is Quitting... close all if needed ...
+	EDN_MSG__QUIT,
+	EDN_MSG__BUFFER_CHANGE_CURRENT,  // set the new current BUFFER ...
+	
+	// DESTINATION : GUI_MANAGER
+	MSG_TO_GUI_MANAGER__START,
+		// GUI windows openning and closing
+		EDN_MSG__GUI_SHOW_MAIN_WINDOWS,
+		EDN_MSG__GUI_SHOW_SEARCH,
+		EDN_MSG__GUI_SHOW_PREFERENCE,
+		EDN_MSG__GUI_SHOW_REPLACE,
+		EDN_MSG__GUI_SHOW_OPEN_FILE,
+		EDN_MSG__GUI_SHOW_SAVE_AS,
+		EDN_MSG__GUI_SHOW_GOTO_LINE,
+	MSG_TO_GUI_MANAGER__STOP,
+	
+	// DESTINATION : GUI
+	// generate by the current buffer to said the buffer has changing
+	MSG_TO_GUI__START,
+		EDN_MSG__BUFFER_REMOVE,
+		EDN_MSG__BUFFER_REMOVE_ALL,
+		EDN_MSG__BUFFER_ADD,
+		EDN_MSG__BUFFER_CHANGE_STATE,
+		EDN_MSG__BUFFER_CHANGE_NAME,
+		EDN_MSG__BUFFER_CHANGE_MODIFY,
+		EDN_MSG__BUFFER_CHANGE_HAS_HISTORY,
+		EDN_MSG__BUFFER_CHANGE_HAS_NOT_HISTORY,
+		EDN_MSG__BUFFER_CHANGE_HAS_FUTURE_HISTORY,
+		EDN_MSG__BUFFER_CHANGE_HAS_NOT_FUTURE_HISTORY,
+	MSG_TO_GUI__STOP,
+	
+	// DESTINATION : Buffer MANAGER
+	MSG_TO_BUFFER_MANAGER__START,
+		// create a new buffer
+		EDN_MSG__NEW,
+		// Event For All buffer ==> goto the buffer MANAGER
+		EDN_MSG__BUFF_ALL_SAVE,
+		EDN_MSG__BUFF_ALL_CLOSE,
+		// Event For Specific Buffer ID :  ==> GOTO the buffer MANAGER
+		EDN_MSG__BUFF_ID_CLOSE,
+		EDN_MSG__BUFF_ID_SAVE,
+	MSG_TO_BUFFER_MANAGER__STOP,
+
+	// DESTINATION : Working AREA
+	MSG_TO_WORKING_AREA__START,
+		// GUI event for the selected buffer
+		EDN_MSG__CURRENT_CHANGE_BUFFER_ID,
+		EDN_MSG__CURRENT_SAVE,
+		EDN_MSG__CURRENT_SAVE_AS,
+		EDN_MSG__CURRENT_SELECT_ALL,
+		EDN_MSG__CURRENT_REMOVE_LINE,
+		EDN_MSG__CURRENT_UN_SELECT,
+		EDN_MSG__CURRENT_COPY,
+		EDN_MSG__CURRENT_CUT,
+		EDN_MSG__CURRENT_PASTE,
+		EDN_MSG__CURRENT_FIND_PREVIOUS,
+		EDN_MSG__CURRENT_FIND_OLD_PREVIOUS,
+		EDN_MSG__CURRENT_FIND_NEXT,
+		EDN_MSG__CURRENT_FIND_OLD_NEXT,
+		EDN_MSG__CURRENT_REPLACE,
+		EDN_MSG__CURRENT_REPLACE_ALL,
+		EDN_MSG__CURRENT_CLOSE,
+		EDN_MSG__CURRENT_UNDO,
+		EDN_MSG__CURRENT_REDO,
+		EDN_MSG__CURRENT_GOTO_LINE,
+		EDN_MSG__REFRESH_DISPLAY,
+		EDN_MSG__CURRENT_SET_CHARSET,
+	MSG_TO_WORKING_AREA__STOP,
+	
+	// DESTINATION : SYSTEM ...
+	MSG_TO_SYSTEM__START,
+	MSG_TO_SYSTEM__STOP,
+	
+	
+	// DESTINATION : CTAGS ...
+	MSG_TO_CTAGS__START,
+		EDN_MSG__OPEN_CTAGS,
+		EDN_MSG__RELOAD_CTAGS,
+		EDN_MSG__JUMP_TO_CURRENT_SELECTION,
+		EDN_MSG__JUMP_BACK,
+	MSG_TO_CTAGS__STOP,
+
+
+}messageType_te;
+
+typedef enum {
+	EDN_CAT_NONE,
+	EDN_CAT_GUI,
+	EDN_CAT_WORK_AREA,
+	EDN_CAT_SYSTEM,
+	EDN_CAT_BUFFER_MANAGER,
+	EDN_CAT_GUI_MANAGER,
+	EDN_CAT_CTAGS,
+}messageCat_te;
+
+
+typedef struct {
+	messageType_te  msgId;
+	int32_t         dataId;
+}messageData_ts;
+
+
+class MsgBroadcastCore;
+
+class MsgBroadcast
+{
+	private:
+		Edn::String             m_className;
+		MsgBroadcastCore *      m_messageSystem;
+		messageCat_te           m_cat;
+	public:
+		MsgBroadcast(const char * className, messageCat_te cat);
+		virtual ~MsgBroadcast(void);
+		// caul when a message is send
+		virtual void     OnMessage(int32_t id, int32_t dataID);
+		Edn::String&     GetName(void) { return m_className; };
+		messageCat_te    GetCat(void) { return m_cat; };
+	protected :
+		void         SendMessage(messageType_te id, int32_t dataID = -1);
+};
+
+
+typedef struct {
+	int32_t         localMessageID;
+	messageCat_te   msgCatDest;
+	messageType_te  msgId;
+	int32_t         data;
+}messageElement_ts;
+
+// need to create a syngleton ...
+class MsgBroadcastCore: public Singleton<MsgBroadcastCore>
+{
+	friend class Singleton<MsgBroadcastCore>;
+	// specific for sigleton system...
+	private:
+		// Constructeur
+		MsgBroadcastCore(void);
+		~MsgBroadcastCore(void);
+	public:
+		void SendMessage(MsgBroadcast * pointerOnSender, messageType_te id, int32_t dataID = -1);
+		void AddReceiver(MsgBroadcast * pointerOnReceiver);
+		void RmReceiver(MsgBroadcast * pointerOnReceiver);
+
+	private:
+		EdnVectorBin<MsgBroadcast*>         m_listMessage;
+		uint32_t                            m_messageID;
+		EdnVectorBin<messageElement_ts>     m_listOfMessage;
+};
+
+
+void GeneralSendMessage(messageType_te id, int32_t dataID = -1);
+
+
+
+
+
+#endif
+

Sources/tools/NameSpaceEdn/Edn.h

@@ -0,0 +1,44 @@
+/**
+ *******************************************************************************
+ * @file Edn.h
+ * @brief Editeur De N'ours : Basic namespace for Edn (header)
+ * @author Edouard DUPIN
+ * @date 16/07/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+
+#include "tools_debug.h"
+#include "toolsMemory.h"
+#include "EdnVectorBin.h"
+
+#ifndef __EDN_H__
+#define __EDN_H__
+
+#define _IN_NAMESPACE_EDN_ (plop)
+
+namespace Edn
+{
+	#include "String.h"
+	#include "File.h"
+}
+
+#undef IN_NAMESPACE_EDN
+
+#endif

Sources/tools/NameSpaceEdn/File.cpp

@@ -0,0 +1,114 @@
+/**
+ *******************************************************************************
+ * @file File.cpp
+ * @brief Editeur De N'ours : File folder and name abstraction (Sources)
+ * @author Edouard DUPIN
+ * @date 16/07/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+
+#include "tools_debug.h"
+#include "tools_globals.h"
+#include "Edn.h"
+
+Edn::File::File(Edn::String &filename, int32_t LineNumber)
+{
+	m_lineNumberOpen = 0;
+	SetCompleateName(filename);
+}
+
+Edn::File::File(Edn::String &filename, Edn::String &folder, int32_t lineNumber)
+{
+	Edn::String tmpString = folder;
+	tmpString += '/';
+	tmpString += filename;
+	SetCompleateName(tmpString);
+	m_lineNumberOpen = lineNumber;
+}
+
+
+Edn::File::~File(void)
+{
+	// nothing to do ...
+}
+
+void Edn::File::ExtranctAndName(Edn::String &inputString)
+{
+	m_folder = "";
+	m_shortFilename = "";
+	
+	for (int32_t iii=inputString.Size()-1; iii >= 0 ; iii--) {
+		/*
+		if (inputString[iii] != '/') {
+			m_shortFilename.Insert(0, inputString[iii]);
+		} else {
+			break;
+		}
+		*/
+	}
+	
+
+
+/*
+	char tmpVal[4096];
+	strncpy(tmpVal, inputString.c_str(), 4096);
+	tmpVal[4096-1] = '\0';
+	char *ptr = strrchr(tmpVal, '/');
+	if (NULL == ptr) {
+		ptr = strrchr(tmpVal, '\\');
+	}
+	Edn::String out = "./";
+	if (NULL != ptr) {
+		*ptr = '\0';
+		out = tmpVal;
+		out+= '/';
+	}
+	return out;
+*/
+}
+
+
+Edn::String Edn::File::GetFolder(void)
+{
+	return m_folder;
+}
+
+Edn::String Edn::File::GetShortFilename(void)
+{
+	return m_shortFilename;
+}
+
+Edn::String Edn::File::GetCompleateName(void)
+{
+	Edn::String out;
+	out  = m_folder;
+	out += '/';
+	out += m_shortFilename;
+}
+
+void Edn::File::SetCompleateName(Edn::String &newFilename)
+{
+	
+}
+
+int32_t Edn::File::GetLineNumber(void)
+{
+	return m_lineNumberOpen;
+}

Sources/tools/NameSpaceEdn/File.h

@@ -0,0 +1,53 @@
+/**
+ *******************************************************************************
+ * @file File.h
+ * @brief Editeur De N'ours : File folder and name abstraction (header)
+ * @author Edouard DUPIN
+ * @date 16/07/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+
+#ifndef _IN_NAMESPACE_EDN_
+#	error This will be include only in "edn.h"
+#else 
+
+class File
+{
+	public:
+		            File(void) { m_lineNumberOpen=0; }
+		            File(Edn::String &filename, int32_t LineNumber = 0);
+		            File(Edn::String &filename, Edn::String &folder, int32_t lineNumber = 0);
+		            ~File(void);
+		Edn::String GetFolder(void);
+		Edn::String GetShortFilename(void);
+		Edn::String GetCompleateName(void);
+		int32_t     GetLineNumber(void);
+		
+		void        SetCompleateName(Edn::String &newFilename);
+		
+	private :
+		void        ExtranctAndName(Edn::String &inputString);
+		Edn::String m_folder;
+		Edn::String m_shortFilename;
+		int32_t     m_lineNumberOpen;
+};
+
+#endif
+

Sources/tools/NameSpaceEdn/String.cpp

@@ -0,0 +1,708 @@
+/**
+ *******************************************************************************
+ * @file EdnString.cpp
+ * @brief Editeur De N'ours : normal sting management... (sources)
+ * @author Edouard DUPIN
+ * @date 26/01/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+#include "Edn.h"
+#include "toolsMemory.h"
+
+
+#undef __class__
+#define __class__	"EdnString"
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+Edn::String::~String(void)
+{
+	m_data.Clear();
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+Edn::String::String(void)
+{
+	//EDN_INFO("new Edn::String()");
+	m_data.Clear();
+	m_data.PushBack('\0');
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+Edn::String::String(const char myInput)
+{
+	m_data.Clear();
+	m_data.PushBack(myInput);
+	m_data.PushBack('\0');
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+Edn::String::String(const char* inputData, int32_t len)
+{
+	m_data.Clear();
+	m_data.PushBack('\0');
+	Set(inputData, len);
+}
+
+void Edn::String::Set(const char * inputData, int32_t len)
+{
+	// overwrite the len if needed : 
+	if ((-1) == len) {
+		len = strlen(inputData);
+	}
+	
+	if (len != 0) {
+		// remove the last '\0'
+		m_data.PopBack();
+		// copy the data ...
+		m_data.PushBack((int8_t*)inputData, len);
+		// add the last '\0'
+		m_data.PushBack('\0');
+	}
+}
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+Edn::String::String(int inputData)
+{
+	char tmpVal[256];
+	// generate the string : 
+	sprintf(tmpVal, "%d", inputData);
+	// set the internal data : 
+	m_data.Clear();
+	m_data.PushBack('\0');
+	Set(tmpVal);
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+Edn::String::String(unsigned int inputData)
+{
+	char tmpVal[256];
+	// generate the string : 
+	sprintf(tmpVal, "%d", inputData);
+	// set the internal data : 
+	m_data.Clear();
+	m_data.PushBack('\0');
+	Set(tmpVal);
+}
+
+Edn::String::String(const Edn::String &ednS)
+{
+	//EDN_INFO("Constructeur de recopie");
+	m_data = ednS.m_data;
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+const Edn::String& Edn::String::operator= (const Edn::String &ednS )
+{
+	//EDN_INFO("OPERATOR de recopie");
+	if( this != &ednS ) // avoid copy to itself
+	{
+		m_data = ednS.m_data;
+	}
+	return *this;
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+const Edn::String& Edn::String::operator= (const char * inputData)
+{
+	m_data.Clear();
+	m_data.PushBack('\0');
+	// calculate the size : 
+	uint32_t len = strlen(inputData);
+	// check the new size ...
+	if (len > 0 ) {
+		// copy all data : 
+		Set(inputData, len);
+	}
+	return *this;
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+const Edn::String& Edn::String::operator= (EdnVectorBin<int8_t> inputData)
+{
+	m_data = inputData;
+	if (m_data.Size()>0) {
+		if (m_data[m_data.Size()-1] != '\0') {
+			m_data.PushBack('\0');
+		}
+	}
+	//EDN_DEBUG("m_dataLen="<<m_dataLen << " m_dataLenUTF8="<<m_dataLenUTF8 << " description=" << m_data);
+	return *this;
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+bool Edn::String::operator== (const Edn::String& ednS) const
+{
+	if( this != &ednS ) {
+		if (ednS.m_data.Size() != m_data.Size()) {
+			//EDN_DEBUG(" not the same size : " << ednS.m_data.Size() << "!=" << m_data.Size());
+			return false;
+		}
+		for (int32_t iii= 0; iii<m_data.Size(); iii++) {
+			//EDN_DEBUG("     check : " << ednS.m_data[iii] << "!=" << m_data[iii]);
+			if (ednS.m_data[iii]!= m_data[iii]){
+				return false;
+			}
+		}
+		return true;
+	}
+	return true;
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+bool Edn::String::operator== (const char * inputData) const
+{
+
+	// calculate the size : 
+	int32_t len = strlen(inputData);
+	if (len+1 != m_data.Size()) {
+		return false;
+	}
+	for (int32_t iii= 0; iii<m_data.Size(); iii++) {
+		if (inputData[iii]!= m_data[iii]){
+			return false;
+		}
+	}
+	return true;
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+bool Edn::String::operator!= (const Edn::String& ednS) const
+{
+	return !(*this == ednS);
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+bool Edn::String::operator!= (const char * inputData) const
+{
+	return !(*this == inputData);
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+const Edn::String& Edn::String::operator+= (const Edn::String &ednS)
+{
+	if (0 < ednS.Size()) {
+		// remove the last '\0'
+		m_data.PopBack();
+		// copy the data ...
+		m_data += ednS.m_data;
+		// This previous include the \0 in case of the 2 string are different...
+		if( this == &ednS ) {
+			// add the removed end string
+			m_data.PushBack('\0');
+		}
+	}
+	return *this;
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+const Edn::String& Edn::String::operator+= (const char * inputData)
+{
+	//EDN_INFO("        string(arg) : \"" << inputData << "\"");
+	//EDN_INFO("        string(direct) : \"" << m_data << "\"");
+	int32_t len = strlen(inputData);
+	
+	if (len != 0) {
+		// remove the last '\0'
+		m_data.PopBack();
+		// copy the data ...
+		m_data.PushBack((int8_t*)inputData, len+1 );
+	}
+	return *this;
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+Edn::String Edn::String::operator+ (const Edn::String &ednS)
+{
+	Edn::String temp;
+	//EDN_INFO("        string(arg) : \"" << ednS.m_data << "\"");
+	//EDN_INFO("        string(direct) : \"" << m_data << "\"");
+	temp += *this;
+	temp += ednS;
+	return temp;
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+Edn::String Edn::String::operator+ (const char * inputData)
+{
+	Edn::String temp;
+	//EDN_INFO("        string(arg) : \"" << inputData << "\"");
+	//EDN_INFO("        string(direct) : \"" << m_data << "\"");
+	temp += *this;
+	temp += inputData;
+	return temp;
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+bool Edn::String::IsEmpty(void) const
+{
+	if(1 >= m_data.Size() ) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+int32_t Edn::String::Size(void) const
+{
+	if (m_data.Size() == 0) {
+		return 0;
+	} else {
+		return m_data.Size() - 1;
+	}
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+void Edn::String::Add(int32_t currentID, const char* inputData)
+{
+	// get the input lenght
+	int32_t len = strlen(inputData);
+	if (0 == len) {
+		EDN_WARNING("no data to add on the current string");
+		return;
+	} else if (currentID < 0) {
+		EDN_WARNING("Curent ID(" << currentID << ") < 0   ==> Add at the start");
+		currentID = 0;
+	} else if (currentID > Size() ) {
+		EDN_ERROR("Curent ID(" << currentID << ") > maxSize ... (" << Size() << ")  ==> add at the end ...");
+		m_data.PushBack((int8_t*)inputData, len);
+		return;
+	}
+	m_data.Insert(currentID, (int8_t*)inputData, len);
+}
+
+
+/**
+ * @brief 
+ *
+ * @param[in,out] 
+ *
+ * @return 
+ *
+ */
+void Edn::String::Remove(int32_t currentID, int32_t len)
+{
+	if (0 >= len) {
+		EDN_ERROR("no data to remove on the current string");
+		return;
+	}
+	// TODO : check the size of the data
+	m_data.Erase(currentID, len);
+}
+
+
+/**
+ * @brief Remove all element in the string
+ *
+ * @param ---
+ *
+ * @return ---
+ *
+ */
+void Edn::String::Clear(void)
+{
+	m_data.Clear();
+	m_data.PushBack('\0');
+}
+
+
+
+/**
+ * @brief find the first accurence after the position indicated
+ *
+ * @param[in] element Element that might be find in the string
+ * @param[in] startPos Stert position to begin the search
+ *
+ * @return the position of the first occurence or -1 if not find...
+ *
+ */
+int32_t Edn::String::FindForward(const char element, int32_t startPos)
+{
+	if (startPos < 0) {
+		startPos = 0;
+	} else if (startPos >= Size() ) {
+		return -1;
+	}
+	for (int32_t iii=startPos; iii< Size(); iii++) {
+		if (m_data[iii] == element) {
+			return iii;
+		}
+	}
+	return -1;
+}
+
+
+/**
+ * @brief find the first accurence before the position indicated.
+ *
+ * @param[in] element Element that might be find in the string
+ * @param[in] startPos Stert position to begin the search
+ *
+ * @return the position of the first occurence begining by the end or -1 if not find...
+ *
+ */
+int32_t Edn::String::FindBack(const char element, int32_t startPos)
+{
+	if (startPos < 0) {
+		return -1;
+	} else if (startPos >= Size() ) {
+		startPos = Size();
+	}
+	for (int32_t iii=startPos; iii>=0; iii--) {
+		if (m_data[iii] == element) {
+			return iii;
+		}
+	}
+	return -1;
+}
+
+
+/**
+ * @brief Extract data from the data between two position
+ *
+ * @param[in] posStart Start position where to extract data
+ * @param[in] posEnd End position where to extract data
+ *
+ * @return the extracted string
+ *
+ */
+Edn::String Edn::String::Extract(int32_t posStart, int32_t posEnd)
+{
+	Edn::String out;
+	if (posStart < 0) {
+		posStart = 0;
+	} else if (posStart >= Size() ) {
+		return out;
+	}
+	if (posEnd < 0) {
+		return out;
+	} else if (posEnd >= Size() ) {
+		posEnd = Size();
+	}
+	out.m_data = m_data.Extract(posStart, posEnd);
+	out.m_data.PushBack('\0');
+	return out;
+}
+
+
+/**
+ * @brief Get a basic vector in int8 data with no \0 at the end of the string
+ *
+ * @param ---
+ *
+ * @return The desired vector with data
+ *
+ */
+EdnVectorBin<int8_t> Edn::String::GetVector(void)
+{
+	EdnVectorBin<int8_t> out = m_data;
+	out.PopBack();
+	return out;
+}
+
+/**
+ * @brief Unitary test for the string system
+ *
+ * @param ---
+ *
+ * @return ---
+ *
+ */
+void Edn::TestUntaire_String(void)
+{
+	EDN_WARNING("*********************************************************");
+	EDN_WARNING("**  Test Unitaire 'EdnString'  (START)");
+	EDN_WARNING("*********************************************************");
+	
+	int32_t iddd = 0;
+	Edn::String * monString = new Edn::String();
+	EDN_INFO("phase : " << iddd++ << " : \"" << monString->c_str() << "\"");
+	delete(monString);
+	
+	monString = new Edn::String("test de direct data");
+	EDN_INFO("phase : " << iddd++ << " : \"" << monString->c_str() << "\"");
+	delete(monString);
+	
+	monString = new Edn::String("test de direct data", 7);
+	EDN_INFO("phase : " << iddd++ << " : \"" << monString->c_str() << "\"");
+	delete(monString);
+	
+	int32_t testId = -6789;
+	monString = new Edn::String(testId);
+	EDN_INFO("phase : " << iddd++ << " : \"" << monString->c_str() << "\"");
+	delete(monString);
+	
+	uint32_t testId2 = 12345;
+	monString = new Edn::String((unsigned int)testId2);
+	EDN_INFO("phase : " << iddd++ << " : \"" << monString->c_str() << "\"");
+	delete(monString);
+	
+	Edn::String plop = "otherString";
+	monString = new Edn::String(plop);
+	EDN_INFO("phase : " << iddd++ << " : \"" << monString->c_str() << "\"");
+	delete(monString);
+	
+	
+	Edn::String s1 = "test de base ...";
+	s1 += s1;
+	EDN_INFO("phase : " << iddd++ << " : \"" << s1.c_str() << "\"");
+	s1 += " plop 2 ";
+	EDN_INFO("phase : " << iddd++ << " : \"" << s1.c_str() << "\"");
+	s1 += plop;
+	EDN_INFO("phase : " << iddd++ << " : \"" << s1.c_str() << "\"");
+	s1 = plop;
+	EDN_INFO("phase : " << iddd++ << " : \"" << s1.c_str() << "\"");
+	s1 = "test direct 44";
+	EDN_INFO("phase : " << iddd++ << " : \"" << s1.c_str() << "\"");
+	EdnVectorBin<int8_t> vb1;
+	vb1.PushBack('v');
+	vb1.PushBack('b');
+	vb1.PushBack('1');
+	s1 = vb1;
+	EDN_INFO("phase : " << iddd++ << " : \"" << s1.c_str() << "\"");
+	vb1.Clear();
+	vb1.PushBack('v');
+	vb1.PushBack('b');
+	vb1.PushBack('2');
+	vb1.PushBack('\0');
+	s1 = vb1;
+	EDN_INFO("phase : " << iddd++ << " : \"" << s1.c_str() << "\"");
+	
+	if (s1 == "vb2") {
+		EDN_INFO("phase : " << iddd++ << " : == OK");
+	} else {
+		EDN_ERROR("phase : " << iddd++ << " : == ERROR");
+	}
+	
+	
+	if (s1 == "vb3") {
+		EDN_ERROR("phase : " << iddd++ << " : == ERROR");
+	} else {
+		EDN_INFO("phase : " << iddd++ << " : == OK");
+	}
+	
+	
+	if (s1 != "vb3") {
+		EDN_INFO("phase : " << iddd++ << " : == OK");
+	} else {
+		EDN_ERROR("phase : " << iddd++ << " : == ERROR");
+	}
+	
+	
+	if (s1 != "vb2") {
+		EDN_ERROR("phase : " << iddd++ << " : == ERROR");
+	} else {
+		EDN_INFO("phase : " << iddd++ << " : == OK");
+	}
+	
+	
+	Edn::String s2 = "vb2";
+	Edn::String s3 = "vb3";
+	
+	if (s1 == s2) {
+		EDN_INFO("phase : " << iddd++ << " : == OK");
+	} else {
+		EDN_ERROR("phase : " << iddd++ << " : == ERROR");
+	}
+	
+	
+	if (s1 == s3) {
+		EDN_ERROR("phase : " << iddd++ << " : == ERROR");
+	} else {
+		EDN_INFO("phase : " << iddd++ << " : == OK");
+	}
+	
+	
+	if (s1 != s3) {
+		EDN_INFO("phase : " << iddd++ << " : == OK");
+	} else {
+		EDN_ERROR("phase : " << iddd++ << " : == ERROR");
+	}
+	
+	
+	if (s1 != s2) {
+		EDN_ERROR("phase : " << iddd++ << " : == ERROR");
+	} else {
+		EDN_INFO("phase : " << iddd++ << " : == OK");
+	}
+	EDN_WARNING("*********************************************************");
+	EDN_WARNING("**  Test Unitaire 'EdnString'  (STOP)");
+	EDN_WARNING("*********************************************************");
+}
+

Sources/tools/NameSpaceEdn/String.h

@@ -0,0 +1,82 @@
+/**
+ *******************************************************************************
+ * @file EdnString.h
+ * @brief Editeur De N'ours : normal sting management... (header)
+ * @author Edouard DUPIN
+ * @date 26/01/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+#ifndef _IN_NAMESPACE_EDN_
+#	error This will be include only in "edn.h"
+#else 
+
+	class String
+	{
+		public:
+			// Constructeurs
+			String(void);
+			String(const char myInput);
+			String(const char* inputData, int32_t len = -1);//, bool noAllocation=false);
+			void Set(const char* inputData, int32_t len=-1);
+			// basic convertion integer en string
+			String(int inputData);
+			String(unsigned int inputData);
+			//String(const wchar_t *inputData);
+			String(const Edn::String &ednS);
+			// destructor : 
+			~String(void);
+			
+			const Edn::String& operator= (const Edn::String &ednS );	// assigment
+			const Edn::String& operator= (const char * inputData);
+			const Edn::String& operator= (EdnVectorBin<int8_t> inputData);
+			bool operator== (const Edn::String& ednS) const;			// == operator
+			bool operator== (const char * inputData) const;
+			bool operator!= (const Edn::String& ednS) const;			// != operator
+			bool operator!= (const char * inputData) const;
+			const Edn::String& operator+= (const Edn::String &ednS);	// += operator
+			const Edn::String& operator+= (const char * inputData);
+			Edn::String operator+ (const Edn::String &ednS);			// + operator
+			Edn::String operator+ (const char * inputData);
+			//operator const char *()
+	
+	
+			bool          IsEmpty(void) const;
+			int32_t       Size(void) const;
+	
+			void          Add(int32_t currentID, const char* inputData);
+			void          Remove(int32_t currentID, int32_t len);
+			void          Clear(void);
+	
+			EdnVectorBin<int8_t>    GetVector(void);
+			char *                  c_str(void) { return (char*)&m_data[0]; };
+	
+			// Sting operation :
+			int32_t       FindForward(const char element, int32_t startPos=0);
+			int32_t       FindBack(const char element, int32_t startPos=0x7FFFFFFF);
+			Edn::String   Extract(int32_t posStart=0, int32_t posEnd=0x7FFFFFFF);
+	
+		private :
+			EdnVectorBin<int8_t> m_data;
+	};
+
+	void TestUntaire_String(void);
+
+#endif
+

Sources/tools/charset/charset.h

@@ -0,0 +1,87 @@
+/**
+ *******************************************************************************
+ * @file charset.h
+ * @brief Editeur De N'ours : Abstraction Charset layer (header)
+ * @author Edouard DUPIN
+ * @date 06/06/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+ 
+#ifndef __CHARSET_H__
+#define __CHARSET_H__
+
+#include "EdnVectorBin.h"
+
+typedef enum {
+	EDN_CHARSET_UTF8,
+	EDN_CHARSET_ISO_8859_1,
+	EDN_CHARSET_ISO_8859_2,
+	EDN_CHARSET_ISO_8859_3,
+	EDN_CHARSET_ISO_8859_4,
+	EDN_CHARSET_ISO_8859_5,
+	EDN_CHARSET_ISO_8859_6,
+	EDN_CHARSET_ISO_8859_7,
+	EDN_CHARSET_ISO_8859_8,
+	EDN_CHARSET_ISO_8859_9,
+	EDN_CHARSET_ISO_8859_10,
+	EDN_CHARSET_ISO_8859_11,
+	EDN_CHARSET_ISO_8859_13,
+	EDN_CHARSET_ISO_8859_14,
+	EDN_CHARSET_ISO_8859_15,
+} charset_te;
+
+// transform ISO <==> Unicode
+void    convertIsoToUnicode(charset_te inputCharset, char                   input_ISO,     int32_t &              output_Unicode);
+void    convertUnicodeToIso(charset_te inputCharset, int32_t                input_Unicode, char &                 output_ISO);
+int32_t convertIsoToUnicode(charset_te inputCharset, EdnVectorBin<char>&    input_ISO,     EdnVectorBin<int32_t>& output_Unicode);
+int32_t convertUnicodeToIso(charset_te inputCharset, EdnVectorBin<int32_t>& input_Unicode, EdnVectorBin<char>&    output_ISO);
+// Transform UTF-8 <==> Unicode
+void    convertUnicodeToUtf8(                        int32_t                input_Unicode, char *                 output_UTF8);
+void    convertUtf8ToUnicode(                        char *                 input_UTF8,    int32_t&               output_Unicode);
+int32_t convertUnicodeToUtf8(                        EdnVectorBin<int32_t>& input_Unicode, EdnVectorBin<char>&    output_UTF8);
+int32_t convertUtf8ToUnicode(                        EdnVectorBin<char>&    input_UTF8,    EdnVectorBin<int32_t>& output_Unicode);
+// Transform ISO <==> UTF-8
+void    convertIsoToUtf8(  charset_te inputCharset,  char                   input_ISO,     char *                 output_UTF8);
+void    convertUtf8ToIso(  charset_te inputCharset,  char *                 input_UTF8,    char &                 output_ISO);
+int32_t convertIsoToUtf8(  charset_te inputCharset,  EdnVectorBin<char>&    input_ISO,     EdnVectorBin<char>&    output_UTF8);
+int32_t convertUtf8ToIso(  charset_te inputCharset,  EdnVectorBin<char>&    input_UTF8,    EdnVectorBin<char>&    output_ISO);
+
+void    Utf8_SizeElement(const char * data, int32_t lenMax , uint8_t &size, bool &baseValid);
+int32_t strUtf8Len(const char *input_UTF8);
+
+
+#ifdef USE_GTK_VERSION_3_0
+#	define GDK_KEY_Esc			(65305)
+#	define GDK_KEY_Alt_Gr		(65027)
+#	define GDK_KEY_Pomme_L		(65515)
+#	define GDK_KEY_Pomme_R		(65516)
+#elif USE_GTK_VERSION_2_0
+#	define GDK_Esc			(65305)
+#	define GDK_Alt_Gr		(65027)
+#	define GDK_Pomme_L		(65515)
+#	define GDK_Pomme_R		(65516)
+#endif
+//#	define GDK_Retur		(65516)
+
+void ConvertInput(GdkEventKey *event, char* Utf8Out, bool &controlKey, bool &moveKey, int32_t &key);
+
+void testDisplayConvChar(void);
+
+#endif
+

Sources/tools/charset/charsetTable.cpp

@@ -0,0 +1,312 @@
+/**
+ *******************************************************************************
+ * @file charsetTable.cpp
+ * @brief Editeur De N'ours : Table of all charset convertions (Sources)
+ * @author Edouard DUPIN
+ * @date 06/06/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+
+#include "tools_debug.h"
+#include "tools_globals.h"
+#include "charsetTable.h"
+
+extern "C" {
+
+	const int32_t TableIso8859_1[] = {
+		0x00000000, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000006, 0x00000007, 0x00000008, 0x00000009, 0x0000000A, 0x0000000B, 0x0000000C, 0x0000000D, 0x0000000E, 0x0000000F, 
+		0x00000010, 0x00000011, 0x00000012, 0x00000013, 0x00000014, 0x00000015, 0x00000016, 0x00000017, 0x00000018, 0x00000019, 0x0000001A, 0x0000001B, 0x0000001C, 0x0000001D, 0x0000001E, 0x0000001F, 
+		0x00000020, 0x00000021, 0x00000022, 0x00000023, 0x00000024, 0x00000025, 0x00000026, 0x00000027, 0x00000028, 0x00000029, 0x0000002A, 0x0000002B, 0x0000002C, 0x0000002D, 0x0000002E, 0x0000002F, 
+		0x00000030, 0x00000031, 0x00000032, 0x00000033, 0x00000034, 0x00000035, 0x00000036, 0x00000037, 0x00000038, 0x00000039, 0x0000003A, 0x0000003B, 0x0000003C, 0x0000003D, 0x0000003E, 0x0000003F, 
+		0x00000040, 0x00000041, 0x00000042, 0x00000043, 0x00000044, 0x00000045, 0x00000046, 0x00000047, 0x00000048, 0x00000049, 0x0000004A, 0x0000004B, 0x0000004C, 0x0000004D, 0x0000004E, 0x0000004F, 
+		0x00000050, 0x00000051, 0x00000052, 0x00000053, 0x00000054, 0x00000055, 0x00000056, 0x00000057, 0x00000058, 0x00000059, 0x0000005A, 0x0000005B, 0x0000005C, 0x0000005D, 0x0000005E, 0x0000005F, 
+		0x00000060, 0x00000061, 0x00000062, 0x00000063, 0x00000064, 0x00000065, 0x00000066, 0x00000067, 0x00000068, 0x00000069, 0x0000006A, 0x0000006B, 0x0000006C, 0x0000006D, 0x0000006E, 0x0000006F, 
+		0x00000070, 0x00000071, 0x00000072, 0x00000073, 0x00000074, 0x00000075, 0x00000076, 0x00000077, 0x00000078, 0x00000079, 0x0000007A, 0x0000007B, 0x0000007C, 0x0000007D, 0x0000007E, 0x0000007F, 
+		0x00000080, 0x00000081, 0x00000082, 0x00000083, 0x00000084, 0x00000085, 0x00000086, 0x00000087, 0x00000088, 0x00000089, 0x0000008A, 0x0000008B, 0x0000008C, 0x0000008D, 0x0000008E, 0x0000008F, 
+		0x00000090, 0x00000091, 0x00000092, 0x00000093, 0x00000094, 0x00000095, 0x00000096, 0x00000097, 0x00000098, 0x00000099, 0x0000009A, 0x0000009B, 0x0000009C, 0x0000009D, 0x0000009E, 0x0000009F, 
+		0x000000A0, 0x000000A1, 0x000000A2, 0x000000A3, 0x000000A4, 0x000000A5, 0x000000A6, 0x000000A7, 0x000000A8, 0x000000A9, 0x000000AA, 0x000000AB, 0x000000AC, 0x000000AD, 0x000000AE, 0x000000AF, 
+		0x000000B0, 0x000000B1, 0x000000B2, 0x000000B3, 0x000000B4, 0x000000B5, 0x000000B6, 0x000000B7, 0x000000B8, 0x000000B9, 0x000000BA, 0x000000BB, 0x000000BC, 0x000000BD, 0x000000BE, 0x000000BF, 
+		0x000000C0, 0x000000C1, 0x000000C2, 0x000000C3, 0x000000C4, 0x000000C5, 0x000000C6, 0x000000C7, 0x000000C8, 0x000000C9, 0x000000CA, 0x000000CB, 0x000000CC, 0x000000CD, 0x000000CE, 0x000000CF, 
+		0x000000D0, 0x000000D1, 0x000000D2, 0x000000D3, 0x000000D4, 0x000000D5, 0x000000D6, 0x000000D7, 0x000000D8, 0x000000D9, 0x000000DA, 0x000000DB, 0x000000DC, 0x000000DD, 0x000000DE, 0x000000DF, 
+		0x000000E0, 0x000000E1, 0x000000E2, 0x000000E3, 0x000000E4, 0x000000E5, 0x000000E6, 0x000000E7, 0x000000E8, 0x000000E9, 0x000000EA, 0x000000EB, 0x000000EC, 0x000000ED, 0x000000EE, 0x000000EF, 
+		0x000000F0, 0x000000F1, 0x000000F2, 0x000000F3, 0x000000F4, 0x000000F5, 0x000000F6, 0x000000F7, 0x000000F8, 0x000000F9, 0x000000FA, 0x000000FB, 0x000000FC, 0x000000FD, 0x000000FE, 0x000000FF
+	};
+
+	const int32_t TableIso8859_2[] = {
+		0x00000000, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000006, 0x00000007, 0x00000008, 0x00000009, 0x0000000A, 0x0000000B, 0x0000000C, 0x0000000D, 0x0000000E, 0x0000000F, 
+		0x00000010, 0x00000011, 0x00000012, 0x00000013, 0x00000014, 0x00000015, 0x00000016, 0x00000017, 0x00000018, 0x00000019, 0x0000001A, 0x0000001B, 0x0000001C, 0x0000001D, 0x0000001E, 0x0000001F, 
+		0x00000020, 0x00000021, 0x00000022, 0x00000023, 0x00000024, 0x00000025, 0x00000026, 0x00000027, 0x00000028, 0x00000029, 0x0000002A, 0x0000002B, 0x0000002C, 0x0000002D, 0x0000002E, 0x0000002F, 
+		0x00000030, 0x00000031, 0x00000032, 0x00000033, 0x00000034, 0x00000035, 0x00000036, 0x00000037, 0x00000038, 0x00000039, 0x0000003A, 0x0000003B, 0x0000003C, 0x0000003D, 0x0000003E, 0x0000003F, 
+		0x00000040, 0x00000041, 0x00000042, 0x00000043, 0x00000044, 0x00000045, 0x00000046, 0x00000047, 0x00000048, 0x00000049, 0x0000004A, 0x0000004B, 0x0000004C, 0x0000004D, 0x0000004E, 0x0000004F, 
+		0x00000050, 0x00000051, 0x00000052, 0x00000053, 0x00000054, 0x00000055, 0x00000056, 0x00000057, 0x00000058, 0x00000059, 0x0000005A, 0x0000005B, 0x0000005C, 0x0000005D, 0x0000005E, 0x0000005F, 
+		0x00000060, 0x00000061, 0x00000062, 0x00000063, 0x00000064, 0x00000065, 0x00000066, 0x00000067, 0x00000068, 0x00000069, 0x0000006A, 0x0000006B, 0x0000006C, 0x0000006D, 0x0000006E, 0x0000006F, 
+		0x00000070, 0x00000071, 0x00000072, 0x00000073, 0x00000074, 0x00000075, 0x00000076, 0x00000077, 0x00000078, 0x00000079, 0x0000007A, 0x0000007B, 0x0000007C, 0x0000007D, 0x0000007E, 0x0000007F, 
+		0x00000080, 0x00000081, 0x00000082, 0x00000083, 0x00000084, 0x00000085, 0x00000086, 0x00000087, 0x00000088, 0x00000089, 0x0000008A, 0x0000008B, 0x0000008C, 0x0000008D, 0x0000008E, 0x0000008F, 
+		0x00000090, 0x00000091, 0x00000092, 0x00000093, 0x00000094, 0x00000095, 0x00000096, 0x00000097, 0x00000098, 0x00000099, 0x0000009A, 0x0000009B, 0x0000009C, 0x0000009D, 0x0000009E, 0x0000009F, 
+		0x000000A0, 0x00000104, 0x000002D8, 0x00000141, 0x000000A4, 0x0000013D, 0x0000015A, 0x000000A7, 0x000000A8, 0x00000160, 0x0000015E, 0x00000164, 0x00000179, 0x000000AD, 0x0000017D, 0x0000017B, 
+		0x000000B0, 0x00000105, 0x000002DB, 0x00000142, 0x000000B4, 0x0000013E, 0x0000015B, 0x000002C7, 0x000000B8, 0x00000161, 0x0000015F, 0x00000165, 0x0000017A, 0x000002DD, 0x0000017E, 0x0000017C, 
+		0x00000154, 0x000000C1, 0x000000C2, 0x00000102, 0x000000C4, 0x00000139, 0x00000106, 0x000000C7, 0x0000010C, 0x000000C9, 0x00000118, 0x000000CB, 0x0000011A, 0x000000CD, 0x000000CE, 0x0000010E, 
+		0x00000110, 0x00000143, 0x00000147, 0x000000D3, 0x000000D4, 0x00000150, 0x000000D6, 0x000000D7, 0x00000158, 0x0000016E, 0x000000DA, 0x00000170, 0x000000DC, 0x000000DD, 0x00000162, 0x000000DF, 
+		0x00000155, 0x000000E1, 0x000000E2, 0x00000103, 0x000000E4, 0x0000013A, 0x00000107, 0x000000E7, 0x0000010D, 0x000000E9, 0x00000119, 0x000000EB, 0x0000011B, 0x000000ED, 0x000000EE, 0x0000010F, 
+		0x00000111, 0x00000144, 0x00000148, 0x000000F3, 0x000000F4, 0x00000151, 0x000000F6, 0x000000F7, 0x00000159, 0x0000016F, 0x000000FA, 0x00000171, 0x000000FC, 0x000000FD, 0x00000163, 0x000002D9
+	};
+
+	const int32_t TableIso8859_3[] = {
+		0x00000000, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000006, 0x00000007, 0x00000008, 0x00000009, 0x0000000A, 0x0000000B, 0x0000000C, 0x0000000D, 0x0000000E, 0x0000000F, 
+		0x00000010, 0x00000011, 0x00000012, 0x00000013, 0x00000014, 0x00000015, 0x00000016, 0x00000017, 0x00000018, 0x00000019, 0x0000001A, 0x0000001B, 0x0000001C, 0x0000001D, 0x0000001E, 0x0000001F, 
+		0x00000020, 0x00000021, 0x00000022, 0x00000023, 0x00000024, 0x00000025, 0x00000026, 0x00000027, 0x00000028, 0x00000029, 0x0000002A, 0x0000002B, 0x0000002C, 0x0000002D, 0x0000002E, 0x0000002F, 
+		0x00000030, 0x00000031, 0x00000032, 0x00000033, 0x00000034, 0x00000035, 0x00000036, 0x00000037, 0x00000038, 0x00000039, 0x0000003A, 0x0000003B, 0x0000003C, 0x0000003D, 0x0000003E, 0x0000003F, 
+		0x00000040, 0x00000041, 0x00000042, 0x00000043, 0x00000044, 0x00000045, 0x00000046, 0x00000047, 0x00000048, 0x00000049, 0x0000004A, 0x0000004B, 0x0000004C, 0x0000004D, 0x0000004E, 0x0000004F, 
+		0x00000050, 0x00000051, 0x00000052, 0x00000053, 0x00000054, 0x00000055, 0x00000056, 0x00000057, 0x00000058, 0x00000059, 0x0000005A, 0x0000005B, 0x0000005C, 0x0000005D, 0x0000005E, 0x0000005F, 
+		0x00000060, 0x00000061, 0x00000062, 0x00000063, 0x00000064, 0x00000065, 0x00000066, 0x00000067, 0x00000068, 0x00000069, 0x0000006A, 0x0000006B, 0x0000006C, 0x0000006D, 0x0000006E, 0x0000006F, 
+		0x00000070, 0x00000071, 0x00000072, 0x00000073, 0x00000074, 0x00000075, 0x00000076, 0x00000077, 0x00000078, 0x00000079, 0x0000007A, 0x0000007B, 0x0000007C, 0x0000007D, 0x0000007E, 0x0000007F, 
+		0x00000080, 0x00000081, 0x00000082, 0x00000083, 0x00000084, 0x00000085, 0x00000086, 0x00000087, 0x00000088, 0x00000089, 0x0000008A, 0x0000008B, 0x0000008C, 0x0000008D, 0x0000008E, 0x0000008F, 
+		0x00000090, 0x00000091, 0x00000092, 0x00000093, 0x00000094, 0x00000095, 0x00000096, 0x00000097, 0x00000098, 0x00000099, 0x0000009A, 0x0000009B, 0x0000009C, 0x0000009D, 0x0000009E, 0x0000009F, 
+		0x000000A0, 0x00000126, 0x000002D8, 0x000000A3, 0x000000A4, 0x00000000, 0x00000124, 0x000000A7, 0x000000A8, 0x00000130, 0x0000015E, 0x0000011E, 0x00000134, 0x000000AD, 0x00000000, 0x0000017B, 
+		0x000000B0, 0x00000127, 0x000000B2, 0x000000B3, 0x000000B4, 0x000000B5, 0x00000125, 0x000000B7, 0x000000B8, 0x00000131, 0x0000015F, 0x0000011F, 0x00000135, 0x000000BD, 0x00000000, 0x0000017C, 
+		0x000000C0, 0x000000C1, 0x000000C2, 0x00000000, 0x000000C4, 0x0000010A, 0x00000108, 0x000000C7, 0x000000C8, 0x000000C9, 0x000000CA, 0x000000CB, 0x000000CC, 0x000000CD, 0x000000CE, 0x000000CF, 
+		0x00000000, 0x000000D1, 0x000000D2, 0x000000D3, 0x000000D4, 0x00000120, 0x000000D6, 0x000000D7, 0x0000011C, 0x000000D9, 0x000000DA, 0x000000DB, 0x000000DC, 0x0000016C, 0x0000015C, 0x000000DF, 
+		0x000000E0, 0x000000E1, 0x000000E2, 0x00000000, 0x000000E4, 0x0000010B, 0x00000109, 0x000000E7, 0x000000E8, 0x000000E9, 0x000000EA, 0x000000EB, 0x000000EC, 0x000000ED, 0x000000EE, 0x000000EF, 
+		0x00000000, 0x000000F1, 0x000000F2, 0x000000F3, 0x000000F4, 0x00000121, 0x000000F6, 0x000000F7, 0x0000011D, 0x000000F9, 0x000000FA, 0x000000FB, 0x000000FC, 0x0000016D, 0x0000015D, 0x000002D9
+	};
+
+	const int32_t TableIso8859_4[] = {
+		0x00000000, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000006, 0x00000007, 0x00000008, 0x00000009, 0x0000000A, 0x0000000B, 0x0000000C, 0x0000000D, 0x0000000E, 0x0000000F, 
+		0x00000010, 0x00000011, 0x00000012, 0x00000013, 0x00000014, 0x00000015, 0x00000016, 0x00000017, 0x00000018, 0x00000019, 0x0000001A, 0x0000001B, 0x0000001C, 0x0000001D, 0x0000001E, 0x0000001F, 
+		0x00000020, 0x00000021, 0x00000022, 0x00000023, 0x00000024, 0x00000025, 0x00000026, 0x00000027, 0x00000028, 0x00000029, 0x0000002A, 0x0000002B, 0x0000002C, 0x0000002D, 0x0000002E, 0x0000002F, 
+		0x00000030, 0x00000031, 0x00000032, 0x00000033, 0x00000034, 0x00000035, 0x00000036, 0x00000037, 0x00000038, 0x00000039, 0x0000003A, 0x0000003B, 0x0000003C, 0x0000003D, 0x0000003E, 0x0000003F, 
+		0x00000040, 0x00000041, 0x00000042, 0x00000043, 0x00000044, 0x00000045, 0x00000046, 0x00000047, 0x00000048, 0x00000049, 0x0000004A, 0x0000004B, 0x0000004C, 0x0000004D, 0x0000004E, 0x0000004F, 
+		0x00000050, 0x00000051, 0x00000052, 0x00000053, 0x00000054, 0x00000055, 0x00000056, 0x00000057, 0x00000058, 0x00000059, 0x0000005A, 0x0000005B, 0x0000005C, 0x0000005D, 0x0000005E, 0x0000005F, 
+		0x00000060, 0x00000061, 0x00000062, 0x00000063, 0x00000064, 0x00000065, 0x00000066, 0x00000067, 0x00000068, 0x00000069, 0x0000006A, 0x0000006B, 0x0000006C, 0x0000006D, 0x0000006E, 0x0000006F, 
+		0x00000070, 0x00000071, 0x00000072, 0x00000073, 0x00000074, 0x00000075, 0x00000076, 0x00000077, 0x00000078, 0x00000079, 0x0000007A, 0x0000007B, 0x0000007C, 0x0000007D, 0x0000007E, 0x0000007F, 
+		0x00000080, 0x00000081, 0x00000082, 0x00000083, 0x00000084, 0x00000085, 0x00000086, 0x00000087, 0x00000088, 0x00000089, 0x0000008A, 0x0000008B, 0x0000008C, 0x0000008D, 0x0000008E, 0x0000008F, 
+		0x00000090, 0x00000091, 0x00000092, 0x00000093, 0x00000094, 0x00000095, 0x00000096, 0x00000097, 0x00000098, 0x00000099, 0x0000009A, 0x0000009B, 0x0000009C, 0x0000009D, 0x0000009E, 0x0000009F, 
+		0x000000A0, 0x00000104, 0x00000138, 0x00000156, 0x000000A4, 0x00000128, 0x0000013B, 0x000000A7, 0x000000A8, 0x00000160, 0x00000112, 0x00000122, 0x00000166, 0x000000AD, 0x0000017D, 0x000000AF, 
+		0x000000B0, 0x00000105, 0x000002DB, 0x00000157, 0x000000B4, 0x00000129, 0x0000013C, 0x000002C7, 0x000000B8, 0x00000161, 0x00000113, 0x00000123, 0x00000167, 0x0000014A, 0x0000017E, 0x0000014B, 
+		0x00000100, 0x000000C1, 0x000000C2, 0x000000C3, 0x000000C4, 0x000000C5, 0x000000C6, 0x0000012E, 0x0000010C, 0x000000C9, 0x00000118, 0x000000CB, 0x00000116, 0x000000CD, 0x000000CE, 0x0000012A, 
+		0x00000110, 0x00000145, 0x0000014C, 0x00000136, 0x000000D4, 0x000000D5, 0x000000D6, 0x000000D7, 0x000000D8, 0x00000172, 0x000000DA, 0x000000DB, 0x000000DC, 0x00000168, 0x0000016A, 0x000000DF, 
+		0x00000101, 0x000000E1, 0x000000E2, 0x000000E3, 0x000000E4, 0x000000E5, 0x000000E6, 0x0000012F, 0x0000010D, 0x000000E9, 0x00000119, 0x000000EB, 0x00000117, 0x000000ED, 0x000000EE, 0x0000012B, 
+		0x00000111, 0x00000146, 0x0000014D, 0x00000137, 0x000000F4, 0x000000F5, 0x000000F6, 0x000000F7, 0x000000F8, 0x00000173, 0x000000FA, 0x000000FB, 0x000000FC, 0x00000169, 0x0000016B, 0x000002D9
+	};
+
+	const int32_t TableIso8859_5[] = {
+		0x00000000, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000006, 0x00000007, 0x00000008, 0x00000009, 0x0000000A, 0x0000000B, 0x0000000C, 0x0000000D, 0x0000000E, 0x0000000F, 
+		0x00000010, 0x00000011, 0x00000012, 0x00000013, 0x00000014, 0x00000015, 0x00000016, 0x00000017, 0x00000018, 0x00000019, 0x0000001A, 0x0000001B, 0x0000001C, 0x0000001D, 0x0000001E, 0x0000001F, 
+		0x00000020, 0x00000021, 0x00000022, 0x00000023, 0x00000024, 0x00000025, 0x00000026, 0x00000027, 0x00000028, 0x00000029, 0x0000002A, 0x0000002B, 0x0000002C, 0x0000002D, 0x0000002E, 0x0000002F, 
+		0x00000030, 0x00000031, 0x00000032, 0x00000033, 0x00000034, 0x00000035, 0x00000036, 0x00000037, 0x00000038, 0x00000039, 0x0000003A, 0x0000003B, 0x0000003C, 0x0000003D, 0x0000003E, 0x0000003F, 
+		0x00000040, 0x00000041, 0x00000042, 0x00000043, 0x00000044, 0x00000045, 0x00000046, 0x00000047, 0x00000048, 0x00000049, 0x0000004A, 0x0000004B, 0x0000004C, 0x0000004D, 0x0000004E, 0x0000004F, 
+		0x00000050, 0x00000051, 0x00000052, 0x00000053, 0x00000054, 0x00000055, 0x00000056, 0x00000057, 0x00000058, 0x00000059, 0x0000005A, 0x0000005B, 0x0000005C, 0x0000005D, 0x0000005E, 0x0000005F, 
+		0x00000060, 0x00000061, 0x00000062, 0x00000063, 0x00000064, 0x00000065, 0x00000066, 0x00000067, 0x00000068, 0x00000069, 0x0000006A, 0x0000006B, 0x0000006C, 0x0000006D, 0x0000006E, 0x0000006F, 
+		0x00000070, 0x00000071, 0x00000072, 0x00000073, 0x00000074, 0x00000075, 0x00000076, 0x00000077, 0x00000078, 0x00000079, 0x0000007A, 0x0000007B, 0x0000007C, 0x0000007D, 0x0000007E, 0x0000007F, 
+		0x00000080, 0x00000081, 0x00000082, 0x00000083, 0x00000084, 0x00000085, 0x00000086, 0x00000087, 0x00000088, 0x00000089, 0x0000008A, 0x0000008B, 0x0000008C, 0x0000008D, 0x0000008E, 0x0000008F, 
+		0x00000090, 0x00000091, 0x00000092, 0x00000093, 0x00000094, 0x00000095, 0x00000096, 0x00000097, 0x00000098, 0x00000099, 0x0000009A, 0x0000009B, 0x0000009C, 0x0000009D, 0x0000009E, 0x0000009F, 
+		0x000000A0, 0x00000401, 0x00000402, 0x00000403, 0x00000404, 0x00000405, 0x00000406, 0x00000407, 0x00000408, 0x00000409, 0x0000040A, 0x0000040B, 0x0000040C, 0x000000AD, 0x0000040E, 0x0000040F, 
+		0x00000410, 0x00000411, 0x00000412, 0x00000413, 0x00000414, 0x00000415, 0x00000416, 0x00000417, 0x00000418, 0x00000419, 0x0000041A, 0x0000041B, 0x0000041C, 0x0000041D, 0x0000041E, 0x0000041F, 
+		0x00000420, 0x00000421, 0x00000422, 0x00000423, 0x00000424, 0x00000425, 0x00000426, 0x00000427, 0x00000428, 0x00000429, 0x0000042A, 0x0000042B, 0x0000042C, 0x0000042D, 0x0000042E, 0x0000042F, 
+		0x00000430, 0x00000431, 0x00000432, 0x00000433, 0x00000434, 0x00000435, 0x00000436, 0x00000437, 0x00000438, 0x00000439, 0x0000043A, 0x0000043B, 0x0000043C, 0x0000043D, 0x0000043E, 0x0000043F, 
+		0x00000440, 0x00000441, 0x00000442, 0x00000443, 0x00000444, 0x00000445, 0x00000446, 0x00000447, 0x00000448, 0x00000449, 0x0000044A, 0x0000044B, 0x0000044C, 0x0000044D, 0x0000044E, 0x0000044F, 
+		0x00002116, 0x00000451, 0x00000452, 0x00000453, 0x00000454, 0x00000455, 0x00000456, 0x00000457, 0x00000458, 0x00000459, 0x0000045A, 0x0000045B, 0x0000045C, 0x000000A7, 0x0000045E, 0x0000045F
+	};
+
+	const int32_t TableIso8859_6[] = {
+		0x00000000, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000006, 0x00000007, 0x00000008, 0x00000009, 0x0000000A, 0x0000000B, 0x0000000C, 0x0000000D, 0x0000000E, 0x0000000F, 
+		0x00000010, 0x00000011, 0x00000012, 0x00000013, 0x00000014, 0x00000015, 0x00000016, 0x00000017, 0x00000018, 0x00000019, 0x0000001A, 0x0000001B, 0x0000001C, 0x0000001D, 0x0000001E, 0x0000001F, 
+		0x00000020, 0x00000021, 0x00000022, 0x00000023, 0x00000024, 0x00000025, 0x00000026, 0x00000027, 0x00000028, 0x00000029, 0x0000002A, 0x0000002B, 0x0000002C, 0x0000002D, 0x0000002E, 0x0000002F, 
+		0x00000030, 0x00000031, 0x00000032, 0x00000033, 0x00000034, 0x00000035, 0x00000036, 0x00000037, 0x00000038, 0x00000039, 0x0000003A, 0x0000003B, 0x0000003C, 0x0000003D, 0x0000003E, 0x0000003F, 
+		0x00000040, 0x00000041, 0x00000042, 0x00000043, 0x00000044, 0x00000045, 0x00000046, 0x00000047, 0x00000048, 0x00000049, 0x0000004A, 0x0000004B, 0x0000004C, 0x0000004D, 0x0000004E, 0x0000004F, 
+		0x00000050, 0x00000051, 0x00000052, 0x00000053, 0x00000054, 0x00000055, 0x00000056, 0x00000057, 0x00000058, 0x00000059, 0x0000005A, 0x0000005B, 0x0000005C, 0x0000005D, 0x0000005E, 0x0000005F, 
+		0x00000060, 0x00000061, 0x00000062, 0x00000063, 0x00000064, 0x00000065, 0x00000066, 0x00000067, 0x00000068, 0x00000069, 0x0000006A, 0x0000006B, 0x0000006C, 0x0000006D, 0x0000006E, 0x0000006F, 
+		0x00000070, 0x00000071, 0x00000072, 0x00000073, 0x00000074, 0x00000075, 0x00000076, 0x00000077, 0x00000078, 0x00000079, 0x0000007A, 0x0000007B, 0x0000007C, 0x0000007D, 0x0000007E, 0x0000007F, 
+		0x00000080, 0x00000081, 0x00000082, 0x00000083, 0x00000084, 0x00000085, 0x00000086, 0x00000087, 0x00000088, 0x00000089, 0x0000008A, 0x0000008B, 0x0000008C, 0x0000008D, 0x0000008E, 0x0000008F, 
+		0x00000090, 0x00000091, 0x00000092, 0x00000093, 0x00000094, 0x00000095, 0x00000096, 0x00000097, 0x00000098, 0x00000099, 0x0000009A, 0x0000009B, 0x0000009C, 0x0000009D, 0x0000009E, 0x0000009F, 
+		0x000000A0, 0x00000000, 0x00000000, 0x00000000, 0x000000A4, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000060C, 0x000000AD, 0x00000000, 0x00000000, 
+		0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000061B, 0x00000000, 0x00000000, 0x00000000, 0x0000061F, 
+		0x00000000, 0x00000621, 0x00000622, 0x00000623, 0x00000624, 0x00000625, 0x00000626, 0x00000627, 0x00000628, 0x00000629, 0x0000062A, 0x0000062B, 0x0000062C, 0x0000062D, 0x0000062E, 0x0000062F, 
+		0x00000630, 0x00000631, 0x00000632, 0x00000633, 0x00000634, 0x00000635, 0x00000636, 0x00000637, 0x00000638, 0x00000639, 0x0000063A, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 
+		0x00000640, 0x00000641, 0x00000642, 0x00000643, 0x00000644, 0x00000645, 0x00000646, 0x00000647, 0x00000648, 0x00000649, 0x0000064A, 0x0000064B, 0x0000064C, 0x0000064D, 0x0000064E, 0x0000064F, 
+		0x00000650, 0x00000651, 0x00000652, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000
+	};
+
+	const int32_t TableIso8859_7[] = {
+		0x00000000, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000006, 0x00000007, 0x00000008, 0x00000009, 0x0000000A, 0x0000000B, 0x0000000C, 0x0000000D, 0x0000000E, 0x0000000F, 
+		0x00000010, 0x00000011, 0x00000012, 0x00000013, 0x00000014, 0x00000015, 0x00000016, 0x00000017, 0x00000018, 0x00000019, 0x0000001A, 0x0000001B, 0x0000001C, 0x0000001D, 0x0000001E, 0x0000001F, 
+		0x00000020, 0x00000021, 0x00000022, 0x00000023, 0x00000024, 0x00000025, 0x00000026, 0x00000027, 0x00000028, 0x00000029, 0x0000002A, 0x0000002B, 0x0000002C, 0x0000002D, 0x0000002E, 0x0000002F, 
+		0x00000030, 0x00000031, 0x00000032, 0x00000033, 0x00000034, 0x00000035, 0x00000036, 0x00000037, 0x00000038, 0x00000039, 0x0000003A, 0x0000003B, 0x0000003C, 0x0000003D, 0x0000003E, 0x0000003F, 
+		0x00000040, 0x00000041, 0x00000042, 0x00000043, 0x00000044, 0x00000045, 0x00000046, 0x00000047, 0x00000048, 0x00000049, 0x0000004A, 0x0000004B, 0x0000004C, 0x0000004D, 0x0000004E, 0x0000004F, 
+		0x00000050, 0x00000051, 0x00000052, 0x00000053, 0x00000054, 0x00000055, 0x00000056, 0x00000057, 0x00000058, 0x00000059, 0x0000005A, 0x0000005B, 0x0000005C, 0x0000005D, 0x0000005E, 0x0000005F, 
+		0x00000060, 0x00000061, 0x00000062, 0x00000063, 0x00000064, 0x00000065, 0x00000066, 0x00000067, 0x00000068, 0x00000069, 0x0000006A, 0x0000006B, 0x0000006C, 0x0000006D, 0x0000006E, 0x0000006F, 
+		0x00000070, 0x00000071, 0x00000072, 0x00000073, 0x00000074, 0x00000075, 0x00000076, 0x00000077, 0x00000078, 0x00000079, 0x0000007A, 0x0000007B, 0x0000007C, 0x0000007D, 0x0000007E, 0x0000007F, 
+		0x00000080, 0x00000081, 0x00000082, 0x00000083, 0x00000084, 0x00000085, 0x00000086, 0x00000087, 0x00000088, 0x00000089, 0x0000008A, 0x0000008B, 0x0000008C, 0x0000008D, 0x0000008E, 0x0000008F, 
+		0x00000090, 0x00000091, 0x00000092, 0x00000093, 0x00000094, 0x00000095, 0x00000096, 0x00000097, 0x00000098, 0x00000099, 0x0000009A, 0x0000009B, 0x0000009C, 0x0000009D, 0x0000009E, 0x0000009F, 
+		0x000000A0, 0x00002018, 0x00002019, 0x000000A3, 0x000020AC, 0x000020AF, 0x000000A6, 0x000000A7, 0x000000A8, 0x000000A9, 0x0000037A, 0x000000AB, 0x000000AC, 0x000000AD, 0x00000000, 0x00002015, 
+		0x000000B0, 0x000000B1, 0x000000B2, 0x000000B3, 0x00000384, 0x00000385, 0x00000386, 0x000000B7, 0x00000388, 0x00000389, 0x0000038A, 0x000000BB, 0x0000038C, 0x000000BD, 0x0000038E, 0x0000038F, 
+		0x00000390, 0x00000391, 0x00000392, 0x00000393, 0x00000394, 0x00000395, 0x00000396, 0x00000397, 0x00000398, 0x00000399, 0x0000039A, 0x0000039B, 0x0000039C, 0x0000039D, 0x0000039E, 0x0000039F, 
+		0x000003A0, 0x000003A1, 0x00000000, 0x000003A3, 0x000003A4, 0x000003A5, 0x000003A6, 0x000003A7, 0x000003A8, 0x000003A9, 0x000003AA, 0x000003AB, 0x000003AC, 0x000003AD, 0x000003AE, 0x000003AF, 
+		0x000003B0, 0x000003B1, 0x000003B2, 0x000003B3, 0x000003B4, 0x000003B5, 0x000003B6, 0x000003B7, 0x000003B8, 0x000003B9, 0x000003BA, 0x000003BB, 0x000003BC, 0x000003BD, 0x000003BE, 0x000003BF, 
+		0x000003C0, 0x000003C1, 0x000003C2, 0x000003C3, 0x000003C4, 0x000003C5, 0x000003C6, 0x000003C7, 0x000003C8, 0x000003C9, 0x000003CA, 0x000003CB, 0x000003CC, 0x000003CD, 0x000003CE, 0x00000000
+	};
+
+	const int32_t TableIso8859_8[] = {
+		0x00000000, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000006, 0x00000007, 0x00000008, 0x00000009, 0x0000000A, 0x0000000B, 0x0000000C, 0x0000000D, 0x0000000E, 0x0000000F, 
+		0x00000010, 0x00000011, 0x00000012, 0x00000013, 0x00000014, 0x00000015, 0x00000016, 0x00000017, 0x00000018, 0x00000019, 0x0000001A, 0x0000001B, 0x0000001C, 0x0000001D, 0x0000001E, 0x0000001F, 
+		0x00000020, 0x00000021, 0x00000022, 0x00000023, 0x00000024, 0x00000025, 0x00000026, 0x00000027, 0x00000028, 0x00000029, 0x0000002A, 0x0000002B, 0x0000002C, 0x0000002D, 0x0000002E, 0x0000002F, 
+		0x00000030, 0x00000031, 0x00000032, 0x00000033, 0x00000034, 0x00000035, 0x00000036, 0x00000037, 0x00000038, 0x00000039, 0x0000003A, 0x0000003B, 0x0000003C, 0x0000003D, 0x0000003E, 0x0000003F, 
+		0x00000040, 0x00000041, 0x00000042, 0x00000043, 0x00000044, 0x00000045, 0x00000046, 0x00000047, 0x00000048, 0x00000049, 0x0000004A, 0x0000004B, 0x0000004C, 0x0000004D, 0x0000004E, 0x0000004F, 
+		0x00000050, 0x00000051, 0x00000052, 0x00000053, 0x00000054, 0x00000055, 0x00000056, 0x00000057, 0x00000058, 0x00000059, 0x0000005A, 0x0000005B, 0x0000005C, 0x0000005D, 0x0000005E, 0x0000005F, 
+		0x00000060, 0x00000061, 0x00000062, 0x00000063, 0x00000064, 0x00000065, 0x00000066, 0x00000067, 0x00000068, 0x00000069, 0x0000006A, 0x0000006B, 0x0000006C, 0x0000006D, 0x0000006E, 0x0000006F, 
+		0x00000070, 0x00000071, 0x00000072, 0x00000073, 0x00000074, 0x00000075, 0x00000076, 0x00000077, 0x00000078, 0x00000079, 0x0000007A, 0x0000007B, 0x0000007C, 0x0000007D, 0x0000007E, 0x0000007F, 
+		0x00000080, 0x00000081, 0x00000082, 0x00000083, 0x00000084, 0x00000085, 0x00000086, 0x00000087, 0x00000088, 0x00000089, 0x0000008A, 0x0000008B, 0x0000008C, 0x0000008D, 0x0000008E, 0x0000008F, 
+		0x00000090, 0x00000091, 0x00000092, 0x00000093, 0x00000094, 0x00000095, 0x00000096, 0x00000097, 0x00000098, 0x00000099, 0x0000009A, 0x0000009B, 0x0000009C, 0x0000009D, 0x0000009E, 0x0000009F, 
+		0x000000A0, 0x00000000, 0x000000A2, 0x000000A3, 0x000000A4, 0x000000A5, 0x000000A6, 0x000000A7, 0x000000A8, 0x000000A9, 0x000000D7, 0x000000AB, 0x000000AC, 0x000000AD, 0x000000AE, 0x000000AF, 
+		0x000000B0, 0x000000B1, 0x000000B2, 0x000000B3, 0x000000B4, 0x000000B5, 0x000000B6, 0x000000B7, 0x000000B8, 0x000000B9, 0x000000F7, 0x000000BB, 0x000000BC, 0x000000BD, 0x000000BE, 0x00000000, 
+		0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 
+		0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00002017, 
+		0x000005D0, 0x000005D1, 0x000005D2, 0x000005D3, 0x000005D4, 0x000005D5, 0x000005D6, 0x000005D7, 0x000005D8, 0x000005D9, 0x000005DA, 0x000005DB, 0x000005DC, 0x000005DD, 0x000005DE, 0x000005DF, 
+		0x000005E0, 0x000005E1, 0x000005E2, 0x000005E3, 0x000005E4, 0x000005E5, 0x000005E6, 0x000005E7, 0x000005E8, 0x000005E9, 0x000005EA, 0x00000000, 0x00000000, 0x0000200E, 0x0000200F, 0x000003C0
+	};
+
+	const int32_t TableIso8859_9[] = {
+		0x00000000, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000006, 0x00000007, 0x00000008, 0x00000009, 0x0000000A, 0x0000000B, 0x0000000C, 0x0000000D, 0x0000000E, 0x0000000F, 
+		0x00000010, 0x00000011, 0x00000012, 0x00000013, 0x00000014, 0x00000015, 0x00000016, 0x00000017, 0x00000018, 0x00000019, 0x0000001A, 0x0000001B, 0x0000001C, 0x0000001D, 0x0000001E, 0x0000001F, 
+		0x00000020, 0x00000021, 0x00000022, 0x00000023, 0x00000024, 0x00000025, 0x00000026, 0x00000027, 0x00000028, 0x00000029, 0x0000002A, 0x0000002B, 0x0000002C, 0x0000002D, 0x0000002E, 0x0000002F, 
+		0x00000030, 0x00000031, 0x00000032, 0x00000033, 0x00000034, 0x00000035, 0x00000036, 0x00000037, 0x00000038, 0x00000039, 0x0000003A, 0x0000003B, 0x0000003C, 0x0000003D, 0x0000003E, 0x0000003F, 
+		0x00000040, 0x00000041, 0x00000042, 0x00000043, 0x00000044, 0x00000045, 0x00000046, 0x00000047, 0x00000048, 0x00000049, 0x0000004A, 0x0000004B, 0x0000004C, 0x0000004D, 0x0000004E, 0x0000004F, 
+		0x00000050, 0x00000051, 0x00000052, 0x00000053, 0x00000054, 0x00000055, 0x00000056, 0x00000057, 0x00000058, 0x00000059, 0x0000005A, 0x0000005B, 0x0000005C, 0x0000005D, 0x0000005E, 0x0000005F, 
+		0x00000060, 0x00000061, 0x00000062, 0x00000063, 0x00000064, 0x00000065, 0x00000066, 0x00000067, 0x00000068, 0x00000069, 0x0000006A, 0x0000006B, 0x0000006C, 0x0000006D, 0x0000006E, 0x0000006F, 
+		0x00000070, 0x00000071, 0x00000072, 0x00000073, 0x00000074, 0x00000075, 0x00000076, 0x00000077, 0x00000078, 0x00000079, 0x0000007A, 0x0000007B, 0x0000007C, 0x0000007D, 0x0000007E, 0x0000007F, 
+		0x00000080, 0x00000081, 0x00000082, 0x00000083, 0x00000084, 0x00000085, 0x00000086, 0x00000087, 0x00000088, 0x00000089, 0x0000008A, 0x0000008B, 0x0000008C, 0x0000008D, 0x0000008E, 0x0000008F, 
+		0x00000090, 0x00000091, 0x00000092, 0x00000093, 0x00000094, 0x00000095, 0x00000096, 0x00000097, 0x00000098, 0x00000099, 0x0000009A, 0x0000009B, 0x0000009C, 0x0000009D, 0x0000009E, 0x0000009F, 
+		0x000000A0, 0x000000A1, 0x000000A2, 0x000000A3, 0x000000A4, 0x000000A5, 0x000000A6, 0x000000A7, 0x000000A8, 0x000000A9, 0x000000AA, 0x000000AB, 0x000000AC, 0x000000AD, 0x000000AE, 0x000000AF, 
+		0x000000B0, 0x000000B1, 0x000000B2, 0x000000B3, 0x000000B4, 0x000000B5, 0x000000B6, 0x000000B7, 0x000000B8, 0x000000B9, 0x000000BA, 0x000000BB, 0x000000BC, 0x000000BD, 0x000000BE, 0x000000BF, 
+		0x000000C0, 0x000000C1, 0x000000C2, 0x000000C3, 0x000000C4, 0x000000C5, 0x000000C6, 0x000000C7, 0x000000C8, 0x000000C9, 0x000000CA, 0x000000CB, 0x000000CC, 0x000000CD, 0x000000CE, 0x000000CF, 
+		0x0000011E, 0x000000D1, 0x000000D2, 0x000000D3, 0x000000D4, 0x000000D5, 0x000000D6, 0x000000D7, 0x000000D8, 0x000000D9, 0x000000DA, 0x000000DB, 0x000000DC, 0x00000130, 0x0000015E, 0x000000DF, 
+		0x000000E0, 0x000000E1, 0x000000E2, 0x000000E3, 0x000000E4, 0x000000E5, 0x000000E6, 0x000000E7, 0x000000E8, 0x000000E9, 0x000000EA, 0x000000EB, 0x000000EC, 0x000000ED, 0x000000EE, 0x000000EF, 
+		0x0000011F, 0x000000F1, 0x000000F2, 0x000000F3, 0x000000F4, 0x000000F5, 0x000000F6, 0x000000F7, 0x000000F8, 0x000000F9, 0x000000FA, 0x000000FB, 0x000000FC, 0x00000131, 0x0000015F, 0x000000FF
+	};
+
+	const int32_t TableIso8859_10[] = {
+		0x00000000, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000006, 0x00000007, 0x00000008, 0x00000009, 0x0000000A, 0x0000000B, 0x0000000C, 0x0000000D, 0x0000000E, 0x0000000F, 
+		0x00000010, 0x00000011, 0x00000012, 0x00000013, 0x00000014, 0x00000015, 0x00000016, 0x00000017, 0x00000018, 0x00000019, 0x0000001A, 0x0000001B, 0x0000001C, 0x0000001D, 0x0000001E, 0x0000001F, 
+		0x00000020, 0x00000021, 0x00000022, 0x00000023, 0x00000024, 0x00000025, 0x00000026, 0x00000027, 0x00000028, 0x00000029, 0x0000002A, 0x0000002B, 0x0000002C, 0x0000002D, 0x0000002E, 0x0000002F, 
+		0x00000030, 0x00000031, 0x00000032, 0x00000033, 0x00000034, 0x00000035, 0x00000036, 0x00000037, 0x00000038, 0x00000039, 0x0000003A, 0x0000003B, 0x0000003C, 0x0000003D, 0x0000003E, 0x0000003F, 
+		0x00000040, 0x00000041, 0x00000042, 0x00000043, 0x00000044, 0x00000045, 0x00000046, 0x00000047, 0x00000048, 0x00000049, 0x0000004A, 0x0000004B, 0x0000004C, 0x0000004D, 0x0000004E, 0x0000004F, 
+		0x00000050, 0x00000051, 0x00000052, 0x00000053, 0x00000054, 0x00000055, 0x00000056, 0x00000057, 0x00000058, 0x00000059, 0x0000005A, 0x0000005B, 0x0000005C, 0x0000005D, 0x0000005E, 0x0000005F, 
+		0x00000060, 0x00000061, 0x00000062, 0x00000063, 0x00000064, 0x00000065, 0x00000066, 0x00000067, 0x00000068, 0x00000069, 0x0000006A, 0x0000006B, 0x0000006C, 0x0000006D, 0x0000006E, 0x0000006F, 
+		0x00000070, 0x00000071, 0x00000072, 0x00000073, 0x00000074, 0x00000075, 0x00000076, 0x00000077, 0x00000078, 0x00000079, 0x0000007A, 0x0000007B, 0x0000007C, 0x0000007D, 0x0000007E, 0x0000007F, 
+		0x00000080, 0x00000081, 0x00000082, 0x00000083, 0x00000084, 0x00000085, 0x00000086, 0x00000087, 0x00000088, 0x00000089, 0x0000008A, 0x0000008B, 0x0000008C, 0x0000008D, 0x0000008E, 0x0000008F, 
+		0x00000090, 0x00000091, 0x00000092, 0x00000093, 0x00000094, 0x00000095, 0x00000096, 0x00000097, 0x00000098, 0x00000099, 0x0000009A, 0x0000009B, 0x0000009C, 0x0000009D, 0x0000009E, 0x0000009F, 
+		0x000000A0, 0x00000104, 0x00000112, 0x00000122, 0x0000012A, 0x00000128, 0x00000136, 0x000000A7, 0x0000013B, 0x00000110, 0x00000160, 0x00000166, 0x0000017D, 0x000000AD, 0x0000016A, 0x0000014A, 
+		0x000000B0, 0x00000105, 0x00000113, 0x00000123, 0x0000012B, 0x00000129, 0x00000137, 0x000000B7, 0x0000013C, 0x00000111, 0x00000161, 0x00000167, 0x0000017E, 0x00002015, 0x0000016B, 0x0000014B, 
+		0x00000100, 0x000000C1, 0x000000C2, 0x000000C3, 0x000000C4, 0x000000C5, 0x000000C6, 0x0000012E, 0x0000010C, 0x000000C9, 0x00000118, 0x000000CB, 0x00000116, 0x000000CD, 0x000000CE, 0x000000CF, 
+		0x000000D0, 0x00000145, 0x0000014C, 0x000000D3, 0x000000D4, 0x000000D5, 0x000000D6, 0x00000168, 0x000000D8, 0x00000172, 0x000000DA, 0x000000DB, 0x000000DC, 0x000000DD, 0x000000DE, 0x000000DF, 
+		0x00000101, 0x000000E1, 0x000000E2, 0x000000E3, 0x000000E4, 0x000000E5, 0x000000E6, 0x0000012F, 0x0000010D, 0x000000E9, 0x00000119, 0x000000EB, 0x00000117, 0x000000ED, 0x000000EE, 0x000000EF, 
+		0x000000F0, 0x00000146, 0x0000014D, 0x000000F3, 0x000000F4, 0x000000F5, 0x000000F6, 0x00000169, 0x000000F8, 0x00000173, 0x000000FA, 0x000000FB, 0x000000FC, 0x000000FD, 0x000000FE, 0x00000138
+	};
+
+	const int32_t TableIso8859_11[] = {
+		0x00000000, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000006, 0x00000007, 0x00000008, 0x00000009, 0x0000000A, 0x0000000B, 0x0000000C, 0x0000000D, 0x0000000E, 0x0000000F, 
+		0x00000010, 0x00000011, 0x00000012, 0x00000013, 0x00000014, 0x00000015, 0x00000016, 0x00000017, 0x00000018, 0x00000019, 0x0000001A, 0x0000001B, 0x0000001C, 0x0000001D, 0x0000001E, 0x0000001F, 
+		0x00000020, 0x00000021, 0x00000022, 0x00000023, 0x00000024, 0x00000025, 0x00000026, 0x00000027, 0x00000028, 0x00000029, 0x0000002A, 0x0000002B, 0x0000002C, 0x0000002D, 0x0000002E, 0x0000002F, 
+		0x00000030, 0x00000031, 0x00000032, 0x00000033, 0x00000034, 0x00000035, 0x00000036, 0x00000037, 0x00000038, 0x00000039, 0x0000003A, 0x0000003B, 0x0000003C, 0x0000003D, 0x0000003E, 0x0000003F, 
+		0x00000040, 0x00000041, 0x00000042, 0x00000043, 0x00000044, 0x00000045, 0x00000046, 0x00000047, 0x00000048, 0x00000049, 0x0000004A, 0x0000004B, 0x0000004C, 0x0000004D, 0x0000004E, 0x0000004F, 
+		0x00000050, 0x00000051, 0x00000052, 0x00000053, 0x00000054, 0x00000055, 0x00000056, 0x00000057, 0x00000058, 0x00000059, 0x0000005A, 0x0000005B, 0x0000005C, 0x0000005D, 0x0000005E, 0x0000005F, 
+		0x00000060, 0x00000061, 0x00000062, 0x00000063, 0x00000064, 0x00000065, 0x00000066, 0x00000067, 0x00000068, 0x00000069, 0x0000006A, 0x0000006B, 0x0000006C, 0x0000006D, 0x0000006E, 0x0000006F, 
+		0x00000070, 0x00000071, 0x00000072, 0x00000073, 0x00000074, 0x00000075, 0x00000076, 0x00000077, 0x00000078, 0x00000079, 0x0000007A, 0x0000007B, 0x0000007C, 0x0000007D, 0x0000007E, 0x0000007F, 
+		0x00000080, 0x00000081, 0x00000082, 0x00000083, 0x00000084, 0x00000085, 0x00000086, 0x00000087, 0x00000088, 0x00000089, 0x0000008A, 0x0000008B, 0x0000008C, 0x0000008D, 0x0000008E, 0x0000008F, 
+		0x00000090, 0x00000091, 0x00000092, 0x00000093, 0x00000094, 0x00000095, 0x00000096, 0x00000097, 0x00000098, 0x00000099, 0x0000009A, 0x0000009B, 0x0000009C, 0x0000009D, 0x0000009E, 0x0000009F, 
+		0x000000A0, 0x00000E01, 0x00000E02, 0x00000E03, 0x00000E04, 0x00000E05, 0x00000E06, 0x00000E07, 0x00000E08, 0x00000E09, 0x00000E0A, 0x00000E0B, 0x00000E0C, 0x00000E0D, 0x00000E0E, 0x00000E0F, 
+		0x00000E10, 0x00000E11, 0x00000E12, 0x00000E13, 0x00000E14, 0x00000E15, 0x00000E16, 0x00000E17, 0x00000E18, 0x00000E19, 0x00000E1A, 0x00000E1B, 0x00000E1C, 0x00000E1D, 0x00000E1E, 0x00000E1F, 
+		0x00000E20, 0x00000E21, 0x00000E22, 0x00000E23, 0x00000E24, 0x00000E25, 0x00000E26, 0x00000E27, 0x00000E28, 0x00000E29, 0x00000E2A, 0x00000E2B, 0x00000E2C, 0x00000E2D, 0x00000E2E, 0x00000E2F, 
+		0x00000E30, 0x00000E31, 0x00000E32, 0x00000E33, 0x00000E34, 0x00000E35, 0x00000E36, 0x00000E37, 0x00000E38, 0x00000E39, 0x00000E3A, 0x00000E80, 0x00000E80, 0x00000E80, 0x00000E80, 0x00000E3F, 
+		0x00000E40, 0x00000E41, 0x00000E42, 0x00000E43, 0x00000E44, 0x00000E45, 0x00000E46, 0x00000E47, 0x00000E48, 0x00000E49, 0x00000E4A, 0x00000E4B, 0x00000E4C, 0x00000E4D, 0x00000E4E, 0x00000E4F, 
+		0x00000E50, 0x00000E51, 0x00000E52, 0x00000E53, 0x00000E54, 0x00000E55, 0x00000E56, 0x00000E57, 0x00000E58, 0x00000E59, 0x00000E5A, 0x00000E5B, 0x000006C0, 0x000006C0, 0x000006C0, 0x000006C0
+	};
+
+	const int32_t TableIso8859_13[] = {
+		0x00000000, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000006, 0x00000007, 0x00000008, 0x00000009, 0x0000000A, 0x0000000B, 0x0000000C, 0x0000000D, 0x0000000E, 0x0000000F, 
+		0x00000010, 0x00000011, 0x00000012, 0x00000013, 0x00000014, 0x00000015, 0x00000016, 0x00000017, 0x00000018, 0x00000019, 0x0000001A, 0x0000001B, 0x0000001C, 0x0000001D, 0x0000001E, 0x0000001F, 
+		0x00000020, 0x00000021, 0x00000022, 0x00000023, 0x00000024, 0x00000025, 0x00000026, 0x00000027, 0x00000028, 0x00000029, 0x0000002A, 0x0000002B, 0x0000002C, 0x0000002D, 0x0000002E, 0x0000002F, 
+		0x00000030, 0x00000031, 0x00000032, 0x00000033, 0x00000034, 0x00000035, 0x00000036, 0x00000037, 0x00000038, 0x00000039, 0x0000003A, 0x0000003B, 0x0000003C, 0x0000003D, 0x0000003E, 0x0000003F, 
+		0x00000040, 0x00000041, 0x00000042, 0x00000043, 0x00000044, 0x00000045, 0x00000046, 0x00000047, 0x00000048, 0x00000049, 0x0000004A, 0x0000004B, 0x0000004C, 0x0000004D, 0x0000004E, 0x0000004F, 
+		0x00000050, 0x00000051, 0x00000052, 0x00000053, 0x00000054, 0x00000055, 0x00000056, 0x00000057, 0x00000058, 0x00000059, 0x0000005A, 0x0000005B, 0x0000005C, 0x0000005D, 0x0000005E, 0x0000005F, 
+		0x00000060, 0x00000061, 0x00000062, 0x00000063, 0x00000064, 0x00000065, 0x00000066, 0x00000067, 0x00000068, 0x00000069, 0x0000006A, 0x0000006B, 0x0000006C, 0x0000006D, 0x0000006E, 0x0000006F, 
+		0x00000070, 0x00000071, 0x00000072, 0x00000073, 0x00000074, 0x00000075, 0x00000076, 0x00000077, 0x00000078, 0x00000079, 0x0000007A, 0x0000007B, 0x0000007C, 0x0000007D, 0x0000007E, 0x0000007F, 
+		0x00000080, 0x00000081, 0x00000082, 0x00000083, 0x00000084, 0x00000085, 0x00000086, 0x00000087, 0x00000088, 0x00000089, 0x0000008A, 0x0000008B, 0x0000008C, 0x0000008D, 0x0000008E, 0x0000008F, 
+		0x00000090, 0x00000091, 0x00000092, 0x00000093, 0x00000094, 0x00000095, 0x00000096, 0x00000097, 0x00000098, 0x00000099, 0x0000009A, 0x0000009B, 0x0000009C, 0x0000009D, 0x0000009E, 0x0000009F, 
+		0x000000A0, 0x0000201D, 0x000000A2, 0x000000A3, 0x000000A4, 0x0000201E, 0x000000A6, 0x000000A7, 0x000000D8, 0x000000A9, 0x00000156, 0x000000AB, 0x000000AC, 0x000000AD, 0x000000AE, 0x000000C6, 
+		0x000000B0, 0x000000B1, 0x000000B2, 0x000000B3, 0x0000201C, 0x000000B5, 0x000000B6, 0x000000B7, 0x000000F8, 0x000000B9, 0x00000157, 0x000000BB, 0x000000BC, 0x000000BD, 0x000000BE, 0x000000E6, 
+		0x00000104, 0x0000012E, 0x00000100, 0x00000106, 0x000000C4, 0x000000C5, 0x00000118, 0x00000112, 0x0000010C, 0x000000C9, 0x00000179, 0x00000116, 0x00000122, 0x00000136, 0x0000012A, 0x0000013B, 
+		0x00000160, 0x00000143, 0x00000145, 0x000000D3, 0x0000014C, 0x000000D5, 0x000000D6, 0x000000D7, 0x00000172, 0x00000141, 0x0000015A, 0x0000016A, 0x000000DC, 0x0000017B, 0x0000017D, 0x000000DF, 
+		0x00000105, 0x0000012F, 0x00000101, 0x00000107, 0x000000E4, 0x000000E5, 0x00000119, 0x00000113, 0x0000010D, 0x000000E9, 0x0000017A, 0x00000117, 0x00000123, 0x00000137, 0x0000012B, 0x0000013C, 
+		0x00000161, 0x00000144, 0x00000146, 0x000000F3, 0x0000014D, 0x000000F5, 0x000000F6, 0x000000F7, 0x00000173, 0x00000142, 0x0000015B, 0x0000016B, 0x000000FC, 0x0000017C, 0x0000017E, 0x00002019
+	};
+
+	const int32_t TableIso8859_14[] = {
+		0x00000000, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000006, 0x00000007, 0x00000008, 0x00000009, 0x0000000A, 0x0000000B, 0x0000000C, 0x0000000D, 0x0000000E, 0x0000000F, 
+		0x00000010, 0x00000011, 0x00000012, 0x00000013, 0x00000014, 0x00000015, 0x00000016, 0x00000017, 0x00000018, 0x00000019, 0x0000001A, 0x0000001B, 0x0000001C, 0x0000001D, 0x0000001E, 0x0000001F, 
+		0x00000020, 0x00000021, 0x00000022, 0x00000023, 0x00000024, 0x00000025, 0x00000026, 0x00000027, 0x00000028, 0x00000029, 0x0000002A, 0x0000002B, 0x0000002C, 0x0000002D, 0x0000002E, 0x0000002F, 
+		0x00000030, 0x00000031, 0x00000032, 0x00000033, 0x00000034, 0x00000035, 0x00000036, 0x00000037, 0x00000038, 0x00000039, 0x0000003A, 0x0000003B, 0x0000003C, 0x0000003D, 0x0000003E, 0x0000003F, 
+		0x00000040, 0x00000041, 0x00000042, 0x00000043, 0x00000044, 0x00000045, 0x00000046, 0x00000047, 0x00000048, 0x00000049, 0x0000004A, 0x0000004B, 0x0000004C, 0x0000004D, 0x0000004E, 0x0000004F, 
+		0x00000050, 0x00000051, 0x00000052, 0x00000053, 0x00000054, 0x00000055, 0x00000056, 0x00000057, 0x00000058, 0x00000059, 0x0000005A, 0x0000005B, 0x0000005C, 0x0000005D, 0x0000005E, 0x0000005F, 
+		0x00000060, 0x00000061, 0x00000062, 0x00000063, 0x00000064, 0x00000065, 0x00000066, 0x00000067, 0x00000068, 0x00000069, 0x0000006A, 0x0000006B, 0x0000006C, 0x0000006D, 0x0000006E, 0x0000006F, 
+		0x00000070, 0x00000071, 0x00000072, 0x00000073, 0x00000074, 0x00000075, 0x00000076, 0x00000077, 0x00000078, 0x00000079, 0x0000007A, 0x0000007B, 0x0000007C, 0x0000007D, 0x0000007E, 0x0000007F, 
+		0x00000080, 0x00000081, 0x00000082, 0x00000083, 0x00000084, 0x00000085, 0x00000086, 0x00000087, 0x00000088, 0x00000089, 0x0000008A, 0x0000008B, 0x0000008C, 0x0000008D, 0x0000008E, 0x0000008F, 
+		0x00000090, 0x00000091, 0x00000092, 0x00000093, 0x00000094, 0x00000095, 0x00000096, 0x00000097, 0x00000098, 0x00000099, 0x0000009A, 0x0000009B, 0x0000009C, 0x0000009D, 0x0000009E, 0x0000009F, 
+		0x000000A0, 0x00001E02, 0x00001E03, 0x000000A3, 0x0000010A, 0x0000010B, 0x00001E0A, 0x000000A7, 0x00001E80, 0x000000A9, 0x00001E82, 0x00001E0B, 0x00001EF2, 0x000000AD, 0x000000AE, 0x00000178, 
+		0x00001E1E, 0x00001E1F, 0x00000120, 0x00000121, 0x00001E40, 0x00001E41, 0x000000B6, 0x00001E56, 0x00001E81, 0x00001E57, 0x00001E83, 0x00001E60, 0x00001EF3, 0x00001E84, 0x00001E85, 0x00001E61, 
+		0x000000C0, 0x000000C1, 0x000000C2, 0x000000C3, 0x000000C4, 0x000000C5, 0x000000C6, 0x000000C7, 0x000000C8, 0x000000C9, 0x000000CA, 0x000000CB, 0x000000CC, 0x000000CD, 0x000000CE, 0x000000CF, 
+		0x00000174, 0x000000D1, 0x000000D2, 0x000000D3, 0x000000D4, 0x000000D5, 0x000000D6, 0x00001E6A, 0x000000D8, 0x000000D9, 0x000000DA, 0x000000DB, 0x000000DC, 0x000000DD, 0x00000176, 0x000000DF, 
+		0x000000E0, 0x000000E1, 0x000000E2, 0x000000E3, 0x000000E4, 0x000000E5, 0x000000E6, 0x000000E7, 0x000000E8, 0x000000E9, 0x000000EA, 0x000000EB, 0x000000EC, 0x000000ED, 0x000000EE, 0x000000EF, 
+		0x00000175, 0x000000F1, 0x000000F2, 0x000000F3, 0x000000F4, 0x000000F5, 0x000000F6, 0x00001E6B, 0x000000F8, 0x000000F9, 0x000000FA, 0x000000FB, 0x000000FC, 0x000000FD, 0x00000177, 0x000000FF
+	};
+
+	const int32_t TableIso8859_15[] = {
+		0x00000000, 0x00000001, 0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000006, 0x00000007, 0x00000008, 0x00000009, 0x0000000A, 0x0000000B, 0x0000000C, 0x0000000D, 0x0000000E, 0x0000000F, 
+		0x00000010, 0x00000011, 0x00000012, 0x00000013, 0x00000014, 0x00000015, 0x00000016, 0x00000017, 0x00000018, 0x00000019, 0x0000001A, 0x0000001B, 0x0000001C, 0x0000001D, 0x0000001E, 0x0000001F, 
+		0x00000020, 0x00000021, 0x00000022, 0x00000023, 0x00000024, 0x00000025, 0x00000026, 0x00000027, 0x00000028, 0x00000029, 0x0000002A, 0x0000002B, 0x0000002C, 0x0000002D, 0x0000002E, 0x0000002F, 
+		0x00000030, 0x00000031, 0x00000032, 0x00000033, 0x00000034, 0x00000035, 0x00000036, 0x00000037, 0x00000038, 0x00000039, 0x0000003A, 0x0000003B, 0x0000003C, 0x0000003D, 0x0000003E, 0x0000003F, 
+		0x00000040, 0x00000041, 0x00000042, 0x00000043, 0x00000044, 0x00000045, 0x00000046, 0x00000047, 0x00000048, 0x00000049, 0x0000004A, 0x0000004B, 0x0000004C, 0x0000004D, 0x0000004E, 0x0000004F, 
+		0x00000050, 0x00000051, 0x00000052, 0x00000053, 0x00000054, 0x00000055, 0x00000056, 0x00000057, 0x00000058, 0x00000059, 0x0000005A, 0x0000005B, 0x0000005C, 0x0000005D, 0x0000005E, 0x0000005F, 
+		0x00000060, 0x00000061, 0x00000062, 0x00000063, 0x00000064, 0x00000065, 0x00000066, 0x00000067, 0x00000068, 0x00000069, 0x0000006A, 0x0000006B, 0x0000006C, 0x0000006D, 0x0000006E, 0x0000006F, 
+		0x00000070, 0x00000071, 0x00000072, 0x00000073, 0x00000074, 0x00000075, 0x00000076, 0x00000077, 0x00000078, 0x00000079, 0x0000007A, 0x0000007B, 0x0000007C, 0x0000007D, 0x0000007E, 0x0000007F, 
+		0x00000080, 0x00000081, 0x00000082, 0x00000083, 0x00000084, 0x00000085, 0x00000086, 0x00000087, 0x00000088, 0x00000089, 0x0000008A, 0x0000008B, 0x0000008C, 0x0000008D, 0x0000008E, 0x0000008F, 
+		0x00000090, 0x00000091, 0x00000092, 0x00000093, 0x00000094, 0x00000095, 0x00000096, 0x00000097, 0x00000098, 0x00000099, 0x0000009A, 0x0000009B, 0x0000009C, 0x0000009D, 0x0000009E, 0x0000009F, 
+		0x000000A0, 0x000000A1, 0x000000A2, 0x000000A3, 0x000020AC, 0x000000A5, 0x00000160, 0x000000A7, 0x00000161, 0x000000A9, 0x000000AA, 0x000000AB, 0x000000AC, 0x000000AD, 0x000000AE, 0x000000AF, 
+		0x000000B0, 0x000000B1, 0x000000B2, 0x000000B3, 0x0000017D, 0x000000B5, 0x000000B6, 0x000000B7, 0x0000017E, 0x000000B9, 0x000000BA, 0x000000BB, 0x00000152, 0x00000153, 0x00000178, 0x000000BF, 
+		0x000000C0, 0x000000C1, 0x000000C2, 0x000000C3, 0x000000C4, 0x000000C5, 0x000000C6, 0x000000C7, 0x000000C8, 0x000000C9, 0x000000CA, 0x000000CB, 0x000000CC, 0x000000CD, 0x000000CE, 0x000000CF, 
+		0x000000D0, 0x000000D1, 0x000000D2, 0x000000D3, 0x000000D4, 0x000000D5, 0x000000D6, 0x000000D7, 0x000000D8, 0x000000D9, 0x000000DA, 0x000000DB, 0x000000DC, 0x000000DD, 0x000000DE, 0x000000DF, 
+		0x000000E0, 0x000000E1, 0x000000E2, 0x000000E3, 0x000000E4, 0x000000E5, 0x000000E6, 0x000000E7, 0x000000E8, 0x000000E9, 0x000000EA, 0x000000EB, 0x000000EC, 0x000000ED, 0x000000EE, 0x000000EF, 
+		0x000000F0, 0x000000F1, 0x000000F2, 0x000000F3, 0x000000F4, 0x000000F5, 0x000000F6, 0x000000F7, 0x000000F8, 0x000000F9, 0x000000FA, 0x000000FB, 0x000000FC, 0x000000FD, 0x000000FE, 0x000000FF
+	};
+
+
+
+
+
+
+
+
+
+
+
+	
+
+}
+

Sources/tools/charset/charsetTable.h

@@ -0,0 +1,51 @@
+/**
+ *******************************************************************************
+ * @file charsetTable.h
+ * @brief Editeur De N'ours : Table of all charset convertions (Header)
+ * @author Edouard DUPIN
+ * @date 06/06/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+#ifndef __CHARSET_TABLE_H__
+#define __CHARSET_TABLE_H__
+
+
+
+extern "C" {
+
+	extern const int32_t TableIso8859_1[];
+	extern const int32_t TableIso8859_2[];
+	extern const int32_t TableIso8859_3[];
+	extern const int32_t TableIso8859_4[];
+	extern const int32_t TableIso8859_5[];
+	extern const int32_t TableIso8859_6[];
+	extern const int32_t TableIso8859_7[];
+	extern const int32_t TableIso8859_8[];
+	extern const int32_t TableIso8859_9[];
+	extern const int32_t TableIso8859_10[];
+	extern const int32_t TableIso8859_11[];
+	extern const int32_t TableIso8859_13[];
+	extern const int32_t TableIso8859_14[];
+	extern const int32_t TableIso8859_15[];
+	
+	;
+}
+
+#endif

Sources/tools/debug/tools_debug.cpp

@@ -0,0 +1,62 @@
+/**
+ *******************************************************************************
+ * @file tools_debug.h
+ * @brief Editeur De N'ours : log implementation
+ * @author Edouard DUPIN
+ * @date 08/06/2010
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+#include "tools_debug.h"
+#include "time.h"
+
+// Max string size : (wide screan console nb caractere)
+#define EDN_LOG_MAX_LENGTH 250
+
+
+#define FUNCTION_NAME_SIZE	(50)
+
+void TOOLS_DisplayFuncName(int32_t ligne, const char* className, const char* funcName)
+{
+	char tmpName[FUNCTION_NAME_SIZE] = "";
+	if (NULL == className) {
+		snprintf(tmpName, FUNCTION_NAME_SIZE, "(l=%5d) %s                                             ",ligne, funcName);
+	} else {
+		snprintf(tmpName, FUNCTION_NAME_SIZE, "(l=%5d) %s::%s                                             ",ligne, className, funcName);
+	}
+	tmpName[FUNCTION_NAME_SIZE-4] = ' ';
+	tmpName[FUNCTION_NAME_SIZE-3] = '|';
+	tmpName[FUNCTION_NAME_SIZE-2] = ' ';
+	tmpName[FUNCTION_NAME_SIZE-1] = '\0';
+	std::cout << tmpName;
+}
+
+
+void TOOLS_DisplayTime(void)
+{
+	time_t rawtime;
+	struct tm * timeinfo;
+	char tmpdata[50];
+	
+	time ( &rawtime );
+	timeinfo = localtime ( &rawtime );
+	sprintf(tmpdata, " %2dh %2dmin %2ds | ", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
+	std::cout << tmpdata ;
+}
+

Sources/tools/debug/tools_debug.h

@@ -0,0 +1,155 @@
+/**
+ *******************************************************************************
+ * @file tools_debug.h
+ * @brief Editeur De N'ours : log implementation
+ * @author Edouard DUPIN
+ * @date 08/06/2010
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+ 
+#ifndef __TOOLS_DEBUG_H__
+#define __TOOLS_DEBUG_H__
+
+#include <iostream>
+#include "types_generique.h"
+
+// Log Message System For EDN
+void TOOLS_DisplayFuncName(int32_t ligne, const char* className, const char* funcName);
+void TOOLS_DisplayTime(void);
+
+//regular colors
+#define COLOR_BLACK				"\e[0;30m"
+#define COLOR_RED				"\e[0;31m"
+#define COLOR_GREEN				"\e[0;32m"
+#define COLOR_YELLOW			"\e[0;33m"
+#define COLOR_BLUE				"\e[0;34m"
+#define COLOR_MAGENTA			"\e[0;35m"
+#define COLOR_CYAN				"\e[0;36m"
+#define COLOR_WHITE				"\e[0;37m"
+//emphasized (bolded) colors
+#define COLOR_BOLD_BLACK		"\e[1;30m"
+#define COLOR_BOLD_RED			"\e[1;31m"
+#define COLOR_BOLD_GREEN		"\e[1;32m"
+#define COLOR_BOLD_YELLOW		"\e[1;33m"
+#define COLOR_BOLD_BLUE			"\e[1;34m"
+#define COLOR_BOLD_MAGENTA		"\e[1;35m"
+#define COLOR_BOLD_CYAN			"\e[1;36m"
+#define COLOR_BOLD_WHITE		"\e[1;37m"
+//background colors
+#define COLOR_BG_BLACK			"\e[40m"
+#define COLOR_BG_RED			"\e[41m"
+#define COLOR_BG_GREEN			"\e[42m"
+#define COLOR_BG_YELLOW			"\e[43m"
+#define COLOR_BG_BLUE			"\e[44m"
+#define COLOR_BG_MAGENTA		"\e[45m"
+#define COLOR_BG_CYAN			"\e[46m"
+#define COLOR_BG_WHITE			"\e[47m"
+// Return to the normal color setings
+#define COLOR_NORMAL			"\e[0m"
+//go to the Top of bash
+#define GO_TOP					"\e[0;0f"
+
+#undef  __class__
+#define __class__				(NULL)
+
+/*
+#define DEFINE_CLASS_NAME(name) 		#undef __class__		\
+										#define __class__	(#name)
+at the start of the class : 
+#undef __class__
+#define __class__	""
+*/
+
+#define EDN_DBG_COMMON(color, info, data)	do {													\
+												std::cout << color;									\
+												TOOLS_DisplayTime();								\
+												TOOLS_DisplayFuncName(__LINE__, __class__, __func__);			\
+												std::cout << "[" << info << "] " << data;			\
+												std::cout << COLOR_NORMAL <<std::endl;				\
+											}while(0)
+
+#define EDN_CRITICAL(data)				EDN_DBG_COMMON(COLOR_BOLD_RED, "CC", data)
+// General 
+#if EDN_DEBUG_LEVEL > 0
+#   define EDN_WARNING(data)			EDN_DBG_COMMON(COLOR_MAGENTA, "WW", data)
+#   define EDN_ERROR(data)				EDN_DBG_COMMON(COLOR_BOLD_RED, "EE", data)
+#else
+#	define EDN_WARNING(data)      do {}while(0)
+#	define EDN_ERROR(data)      do {}while(0)
+#endif
+
+#if EDN_DEBUG_LEVEL > 1
+#	define EDN_INFO(data)				EDN_DBG_COMMON(COLOR_CYAN, "II", data)
+#else
+#	define EDN_INFO(data)      do {}while(0)
+#endif
+
+#if EDN_DEBUG_LEVEL > 2
+#   define EDN_DEBUG(data)				EDN_DBG_COMMON(COLOR_YELLOW, "DD", data)
+#else
+#	define EDN_DEBUG(data)      do {}while(0)
+#endif
+
+
+
+#if EDN_DEBUG_LEVEL > 0
+#   define EDN_ASSERT(cond, format, ...)                                                    \
+        do {                                                                                  \
+            if (!(cond)) {                                                                    \
+                EDN_CRITICAL(format, ##__VA_ARGS__);   \
+                assert(!#cond);                                                               \
+            }                                                                                 \
+        } while (0)
+#else
+#   define EDN_ASSERT(cond, format, ...)            \
+        do {                                        \
+            assert(cond);                           \
+        } while (0)
+#endif
+
+#if EDN_DEBUG_LEVEL > 1
+#   define EDN_CHECK_INOUT(cond) EDN_ASSERT((cond), "Internal input error : "#cond)
+#elif EDN_DEBUG_LEVEL > 0
+//  Critical warning mode
+#   define EDN_CHECK_INOUT(cond)                             \
+        do {                                                   \
+            if (!(cond)) {                                     \
+                EDN_CRITICAL("Internal input error : "#cond);\
+            }                                                  \
+        } while (0)
+#else
+//  Default : No check
+#   define EDN_CHECK_INOUT(cond) do { } while (0)
+#endif
+
+
+// Enable or disable the magic element checking...
+#if EDN_DEBUG_LEVEL > 0
+    #define CHECK_MAGIC(cond)            EDN_ASSERT((cond), "MAGIC check error : "#cond)
+    #define EDN_ENABLE_CHECK_MAGIC     (1)
+#else
+    #define CHECK_MAGIC(cond)            do {}while(0)
+#endif
+
+
+
+
+
+
+#endif

Sources/tools/debug/types_generique.h

@@ -0,0 +1,87 @@
+/**
+ *******************************************************************************
+ * @file types_generique.h
+ * @brief Editeur De N'ours : generique define type
+ * @author Edouard DUPIN
+ * @date 08/06/2010
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+ 
+#ifndef __TOOLS_TYPES_GENERIQUE_H__
+#define __TOOLS_TYPES_GENERIQUE_H__
+
+// includes system, malloc, EXIT_SUCCESS
+#include <stdlib.h>
+// includes fopen, fwrite, fseek, ftell
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <assert.h>
+
+extern "C" {
+	// includes GDK_q
+	#include <gdk/gdkkeysyms.h>
+	#include <gtk/gtk.h>
+}
+
+
+
+#ifndef __int8_t_defined
+#   define __int8_t_defined
+    typedef   signed char                    int8_t;
+    typedef   signed short int               int16_t;
+    typedef   int                            int32_t;
+    typedef   signed long long int           int64_t;
+#endif
+
+typedef unsigned char                   uint8_t;
+typedef unsigned short int              uint16_t;
+typedef unsigned long int               uint32_t;
+typedef unsigned long long int          uint64_t;
+
+typedef  bool     BOOL;
+
+typedef enum {
+    ERR_NONE = 0,   //!< No error, luckily everything went fine
+    ERR_FAIL,       //!< Miscellaneous failure
+    ERR_INVAL,      //!< Invalid entry parameter
+    ERR_MEM,        //!< Dynamic memory allocation failure
+    ERR_TIMEOUT,    //!< Request time out
+    ERR_BUSY,       //!< Element curently Busy
+}erreurCode_te;
+
+
+#define edn_min(elemA, elemB)					((elemA)<(elemB)) ? (elemA) : (elemB)
+#define edn_max(elemA, elemB)					((elemA)<(elemB)) ? (elemB) : (elemA)
+#define edn_average(minimim, elem, maximum)		((minimim)>(elem)) ? (minimim) : ((maximum)<(elem)) ? (maximum) : (elem)
+
+
+
+
+
+typedef struct {
+	int32_t x;
+	int32_t y;
+} position_ts;
+
+
+
+#endif
+
+

Sources/tools/globals/tools_globals.cpp

@@ -0,0 +1,236 @@
+/**
+ *******************************************************************************
+ * @file tools_Globals.cpp
+ * @brief Editeur De N'ours : Globals Values
+ * @author Edouard DUPIN
+ * @date 05/12/2010
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+
+#include "tools_globals.h"
+#include "ColorizeManager.h"
+#include "MsgBroadcast.h"
+#include <string>
+
+#undef __class__
+#define __class__	"globals"
+
+// Variables privé du namespace
+
+static std::string curentFileName = "???";
+
+
+erreurCode_te globals::init(void)
+{
+	erreurCode_te ret = ERR_NONE;
+	
+
+	return ret;
+}
+
+
+
+// -----------------------------------------------------------
+static bool displayEOL = false;
+bool globals::IsSetDisplayEndOfLine(void)
+{
+	return displayEOL;
+}
+
+void globals::SetDisplayEndOfLine(bool newVal)
+{
+	EDN_INFO("Set EndOfLine " << newVal);
+	displayEOL = newVal;
+	GeneralSendMessage(EDN_MSG__REFRESH_DISPLAY);
+}
+
+// -----------------------------------------------------------
+static bool displaySpaceChar = true;
+bool globals::IsSetDisplaySpaceChar(void)
+{
+	return displaySpaceChar;
+}
+
+void globals::SetDisplaySpaceChar(bool newVal)
+{
+	EDN_INFO("Set SpaceChar " << newVal);
+	displaySpaceChar = newVal;
+	GeneralSendMessage(EDN_MSG__REFRESH_DISPLAY);
+}
+
+
+// -----------------------------------------------------------
+static bool AutoIndent = true;
+bool globals::IsSetAutoIndent(void)
+{
+	return AutoIndent;
+}
+
+void globals::SetAutoIndent(bool newVal)
+{
+	EDN_INFO("Set AutoIndent " << newVal);
+	AutoIndent = newVal;
+}
+
+// -----------------------------------------------------------
+
+
+
+
+int32_t globals::getNbColoneBorder(void)
+{
+	return 6;
+}
+
+int32_t globals::getNbLineBorder(void)
+{
+	return 3;
+}
+
+
+
+static bool shiftIsSet = false;
+void globals::SetShift(void)
+{
+	shiftIsSet = true;
+	EDN_INFO(" SHIFT => Set");
+}
+
+void globals::UnSetShift(void)
+{
+	shiftIsSet = false;
+	EDN_INFO(" SHIFT => UnSet");
+}
+
+bool globals::IsSetShift(void)
+{
+	return shiftIsSet;
+}
+
+
+
+static bool altIsSet = false;
+void globals::SetAlt(void)
+{
+	altIsSet = true;
+}
+
+void globals::UnSetAlt(void)
+{
+	altIsSet = false;
+}
+
+bool globals::IsSetAlt(void)
+{
+	return altIsSet;
+}
+
+
+static bool ctrlIsSet = false;
+void globals::SetCtrl(void)
+{
+	ctrlIsSet = true;
+}
+
+void globals::UnSetCtrl(void)
+{
+	ctrlIsSet = false;
+}
+
+bool globals::IsSetCtrl(void)
+{
+	return ctrlIsSet;
+}
+
+
+static bool pommeIsSet = false;
+void globals::SetPomme(void)
+{
+	pommeIsSet = true;
+}
+
+void globals::UnSetPomme(void)
+{
+	pommeIsSet = false;
+}
+
+bool globals::IsSetPomme(void)
+{
+	return pommeIsSet;
+}
+
+static bool insertIsSet = false;
+void globals::SetInsert(void)
+{
+	insertIsSet = true;
+}
+
+void globals::UnSetInsert(void)
+{
+	insertIsSet = false;
+}
+void globals::ToggleInsert(void)
+{
+	if (true==insertIsSet) {
+		insertIsSet = false;
+	} else {
+		insertIsSet = true;
+	}
+}
+
+bool globals::IsSetInsert(void)
+{
+	return insertIsSet;
+}
+
+
+
+
+/*
+ * Basic GUI system : 
+ *
+ *
+ *
+ *
+ */
+
+
+
+void globals::DisplaySystemString(std::vector<int32_t> &data)
+{
+	// Display the copyed data ... 
+	uint32_t i;
+	EDN_INFO("Display Data : ");
+	printf(" ========================================================\n");
+	for(i=0; i<data.size(); i++) {
+#		ifdef USE_GTK_VERSION_2_0
+		if (GDK_Return == data[i]) {
+#       elif USE_GTK_VERSION_3_0
+		if (GDK_KEY_Return == data[i]) {
+#       endif
+			printf("\n = ");
+		} else {
+			printf("%c", (char)data[i]);
+		}
+	}
+	printf("\n ========================================================\n");
+}
+
+
+

Sources/tools/globals/tools_globals.h

@@ -0,0 +1,71 @@
+/**
+ *******************************************************************************
+ * @file tools_globals.h
+ * @brief Editeur De N'ours : Globals Values (header)
+ * @author Edouard DUPIN
+ * @date 05/12/2010
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+ 
+#ifndef __TOOLS_GLOBALS_H__
+#define __TOOLS_GLOBALS_H__
+
+#include "tools_debug.h"
+#include <string>
+#include <vector>
+
+namespace globals
+{
+	erreurCode_te	init(void);
+	int32_t			getNbColoneBorder(void);
+	int32_t			getNbLineBorder(void);
+
+	bool    IsSetDisplayEndOfLine(void);
+	void    SetDisplayEndOfLine(bool newVal);
+	
+	bool    IsSetDisplaySpaceChar(void);
+	void    SetDisplaySpaceChar(bool newVal);
+	
+	bool    IsSetAutoIndent(void);
+	void    SetAutoIndent(bool newVal);
+
+	void			init2(void);
+
+	void	SetShift(void);
+	void	UnSetShift(void);
+	bool	IsSetShift(void);
+	void	SetAlt(void);
+	void	UnSetAlt(void);
+	bool	IsSetAlt(void);
+	void	SetCtrl(void);
+	void	UnSetCtrl(void);
+	bool	IsSetCtrl(void);
+	void	SetPomme(void);
+	void	UnSetPomme(void);
+	bool	IsSetPomme(void);
+	void	SetInsert(void);
+	void	UnSetInsert(void);
+	void	ToggleInsert(void);
+	bool	IsSetInsert(void);
+	void	DisplaySystemString(std::vector<int32_t> &data);
+}
+
+#endif
+
+

Sources/tools/memory/toolsMemory.h

@@ -0,0 +1,93 @@
+/**
+ *******************************************************************************
+ * @file toolsmemory.h
+ * @brief Editeur De N'ours : Memory implementation (headers)
+ * @author Edouard DUPIN
+ * @date 12/01/2011
+ * @par Project
+ * Edn
+ *
+ * @par Copyright
+ * Copyright 2010 Edouard DUPIN, all right reserved
+ *
+ * This software is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY.
+ *
+ * Licence summary : 
+ *    You can modify and redistribute the sources code and binaries.
+ *    You can send me the bug-fix
+ *    You can not earn money with this Software (if the source extract from Edn
+ *        represent less than 50% of original Sources)
+ * Term of the licence in in the file licence.txt.
+ *
+ *******************************************************************************
+ */
+ 
+#ifndef __TOOLS_MEMORY_H__
+#define __TOOLS_MEMORY_H__
+
+
+
+// General 
+#if EDN_MEMORY_CHECKER > 0
+    void EDN_MemFree( void * pointerData, const char * variableName, const char * functionName, int32_t line, const char * fileName );
+    void * EDN_MemMalloc( size_t num, size_t size, uint8_t init, const char * variableName, const char * functionName, int32_t line, const char * fileName );
+    void EDN_MemShowLogs( void );
+#   define EDN_MALLOC(pointerData, nbElements, dataType)              do {                                                                                                                                \
+                                                                            pointerData = (dataType *)EDN_MemMalloc( (nbElements), sizeof(dataType), 0, #pointerData, __func__, __LINE__, __FILE__);    \
+                                                                        }while(0)
+#   define EDN_MALLOC_CAST(pointerData, nbElements, dataType, cast)   do {                                                                                                                                \
+                                                                            pointerData = (cast)EDN_MemMalloc( (nbElements), sizeof(dataType), 0, #pointerData, __func__, __LINE__, __FILE__);            \
+                                                                        }while(0)
+#   define EDN_CALLOC(pointerData, nbElements, dataType)              do {                                                                                                                                \
+                                                                            pointerData = (dataType *)EDN_MemMalloc( (nbElements), sizeof(dataType), 1, #pointerData, __func__, __LINE__, __FILE__);    \
+                                                                        }while(0)
+#   define EDN_CALLOC_CAST(pointerData, nbElements, dataType, cast)   do {                                                                                                                                \
+                                                                            pointerData = (cast)EDN_MemMalloc( (nbElements), sizeof(dataType), 1, #pointerData, __func__, __LINE__, __FILE__);            \
+                                                                        }while(0)
+#   define EDN_FREE(pointerData)                                      do {                                                                            \
+                                                                            EDN_MemFree( (pointerData) , #pointerData, __func__, __LINE__, __FILE__); \
+                                                                            (pointerData) = NULL;                                                       \
+                                                                        }while(0)
+#   define EDN_MEM_SHOW_LOG()                                         do {                                                                            \
+                                                                            EDN_MemShowLogs();                                                        \
+                                                                        }while(0)
+#else
+
+#	define EDN_MALLOC(pointerData, nbElements, dataType)					do {																		\
+																				(pointerData) = (dataType *)malloc( (nbElements) * sizeof(dataType) );	\
+																			}while(0)
+
+#	define EDN_MALLOC_CAST(pointerData, nbElements, dataType, cast)		do {																	\
+																				(pointerData) = (cast)malloc( (nbElements) * sizeof(dataType) );	\
+																			}while(0)
+
+#	define EDN_CALLOC(pointerData, nbElements, dataType)					do {																		\
+																				(pointerData) = (dataType *)calloc( (nbElements), sizeof(dataType) );	\
+																			}while(0)
+
+#	define EDN_CALLOC_CAST(pointerData, nbElements, dataType, cast)		do {																\
+																				(pointerData) = (cast)calloc( (nbElements), sizeof(dataType) );	\
+																			}while(0)
+
+#	define EDN_REALLOC(pointerData, nbElements, dataType)					do {																						\
+																				(pointerData) = (dataType *)realloc( (pointerData), (nbElements)* sizeof(dataType) );	\
+																			}while(0)
+
+#	define EDN_REALLOC_CAST(pointerData, nbElements, dataType, cast)		do {																					\
+																				(pointerData) = (cast)realloc( (pointerData), (nbElements) * sizeof(dataType) );	\
+																			}while(0)
+
+#	define EDN_FREE(pointerData)	do {						\
+										free( pointerData );	\
+										(pointerData) = NULL;	\
+									}while(0)
+
+#	define EDN_MEM_SHOW_LOG()		do {													\
+										sup_system_diag("No Memory check availlable");		\
+									}while(0)
+#endif
+
+
+#endif
+

Sources/tools/tinyXML/tinystr.cpp

@@ -0,0 +1,116 @@
+/*
+www.sourceforge.net/projects/tinyxml
+Original file by Yves Berquin.
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+*/
+
+/*
+ * THIS FILE WAS ALTERED BY Tyge L<>vset, 7. April 2005.
+ */
+
+
+#ifndef TIXML_USE_STL
+
+#include "tinystr.h"
+
+// Error value for find primitive
+const TiXmlString::size_type TiXmlString::npos = static_cast< TiXmlString::size_type >(-1);
+
+
+// Null rep.
+TiXmlString::Rep TiXmlString::nullrep_ = { 0, 0, { '\0' } };
+
+
+void TiXmlString::reserve (size_type cap)
+{
+	if (cap > capacity())
+	{
+		TiXmlString tmp;
+		tmp.init(length(), cap);
+		memcpy(tmp.start(), data(), length());
+		swap(tmp);
+	}
+}
+
+
+TiXmlString& TiXmlString::assign(const char* str, size_type len)
+{
+	size_type cap = capacity();
+	if (len > cap || cap > 3*(len + 8))
+	{
+		TiXmlString tmp;
+		tmp.init(len);
+		memcpy(tmp.start(), str, len);
+		swap(tmp);
+	}
+	else
+	{
+		memmove(start(), str, len);
+		set_size(len);
+	}
+	return *this;
+}
+
+
+TiXmlString& TiXmlString::append(const char* str, size_type len)
+{
+	size_type newsize = length() + len;
+	if (newsize > capacity())
+	{
+		reserve (newsize + capacity());
+	}
+	memmove(finish(), str, len);
+	set_size(newsize);
+	return *this;
+}
+
+
+TiXmlString operator + (const TiXmlString & a, const TiXmlString & b)
+{
+	TiXmlString tmp;
+	tmp.reserve(a.length() + b.length());
+	tmp += a;
+	tmp += b;
+	return tmp;
+}
+
+TiXmlString operator + (const TiXmlString & a, const char* b)
+{
+	TiXmlString tmp;
+	TiXmlString::size_type b_len = static_cast<TiXmlString::size_type>( strlen(b) );
+	tmp.reserve(a.length() + b_len);
+	tmp += a;
+	tmp.append(b, b_len);
+	return tmp;
+}
+
+TiXmlString operator + (const char* a, const TiXmlString & b)
+{
+	TiXmlString tmp;
+	TiXmlString::size_type a_len = static_cast<TiXmlString::size_type>( strlen(a) );
+	tmp.reserve(a_len + b.length());
+	tmp.append(a, a_len);
+	tmp += b;
+	return tmp;
+}
+
+
+#endif	// TIXML_USE_STL

Sources/tools/tinyXML/tinystr.h

@@ -0,0 +1,319 @@
+/*
+www.sourceforge.net/projects/tinyxml
+Original file by Yves Berquin.
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+*/
+
+/*
+ * THIS FILE WAS ALTERED BY Tyge Lovset, 7. April 2005.
+ *
+ * - completely rewritten. compact, clean, and fast implementation.
+ * - sizeof(TiXmlString) = pointer size (4 bytes on 32-bit systems)
+ * - fixed reserve() to work as per specification.
+ * - fixed buggy compares operator==(), operator<(), and operator>()
+ * - fixed operator+=() to take a const ref argument, following spec.
+ * - added "copy" constructor with length, and most compare operators.
+ * - added swap(), clear(), size(), capacity(), operator+().
+ */
+
+#ifndef TIXML_USE_STL
+
+#ifndef TIXML_STRING_INCLUDED
+#define TIXML_STRING_INCLUDED
+
+#include <assert.h>
+#include <string.h>
+
+/*	The support for explicit isn't that universal, and it isn't really
+	required - it is used to check that the TiXmlString class isn't incorrectly
+	used. Be nice to old compilers and macro it here:
+*/
+#if defined(_MSC_VER) && (_MSC_VER >= 1200 )
+	// Microsoft visual studio, version 6 and higher.
+	#define TIXML_EXPLICIT explicit
+#elif defined(__GNUC__) && (__GNUC__ >= 3 )
+	// GCC version 3 and higher.s
+	#define TIXML_EXPLICIT explicit
+#else
+	#define TIXML_EXPLICIT
+#endif
+
+
+/*
+   TiXmlString is an emulation of a subset of the std::string template.
+   Its purpose is to allow compiling TinyXML on compilers with no or poor STL support.
+   Only the member functions relevant to the TinyXML project have been implemented.
+   The buffer allocation is made by a simplistic power of 2 like mechanism : if we increase
+   a string and there's no more room, we allocate a buffer twice as big as we need.
+*/
+class TiXmlString
+{
+  public :
+	// The size type used
+  	typedef size_t size_type;
+
+	// Error value for find primitive
+	static const size_type npos; // = -1;
+
+
+	// TiXmlString empty constructor
+	TiXmlString () : rep_(&nullrep_)
+	{
+	}
+
+	// TiXmlString copy constructor
+	TiXmlString ( const TiXmlString & copy) : rep_(0)
+	{
+		init(copy.length());
+		memcpy(start(), copy.data(), length());
+	}
+
+	// TiXmlString constructor, based on a string
+	TIXML_EXPLICIT TiXmlString ( const char * copy) : rep_(0)
+	{
+		init( static_cast<size_type>( strlen(copy) ));
+		memcpy(start(), copy, length());
+	}
+
+	// TiXmlString constructor, based on a string
+	TIXML_EXPLICIT TiXmlString ( const char * str, size_type len) : rep_(0)
+	{
+		init(len);
+		memcpy(start(), str, len);
+	}
+
+	// TiXmlString destructor
+	~TiXmlString ()
+	{
+		quit();
+	}
+
+	// = operator
+	TiXmlString& operator = (const char * copy)
+	{
+		return assign( copy, (size_type)strlen(copy));
+	}
+
+	// = operator
+	TiXmlString& operator = (const TiXmlString & copy)
+	{
+		return assign(copy.start(), copy.length());
+	}
+
+
+	// += operator. Maps to append
+	TiXmlString& operator += (const char * suffix)
+	{
+		return append(suffix, static_cast<size_type>( strlen(suffix) ));
+	}
+
+	// += operator. Maps to append
+	TiXmlString& operator += (char single)
+	{
+		return append(&single, 1);
+	}
+
+	// += operator. Maps to append
+	TiXmlString& operator += (const TiXmlString & suffix)
+	{
+		return append(suffix.data(), suffix.length());
+	}
+
+
+	// Convert a TiXmlString into a null-terminated char *
+	const char * c_str () const { return rep_->str; }
+
+	// Convert a TiXmlString into a char * (need not be null terminated).
+	const char * data () const { return rep_->str; }
+
+	// Return the length of a TiXmlString
+	size_type length () const { return rep_->size; }
+
+	// Alias for length()
+	size_type size () const { return rep_->size; }
+
+	// Checks if a TiXmlString is empty
+	bool empty () const { return rep_->size == 0; }
+
+	// Return capacity of string
+	size_type capacity () const { return rep_->capacity; }
+
+
+	// single char extraction
+	const char& at (size_type index) const
+	{
+		assert( index < length() );
+		return rep_->str[ index ];
+	}
+
+	// [] operator
+	char& operator [] (size_type index) const
+	{
+		assert( index < length() );
+		return rep_->str[ index ];
+	}
+
+	// find a char in a string. Return TiXmlString::npos if not found
+	size_type find (char lookup) const
+	{
+		return find(lookup, 0);
+	}
+
+	// find a char in a string from an offset. Return TiXmlString::npos if not found
+	size_type find (char tofind, size_type offset) const
+	{
+		if (offset >= length()) return npos;
+
+		for (const char* p = c_str() + offset; *p != '\0'; ++p)
+		{
+		   if (*p == tofind) return static_cast< size_type >( p - c_str() );
+		}
+		return npos;
+	}
+
+	void clear ()
+	{
+		//Lee:
+		//The original was just too strange, though correct:
+		//	TiXmlString().swap(*this);
+		//Instead use the quit & re-init:
+		quit();
+		init(0,0);
+	}
+
+	/*	Function to reserve a big amount of data when we know we'll need it. Be aware that this
+		function DOES NOT clear the content of the TiXmlString if any exists.
+	*/
+	void reserve (size_type cap);
+
+	TiXmlString& assign (const char* str, size_type len);
+
+	TiXmlString& append (const char* str, size_type len);
+
+	void swap (TiXmlString& other)
+	{
+		Rep* r = rep_;
+		rep_ = other.rep_;
+		other.rep_ = r;
+	}
+
+  private:
+
+	void init(size_type sz) { init(sz, sz); }
+	void set_size(size_type sz) { rep_->str[ rep_->size = sz ] = '\0'; }
+	char* start() const { return rep_->str; }
+	char* finish() const { return rep_->str + rep_->size; }
+
+	struct Rep
+	{
+		size_type size, capacity;
+		char str[1];
+	};
+
+	void init(size_type sz, size_type cap)
+	{
+		if (cap)
+		{
+			// Lee: the original form:
+			//	rep_ = static_cast<Rep*>(operator new(sizeof(Rep) + cap));
+			// doesn't work in some cases of new being overloaded. Switching
+			// to the normal allocation, although use an 'int' for systems
+			// that are overly picky about structure alignment.
+			const size_type bytesNeeded = sizeof(Rep) + cap;
+			const size_type intsNeeded = ( bytesNeeded + sizeof(int) - 1 ) / sizeof( int ); 
+			rep_ = reinterpret_cast<Rep*>( new int[ intsNeeded ] );
+
+			rep_->str[ rep_->size = sz ] = '\0';
+			rep_->capacity = cap;
+		}
+		else
+		{
+			rep_ = &nullrep_;
+		}
+	}
+
+	void quit()
+	{
+		if (rep_ != &nullrep_)
+		{
+			// The rep_ is really an array of ints. (see the allocator, above).
+			// Cast it back before delete, so the compiler won't incorrectly call destructors.
+			delete [] ( reinterpret_cast<int*>( rep_ ) );
+		}
+	}
+
+	Rep * rep_;
+	static Rep nullrep_;
+
+} ;
+
+
+inline bool operator == (const TiXmlString & a, const TiXmlString & b)
+{
+	return    ( a.length() == b.length() )				// optimization on some platforms
+	       && ( strcmp(a.c_str(), b.c_str()) == 0 );	// actual compare
+}
+inline bool operator < (const TiXmlString & a, const TiXmlString & b)
+{
+	return strcmp(a.c_str(), b.c_str()) < 0;
+}
+
+inline bool operator != (const TiXmlString & a, const TiXmlString & b) { return !(a == b); }
+inline bool operator >  (const TiXmlString & a, const TiXmlString & b) { return b < a; }
+inline bool operator <= (const TiXmlString & a, const TiXmlString & b) { return !(b < a); }
+inline bool operator >= (const TiXmlString & a, const TiXmlString & b) { return !(a < b); }
+
+inline bool operator == (const TiXmlString & a, const char* b) { return strcmp(a.c_str(), b) == 0; }
+inline bool operator == (const char* a, const TiXmlString & b) { return b == a; }
+inline bool operator != (const TiXmlString & a, const char* b) { return !(a == b); }
+inline bool operator != (const char* a, const TiXmlString & b) { return !(b == a); }
+
+TiXmlString operator + (const TiXmlString & a, const TiXmlString & b);
+TiXmlString operator + (const TiXmlString & a, const char* b);
+TiXmlString operator + (const char* a, const TiXmlString & b);
+
+
+/*
+   TiXmlOutStream is an emulation of std::ostream. It is based on TiXmlString.
+   Only the operators that we need for TinyXML have been developped.
+*/
+class TiXmlOutStream : public TiXmlString
+{
+public :
+
+	// TiXmlOutStream << operator.
+	TiXmlOutStream & operator << (const TiXmlString & in)
+	{
+		*this += in;
+		return *this;
+	}
+
+	// TiXmlOutStream << operator.
+	TiXmlOutStream & operator << (const char * in)
+	{
+		*this += in;
+		return *this;
+	}
+
+} ;
+
+#endif	// TIXML_STRING_INCLUDED
+#endif	// TIXML_USE_STL

Sources/tools/tinyXML/tinyxmlerror.cpp

@@ -0,0 +1,52 @@
+/*
+www.sourceforge.net/projects/tinyxml
+Original code (2.0 and earlier )copyright (c) 2000-2006 Lee Thomason (www.grinninglizard.com)
+
+This software is provided 'as-is', without any express or implied 
+warranty. In no event will the authors be held liable for any 
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any 
+purpose, including commercial applications, and to alter it and 
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+*/
+
+#include "tinyxml.h"
+
+// The goal of the seperate error file is to make the first
+// step towards localization. tinyxml (currently) only supports
+// english error messages, but the could now be translated.
+//
+// It also cleans up the code a bit.
+//
+
+const char* TiXmlBase::errorString[ TIXML_ERROR_STRING_COUNT ] =
+{
+	"No error",
+	"Error",
+	"Failed to open file",
+	"Error parsing Element.",
+	"Failed to read Element name",
+	"Error reading Element value.",
+	"Error reading Attributes.",
+	"Error: empty tag.",
+	"Error reading end tag.",
+	"Error parsing Unknown.",
+	"Error parsing Comment.",
+	"Error parsing Declaration.",
+	"Error document empty.",
+	"Error null (0) or unexpected EOF found in input stream.",
+	"Error parsing CDATA.",
+	"Error when TiXmlDocument added to document, because TiXmlDocument can only be at the root.",
+};