Reorganise the internal data of this repository

Sources/appl/Buffer/Buffer.cpp

@@ -0,0 +1,136 @@
+/**
+ *******************************************************************************
+ * @file Buffer.c
+ * @brief Editeur De N'ours : Text Buffer 
+ * @author Edouard DUPIN
+ * @date 08/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 <appl/Debug.h>
+#include <appl/global.h>
+#include <Buffer.h>
+#include <BufferManager.h>
+#include <ewol/EObject.h>
+
+#undef __class__
+#define __class__	"Buffer"
+
+/**
+ * @brief
+ *
+ * @param[in,out] ---
+ *
+ * @return ---
+ *
+ */
+Buffer::Buffer()
+{
+	static int32_t fileBasicID = 0;
+	m_updatePositionRequested = false;
+	m_fileModify = true;
+	m_haveName = false;
+	etk::UString mString = "Untitle - ";
+	mString += fileBasicID++;
+	SetFileName(mString);
+	m_haveName = false;
+}
+
+/**
+ * @brief
+ *
+ * @param[in,out] ---
+ *
+ * @return ---
+ *
+ */
+Buffer::Buffer(etk::File &newName)
+{
+	m_fileModify = false;
+	SetFileName(newName);
+}
+
+/**
+ * @brief
+ *
+ * @param[in,out] ---
+ *
+ * @return ---
+ *
+ */
+Buffer::~Buffer(void)
+{
+
+}
+/**
+ * @brief
+ *
+ * @param[in,out] ---
+ *
+ * @return ---
+ *
+ */
+bool Buffer::IsModify(void)
+{
+	return m_fileModify;
+}
+
+void Buffer::SetModify(bool status)
+{
+	if (status != m_fileModify) {
+		m_fileModify = status;
+		// TODO : Remove from here
+		etk::UString data = "Modify";
+		ewol::EObjectMessageMultiCast::AnonymousSend(ednMsgBufferState, data);
+	}
+}
+
+
+/**
+ * @brief
+ *
+ * @param[in,out] ---
+ *
+ * @return ---
+ *
+ */
+bool Buffer::NeedToUpdateDisplayPosition(void)
+{
+	bool tmpVal = m_updatePositionRequested;
+	m_updatePositionRequested = false;
+	return tmpVal;
+}
+
+Vector2D<float>  Buffer::GetBorderSize(void)
+{
+	Vector2D<float>  tmpVal;
+	tmpVal.x = 30;
+	tmpVal.y = 30;
+	return tmpVal;
+}
+
+
+Vector2D<float>  Buffer::GetPosition(int32_t fontId,bool& centerRequested)
+{
+	centerRequested = false;
+	Vector2D<float>  tmpVal;
+	tmpVal.x = 0;
+	tmpVal.y = 0;
+	return tmpVal;
+}

Sources/appl/Buffer/Buffer.h

@@ -0,0 +1,139 @@
+/**
+ *******************************************************************************
+ * @file Buffer.h
+ * @brief Editeur De N'ours : Text Buffer (header)
+ * @author Edouard DUPIN
+ * @date 08/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 __BUFFER_H__
+#define __BUFFER_H__
+
+#include <etk/UString.h>
+#include <etk/File.h>
+#include <etk/unicode.h>
+#include <ewol/ewol.h>
+
+
+typedef struct{
+	uint32_t nbTotalLine;				//!< Number of line in the buffer
+	uint32_t nbTotalColomn;				//!< Number of line in the buffer
+	uint32_t startLineDisplay;			//!< First line display.
+	uint32_t startColomnDisplay;		//!< First Colomn displayed
+	uint32_t diplayableColomn;			//!< NB colomn that can be displayed
+	uint32_t diplayableLine;			//!< NB Line that can be displayed
+}infoStatBuffer_ts;
+
+
+class Buffer {
+	public:
+		                  Buffer(void);
+		                  Buffer(etk::File &newName);
+		virtual          ~Buffer(void);
+		
+		etk::File         GetFileName(void)
+		{
+			return m_fileName;
+		};
+		
+		void              SetFileName(etk::File &newName)
+		{
+			m_fileName = newName;
+			m_haveName = true;
+			NameChange();
+		};
+		
+		void              SetFileName(etk::UString &newName)
+		{
+			m_fileName.SetCompleateName(newName, etk::FILE_TYPE_DIRECT);
+			m_haveName = true;
+			NameChange();
+		};
+		
+		bool              HaveName(void)
+		{
+			return m_haveName;
+		}
+		
+		virtual void      Save(void) {};
+				bool      IsModify(void);
+	protected:
+				void      SetModify(bool status);
+		virtual void      NameChange(void) { /*APPL_DEBUG("check name change ==> no HL change possible");*/};
+	public:
+		virtual void      GetInfo(infoStatBuffer_ts &infoToUpdate) {};
+		virtual void      SetLineDisplay(uint32_t lineNumber) {};
+		
+		virtual int32_t   Display(ewol::OObject2DTextColored& OOTextNormal,
+		                          ewol::OObject2DTextColored& OOTextBold,
+		                          ewol::OObject2DTextColored& OOTextItalic,
+		                          ewol::OObject2DTextColored& OOTextBoldItalic,
+		                          ewol::OObject2DColored& OOColored, int32_t offsetX, int32_t offsetY, int32_t sizeX, int32_t sizeY)
+		{
+			return ERR_NONE;
+		}
+		virtual void      AddChar(uniChar_t unicodeData) {};
+		virtual void      cursorMove(ewol::eventKbMoveType_te moveTypeEvent) {};
+		virtual void      MouseSelectFromCursorTo(int32_t fontId, int32_t width, int32_t height) {};
+		virtual void      MouseEvent(int32_t fontId, int32_t width, int32_t height) {};
+		virtual void      MouseEventDouble(void) {};
+		virtual void      MouseEventTriple(void) {};
+		virtual void      RemoveLine(void) {};
+		virtual void      SelectAll(void) {};
+		virtual void      SelectNone(void) {};
+		virtual void      Undo(void) {};
+		virtual void      Redo(void) {};
+		virtual void      SetCharset(unicode::charset_te newCharset) {};
+
+		//virtual void	SelectAll(void);
+		virtual void      Copy(int8_t clipboardID) {};
+		virtual void      Cut(int8_t clipboardID) {};
+		virtual void      Paste(int8_t clipboardID) {};
+		virtual void      Search(etk::UString &data, bool back, bool caseSensitive, bool wrap, bool regExp) {};
+		virtual void      Replace(etk::UString &data) {};
+		virtual int32_t   FindLine(etk::UString &data) { return 0; };
+		virtual void      JumpAtLine(int32_t newLine) {};
+		virtual int32_t   GetCurrentLine(void) { return 0; };
+		
+		virtual int32_t   GetNumberOfLine(void) { return 1; };
+		
+		// moving with cursor change position:
+	private:
+		bool       m_updatePositionRequested; //!< if a position xhange in the windows ...
+		Vector2D<float>  m_maximumSize;             //!< current maxSize of the buffer
+	protected:
+		void RequestUpdateOfThePosition(void) { m_updatePositionRequested = true; };
+		void SetMaximumSize(Vector2D<float>  maxSize) { m_maximumSize = maxSize; };
+	public:
+		bool                NeedToUpdateDisplayPosition(void);
+		virtual Vector2D<float>   GetBorderSize(void);               // this is to requested the minimum size for the buffer that is not consider as visible ...
+		virtual Vector2D<float>   GetPosition(int32_t fontId, bool& centerRequested);
+		Vector2D<float>           GetMaxSize(void) { return m_maximumSize; };
+	protected:
+		bool              m_fileModify;           //!< 
+		// naming
+		etk::File         m_fileName;             //!< filename of the curent buffer
+		bool              m_haveName;             //!< to know if the file have a name or NOT
+};
+
+
+#endif
+
+

Sources/appl/Buffer/BufferEmpty.cpp

@@ -0,0 +1,104 @@
+/**
+ *******************************************************************************
+ * @file BufferEmpty.cpp
+ * @brief Editeur De N'ours : Text Buffer (edit For No buffer Display)
+ * @author Edouard DUPIN
+ * @date 19/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 <appl/Debug.h>
+#include <appl/global.h>
+#include <BufferEmpty.h>
+#include <ColorizeManager.h>
+#include <MainWindows.h>
+
+#undef __class__
+#define __class__	"BufferEmpty"
+
+/**
+ * @brief
+ *
+ * @param[in,out] ---
+ *
+ * @return ---
+ *
+ */
+BufferEmpty::BufferEmpty()
+{
+
+}
+
+/**
+ * @brief
+ *
+ * @param[in,out] ---
+ *
+ * @return ---
+ *
+ */
+BufferEmpty::~BufferEmpty(void)
+{
+
+}
+
+
+/**
+ * @brief
+ *
+ * @param[in,out] ---
+ *
+ * @return ---
+ *
+ */
+int32_t BufferEmpty::Display(ewol::OObject2DTextColored& OOTextNormal,
+                             ewol::OObject2DTextColored& OOTextBold,
+                             ewol::OObject2DTextColored& OOTextItalic,
+                             ewol::OObject2DTextColored& OOTextBoldItalic,
+                             ewol::OObject2DColored& OOColored, int32_t offsetX, int32_t offsetY, int32_t sizeX, int32_t sizeY)
+{
+	// Get color : 
+	Colorize	*myColor = NULL;
+	
+	int32_t fontId = OOTextNormal.GetFontID();
+	int32_t letterHeight = ewol::GetHeight(fontId);
+	
+	Vector2D<float>  textPos;
+	textPos.x = 20;
+	textPos.y = sizeY - 20 - letterHeight;
+	
+	myColor = ColorizeManager::Get("normal");
+	OOTextBold.SetColor(myColor->GetFG());
+	etk::UString tmpDisplay = "edn - Editeur De N'ours";
+	OOTextBold.Text(textPos, tmpDisplay);
+	
+	myColor = ColorizeManager::Get("commentDoxygen");
+	OOTextNormal.SetColor(myColor->GetFG());
+	textPos.y = (int32_t)(textPos.y - letterHeight*1.30);
+	tmpDisplay = "No Buffer Availlable to display";
+	OOTextNormal.Text(textPos, tmpDisplay);
+	
+	OOColored.SetColor(etk::color::white);
+	OOColored.Rectangle( 0, 0, sizeX, sizeY);
+	
+	return ERR_NONE;
+}
+
+
+

Sources/appl/Buffer/BufferEmpty.h

@@ -0,0 +1,46 @@
+/**
+ *******************************************************************************
+ * @file BufferEmpty.h
+ * @brief Editeur De N'ours : Text Buffer (edit For No buffer Display) (header)
+ * @author Edouard DUPIN
+ * @date 19/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 __BUFFER_EMPTY_H__
+#define __BUFFER_EMPTY_H__
+
+#include <Buffer.h>
+
+class BufferEmpty : public Buffer {
+	public:
+		BufferEmpty(void);
+		virtual ~BufferEmpty(void);
+		int32_t Display(ewol::OObject2DTextColored& OOTextNormal,
+		                ewol::OObject2DTextColored& OOTextBold,
+		                ewol::OObject2DTextColored& OOTextItalic,
+		                ewol::OObject2DTextColored& OOTextBoldItalic,
+		                ewol::OObject2DColored& OOColored, int32_t offsetX, int32_t offsetY, int32_t sizeX, int32_t sizeY);
+
+};
+
+
+#endif
+
+

Sources/appl/Buffer/BufferManager.cpp

@@ -0,0 +1,608 @@
+/**
+ *******************************************************************************
+ * @file BufferManager.cpp
+ * @brief Editeur De N'ours : Text Buffer manager (sources)
+ * @author Edouard DUPIN
+ * @date 08/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 <appl/Debug.h>
+#include <appl/global.h>
+#include <BufferManager.h>
+#include <ewol/EObject.h>
+#include <ewol/EObjectManager.h>
+
+#undef __class__
+#define __class__	"classBufferManager"
+
+class classBufferManager: public ewol::EObject
+{
+	public:
+		// Constructeur
+		classBufferManager(void);
+		~classBufferManager(void);
+		/**
+		 * @brief Get the current Object type of the EObject
+		 * @note In Embended platforme, it is many time no -rtti flag, then it is not possible to use dynamic cast ==> this will replace it
+		 * @param[in] objectType type description
+		 * @return true if the object is compatible, otherwise false
+		 */
+		const char * const GetObjectType(void)
+		{
+			return "ApplBufferManager";
+		}
+	public:
+		/**
+		 * @brief Receive a message from an other EObject with a specific eventId and data
+		 * @param[in] CallerObject Pointer on the EObject that information came from
+		 * @param[in] eventId Message registered by this class
+		 * @param[in] data Data registered by this class
+		 * @return ---
+		 */
+		virtual void OnReceiveMessage(ewol::EObject * CallerObject, const char * eventId, etk::UString data);
+	private:
+		// return the ID of the buffer allocated
+		// create a buffer with no element
+		int32_t     Create(void);
+		// open curent filename
+		int32_t     Open(etk::File &myFile);
+		bool        Remove(int32_t BufferID);
+	public:
+		int32_t     GetSelected(void) { return m_idSelected;};
+		//void        SetSelected(int32_t id) {m_idSelected = id;};
+		Buffer *    Get(int32_t BufferID);
+		bool        Exist(int32_t BufferID);
+		bool        Exist(etk::File &myFile);
+		int32_t     GetId(etk::File &myFile);
+		// return the number of buffer (open in the past) if 5 buffer open and 4 close ==> return 5
+		uint32_t    Size(void);
+		uint32_t    SizeOpen(void);
+		int32_t     WitchBuffer(int32_t iEmeElement);
+		
+
+	private:
+		
+		etk::Vector<Buffer*> listBuffer;  //!< element List of the char Elements
+		
+		void        RemoveAll(void);          //!< remove all buffer
+		int32_t     m_idSelected;
+		Buffer *    BufferNotExiste;          //!< When an error arrive in get buffer we return the Error buffer (not writable)
+};
+
+
+// Constructeur
+/**
+ * @brief
+ *
+ * @param[in,out] ---
+ *
+ * @return ---
+ *
+ */
+classBufferManager::classBufferManager(void)
+{
+	// nothing to do ...
+	BufferNotExiste = new BufferEmpty();
+	m_idSelected = -1;
+	RegisterMultiCast(ednMsgGuiNew);
+	RegisterMultiCast(ednMsgOpenFile);
+	RegisterMultiCast(ednMsgGuiClose);
+	RegisterMultiCast(ednMsgGuiSave);
+	RegisterMultiCast(ednMsgCodeViewSelectedId);
+	RegisterMultiCast(ednMsgBufferId);
+}
+
+/**
+ * @brief
+ *
+ * @param[in,out] ---
+ *
+ * @return ---
+ *
+ */
+classBufferManager::~classBufferManager(void)
+{
+	//clean All Buffer
+	APPL_INFO("~classBufferManager::RemoveAll();");
+	RemoveAll();
+	// clear The list of Buffer
+	APPL_INFO("~classBufferManager::listBuffer.Clear();");
+	listBuffer.Clear();
+	APPL_INFO("~classBufferManager::delete(BufferNotExiste);");
+	delete(BufferNotExiste);
+}
+
+
+/**
+ * @brief Receive a message from an other EObject with a specific eventId and data
+ * @param[in] CallerObject Pointer on the EObject that information came from
+ * @param[in] eventId Message registered by this class
+ * @param[in] data Data registered by this class
+ * @return ---
+ */
+void classBufferManager::OnReceiveMessage(ewol::EObject * CallerObject, const char * eventId, etk::UString data)
+{
+	ewol::EObject::OnReceiveMessage(CallerObject, eventId, data);
+	
+	if (eventId == ednMsgBufferId) {
+		// select a new buffer ID :
+		if (data == "") {
+			APPL_ERROR("Request select buffer ID = \"\" ");
+		} else {
+			int32_t newID = -1;
+			sscanf(data.c_str(), "%d", &newID);
+			if(true == Exist(newID)) {
+				m_idSelected = newID;
+			} else {
+				m_idSelected = -1;
+				APPL_ERROR("Request a non existant ID : " << newID << " reset to -1...");
+			}
+		}
+	} else if (eventId == ednMsgGuiNew) {
+		int32_t newOne = Create();
+		if (-1 != newOne) {
+			m_idSelected = newOne;
+			SendMultiCast(ednMsgBufferId, m_idSelected);
+			SendMultiCast(ednMsgBufferListChange);
+		}
+	} else if (eventId == ednMsgOpenFile) {
+		if (data != "" ) {
+			etk::File myFile(data, etk::FILE_TYPE_DIRECT);
+			int32_t newOne = Open(myFile);
+			if (-1 != newOne) {
+				m_idSelected = newOne;
+				SendMultiCast(ednMsgBufferId, m_idSelected);
+				SendMultiCast(ednMsgBufferListChange);
+			} else {
+				// TODO : notify user that we can not open the request file...
+				APPL_ERROR("Can not open the file : \"" << myFile << "\"");
+			}
+		}
+	} else if (eventId == ednMsgGuiSave) {
+		if (data == "") {
+			APPL_ERROR("Null data for close file ... ");
+		} else {
+			if (data == "current") {
+				// Check buffer existence
+				if(true == Exist(m_idSelected)) {
+					// If no name ==> request a Gui display ...
+					if (Get(m_idSelected)->HaveName() == false) {
+						SendMultiCast(ednMsgGuiSaveAs, "current");
+					} else {
+						Get(m_idSelected)->Save();
+					}
+				}
+			} else {
+				int32_t newId;
+				sscanf(data.c_str(), "%d", &newId);
+				if (false == Exist(newId)) {
+					APPL_ERROR("Request a save As with a non existant ID=" << newId);
+				} else {
+					// If no name ==> request a Gui display ...
+					if (Get(newId)->HaveName() == false) {
+						SendMultiCast(ednMsgGuiSaveAs, newId);
+					} else {
+						Get(m_idSelected)->Save();
+					}
+				}
+				SendMultiCast(ednMsgBufferState, "saved");
+			}
+		}
+	} else if (eventId == ednMsgGuiClose) {
+		if (data == "") {
+			APPL_ERROR("Null data for close file ... ");
+		} else {
+			if (data == "All") {
+				
+			} else {
+				int32_t closeID = -1;
+				if (data == "current") {
+					closeID = m_idSelected;
+					APPL_DEBUG("Close specific buffer ID" << closeID);
+				} else {
+					// close specific buffer ...
+					sscanf(data.c_str(), "%d", &closeID);
+					APPL_DEBUG("Close specific buffer ID="<< closeID);
+				}
+				if(true == Exist(closeID)) {
+					// Get the new display buffer 
+					if (m_idSelected == closeID) {
+						// Try previous buffer
+						int32_t destBuffer = -1;
+						for(int32_t ii=closeID-1; ii >= 0; ii--) {
+							if (true == Exist(ii) ) {
+								destBuffer = ii;
+								break;
+							}
+						}
+						// try next buffer
+						if (-1 == destBuffer) {
+							for(int32_t ii=closeID+1; ii < listBuffer.Size(); ii++) {
+								if (true == Exist(ii) ) {
+									destBuffer = ii;
+									break;
+								}
+							}
+						}
+						// set it to the currect display
+						m_idSelected = destBuffer;
+						SendMultiCast(ednMsgBufferId, destBuffer);
+					}
+					// Remove requested buffer
+					Remove(closeID);
+					SendMultiCast(ednMsgBufferListChange);
+				} else {
+					APPL_ERROR("Request Close of a non existant ID : " << closeID);
+				}
+			}
+		}
+	} else if (eventId == ednMsgCodeViewSelectedId) {
+		//Change the selected buffer
+		if (data == "") {
+			APPL_ERROR("Null data for changing buffer ID file ... ");
+		} else {
+			int32_t newId;
+			sscanf(data.c_str(), "%d", &newId);
+			if (true == Exist(newId)) {
+				m_idSelected = newId;
+			} else {
+				APPL_ERROR("code biew request the selection of an non -existant buffer ==> reset to -1");
+				m_idSelected = -1;
+			}
+			SendMultiCast(ednMsgBufferId, m_idSelected);
+			SendMultiCast(ednMsgBufferListChange);
+		}
+	}
+	/*
+	switch (id)
+	{
+			// Check buffer existence
+			if(true == Exist(dataID)) {
+				// If no name ==> request a Gui display ...
+				if (Get(dataID)->HaveName() == false) {
+					SendMessage(APPL_MSG__GUI_SHOW_SAVE_AS, dataID);
+				} else {
+					Get(dataID)->Save();
+				}
+			}
+			break;
+	}
+	*/
+}
+
+
+
+
+
+
+
+/**
+ * @brief Remove all buffer opened
+ *
+ * @param[in,out] ---
+ *
+ * @return ---
+ *
+ */
+void classBufferManager::RemoveAll(void)
+{
+	int32_t i;
+	for (i=0; i<listBuffer.Size(); i++) {
+		Remove(i);
+	}
+	SendMultiCast(ednMsgGuiClose, "All");
+}
+
+
+
+/**
+ * @brief Create a new buffer with no name and empty
+ *
+ * @param[in,out] ---
+ *
+ * @return The ID of the curent buffer where the file is loaded
+ *
+ */
+int32_t	classBufferManager::Create(void)
+{
+	// allocate a new Buffer
+	Buffer *myBuffer = new BufferText();
+	// Add at the list of element
+	listBuffer.PushBack(myBuffer);
+	int32_t basicID = listBuffer.Size() - 1;
+	return basicID;
+}
+
+
+/**
+ * @brief open a file with the name set in parameters
+ *
+ * @param[in]		filename			curent filename
+ *
+ * @return The ID of the curent buffer where the file is loaded
+ *
+ * @todo : check if this file is not curently open and return the old ID
+ *
+ */
+int32_t classBufferManager::Open(etk::File &myFile)
+{
+	if (false == Exist(myFile)) {
+		// allocate a new Buffer
+		Buffer *myBuffer = new BufferText(myFile);
+		// Add at the list of element
+		listBuffer.PushBack(myBuffer);
+		return listBuffer.Size() - 1;
+	} else {
+		// the buffer already existed ==> we open it ...
+		return GetId(myFile);
+	}
+}
+
+
+
+Buffer * classBufferManager::Get(int32_t BufferID)
+{
+	// possible special case : -1;
+	if (-1 >= BufferID) {
+		return BufferNotExiste;
+	}
+	// check if the Buffer existed
+	if (BufferID < listBuffer.Size()) {
+		// check if the buffer already existed
+		if (NULL != listBuffer[BufferID]) {
+			return listBuffer[BufferID];
+		} else {
+			APPL_ERROR("non existing Buffer " << BufferID);
+		}
+	} else {
+		APPL_ERROR("call an non existing Buffer number too hight : " << BufferID << " > " << listBuffer.Size());
+	}
+	return BufferNotExiste;
+}
+
+
+bool classBufferManager::Exist(int32_t BufferID)
+{
+	if (-1 >= BufferID) {
+		return false;
+	}
+	// check if the Buffer existed
+	if (BufferID < listBuffer.Size()) {
+		// check if the buffer already existed
+		if (NULL != listBuffer[BufferID]) {
+			return true;
+		}
+	}
+	return false;
+}
+
+
+bool classBufferManager::Exist(etk::File &myFile )
+{
+	if (-1 == GetId(myFile)) {
+		return false;
+	}
+	return true;
+}
+
+
+int32_t classBufferManager::GetId(etk::File &myFile)
+{
+	int32_t iii;
+	// check if the Buffer existed
+	for (iii=0; iii < listBuffer.Size(); iii++) {
+		// check if the buffer already existed
+		if (NULL != listBuffer[iii]) {
+			if ( listBuffer[iii]->GetFileName() == myFile) {
+				return iii;
+			}
+		}
+	}
+	return -1;
+}
+
+
+// return the number of buffer (open in the past) if 5 buffer open and 4 close ==> return 5
+uint32_t classBufferManager::Size(void)
+{
+	return listBuffer.Size();
+}
+
+// nb of opens file Now ...
+uint32_t classBufferManager::SizeOpen(void)
+{
+	uint32_t jjj = 0;
+	// check if the Buffer existed
+	for (int32_t iii=0; iii<listBuffer.Size(); iii++) {
+		// check if the buffer already existed
+		if (NULL != listBuffer[iii]) {
+			jjj++;
+		}
+	}
+	return jjj;
+}
+
+/**
+ * @brief
+ *
+ * @param[in,out] ---
+ *
+ * @return ---
+ *
+ */
+bool classBufferManager::Remove(int32_t BufferID)
+{
+	if (-1 >= BufferID) {
+		return false;
+	}
+	// check if the Buffer existed
+	if (BufferID < listBuffer.Size()) {
+		// check if the buffer already existed
+		if (NULL != listBuffer[BufferID]) {
+			// TODO : Check if it saved...
+			/*
+			if (false == IsSaved(BufferID) ) {
+				APPL_INFO("Buffer " << BufferID << " : Not Saved", BufferID);
+			}
+			*/
+			// Delete the Buffer
+			delete( listBuffer[BufferID] );
+			listBuffer[BufferID] = NULL;
+			/*
+			ewol::widgetMessageMultiCast::Send(GetWidgetId(), ednMsgBufferListChange);
+			*/
+			return true;
+		} else {
+			APPL_INFO("non existing Buffer " << BufferID);
+			return false;
+		}
+	} else {
+		APPL_INFO("call an non existing Buffer number too hight : " << BufferID << " > " << listBuffer.Size());
+		return false;
+	}
+}
+
+/**
+ * @brief to get the element 14 in the buffer 
+ *
+ * @param[in,out] ---
+ *
+ * @return ---
+ *
+ */
+int32_t classBufferManager::WitchBuffer(int32_t iEmeElement)
+{
+	int32_t i;
+	for (i=0; i<listBuffer.Size(); i++) {
+		if (NULL != listBuffer[i]) {
+			iEmeElement--;
+			// find the element : 
+			if (0 == iEmeElement) {
+				return i;
+			}
+		}
+	}
+	return -1;
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//  Namespace part : 
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+static classBufferManager * localManager = NULL;
+
+void BufferManager::Init(void)
+{
+	if (NULL == localManager) {
+		EWOL_ERROR("classBufferManager ==> already exist, just unlink the previous ...");
+		localManager = NULL;
+	}
+	localManager = new classBufferManager();
+	
+	if (NULL == localManager) {
+		EWOL_CRITICAL("Allocation of classBufferManager not done ...");
+	}
+}
+
+void BufferManager::UnInit(void)
+{
+	if (NULL == localManager) {
+		EWOL_ERROR("classBufferManager ==> request UnInit, but does not exist ...");
+		return;
+	}
+	delete(localManager);
+	localManager = NULL;
+}
+
+int32_t BufferManager::GetSelected(void)
+{
+	if (NULL == localManager) {
+		EWOL_ERROR("classBufferManager ==> request UnInit, but does not exist ...");
+		return -1;
+	}
+	return localManager->GetSelected();
+}
+
+Buffer * BufferManager::Get(int32_t BufferID)
+{
+	if (NULL == localManager) {
+		EWOL_ERROR("classBufferManager ==> request UnInit, but does not exist ...");
+		return NULL;
+	}
+	return localManager->Get(BufferID);
+}
+
+bool BufferManager::Exist(int32_t BufferID)
+{
+	if (NULL == localManager) {
+		EWOL_ERROR("classBufferManager ==> request UnInit, but does not exist ...");
+		return false;
+	}
+	return localManager->Exist(BufferID);
+}
+
+bool BufferManager::Exist(etk::File &myFile)
+{
+	if (NULL == localManager) {
+		EWOL_ERROR("classBufferManager ==> request UnInit, but does not exist ...");
+		return false;
+	}
+	return localManager->Exist(myFile);
+}
+
+int32_t BufferManager::GetId(etk::File &myFile)
+{
+	if (NULL == localManager) {
+		EWOL_ERROR("classBufferManager ==> request UnInit, but does not exist ...");
+		return -1;
+	}
+	return localManager->GetId(myFile);
+}
+
+uint32_t BufferManager::Size(void)
+{
+	if (NULL == localManager) {
+		EWOL_ERROR("classBufferManager ==> request UnInit, but does not exist ...");
+		return 0;
+	}
+	return localManager->Size();
+}
+
+uint32_t BufferManager::SizeOpen(void)
+{
+	if (NULL == localManager) {
+		EWOL_ERROR("classBufferManager ==> request UnInit, but does not exist ...");
+		return 0;
+	}
+	return localManager->SizeOpen();
+}
+
+int32_t BufferManager::WitchBuffer(int32_t iEmeElement)
+{
+	if (NULL == localManager) {
+		EWOL_ERROR("classBufferManager ==> request UnInit, but does not exist ...");
+		return -1;
+	}
+	return localManager->WitchBuffer(iEmeElement);
+}
+
+

Sources/appl/Buffer/BufferManager.h

@@ -0,0 +1,51 @@
+/**
+ *******************************************************************************
+ * @file BufferManager.h
+ * @brief Editeur De N'ours : Text Buffer (header)
+ * @author Edouard DUPIN
+ * @date 08/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 __BUFFER_MANAGER_H__
+#define __BUFFER_MANAGER_H__
+
+#include <Buffer.h>
+#include <BufferText.h>
+#include <BufferEmpty.h>
+#include <appl/globalMsg.h>
+#include <ewol/Widget.h>
+
+namespace BufferManager
+{
+	void        Init(void);
+	void        UnInit(void);
+	int32_t     GetSelected(void);
+	Buffer *    Get(int32_t BufferID);
+	bool        Exist(int32_t BufferID);
+	bool        Exist(etk::File &myFile);
+	int32_t     GetId(etk::File &myFile);
+	// return the number of buffer (open in the past) if 5 buffer open and 4 close ==> return 5
+	uint32_t    Size(void);
+	uint32_t    SizeOpen(void);
+	int32_t     WitchBuffer(int32_t iEmeElement);
+};
+
+#endif
+

Sources/appl/Buffer/BufferText.h

@@ -0,0 +1,114 @@
+/**
+ *******************************************************************************
+ * @file BufferText.h
+ * @brief Editeur De N'ours : Text Buffer (edit only ASCII text File) (header)
+ * @author Edouard DUPIN
+ * @date 19/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 __BUFFER_TEXT_H__
+#define __BUFFER_TEXT_H__
+
+#include "ColorizeManager.h"
+#include "Buffer.h"
+#include "EdnBuf.h"
+
+typedef enum {
+	CURSOR_DISPLAY_MODE_NORMAL = 259,
+	CURSOR_DISPLAY_MODE_INSERT,
+	CURSOR_DISPLAY_MODE_NOT_FOCUS,
+} cursorDisplayMode_te;
+
+class BufferText : public Buffer {
+	public:
+		          BufferText(void);
+		          BufferText(etk::File &fileName);
+		virtual  ~BufferText(void);
+		void      Save(void);
+		
+		void      GetInfo(infoStatBuffer_ts &infoToUpdate);
+		void      SetLineDisplay(uint32_t lineNumber);
+		
+		int32_t   Display(ewol::OObject2DTextColored& OOTextNormal,
+		                  ewol::OObject2DTextColored& OOTextBold,
+		                  ewol::OObject2DTextColored& OOTextItalic,
+		                  ewol::OObject2DTextColored& OOTextBoldItalic,
+		                  ewol::OObject2DColored& OOColored,
+		                  int32_t offsetX, int32_t offsetY,
+		                  int32_t sizeX, int32_t sizeY);
+		void      AddChar(uniChar_t unicodeData);
+		void      cursorMove(ewol::eventKbMoveType_te moveTypeEvent);
+		void      MouseSelectFromCursorTo(int32_t fontId, int32_t width, int32_t height);
+		void      MouseEvent(int32_t fontId, int32_t width, int32_t height);
+		void      MouseEventDouble(void);
+		void      MouseEventTriple(void);
+
+		void      Copy(int8_t clipboardID);
+		void      Cut(int8_t clipboardID);
+		void      Paste(int8_t clipboardID);
+
+		void      Search(etk::UString &data, bool back, bool caseSensitive, bool wrap, bool regExp);
+		void      Replace(etk::UString &data);
+		int32_t   FindLine(etk::UString &data);
+		void      JumpAtLine(int32_t newLine);
+		int32_t   GetCurrentLine(void);
+		
+		void      RemoveLine(void);
+		void      SelectAll(void);
+		void      SelectNone(void);
+		void      Undo(void);
+		void      Redo(void);
+		void      SetCharset(unicode::charset_te newCharset);
+		int32_t   GetNumberOfLine(void);
+	protected:
+		void      NameChange(void);
+
+	private:
+		int32_t   GetLineNumberNumberOfElement(void);
+		
+		// Direct buffer IO
+		EdnBuf                  m_EdnBuf;                   //!< buffer associated on this displayer
+		Vector2D<float>         m_displaySize;              //!< number of char displayable in the screan
+		// Cursor :
+		int32_t                 m_cursorPos;                //!< position in the buffer of the cursor
+		int32_t                 m_cursorPreferredCol;       //!< colomn of the last up and down ...
+		cursorDisplayMode_te    m_cursorMode;               //!< type of cursor Selected
+		
+		// internal function
+		void                    BasicInit(void);
+	private:
+		bool m_centerRequested;
+	public:
+		virtual Vector2D<float> GetPosition(int32_t fontId, bool& centerRequested);
+	private:
+		bool     TextDMoveUp(int32_t offset);
+		bool     TextDMoveDown(int32_t offset);
+		void     SetInsertPosition(int32_t newPosition, bool insertChar = false);
+		
+		int32_t  GetMousePosition(int32_t fontId, int32_t width, int32_t height);
+		
+		void     DrawLineNumber(ewol::OObject2DTextColored* OOText, ewol::OObject2DColored* OOColored, int32_t sizeX, int32_t sizeY, int32_t nbColomn, int32_t lineNumber, int32_t positionY);
+		void     DrawCursor(ewol::OObject2DColored* OOColored, int32_t x, int32_t y, int32_t letterHeight, int32_t letterWidth, clipping_ts &clip);
+
+};
+
+#endif
+
+

Sources/appl/Buffer/EdnBuf/EdnBuf.h

@@ -0,0 +1,209 @@
+/**
+ *******************************************************************************
+ * @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 <etk/unicode.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 struct {
+	etk::Vector<colorInformation_ts>    HLData;
+	int32_t                                 posHLPass1;
+	int32_t                                 posHLPass2;
+}displayHLData_ts;
+
+
+
+class EdnBuf {
+	// TODO : Set an iterator to acces at every data without knowin the system ...
+	public:
+		// constructer
+		EdnBuf(void);
+		// destructer
+		~EdnBuf(void);
+		// public function :
+		void    GetAll(                 etk::Vector<int8_t> &text);
+		void    SetAll(                 etk::Vector<int8_t> &text);
+		void    GetRange(               int32_t start, int32_t end, etk::Vector<int8_t> &output);
+		void    GetRange(               int32_t start, int32_t end, etk::UString &output);
+		bool    DumpIn(                 FILE *myFile);
+		bool    DumpFrom(               FILE *myFile);
+		// replace with operator [] ...
+		int8_t  operator[] (int32_t);
+		int32_t Insert(                 int32_t pos, etk::Vector<int8_t> &insertText);
+		int32_t Insert(                 int32_t pos, etk::UString &insertText);
+		int32_t Replace(                int32_t start, int32_t end, etk::Vector<int8_t> &insertText);
+		int32_t Replace(                int32_t start, int32_t end, etk::UString &insertText);
+		void    Remove(                 int32_t start, int32_t end);
+		int32_t Indent(                 void);
+		int32_t UnIndent(               void);
+		
+		
+		void    GetLineText(            int32_t pos, etk::Vector<int8_t> &text);
+		int32_t StartOfLine(            int32_t pos);
+		int32_t EndOfLine(              int32_t pos);
+		
+		int32_t GetExpandedChar(        int32_t &pos, int32_t indent, uniChar_t outUnicode[MAX_EXP_CHAR_LEN], uint32_t &currentChar);
+		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 : Remove
+		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(             etk::Vector<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, etk::UString &search, int32_t *foundPos, int32_t *foundPosEnd, bool caseSensitive = true);
+		bool    SearchBackward(         int32_t startPos, etk::UString &search, int32_t *foundPos, int32_t *foundPosEnd, 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(void);
+		void        Select(            int32_t start, int32_t end);
+		void        Unselect(          void);
+		void        RectSelect(        int32_t start, int32_t end, int32_t rectStart, int32_t rectEnd);
+		bool        GetSelectionPos(   int32_t &start, int32_t &end, bool &isRect, int32_t &rectStart, int32_t &rectEnd);
+		void        GetSelectionText(  etk::Vector<int8_t> &text);
+		void        GetSelectionText(  etk::UString &text);
+		void        RemoveSelected(    void);
+		int32_t     ReplaceSelected(   etk::Vector<int8_t> &text);
+		int32_t     ReplaceSelected(   etk::UString &text);
+	private:
+		// current selection of the buffer
+		selection   m_selectionList;   //!< Selection area of the buffer
+		void        UpdateSelection(   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;
+		etk::Vector<EdnBufHistory*>         m_historyUndo;
+		etk::Vector<EdnBufHistory*>         m_historyRedo;
+
+	// -----------------------------------------
+	// hightlight section : 
+	// -----------------------------------------
+	private:
+		Highlight *                             m_Highlight;         //!< internal link with the Highlight system
+		etk::Vector<colorInformation_ts>    m_HLDataPass1;       //!< colorisation position in the current buffer pass 1
+		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; };
+		unicode::charset_te  GetCharsetType(void)                       { return m_charsetType; };
+		void                 SetCharsetType(unicode::charset_te newOne) { m_charsetType = newOne; if (unicode::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=unicode::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)
+		unicode::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, etk::Vector<int8_t> &deletedText);
+
+
+		int32_t LocalInsert(                    int32_t pos, etk::Vector<int8_t> &insertText);
+		int32_t LocalInsert(                    int32_t pos, etk::UString &insertText);
+		
+		bool    charMatch(                      char first, char second, bool caseSensitive = true);
+};
+
+#endif

Sources/appl/Buffer/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 <appl/Debug.h>
+#include <appl/global.h>
+#include <EdnBufHistory.h>
+
+
+#undef __class__
+#define __class__	"EdnBufHistory"
+
+EdnBufHistory::EdnBufHistory(void)
+{
+	//APPL_INFO("EdnBufHistory new");
+	m_pos = 0;
+	m_nInserted = 0;
+}
+
+EdnBufHistory::EdnBufHistory(int32_t pos, int32_t nInserted, etk::Vector<int8_t> &deletedText)
+{
+	//APPL_INFO("EdnBufHistory new + data");
+	m_pos = pos;
+	m_nInserted = nInserted;
+	m_deletedText = deletedText;
+}
+
+void EdnBufHistory::Set(int32_t pos, int32_t nInserted, etk::Vector<int8_t> &deletedText)
+{
+	//APPL_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(etk::Vector<int8_t> &deletedText)
+{
+	deletedText = m_deletedText;
+}
+

Sources/appl/Buffer/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 <etk/Vector.h>
+
+class EdnBufHistory{
+	public:
+					 EdnBufHistory(void);
+					 EdnBufHistory(int32_t pos, int32_t nInserted, etk::Vector<int8_t> &deletedText);
+					~EdnBufHistory(void);
+		void		 Set(int32_t pos, int32_t nInserted, etk::Vector<int8_t> &deletedText);
+		int32_t		 getPos(void);
+		int32_t		 getnbDeleted(void);
+		int32_t		 getnbInserted(void);
+		void		 getData(etk::Vector<int8_t> &deletedText);
+	private:
+		int32_t m_pos;
+		int32_t m_nInserted;
+		etk::Vector<int8_t> m_deletedText;
+};
+
+#endif
+

Sources/appl/Buffer/EdnBuf/EdnBuf_HighLight.cpp

@@ -0,0 +1,370 @@
+/**
+ *******************************************************************************
+ * @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 <appl/Debug.h>
+#include <appl/global.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());
+	}
+}
+
+// TODO : Check this fuction it have too many conditionnal inside ==> can do a better algo
+void EdnBuf::RegenerateHighLightAt(int32_t pos, int32_t nbDeleted, int32_t nbAdded)
+{
+	//GTimeVal timeStart;
+	//g_get_current_time(&timeStart);
+	
+	// prevent ERROR...
+	if (NULL == m_Highlight) {
+		return;
+	}
+	// prevent No data Call
+	if(		0 == nbDeleted
+		&&	0 == nbAdded)
+	{
+		return;
+	}
+	// normal case
+	//APPL_INFO("(pos="<<pos<<", nbDeleted="<<nbDeleted<<", nbAdded=" << nbAdded << "\");");
+	int32_t i;
+	/*
+	for (i=0; i< (int32_t)m_HLDataPass1.Size(); i++) {
+		etk::UString ploppp;
+		if (NULL != m_HLDataPass1[i].patern ) {
+			ploppp = ((HighlightPattern*)m_HLDataPass1[i].patern)->GetName();
+		}
+		APPL_DEBUG("HighLight (previous) element id=" << i << " S=" << m_HLDataPass1[i].beginStart << " E=" << m_HLDataPass1[i].endStop << " patern name=" << ploppp );
+	}
+	*/
+	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(0);
+				//APPL_DEBUG("1 * Erase 0");
+			} else {
+				m_HLDataPass1.EraseLen(0,stopId);
+				//APPL_DEBUG("2 * Erase 0->" << stopId);
+			}
+		} else if(-1 == stopId) {
+			//APPL_DEBUG("3 * Erase " << startId+1 << "-> end");
+			m_HLDataPass1.EraseLen(startId+1, m_HLDataPass1.Size() - startId);
+			stopId = -1;
+		} else {
+			int32_t currentSize = m_HLDataPass1.Size();
+			//APPL_DEBUG("4 * Erase " << startId+1 << "->" << stopId << " in " << currentSize << " elements" );
+			m_HLDataPass1.EraseLen(startId+1, stopId - startId);
+			if (stopId == currentSize-1) {
+				stopId = -1;
+			}
+		}
+		//APPL_DEBUG("new size=" << (int32_t)m_HLDataPass1.Size()-1);
+		/*
+				for (i=0; i< (int32_t)m_HLDataPass1.Size(); i++) {
+					etk::UString ploppp;
+					if (NULL != m_HLDataPass1[i].patern ) {
+						ploppp = ((HighlightPattern*)m_HLDataPass1[i].patern)->GetName();
+					}
+					APPL_DEBUG("HighLight (Middle) element id=" << i << " S=" << m_HLDataPass1[i].beginStart << " E=" << m_HLDataPass1[i].endStop << " patern name=" << ploppp );
+				}
+		*/
+		// 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++) {
+			//APPL_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)
+		{
+			//APPL_DEBUG("*******  Regenerate ALL");
+			GenerateHighLightAt(0, m_data.Size());
+		} else if(-1 == startId) {
+			//APPL_DEBUG("*******  Regenerate START");
+			GenerateHighLightAt(0, m_HLDataPass1[0].beginStart, 0);
+		} else if(-1 == stopId) {
+			//APPL_DEBUG("*******  Regenerate STOP");
+			GenerateHighLightAt(m_HLDataPass1[m_HLDataPass1.Size() -1].endStop, m_data.Size(), m_HLDataPass1.Size());
+		} else {
+			//APPL_DEBUG("*******  Regenerate RANGE");
+			GenerateHighLightAt(m_HLDataPass1[startId].endStop, m_HLDataPass1[startId+1].beginStart, startId+1);
+		}
+	} else {
+		// Parse the new element ...
+		GenerateHighLightAt(0, m_data.Size());
+	}
+	/*
+	for (i=0; i< (int32_t)m_HLDataPass1.Size(); i++) {
+		etk::UString ploppp;
+		if (NULL != m_HLDataPass1[i].patern ) {
+			ploppp = ((HighlightPattern*)m_HLDataPass1[i].patern)->GetName();
+		}
+		APPL_DEBUG("HighLight (end) element id=" << i << " S=" << m_HLDataPass1[i].beginStart << " E=" << m_HLDataPass1[i].endStop << " patern name=" << ploppp );
+	}
+	*/
+	//GTimeVal timeStop;
+	//g_get_current_time(&timeStop);
+	//APPL_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()) {
+		APPL_DEBUG("==> BEGIN : start="<<m_HLDataPass1[startId].beginStart<<", stop="<<m_HLDataPass1[startId].endStop<<" id=" << startId << "/" << (int32_t)m_HLDataPass1.Size()-1);
+	} else {
+		APPL_DEBUG("==> BEGIN : start=???, stop=??? id=" << startId);
+	}
+	if (-1 != stopId && stopId < (int32_t)m_HLDataPass1.Size()) {
+		APPL_DEBUG("==> END   : start="<<m_HLDataPass1[stopId].beginStart<<", stop="<<m_HLDataPass1[stopId].endStop<<" id=" << stopId<< "/" << (int32_t)m_HLDataPass1.Size()-1);
+	} else {
+		APPL_DEBUG("==> END   : start=???, stop=??? id=" << stopId);
+	}
+	*/
+}
+
+
+
+
+void EdnBuf::GenerateHighLightAt(int32_t pos, int32_t endPos, int32_t addinPos)
+{
+	if (NULL == m_Highlight) {
+		return;
+	}
+	//APPL_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 = etk_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;
+	}
+	//GTimeVal timeStart;
+	//g_get_current_time(&timeStart);
+	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;
+	//APPL_DEBUG("List of section between : "<< startId << " & " << stopId);
+	int32_t endSearch = stopId+1;
+	if (-1 == stopId) {
+		endSearch = m_HLDataPass1.Size();
+	}
+	for (k=etk_max(startId, 0); k<endSearch; k++) {
+		// empty section :
+		if (0==k) {
+			if (HLStart < m_HLDataPass1[k].beginStart) {
+				//APPL_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 {
+			//APPL_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 :
+		//APPL_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()) {
+		if (m_HLDataPass1.Size() != 0) {
+			//APPL_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 {
+			//APPL_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);
+	//APPL_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 = etk_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/appl/Buffer/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 <appl/Debug.h>
+#include <appl/global.h>
+#include <EdnBuf.h>
+
+
+#undef __class__
+#define __class__	"EdnBuf{History}"
+
+
+
+
+int32_t EdnBuf::Undo(void)
+{
+	int32_t nbElement = m_historyUndo.Size();
+	//APPL_DEBUG("EdnBuf::Undo Request id="<<nbElement);
+	int32_t posDest = -1;
+	if (0 == nbElement) {
+		// nothing to do ...
+		APPL_ERROR("EdnBuf::Undo No more History");
+		return -1;
+	}
+	nbElement--;
+	if (m_historyUndo[nbElement] == NULL) {
+		APPL_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();
+	etk::Vector<int8_t> deletedText;
+	m_historyUndo[nbElement]->getData(deletedText);
+	m_isUndoProcessing = true;
+	if (0 == nbInserted) {
+		// just add data at position ...
+		if (0 == nbDeleted) {
+			APPL_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();
+	//APPL_DEBUG("EdnBuf::Redo Request id="<<nbElement);
+	int32_t posDest = -1;
+	if (0 == nbElement) {
+		// nothing to do ...
+		APPL_ERROR("EdnBuf::Redo No more History");
+		return -1;
+	}
+	nbElement--;
+	if (m_historyRedo[nbElement] == NULL) {
+		APPL_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();
+	etk::Vector<int8_t> deletedText;
+	m_historyRedo[nbElement]->getData(deletedText);
+	m_isRedoProcessing = true;
+	if (0 == nbInserted) {
+		// just add data at position ...
+		if (0 == nbDeleted) {
+			APPL_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/appl/Buffer/EdnBuf/EdnBuf_Selection.cpp

@@ -0,0 +1,310 @@
+/**
+ *******************************************************************************
+ * @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 <appl/Debug.h>
+#include <appl/global.h>
+#include <EdnBuf.h>
+
+
+#undef __class__
+#define __class__	"EdnBuf{Selection}"
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+bool EdnBuf::SelectHasSelection(void)
+{
+	return m_selectionList.selected;
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnBuf::Select(int32_t start, int32_t end)
+{
+	//selection oldSelection = m_selectionList[select];
+	m_selectionList.selected = start != end;
+	m_selectionList.zeroWidth = (start == end) ? true : false;
+	m_selectionList.rectangular = false;
+	m_selectionList.start = etk_min(start, end);
+	m_selectionList.end = etk_max(start, end);
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnBuf::Unselect(void)
+{
+	//selection oldSelection = m_selectionList[select];
+	m_selectionList.selected = false;
+	m_selectionList.zeroWidth = false;
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * @param[in,out] ---
+ * @param[in,out] ---
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnBuf::RectSelect(int32_t start, int32_t end, int32_t rectStart, int32_t rectEnd)
+{
+	m_selectionList.selected = rectStart < rectEnd;
+	m_selectionList.zeroWidth = (rectStart == rectEnd) ? false : true;
+	m_selectionList.rectangular = true;
+	m_selectionList.start = start;
+	m_selectionList.end = end;
+	m_selectionList.rectStart = rectStart;
+	m_selectionList.rectEnd = rectEnd;
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+bool EdnBuf::GetSelectionPos(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.rectangular;
+	start = m_selectionList.start;
+	end = m_selectionList.end;
+	if (m_selectionList.rectangular) {
+		rectStart = m_selectionList.rectStart;
+		rectEnd = m_selectionList.rectEnd;
+	}
+	return m_selectionList.selected;
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnBuf::GetSelectionText(etk::Vector<int8_t> &text)
+{
+	int32_t start, end, rectStart, rectEnd;
+	bool isRect;
+	// remove output data
+	text.Clear();
+	
+	bool isSelected = GetSelectionPos(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);
+	}
+}
+void EdnBuf::GetSelectionText(etk::UString &text)
+{
+	int32_t start, end, rectStart, rectEnd;
+	bool isRect;
+	// remove output data
+	text = "";
+	
+	bool isSelected = GetSelectionPos(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(void)
+{
+	int32_t start, end;
+	int32_t rectStart, rectEnd;
+	bool isRect;
+	bool isSelected = GetSelectionPos(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();
+}
+
+
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+int32_t EdnBuf::ReplaceSelected(etk::Vector<int8_t> &text)
+{
+	int32_t start, end, rectStart, rectEnd;
+	bool isRect;
+	bool isSelected = GetSelectionPos(start, end, isRect, rectStart, rectEnd);
+	
+	// No data selected ...
+	if (false == isSelected) {
+		return 0;
+	}
+	int32_t returnSize = 0;
+	// Rectangular selection
+	if (true == isRect) {
+		//ReplaceRect(start, end, rectStart, rectEnd, text);
+		// TODO : ...
+	} else {
+		returnSize = Replace(start, end, text);
+	}
+	// Clean selection
+	m_selectionList.selected = false;
+	return returnSize;
+}
+int32_t EdnBuf::ReplaceSelected(etk::UString &text)
+{
+	int32_t start, end, rectStart, rectEnd;
+	bool isRect;
+	bool isSelected = GetSelectionPos(start, end, isRect, rectStart, rectEnd);
+	
+	// No data selected ...
+	if (false == isSelected) {
+		return 0;
+	}
+	int32_t returnSize = 0;
+	// Rectangular selection
+	if (true == isRect) {
+		//ReplaceRect(start, end, rectStart, rectEnd, text);
+		// TODO : ...
+	} else {
+		returnSize = Replace(start, end, text);
+	}
+	// Clean selection
+	m_selectionList.selected = false;
+	return returnSize;
+}
+
+
+/*
+** Update an individual selection for changes in the corresponding text
+*/
+/**
+ * @brief 
+ * 
+ * @param[in,out] ---
+ * 
+ * @return ---
+ * 
+ */
+void EdnBuf::UpdateSelection(int32_t pos, int32_t nDeleted, int32_t nInserted)
+{
+	if(		(		false == m_selectionList.selected
+				&&	false == m_selectionList.zeroWidth)
+		||	pos > m_selectionList.end )
+	{
+		return;
+	}
+	if (pos+nDeleted <= m_selectionList.start) {
+		m_selectionList.start += nInserted - nDeleted;
+		m_selectionList.end += nInserted - nDeleted;
+	} else if(		pos <= m_selectionList.start
+				&&	pos+nDeleted >= m_selectionList.end)
+	{
+		m_selectionList.start = pos;
+		m_selectionList.end = pos;
+		m_selectionList.selected = false;
+		m_selectionList.zeroWidth = false;
+	} else if(		pos <= m_selectionList.start
+				&&	pos+nDeleted < m_selectionList.end)
+	{
+		m_selectionList.start = pos;
+		m_selectionList.end = nInserted + m_selectionList.end - nDeleted;
+	} else if(pos < m_selectionList.end) {
+		m_selectionList.end += nInserted - nDeleted;
+		if (m_selectionList.end <= m_selectionList.start) {
+			m_selectionList.selected = false;
+		}
+	}
+}
+

Sources/appl/Buffer/EdnVectorBuf.cpp

@@ -0,0 +1,704 @@
+/**
+ *******************************************************************************
+ * @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 <appl/Debug.h>
+#include <appl/global.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
+	m_data = (int8_t *)malloc( m_allocated * sizeof(int8_t) );
+	APPL_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) {
+		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);
+	APPL_INFO("load data : filesize=" << length << ", readData=" << nbReadData);
+	// check ERROR
+	if (nbReadData != length) {
+		APPL_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) {
+			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
+		m_data = (int8_t *)malloc( m_allocated * sizeof(int8_t) );
+		APPL_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)
+{
+	APPL_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)
+{
+	APPL_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, etk::Vector<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 ) {
+		APPL_ERROR("Request higher than buffer size : pos="<<pos<< " bufferSize="<<Size());
+		return;
+	}
+	if( pos+nbRemoveElement > Size() ) {
+		APPL_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;
+	}
+	APPL_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)
+		m_data = (int8_t *)malloc( newSize * sizeof(int8_t) );
+	} else {
+		// move datas
+		m_data = (int8_t *)realloc( m_data, newSize* sizeof(int8_t) );
+	}
+	// Check result with assert : 
+	APPL_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 ) {
+		APPL_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, etk::Vector<int8_t>& items)
+{
+	if(		pos > Size()
+		||	pos < 0 ) {
+		APPL_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 ) {
+		APPL_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, etk::Vector<int8_t>& items)
+{
+	if(		pos > Size()
+		||	pos < 0 ) {
+		APPL_ERROR("Request higher than buffer size : pos="<<pos<< " bufferSize="<<Size());
+		return;
+	}
+	if( pos+nbRemoveElement > Size() ) {
+		APPL_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 ) {
+		APPL_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 ) {
+		APPL_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)
+{
+	APPL_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) {
+			APPL_INFO( "Element " << i << " : GAP");
+		} else {
+			APPL_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';
+	
+	etk::Vector<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/appl/Buffer/EdnVectorBuf.h

@@ -0,0 +1,341 @@
+/**
+ *******************************************************************************
+ * @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 <etk/Vector.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
+				{
+					APPL_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
+				{
+					APPL_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, etk::Vector<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, etk::Vector<int8_t>& items);
+		// Remove and insert functions
+		void							Replace(	int32_t pos, const int8_t& item);
+		void							Replace(	int32_t pos, int32_t nbRemoveElement, etk::Vector<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