HeeroYui/edn
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

First compilation of edn with ewol ==> did not work at all

Browse Source
This commit is contained in:
Edouard Dupin 2012-01-11 15:26:53 +01:00
parent 2d355d05c6
commit 70837bd769
86 changed files with 1169 additions and 11667 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

340
Makefile_old Normal file
View File

@ -0,0 +1,340 @@
##################################################################################################################
# #
# Fichier : Makefile #
# #
# Type : Makefile d'un programme complet #
# #
# Auteur : Heero Yui #
# #
# Evolutions : Date Auteur Raison #
# 2010-01-29 Heero Yui Mise en place d'un makefile ultra simple #
# 2011-07-14 Heero Yui Rework the current dorder includion (simplification) #
# #
# Notes : This makefile might be edited with an editor compatible with escape char and carrer return #
# char #
# #
# Concu Pour le projet edn #
# #
##################################################################################################################
export F_GRAS=
export F_INVERSER=
export F_SOUSLIGNER=
export F_NORMALE=
export F_NOIR=
export F_ROUGE=
export F_VERT=
export F_MARRON=
export F_BLUE=
export F_VIOLET=
export F_CYAN=
export F_GRIS=
export CADRE_HAUT_BAS=' $(F_INVERSER) $(F_NORMALE)'
export CADRE_COTERS=' $(F_INVERSER) $(F_NORMALE) $(F_INVERSER) $(F_NORMALE)'
VERSION_TAG=$(shell git describe --tags)
#$(info $(VERSION_TAG))
VERSION_TAG_SHORT=$(shell git describe --tags --abbrev=0)
#$(info $(VERSION_TAG_SHORT))
VERSION_BUILD_TIME=$(shell date)
#$(info $(VERSION_BUILD_TIME))
###############################################################################
### Compilateur base system ###
###############################################################################
CXX=g++
CC=gcc
AR=ar
DEBUG:=1
###############################################################################
### Compilation Define ###
###############################################################################
ifeq ("$(DEBUG)", "0")
DEFINE= -DEDN_DEBUG_LEVEL=1 -DNDEBUG -DVERSION_TAG_NAME="\"$(VERSION_TAG)-release\""
else
DEFINE= -DEDN_DEBUG_LEVEL=3 -DVERSION_TAG_NAME="\"$(VERSION_TAG)-debug\""
endif
DEFINE+= -DVERSION_BUILD_TIME="\"$(VERSION_BUILD_TIME)\""
GTKFLAGS=
ifeq ($(shell if `pkg-config --exists gtk+-3.0` ; then echo "yes"; else echo "no"; fi), yes)
GTKFLAGS= `pkg-config --cflags --libs gtk+-3.0` -DUSE_GTK_VERSION_3_0
else
ifeq ($(shell if `pkg-config --exists gtk+-2.0` ; then echo "yes"; else echo "no"; fi), yes)
GTKFLAGS= `pkg-config --cflags --libs gtk+-2.0` -DUSE_GTK_VERSION_2_0
else
$(error No GTK 3.0 or 2.0 librairies ...)
endif
endif
###############################################################################
### Basic Cfags ###
###############################################################################
# basic GTK librairy
CXXFLAGS= $(GTKFLAGS)
# Linux thread system
CXXFLAGS+= -lpthread
# Enable debug (cgdb edn)
CXXFLAGS+= -g -O0
#CXXFLAGS+= -O2
# display all flags
CXXFLAGS+= -Wall
# ...
CXXFLAGS+= -D_REENTRANT
# internal defines
CXXFLAGS+= $(DEFINE)
CFLAGS= $(CXXFLAGS) -std=c99
# basic GTK librairy
LDFLAGS= $(GTKFLAGS)
# Linux thread system
LDFLAGS+= -lpthread
# Dynamic connection of the CALLBACK of the GUI
LDFLAGS+= -Wl,--export-dynamic
###############################################################################
### Project Name ###
###############################################################################
PROG_NAME=edn
###############################################################################
### Basic Project description Files ###
###############################################################################
FILE_DIRECTORY=Sources
OUTPUT_NAME_RELEASE=$(PROG_NAME)_release
OUTPUT_NAME_DEBUG=$(PROG_NAME)_debug
OBJECT_DIR=Object
ifeq ("$(DEBUG)", "0")
OBJECT_DIRECTORY=$(OBJECT_DIR)/release
OUTPUT_NAME = $(OUTPUT_NAME_RELEASE)
else
OBJECT_DIRECTORY=$(OBJECT_DIR)/debug
OUTPUT_NAME = $(OUTPUT_NAME_DEBUG)
endif
###############################################################################
### Generique dependency ###
###############################################################################
MAKE_DEPENDENCE=Makefile
###############################################################################
### Files Listes ###
###############################################################################
# tiny XML (extern OPEN Sources) :
CXXFILES = tools/tinyXML/tinyxml.cpp \
tools/tinyXML/tinyxmlparser.cpp \
tools/tinyXML/tinyxmlerror.cpp \
tools/tinyXML/tinystr.cpp
# ExuberantCtags reading file tools (extern OPEN Sources) :
CXXFILES+= ctags/readtags.cpp \
ctags/CTagsManager.cpp
# Globals debug tool:
CXXFILES+= tools/debug/tools_debug.cpp \
tools/globals/tools_globals.cpp \
tools/memory/toolsMemory.cpp
# Buffers internal:
CXXFILES+= tools/EdnTemplate/EdnVectorBuf.cpp \
tools/EdnBuf/EdnBuf.cpp \
tools/EdnBuf/EdnBuf_HighLight.cpp \
tools/EdnBuf/EdnBuf_History.cpp \
tools/EdnBuf/EdnBuf_Selection.cpp \
tools/EdnBuf/EdnBufHistory.cpp
# Tools internal:
CXXFILES+= tools/Display/Display.cpp \
tools/ClipBoard/ClipBoard.cpp \
tools/MsgBroadcast/MsgBroadcast.cpp \
tools/MsgBroadcast/AccelKey.cpp \
tools/charset/charsetTable.cpp \
tools/charset/charset.cpp \
tools/NameSpaceEdn/File.cpp \
tools/NameSpaceEdn/String.cpp \
tools/NameSpaceEdn/RegExp.cpp
# Gui:
CXXFILES+= CustumWidget/BufferView/BufferView.cpp \
CustumWidget/CodeView/CodeView.cpp \
GuiTools/WindowsManager/WindowsManager.cpp \
GuiTools/MainWindows/MainWindows.cpp \
GuiTools/MainWindows/StatusBar.cpp \
GuiTools/MainWindows/MenuBar.cpp \
GuiTools/MainWindows/ToolBar.cpp \
GuiTools/Search/Search.cpp \
GuiTools/Search/SearchData.cpp
# Basic Interface :
CXXFILES+= Buffer/Buffer.cpp \
Buffer/BufferText.cpp \
Buffer/BufferEmpty.cpp \
Buffer/BufferManager.cpp \
Colorize/Colorize.cpp \
Colorize/ColorizeManager.cpp \
Highlight/HighlightPattern.cpp \
Highlight/Highlight.cpp \
Highlight/HighlightManager.cpp
# Main entry file :
CXXFILES+= init.cpp
###############################################################################
### Liste of folder where .h can be ###
###############################################################################
LISTE_MODULES = $(dir $(CXXFILES))
INCLUDE_DIRECTORY = $(addprefix -I$(FILE_DIRECTORY)/, $(LISTE_MODULES))
###############################################################################
### Build Object Files List ###
###############################################################################
OBJ = $(addprefix $(OBJECT_DIRECTORY)/, $(CXXFILES:.cpp=.o))
###############################################################################
### Main Part of Makefile ###
###############################################################################
all: build
-include $(OBJ:.o=.d)
build: .encadrer .versionFile $(OUTPUT_NAME)
.encadrer:
@echo $(CADRE_HAUT_BAS)
@echo $(CADRE_COTERS)
@echo ' DEBUT DE COMPILATION DU PROGRAMME :'$(CADRE_COTERS)
@echo ' Repertoire Sources : $(FILE_DIRECTORY)/'$(CADRE_COTERS)
@echo ' Repertoire object : $(OBJECT_DIRECTORY)/'$(CADRE_COTERS)
@echo ' Binaire de sortie : $(F_VIOLET)$(OUTPUT_NAME) $(F_NORMALE)'$(CADRE_COTERS)
@echo $(CADRE_COTERS)
@echo $(CADRE_HAUT_BAS)
@mkdir -p $(addprefix $(OBJECT_DIRECTORY)/, $(LISTE_MODULES))
FILE_IMAGES= data/imagesSources/*.png
.versionFile :
@rm -f $(OBJECT_DIRECTORY)/GuiTools/WindowsManager/WindowsManager.o
# Tool used to create a binary version of every element png or other needed by the application
pngToCpp: tools/pngToCpp/pngToCpp.c
@echo $(F_ROUGE)" (bin) $@"$(F_NORMALE)
@$(CXX) $< -o $@
@strip -s $@
# Generate basic
$(FILE_DIRECTORY)/GuiTools/myImage.cpp: $(FILE_IMAGES) $(MAKE_DEPENDENCE) pngToCpp
@echo $(F_BLUE)" (.cpp) *.png ==> $@"$(F_NORMALE)
@./pngToCpp $@ $(FILE_IMAGES)
# build C++
$(OBJECT_DIRECTORY)/%.o: $(FILE_DIRECTORY)/%.cpp $(MAKE_DEPENDENCE)
@echo $(F_VERT)" (.o) $<"$(F_NORMALE)
@$(CXX) $< -c -o $@ $(INCLUDE_DIRECTORY) $(CXXFLAGS) -MMD
# build binary Release Mode
$(OUTPUT_NAME_RELEASE): $(OBJ) $(MAKE_DEPENDENCE)
@echo $(F_ROUGE)" (bin) $@ "$(F_NORMALE)
@$(CXX) $(OBJ) $(LDFLAGS) -o $@
@cp $@ $(PROG_NAME)
# build binary Debug Mode
$(OUTPUT_NAME_DEBUG): $(OBJ) $(MAKE_DEPENDENCE)
@echo $(F_ROUGE)" (bin) $@ "$(F_NORMALE)
@$(CXX) $(OBJ) $(LDFLAGS) -o $@
@cp $@ $(PROG_NAME)
clean:
@echo $(CADRE_HAUT_BAS)
@echo ' CLEANING : $(F_VIOLET)$(OUTPUT_NAME)$(F_NORMALE)'$(CADRE_COTERS)
@echo $(CADRE_HAUT_BAS)
@echo Remove Folder : $(OBJECT_DIR)
@rm -rf $(OBJECT_DIR)
@echo Remove File : $(PROG_NAME) $(OUTPUT_NAME_DEBUG) $(OUTPUT_NAME_RELEASE)
@rm -f $(PROG_NAME) $(OUTPUT_NAME_DEBUG) $(OUTPUT_NAME_RELEASE)
@echo Remove File : pngToCpp
@rm -f pngToCpp
@echo Remove File : $(FILE_DIRECTORY)/GuiTools/myImage.*
@rm -f $(FILE_DIRECTORY)/GuiTools/myImage.*
@echo Remove doxygen files : doxygen/*
@rm -rf doxygen
@rm -f doxygen.log
@echo Remove temporary files *.bck
@rm -f `find . -name "*.bck"`
count:
wc -l Makefile `find $(FILE_DIRECTORY)/ -name "*.cpp"` `find $(FILE_DIRECTORY)/ -name "*.h"`
install: .encadrer .versionFile $(OUTPUT_NAME_RELEASE)
@echo $(CADRE_HAUT_BAS)
@echo ' INSTALL : $(F_VIOLET)$(OUTPUT_NAME_RELEASE)=>$(PROG_NAME)$(F_NORMALE)'$(CADRE_COTERS)
@echo $(CADRE_HAUT_BAS)
@echo $(F_ROUGE)" (stripped) $(OUTPUT_NAME_RELEASE) => $(PROG_NAME) "$(F_NORMALE)
@cp $(OUTPUT_NAME_RELEASE) $(PROG_NAME)
@strip -s $(PROG_NAME)
@echo $(F_VERT)" (copy) $(PROG_NAME) /usr/bin/ "$(F_NORMALE)
@cp -vf $(PROG_NAME) /usr/bin/
@echo $(F_VERT)" (data) data/* ==> /usr/share/edn/ "$(F_NORMALE)
@mkdir -p /usr/share/edn/
@rm -rf /usr/share/edn/*
@cp -vf data/*.xml /usr/share/edn/
@mkdir -p /usr/share/edn/images/
@cp -vf data/imagesSources/icone.png /usr/share/edn/images/
@cp -vf data/imagesSources/delete-24px.png /usr/share/edn/images/
# gnome adding for the program at the list (manage icone in .xpm)
@cp -vf data/edn.desktop /usr/share/applications/
@cp -vf data/imagesSources/icone.png /usr/share/app-install/icons/Edn.png
@cp -vf data/imagesSources/icone.xpm /usr/share/pixmaps/Edn.xpm
# http://alp.developpez.com/tutoriels/debian/creer-paquet/
package: .encadrer
@echo 'Create Folders ...'
@mkdir -p package/$(PROG_NAME)/DEBIAN/
@mkdir -p package/$(PROG_NAME)/usr/bin/
@mkdir -p package/$(PROG_NAME)/usr/share/doc/
@mkdir -p package/$(PROG_NAME)/usr/share/edn/
# Create the control file
@echo "Package: "$(PROG_NAME) > package/$(PROG_NAME)/DEBIAN/control
@echo "Version: "$(VERSION_TAG_SHORT) >> package/$(PROG_NAME)/DEBIAN/control
@echo "Section: Development,Editors" >> package/$(PROG_NAME)/DEBIAN/control
@echo "Priority: optional" >>package/$(PROG_NAME)/DEBIAN/control
@echo "Architecture: all" >> package/$(PROG_NAME)/DEBIAN/control
@echo "Depends: bash" >> package/$(PROG_NAME)/DEBIAN/control
@echo "Maintainer: Mr DUPIN Edouard <yui.heero@gmail.com>" >> package/$(PROG_NAME)/DEBIAN/control
@echo "Description: Text editor for sources code with ctags management" >> package/$(PROG_NAME)/DEBIAN/control
@echo "" >> package/$(PROG_NAME)/DEBIAN/control
# Create the PostRm
@echo "#!/bin/bash" > package/$(PROG_NAME)/DEBIAN/postrm
@echo "rm ~/."$(PROG_NAME) >> package/$(PROG_NAME)/DEBIAN/postrm
@echo "" >> package/$(PROG_NAME)/DEBIAN/postrm
# Enable Execution in script
@chmod 755 package/$(PROG_NAME)/DEBIAN/post*
@#chmod 755 package/$(PROG_NAME)/DEBIAN/pre*
# copy licence and information :
@cp README package/$(PROG_NAME)/usr/share/doc/README
@cp licence.txt package/$(PROG_NAME)/usr/share/doc/copyright
@echo "First generation in progress" >> package/$(PROG_NAME)/usr/share/doc/changelog
@cp -vf $(PROG_NAME) package/$(PROG_NAME)/usr/bin/
@cp -vf data/*.xml package/$(PROG_NAME)/usr/share/edn/
@cd package; dpkg-deb --build $(PROG_NAME)

23
jni/Android.mk Normal file
View File

@ -0,0 +1,23 @@
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE := ednpackage
LOCAL_STATIC_LIBRARIES := ewol
LOCAL_C_INCLUDES := $(LOCAL_PATH)
# load the common sources file of the platform
include $(LOCAL_PATH)/file.mk
LOCAL_SRC_FILES := ewolAndroidAbstraction.cpp \
$(FILE_LIST)
LOCAL_LDLIBS := -llog -landroid
include $(BUILD_SHARED_LIBRARY)
NDK_MODULE_PATH := $(LOCAL_PATH)/../../
$(call import-module,ewol/Sources)

24
jni/Linux.mk Normal file
View File

@ -0,0 +1,24 @@
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
# load the common sources file of the platform
include $(LOCAL_PATH)/file.mk
LOCAL_MODULE := ednn
LOCAL_STATIC_LIBRARIES := ewol etk tinyxml libzip libpng
LOCAL_C_INCLUDES := -I$(LOCAL_PATH) $(addprefix -I$(LOCAL_PATH)/, $(sort $(dir $(FILE_LIST))))
LOCAL_SRC_FILES := $(FILE_LIST)
LOCAL_LDLIBS :=
LOCAL_CFLAGS := -DEWOL_USE_FREE_TYPE \
-DEDN_DEBUG_LEVEL=3
include $(BUILD_EXECUTABLE)
NDK_MODULE_PATH := $(LOCAL_PATH)/../../
$(call import-module,ewol/Sources)

18
jni/edn/Buffer/Buffer.cpp
View File

@ -23,10 +23,10 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "Buffer.h"
#include "BufferManager.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <Buffer.h>
#include <BufferManager.h>
#undef __class__
#define __class__ "Buffer"
@ -44,7 +44,7 @@ Buffer::Buffer()
static int32_t fileBasicID = 0;
m_fileModify = true;
m_haveName = false;
Edn::String mString = "Untitle - ";
etk::String mString = "Untitle - ";
mString += fileBasicID++;
SetFileName(mString);
m_haveName = false;
@ -58,7 +58,7 @@ Buffer::Buffer()
* @return ---
*
*/
Buffer::Buffer(Edn::File &newName)
Buffer::Buffer(etk::File &newName)
{
m_fileModify = false;
SetFileName(newName);
@ -269,17 +269,17 @@ void Buffer::AddChar(char * UTF8data)
// nothing to do
}
void Buffer::Search(Edn::String &data, bool back, bool caseSensitive, bool wrap, bool regExp)
void Buffer::Search(etk::String &data, bool back, bool caseSensitive, bool wrap, bool regExp)
{
// nothing to do
}
void Buffer::Replace(Edn::String &data)
void Buffer::Replace(etk::String &data)
{
// nothing to do
}
int32_t Buffer::FindLine(Edn::String &data)
int32_t Buffer::FindLine(etk::String &data)
{
// nothing to do
return 0;

27
jni/edn/Buffer/Buffer.h
View File

@ -26,10 +26,11 @@
#ifndef __BUFFER_H__
#define __BUFFER_H__
#include <string>
#include "Display.h"
#include "charset.h"
#include "Edn.h"
#include <etk/String.h>
#include <etk/File.h>
#include <Display.h>
#include <charset.h>
typedef struct{
@ -45,24 +46,24 @@ typedef struct{
class Buffer {
public:
Buffer(void);
Buffer(Edn::File &newName);
Buffer(etk::File &newName);
virtual ~Buffer(void);
Edn::File GetFileName(void)
etk::File GetFileName(void)
{
return m_fileName;
};
void SetFileName(Edn::File &newName)
void SetFileName(etk::File &newName)
{
m_fileName = newName;
m_haveName = true;
NameChange();
};
void SetFileName(Edn::String &newName)
void SetFileName(etk::String &newName)
{
m_fileName.SetCompleateName(newName);
m_fileName.SetCompleateName(newName, etk::FILE_TYPE_DIRECT);
m_haveName = true;
NameChange();
};
@ -102,16 +103,16 @@ class Buffer {
virtual void Copy(int8_t clipboardID);
virtual void Cut(int8_t clipboardID);
virtual void Paste(int8_t clipboardID);
virtual void Search(Edn::String &data, bool back, bool caseSensitive, bool wrap, bool regExp);
virtual void Replace(Edn::String &data);
virtual int32_t FindLine(Edn::String &data);
virtual void Search(etk::String &data, bool back, bool caseSensitive, bool wrap, bool regExp);
virtual void Replace(etk::String &data);
virtual int32_t FindLine(etk::String &data);
virtual void JumpAtLine(int32_t newLine);
virtual int32_t GetCurrentLine(void);
protected:
bool m_fileModify; //!<
// naming
Edn::File m_fileName; //!< filename of the curent buffer
etk::File m_fileName; //!< filename of the curent buffer
bool m_haveName; //!< to know if the file have a name or NOT
};

10
jni/edn/Buffer/BufferEmpty.cpp
View File

@ -23,11 +23,11 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "BufferEmpty.h"
#include "ColorizeManager.h"
#include "MainWindows.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <BufferEmpty.h>
#include <ColorizeManager.h>
#include <MainWindows.h>
#undef __class__
#define __class__ "BufferEmpty"

2
jni/edn/Buffer/BufferEmpty.h
View File

@ -26,7 +26,7 @@
#ifndef __BUFFER_EMPTY_H__
#define __BUFFER_EMPTY_H__
#include "Buffer.h"
#include <Buffer.h>
class BufferEmpty : public Buffer {
public:

13
jni/edn/Buffer/BufferManager.cpp
View File

@ -24,10 +24,9 @@
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "BufferManager.h"
//#include "MsgBroadcast.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <BufferManager.h>
#undef __class__
#define __class__ "BufferManager"
@ -185,7 +184,7 @@ int32_t BufferManager::Create(void)
* @todo : check if this file is not curently open and return the old ID
*
*/
int32_t BufferManager::Open(Edn::File &myFile)
int32_t BufferManager::Open(etk::File &myFile)
{
// TODO : Check here if the file is already open ==> and display it if needed
// allocate a new Buffer
@ -236,7 +235,7 @@ bool BufferManager::Exist(int32_t BufferID)
}
bool BufferManager::Exist(Edn::File &myFile )
bool BufferManager::Exist(etk::File &myFile )
{
if (-1 == GetId(myFile)) {
return false;
@ -245,7 +244,7 @@ bool BufferManager::Exist(Edn::File &myFile )
}
int32_t BufferManager::GetId(Edn::File &myFile)
int32_t BufferManager::GetId(etk::File &myFile)
{
int32_t iii;
// check if the Buffer existed

22
jni/edn/Buffer/BufferManager.h
View File

@ -26,15 +26,15 @@
#ifndef __BUFFER_MANAGER_H__
#define __BUFFER_MANAGER_H__
#include "Buffer.h"
#include "BufferText.h"
#include "BufferEmpty.h"
#include "Singleton.h"
#include "MsgBroadcast.h"
#include <Buffer.h>
#include <BufferText.h>
#include <BufferEmpty.h>
#include <etk/Singleton.h>
#include <MsgBroadcast.h>
class BufferManager: public Singleton<BufferManager>, public MsgBroadcast
class BufferManager: public etk::Singleton<BufferManager>, public MsgBroadcast
{
friend class Singleton<BufferManager>;
friend class etk::Singleton<BufferManager>;
// specific for sigleton system...
private:
// Constructeur
@ -48,13 +48,13 @@ class BufferManager: public Singleton<BufferManager>, public MsgBroadcast
// create a buffer with no element
int32_t Create(void);
// open curent filename
int32_t Open(Edn::File &myFile);
int32_t Open(etk::File &myFile);
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(Edn::File &myFile);
int32_t GetId(Edn::File &myFile);
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);
int32_t WitchBuffer(int32_t iEmeElement);
@ -63,7 +63,7 @@ class BufferManager: public Singleton<BufferManager>, public MsgBroadcast
private:
Edn::VectorType<Buffer*> listBuffer; //!< element List of the char Elements
etk::VectorType<Buffer*> listBuffer; //!< element List of the char Elements
void RemoveAll(void); //!< remove all buffer
int32_t m_idSelected;

51
jni/edn/Buffer/BufferText.cpp
View File

@ -23,13 +23,12 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "ClipBoard.h"
#include "BufferText.h"
#include "toolsMemory.h"
#include "Edn.h"
#include "RegExp.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <ClipBoard.h>
#include <BufferText.h>
#include <toolsMemory.h>
#include <etk/RegExp.h>
#undef __class__
#define __class__ "BufferText"
@ -125,7 +124,7 @@ BufferText::BufferText()
* @return ---
*
*/
BufferText::BufferText(Edn::File &fileName) : Buffer(fileName)
BufferText::BufferText(etk::File &fileName) : Buffer(fileName)
{
BasicInit();
NameChange();
@ -327,8 +326,8 @@ int32_t BufferText::Display(DrawerManager &drawer)
int displayLines = 0;
// Regenerate the colorizing if necessary ...
m_EdnBuf.HightlightGenerateLines(m_displayLocalSyntax, m_displayStartBufferPos, m_displaySize.y);
GTimeVal timeStart;
g_get_current_time(&timeStart);
//GTimeVal timeStart;
//g_get_current_time(&timeStart);
// draw the lineNumber :
int32_t currentLineID = m_displayStart.y+1;
@ -450,9 +449,9 @@ int32_t BufferText::Display(DrawerManager &drawer)
}
drawer.Flush();
GTimeVal timeStop;
g_get_current_time(&timeStop);
EDN_DEBUG("Display Generation = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s");
//GTimeVal timeStop;
//g_get_current_time(&timeStop);
//EDN_DEBUG("Display Generation = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s");
return ERR_NONE;
}
@ -993,7 +992,7 @@ void BufferText::AddChar(char * UTF8data)
if (1==size) {
if (UTF8data[0] == 0x09) {
if (false == haveSelectionActive) {
Edn::VectorType<int8_t> tmpVect;
etk::VectorType<int8_t> tmpVect;
tmpVect.PushBack(0x09);
m_EdnBuf.Insert(m_cursorPos, tmpVect);
SetInsertPosition(m_cursorPos+1, true);
@ -1002,7 +1001,7 @@ void BufferText::AddChar(char * UTF8data)
// count the number of line :
int32_t nbSelectedLines = m_EdnBuf.CountLines(SelectionStart, SelectionEnd);
if (0 == nbSelectedLines) {
Edn::VectorType<int8_t> tmpVect;
etk::VectorType<int8_t> tmpVect;
tmpVect.PushBack(0x09);
m_EdnBuf.ReplaceSelected(SELECTION_PRIMARY, tmpVect);
SetInsertPosition(SelectionStart+tmpVect.Size(), true);
@ -1016,7 +1015,7 @@ void BufferText::AddChar(char * UTF8data)
}
actionDone = true;
} else if (UTF8data[0] == '\n') {
Edn::VectorType<int8_t> tmpVect;
etk::VectorType<int8_t> tmpVect;
if (true == globals::IsSetShift()) {
tmpVect.PushBack('\r');
} else {
@ -1075,7 +1074,7 @@ void BufferText::AddChar(char * UTF8data)
if (false == actionDone) {
if (true == m_EdnBuf.GetUTF8Mode()) {
Edn::VectorType<int8_t> tmpVect;
etk::VectorType<int8_t> tmpVect;
int32_t localOfset = strlen(UTF8data);
tmpVect.PushBack((int8_t*)UTF8data, localOfset);
if (false == haveSelectionActive) {
@ -1090,7 +1089,7 @@ void BufferText::AddChar(char * UTF8data)
char output_ISO;
convertUtf8ToIso(m_EdnBuf.GetCharsetType(), UTF8data, output_ISO);
//printf(" insert : \"%s\"==> 0x%08x=%d ", UTF8data, (unsigned int)output_ISO, (int)output_ISO);
Edn::VectorType<int8_t> tmpVect;
etk::VectorType<int8_t> tmpVect;
tmpVect.PushBack(output_ISO);
if (false == haveSelectionActive) {
m_EdnBuf.Insert(m_cursorPos, tmpVect);
@ -1107,14 +1106,14 @@ void BufferText::AddChar(char * UTF8data)
}
int32_t BufferText::FindLine(Edn::String &data)
int32_t BufferText::FindLine(etk::String &data)
{
if ( 0 == data.Size()) {
EDN_WARNING("no search data");
return 0;
}
EDN_INFO("Search data line : \"" << data << "\"");
Edn::VectorType<int8_t> mVectSearch;
etk::VectorType<int8_t> mVectSearch;
mVectSearch = data.GetVector();
//EDN_INFO("search data Forward : startSearchPos=" << startSearchPos );
int32_t foundPos;
@ -1151,7 +1150,7 @@ int32_t BufferText::GetCurrentLine(void)
void BufferText::Search(Edn::String &data, bool back, bool caseSensitive, bool wrap, bool regExp)
void BufferText::Search(etk::String &data, bool back, bool caseSensitive, bool wrap, bool regExp)
{
EDN_INFO("Search data : \"" << data << "\"");
@ -1172,7 +1171,7 @@ void BufferText::Search(Edn::String &data, bool back, bool caseSensitive, bool w
EDN_WARNING("no search data");
return;
}
Edn::VectorType<int8_t> mVectSearch;
etk::VectorType<int8_t> mVectSearch;
mVectSearch = data.GetVector();
if (false == back) {
//EDN_INFO("search data Forward : startSearchPos=" << startSearchPos );
@ -1239,14 +1238,14 @@ void BufferText::Search(Edn::String &data, bool back, bool caseSensitive, bool w
}
void BufferText::Replace(Edn::String &data)
void BufferText::Replace(etk::String &data)
{
int32_t SelectionStart, SelectionEnd, SelectionRectStart, SelectionRectEnd;
bool SelectionIsRect;
bool haveSelectionActive = m_EdnBuf.GetSelectionPos(SELECTION_PRIMARY, SelectionStart, SelectionEnd, SelectionIsRect, SelectionRectStart, SelectionRectEnd);
if (true == haveSelectionActive) {
// Replace Data :
Edn::VectorType<int8_t> myData = data.GetVector();
etk::VectorType<int8_t> myData = data.GetVector();
m_EdnBuf.ReplaceSelected(SELECTION_PRIMARY, myData);
SetInsertPosition(SelectionStart + myData.Size());
}
@ -1264,7 +1263,7 @@ void BufferText::Replace(Edn::String &data)
*/
void BufferText::Copy(int8_t clipboardID)
{
Edn::VectorType<int8_t> mVect;
etk::VectorType<int8_t> mVect;
// get the curent selected data
if (true == m_EdnBuf.SelectHasSelection(SELECTION_PRIMARY) ) {
m_EdnBuf.GetSelectionText(SELECTION_PRIMARY, mVect);
@ -1313,7 +1312,7 @@ void BufferText::Cut(int8_t clipboardID)
*/
void BufferText::Paste(int8_t clipboardID)
{
Edn::VectorType<int8_t> mVect;
etk::VectorType<int8_t> mVect;
// copy data from the click board :
ClipBoard::Get(clipboardID, mVect);

8
jni/edn/Buffer/BufferText.h
View File

@ -39,7 +39,7 @@ typedef enum {
class BufferText : public Buffer {
public:
BufferText(void);
BufferText(Edn::File &fileName);
BufferText(etk::File &fileName);
virtual ~BufferText(void);
void Save(void);
@ -61,9 +61,9 @@ class BufferText : public Buffer {
void Cut(int8_t clipboardID);
void Paste(int8_t clipboardID);
void Search(Edn::String &data, bool back, bool caseSensitive, bool wrap, bool regExp);
void Replace(Edn::String &data);
int32_t FindLine(Edn::String &data);
void Search(etk::String &data, bool back, bool caseSensitive, bool wrap, bool regExp);
void Replace(etk::String &data);
int32_t FindLine(etk::String &data);
void JumpAtLine(int32_t newLine);
int32_t GetCurrentLine(void);

13
jni/edn/Colorize/Colorize.cpp
View File

@ -23,17 +23,16 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "Colorize.h"
#include "Edn.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <Colorize.h>
#undef __class__
#define __class__ "Colorize"
Colorize::Colorize( Edn::String &newColorName)
Colorize::Colorize( etk::String &newColorName)
{
m_colorFG.red=0;
@ -82,14 +81,14 @@ void Colorize::SetName(const char *newColorName)
ColorName = newColorName;
}
void Colorize::SetName(Edn::String &newColorName)
void Colorize::SetName(etk::String &newColorName)
{
//EDN_INFO("color change name : \"%s\" ==> \"%s\"",ColorName.c_str(), newColorName.c_str());
ColorName = newColorName;
}
Edn::String Colorize::GetName(void)
etk::String Colorize::GetName(void)
{
return ColorName;
}

18
jni/edn/Colorize/Colorize.h
View File

@ -25,9 +25,7 @@
#ifndef __COLORIZE_H__
#define __COLORIZE_H__
#include "Edn.h"
/*
extern "C" {
typedef struct {
float red;
@ -35,22 +33,22 @@ extern "C" {
float blue;
} color_ts;
}
*/
class Colorize {
public:
// Constructeur
Colorize(void);
Colorize(Edn::String &newColorName);
Colorize(etk::String &newColorName);
~Colorize(void);
void SetName(Edn::String &newColorName);
void SetName(etk::String &newColorName);
void SetName(const char *newColorName);
Edn::String GetName(void);
etk::String GetName(void);
void SetFgColor(const char *myColor);
void SetBgColor(const char *myColor);
void ApplyFG(cairo_t * cr) { cairo_set_source_rgba(cr, m_colorFG.red, m_colorFG.green, m_colorFG.blue, 1); };
void ApplyBG(cairo_t * cr) { cairo_set_source_rgba(cr, m_colorBG.red, m_colorBG.green, m_colorBG.blue, 1); };
//void ApplyFG(cairo_t * cr) { cairo_set_source_rgba(cr, m_colorFG.red, m_colorFG.green, m_colorFG.blue, 1); };
//void ApplyBG(cairo_t * cr) { cairo_set_source_rgba(cr, m_colorBG.red, m_colorBG.green, m_colorBG.blue, 1); };
color_ts & GetFG(void) { return m_colorFG; };
color_ts & GetBG(void) { return m_colorBG; };
@ -65,7 +63,7 @@ class Colorize {
void Display(int32_t i) { EDN_INFO(" " << i << " : \"" << ColorName.c_str() << "\"" /*<< " fg="<< m_colorFG.red <<","<< m_colorFG.green <<","<< m_colorFG.blue <<" bg="<< m_colorBG.red <<","<< m_colorBG.green <<","<< m_colorBG.blue*/ ); };
private:
Edn::String ColorName; //!< curent color Name
etk::String ColorName; //!< curent color Name
color_ts m_colorFG;
color_ts m_colorBG;

24
jni/edn/Colorize/ColorizeManager.cpp
View File

@ -22,10 +22,10 @@
*
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "ColorizeManager.h"
#include "tinyxml.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <ColorizeManager.h>
#include <tinyXML/tinyxml.h>
#define PFX "ColorizeManager "
@ -58,8 +58,8 @@ void ColorizeManager::OnMessage(int32_t id, int32_t dataID)
case EDN_MSG__RELOAD_COLOR_FILE:
{
// Reaload File
// TODO : Check this : Pb in the recopy Edn::String element
Edn::String plop = m_fileColor;
// TODO : Check this : Pb in the recopy etk::String element
etk::String plop = m_fileColor;
LoadFile(plop.c_str());
}
break;
@ -67,7 +67,7 @@ void ColorizeManager::OnMessage(int32_t id, int32_t dataID)
}
void ColorizeManager::LoadFile(Edn::String &xmlFilename)
void ColorizeManager::LoadFile(etk::String &xmlFilename)
{
LoadFile(xmlFilename.c_str());
}
@ -236,7 +236,7 @@ Colorize *ColorizeManager::Get(const char *colorName)
{
int32_t i;
for (i=0; i<listMyColor.Size(); i++) {
Edn::String elementName = listMyColor[i]->GetName();
etk::String elementName = listMyColor[i]->GetName();
if (elementName == colorName) {
return listMyColor[i];
}
@ -246,7 +246,7 @@ Colorize *ColorizeManager::Get(const char *colorName)
return errorColor;
}
Colorize *ColorizeManager::Get(Edn::String &colorName)
Colorize *ColorizeManager::Get(etk::String &colorName)
{
return Get(colorName.c_str());
}
@ -265,14 +265,14 @@ bool ColorizeManager::Exist(const char *colorName)
{
int32_t i;
for (i=0; i<listMyColor.Size(); i++) {
Edn::String elementName = listMyColor[i]->GetName();
etk::String elementName = listMyColor[i]->GetName();
if (elementName == colorName) {
return true;
}
}
return false;
}
bool ColorizeManager::Exist(Edn::String &colorName)
bool ColorizeManager::Exist(etk::String &colorName)
{
return Exist(colorName.c_str());
}
@ -282,7 +282,7 @@ void ColorizeManager::DisplayListOfColor(void)
int32_t i;
EDN_INFO(PFX"List of ALL COLOR : ");
for (i=0; i<listMyColor.Size(); i++) {
//Edn::String elementName = listMyColor[i]->GetName();
//etk::String elementName = listMyColor[i]->GetName();
//EDN_INFO(i << " : \"" << elementName.c_str() << "\"" );
listMyColor[i]->Display(i);
}

21
jni/edn/Colorize/ColorizeManager.h
View File

@ -26,10 +26,9 @@
#ifndef __COLORIZE_MANAGER_H__
#define __COLORIZE_MANAGER_H__
#include "Singleton.h"
#include "Colorize.h"
#include "MsgBroadcast.h"
#include "Edn.h"
#include <etk/Singleton.h>
#include <Colorize.h>
#include <MsgBroadcast.h>
typedef enum {
// BASIC color for codeViewer
@ -50,9 +49,9 @@ typedef enum {
class ColorizeManager: public Singleton<ColorizeManager>, public MsgBroadcast
class ColorizeManager: public etk::Singleton<ColorizeManager>, public MsgBroadcast
{
friend class Singleton<ColorizeManager>;
friend class etk::Singleton<ColorizeManager>;
// specific for sigleton system...
private:
// Constructeur
@ -61,18 +60,18 @@ class ColorizeManager: public Singleton<ColorizeManager>, public MsgBroadcast
public:
void OnMessage(int32_t id, int32_t dataID);
public:
void LoadFile(Edn::String &xmlFilename);
void LoadFile(etk::String &xmlFilename);
void LoadFile(const char * xmlFilename);
Colorize * Get(const char *colorName);
Colorize * Get(Edn::String &colorName);
Colorize * Get(etk::String &colorName);
color_ts & Get(basicColor_te myColor);
bool Exist(Edn::String &colorName);
bool Exist(etk::String &colorName);
bool Exist(const char *colorName);
void DisplayListOfColor(void);
private:
Edn::String m_fileColor;
Edn::VectorType<Colorize*> listMyColor; //!< List of ALL Color
etk::String m_fileColor;
etk::VectorType<Colorize*> listMyColor; //!< List of ALL Color
Colorize * errorColor;
color_ts basicColors[COLOR_NUMBER_MAX];
};

32
jni/edn/CustumWidget/BufferView/BufferView.cpp
View File

@ -23,13 +23,13 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "Display.h"
#include "BufferView.h"
#include "BufferManager.h"
#include "ColorizeManager.h"
#include "MainWindows.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <Display.h>
#include <BufferView.h>
#include <BufferManager.h>
#include <ColorizeManager.h>
#include <MainWindows.h>
#undef __class__
#define __class__ "BufferView"
@ -39,9 +39,9 @@ BufferView::BufferView(void) : MsgBroadcast("Buffer View", EDN_CAT_GUI)
m_shawableAreaX = 0;
m_shawableAreaY = 0;
// Init link with the buffer Manager
m_bufferManager = BufferManager::getInstance();
m_colorManager = ColorizeManager::getInstance();
//m_bufferManager = BufferManager::Get();
//m_colorManager = ColorizeManager::Get();
#if 0
m_widget = gtk_drawing_area_new();
gtk_widget_set_size_request( m_widget, 250, 100);
@ -74,6 +74,7 @@ BufferView::BufferView(void) : MsgBroadcast("Buffer View", EDN_CAT_GUI)
# elif defined( USE_GTK_VERSION_2_0 )
g_signal_connect( G_OBJECT(m_widget), "expose_event", G_CALLBACK(CB_displayDraw), this);
# endif
#endif
m_selectedID = -1;
}
@ -82,11 +83,12 @@ BufferView::~BufferView(void)
{
}
/*
GtkWidget * BufferView::GetMainWidget(void)
{
return m_widget;
}
*/
void BufferView::OnMessage(int32_t id, int32_t dataID)
{
@ -98,15 +100,15 @@ void BufferView::OnMessage(int32_t id, int32_t dataID)
case EDN_MSG__BUFFER_CHANGE_NAME:
case EDN_MSG__BUFFER_CHANGE_MODIFY:
// change Title :
gtk_widget_queue_draw(m_widget);
//gtk_widget_queue_draw(m_widget);
break;
case EDN_MSG__USER_DISPLAY_CHANGE:
// Redraw all the display ...
gtk_widget_queue_draw(m_widget);
//gtk_widget_queue_draw(m_widget);
break;
}
}
#if 0
gboolean BufferView::CB_displayDraw( GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
@ -381,5 +383,5 @@ gint BufferView::CB_mouseMotionEvent( GtkWidget *widget, GdkEventMotion *event,
*/
return true;
}
#endif

20
jni/edn/CustumWidget/BufferView/BufferView.h
View File

@ -25,12 +25,11 @@
#ifndef __BUFFER_VIEW_H__
#define __BUFFER_VIEW_H__
#include "tools_debug.h"
#include "Singleton.h"
#include "CodeView.h"
#include "BufferManager.h"
#include "Display.h"
#include "MsgBroadcast.h"
#include <tools_debug.h>
#include <CodeView.h>
#include <BufferManager.h>
#include <Display.h>
#include <MsgBroadcast.h>
@ -40,8 +39,9 @@ class BufferView : public MsgBroadcast
// Constructeur
BufferView(void);
~BufferView(void);
GtkWidget *GetMainWidget(void);
//GtkWidget *GetMainWidget(void);
void OnMessage(int32_t id, int32_t dataID);
/*
// sur : GTK+ callback :
static gboolean CB_displayDraw( GtkWidget *widget, GdkEventExpose *event, gpointer data);
static gboolean CB_displayInit( GtkWidget *widget, gpointer data);
@ -56,12 +56,12 @@ class BufferView : public MsgBroadcast
static void OnPopupEventClose(GtkWidget *menuitem, gpointer data);
static void OnPopupEventSave(GtkWidget *menuitem, gpointer data);
static void OnPopupEventSaveAs(GtkWidget *menuitem, gpointer data);
*/
private:
void ViewPopupMenu(GtkWidget *parrent, GdkEventButton *event, int32_t BufferID);
//void ViewPopupMenu(GtkWidget *parrent, GdkEventButton *event, int32_t BufferID);
// main windows widget :
GtkWidget * m_widget;
//GtkWidget * m_widget;
// récupération des proprieter général...
BufferManager * m_bufferManager;
ColorizeManager * m_colorManager;

41
jni/edn/CustumWidget/CodeView/CodeView.cpp
View File

@ -24,16 +24,16 @@
*******************************************************************************
*/
#include "CodeView.h"
#include <CodeView.h>
#include "tools_debug.h"
#include "tools_globals.h"
#include "Display.h"
#include "CodeView.h"
#include "BufferManager.h"
#include "ColorizeManager.h"
#include "ClipBoard.h"
#include "SearchData.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <Display.h>
#include <CodeView.h>
#include <BufferManager.h>
#include <ColorizeManager.h>
#include <ClipBoard.h>
#include <SearchData.h>
CodeView::CodeView(void) : MsgBroadcast("Code View", EDN_CAT_WORK_AREA)
@ -44,9 +44,9 @@ CodeView::CodeView(void) : MsgBroadcast("Code View", EDN_CAT_WORK_AREA)
m_shawableAreaY = 0;
// Init link with the buffer Manager
m_bufferManager = BufferManager::getInstance();
m_colorManager = ColorizeManager::getInstance();
//m_bufferManager = BufferManager::Get();
//m_colorManager = ColorizeManager::Get();
/*
m_widget = gtk_drawing_area_new();
gtk_widget_set_size_request( m_widget, 200, 100);
@ -79,18 +79,19 @@ CodeView::CodeView(void) : MsgBroadcast("Code View", EDN_CAT_WORK_AREA)
# elif defined( USE_GTK_VERSION_2_0 )
g_signal_connect( G_OBJECT(m_widget), "expose_event", G_CALLBACK(CB_displayDraw), this);
# endif
*/
}
CodeView::~CodeView(void)
{
}
/*
GtkWidget * CodeView::GetMainWidget(void)
{
return m_widget;
}
*/
void CodeView::OnMessage(int32_t id, int32_t dataID)
{
@ -138,21 +139,21 @@ void CodeView::OnMessage(int32_t id, int32_t dataID)
break;
case EDN_MSG__CURRENT_FIND_PREVIOUS:
{
Edn::String myDataString;
etk::String myDataString;
SearchData::GetSearch(myDataString);
m_bufferManager->Get(m_bufferID)->Search(myDataString, true, SearchData::GetCase(), SearchData::GetWrap(), SearchData::GetRegExp() );
}
break;
case EDN_MSG__CURRENT_FIND_NEXT:
{
Edn::String myDataString;
etk::String myDataString;
SearchData::GetSearch(myDataString);
m_bufferManager->Get(m_bufferID)->Search(myDataString, false, SearchData::GetCase(), SearchData::GetWrap(), SearchData::GetRegExp() );
}
break;
case EDN_MSG__CURRENT_REPLACE:
{
Edn::String myDataString;
etk::String myDataString;
SearchData::GetReplace(myDataString);
m_bufferManager->Get(m_bufferID)->Replace(myDataString);
}
@ -184,11 +185,11 @@ void CodeView::OnMessage(int32_t id, int32_t dataID)
break;
}
// Force redraw of the widget
gtk_widget_queue_draw(m_widget);
//gtk_widget_queue_draw(m_widget);
}
#if 0
gboolean CodeView::CB_displayDraw( GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
CodeView * self = reinterpret_cast<CodeView*>(data);
@ -416,6 +417,6 @@ gint CodeView::CB_mouseScrollEvent( GtkWidget *widget, GdkEventScroll *event, gp
}
#endif

15
jni/edn/CustumWidget/CodeView/CodeView.h
View File

@ -26,12 +26,11 @@
#ifndef __CODE_VIEW_H__
#define __CODE_VIEW_H__
#include "tools_debug.h"
#include "Singleton.h"
#include "CodeView.h"
#include "BufferManager.h"
#include "Display.h"
#include "MsgBroadcast.h"
#include <tools_debug.h>
#include <CodeView.h>
#include <BufferManager.h>
#include <Display.h>
#include <MsgBroadcast.h>
class CodeView : public MsgBroadcast
{
@ -40,6 +39,7 @@ class CodeView : public MsgBroadcast
CodeView(void);
~CodeView(void);
void OnMessage(int32_t id, int32_t dataID);
/*
GtkWidget *GetMainWidget(void);
// sur : GTK+ callback :
static gboolean CB_displayDraw( GtkWidget *widget, GdkEventExpose *event, gpointer data);
@ -50,10 +50,11 @@ class CodeView : public MsgBroadcast
static gint CB_mouseButtonEvent(GtkWidget *widget, GdkEventButton *event, gpointer data);
static gint CB_mouseMotionEvent( GtkWidget *widget, GdkEventMotion *event, gpointer data);
static gint CB_mouseScrollEvent( GtkWidget *widget, GdkEventScroll *event, gpointer data);
*/
private:
// main windows widget :
GtkWidget * m_widget;
//GtkWidget * m_widget;
// récupération des proprieter général...
BufferManager * m_bufferManager;
ColorizeManager * m_colorManager;

59
jni/edn/CustumWidget/MainAreaView/MainAreaView.cpp
View File

@ -1,59 +0,0 @@
/**
*******************************************************************************
* @file Search.h
* @brief Editeur De N'ours : Search system (header)
* @author Edouard DUPIN
* @date 03/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 __SEARCH_H__
#define __SEARCH_H__
#include "tools_debug.h"
#include "Singleton.h"
class MainAreaView: public Singleton<MainAreaView>
{
friend class Singleton<MainAreaView>;
// specific for sigleton system...
private:
// Constructeur
MainAreaView(void);
~MainAreaView(void);
public:
GtkWidget * GetWidget(void);
void SplitV(void); // split current window vertically (max 1 by section)
void SplitH(void); // split current window horizontaly (max 3)
void Remove(void); // remove current selected element
//ViewArea * GetCurent(void); // Get a pointer on the current displayed area
private:
GtkWidget * m_localDialog; //!< local dialog element
ViewArea * m_EntrySearch[6];
uint8_t m_CurentSelected
};
#endif

0
jni/edn/CustumWidget/MainAreaView/MainAreaView.h
View File

46
jni/edn/GuiTools/MainWindows/MainWindows.cpp
View File

@ -23,25 +23,25 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "MainWindows.h"
#include "CodeView.h"
#include "ClipBoard.h"
#include "BufferView.h"
#include "AccelKey.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <MainWindows.h>
#include <CodeView.h>
#include <ClipBoard.h>
#include <BufferView.h>
#include <AccelKey.h>
#undef __class__
#define __class__ "MainWindows"
MainWindows::MainWindows(void) : MsgBroadcast("Main Windows", EDN_CAT_GUI)
{
#if 0
m_mainWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
// select the program icone
GError *err = NULL;
Edn::String iconeFile;
etk::String iconeFile;
#ifdef NDEBUG
iconeFile = "/usr/share/edn/images/icone.png";
#else
@ -79,7 +79,7 @@ MainWindows::MainWindows(void) : MsgBroadcast("Main Windows", EDN_CAT_GUI)
GtkWidget *hboxMenu = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start( GTK_BOX (vbox), hboxMenu, FALSE, FALSE, 0);
// Add Exit boutton
Edn::String ExitIconeFile;
etk::String ExitIconeFile;
#ifdef NDEBUG
ExitIconeFile = "/usr/share/edn/images/delete-24px.png";
#else
@ -140,7 +140,7 @@ MainWindows::MainWindows(void) : MsgBroadcast("Main Windows", EDN_CAT_GUI)
// recursive version of gtk_widget_show
gtk_widget_show_all(m_mainWindow);
#endif
}
MainWindows::~MainWindows(void)
@ -154,9 +154,9 @@ MainWindows::~MainWindows(void)
void MainWindows::SetTitle(Edn::File &fileName, bool isModify)
void MainWindows::SetTitle(etk::File &fileName, bool isModify)
{
Edn::String tmp = "";
etk::String tmp = "";
if (fileName.GetShortFilename() != "") {
tmp += fileName.GetShortFilename();
tmp += " - ";
@ -164,7 +164,7 @@ void MainWindows::SetTitle(Edn::File &fileName, bool isModify)
tmp += " - ";
}
tmp += "Edn";
gtk_window_set_title(GTK_WINDOW(m_mainWindow), tmp.c_str());
//gtk_window_set_title(GTK_WINDOW(m_mainWindow), tmp.c_str());
tmp = " ";
if (fileName.GetShortFilename() != "") {
tmp += fileName.GetFolder();
@ -173,16 +173,16 @@ void MainWindows::SetTitle(Edn::File &fileName, bool isModify)
} else {
tmp += "Edn";
}
tmp += " ";
gtk_label_set_text(GTK_LABEL(m_internalTitleLabel), tmp.c_str());
tmp += " ";
//gtk_label_set_text(GTK_LABEL(m_internalTitleLabel), tmp.c_str());
}
void MainWindows::SetNoTitle(void)
{
Edn::String tmp = "Edn";
gtk_window_set_title(GTK_WINDOW(m_mainWindow), tmp.c_str());
gtk_label_set_text(GTK_LABEL(m_internalTitleLabel), tmp.c_str());
etk::String tmp = "Edn";
//gtk_window_set_title(GTK_WINDOW(m_mainWindow), tmp.c_str());
//gtk_label_set_text(GTK_LABEL(m_internalTitleLabel), tmp.c_str());
}
void MainWindows::OnMessage(int32_t id, int32_t dataID)
@ -195,16 +195,18 @@ void MainWindows::OnMessage(int32_t id, int32_t dataID)
if (-1 == dataID) {
SetNoTitle();
} else {
/*
Buffer *mybuf = BufferManager::getInstance()->Get(dataID);
if (NULL != mybuf) {
Edn::File plop = mybuf->GetFileName();
etk::File plop = mybuf->GetFileName();
SetTitle(plop, mybuf->IsModify() );
}
*/
}
break;
}
}
/*
bool MainWindows::OnQuit(GtkWidget *widget, gpointer data)
{
//MainWindows * self = reinterpret_cast<MainWindows*>(data);
@ -232,7 +234,7 @@ gboolean MainWindows::OnStateChange(GtkWidget *widget, GdkEvent* event, gpointer
}
}
}
*/

32
jni/edn/GuiTools/MainWindows/MainWindows.h
View File

@ -24,39 +24,40 @@
*/
#include "tools_debug.h"
#include "Singleton.h"
#include "MsgBroadcast.h"
#include <tools_debug.h>
#include <etk/Singleton.h>
#include <MsgBroadcast.h>
#include "CodeView.h"
#include "BufferView.h"
#include "BufferManager.h"
#include "MenuBar.h"
#include "StatusBar.h"
#include "ToolBar.h"
#include <CodeView.h>
#include <BufferView.h>
#include <BufferManager.h>
#include <MenuBar.h>
#include <StatusBar.h>
#include <ToolBar.h>
#ifndef __MAIN_WINDOWS_H__
#define __MAIN_WINDOWS_H__
class MainWindows: public Singleton<MainWindows>, public MsgBroadcast
class MainWindows: public etk::Singleton<MainWindows>, public MsgBroadcast
{
friend class Singleton<MainWindows>;
friend class etk::Singleton<MainWindows>;
// specific for sigleton system...
private:
// Constructeur
MainWindows(void);
~MainWindows(void);
public:
GtkWidget * GetWidget(void) { return m_mainWindow;};
//GtkWidget * GetWidget(void) { return m_mainWindow;};
void OnMessage(int32_t id, int32_t dataID);
static bool OnQuit(GtkWidget *widget, gpointer data);
static gboolean OnStateChange(GtkWidget *widget, GdkEvent* event, gpointer data);
//static bool OnQuit(GtkWidget *widget, gpointer data);
//static gboolean OnStateChange(GtkWidget *widget, GdkEvent* event, gpointer data);
private:
void SetTitle(Edn::File &fileName, bool isModify);
void SetTitle(etk::File &fileName, bool isModify);
void SetNoTitle(void);
// main windows widget :
/*
GtkWidget * m_mainWindow;
GtkWidget * m_internalTitleLabel;
BufferView m_BufferView;
@ -64,6 +65,7 @@ class MainWindows: public Singleton<MainWindows>, public MsgBroadcast
MenuBar m_MenuBar;
StatusBar m_StatusBar;
ToolBar m_ToolBar;
*/
};
#endif

20
jni/edn/GuiTools/MainWindows/MenuBar.cpp
View File

@ -24,12 +24,12 @@
*/
#include "tools_debug.h"
#include "MenuBar.h"
#include "ClipBoard.h"
#include "charset.h"
#include "ColorizeManager.h"
#include <tools_debug.h>
#include <MenuBar.h>
#include <ClipBoard.h>
#include <charset.h>
#include <ColorizeManager.h>
#if 0
#define MENU_MSG
const char * MSG_TogleDisplayChar = "Request a Togle of char displaying";
const char * MSG_TogleDisplayEOL = "Request a Togle of displaying EndOfLine";
@ -79,7 +79,7 @@ static void CB_menuInternal(GtkMenuItem *menu_item, gpointer data)
GeneralSendMessage(EDN_MSG__CURRENT_SET_CHARSET, EDN_CHARSET_UTF8);
} else if (myPointer == MSG_LoadColorWhite) {
ColorizeManager * myColorSystem = ColorizeManager::getInstance();
Edn::String homedir;
etk::String homedir;
# ifdef NDEBUG
homedir = "/usr/share/edn/";
# else
@ -89,7 +89,7 @@ static void CB_menuInternal(GtkMenuItem *menu_item, gpointer data)
myColorSystem->LoadFile(homedir);
} else if (myPointer == MSG_LoadColorBlack) {
ColorizeManager * myColorSystem = ColorizeManager::getInstance();
Edn::String homedir;
etk::String homedir;
# ifdef NDEBUG
homedir = "/usr/share/edn/";
# else
@ -217,7 +217,7 @@ class MenuBarMain
GtkWidget * m_parent;
GtkWidget * m_menu;
GtkWidget * m_menuListe;
Edn::VectorType<messageData_ts*> m_message;
etk::VectorType<messageData_ts*> m_message;
};
#undef __class__
@ -383,4 +383,4 @@ void MenuBar::OnMessage(int32_t id, int32_t dataID)
//EDN_INFO("ReceiveMessage");
}
#endif

24
jni/edn/GuiTools/MainWindows/MenuBar.h
View File

@ -23,30 +23,32 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "MsgBroadcast.h"
#include "VectorType.h"
#include "AccelKey.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <MsgBroadcast.h>
#include <etk/VectorType.h>
#include <AccelKey.h>
#ifndef __MENU_BAR_H__
#define __MENU_BAR_H__
class MenuBarMain;
//class MenuBarMain;
class MenuBar: public MsgBroadcast
{
public:
// Constructeur
MenuBar(void);
~MenuBar(void);
GtkWidget * GetWidget(void) { return m_mainWidget; };
void OnMessage(int32_t id, int32_t dataID);
MenuBar(void) : MsgBroadcast("Menu bar", EDN_CAT_GUI){};
~MenuBar(void) {};
//GtkWidget * GetWidget(void) { return m_mainWidget; };
void OnMessage(int32_t id, int32_t dataID) {};
private:
/*
GtkWidget * m_mainWidget;
GtkAccelGroup * m_accelGroup;
Edn::VectorType<MenuBarMain*> m_listMenu;
etk::VectorType<MenuBarMain*> m_listMenu;
*/
};

6
jni/edn/GuiTools/MainWindows/StatusBar.cpp
View File

@ -23,13 +23,14 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "StatusBar.h"
#include <tools_debug.h>
#include <StatusBar.h>
StatusBar::StatusBar(void) : MsgBroadcast("Status bar", EDN_CAT_GUI)
{
/*
m_mainWidget = gtk_statusbar_new();
// pas très bien compris pourquoi mais ca marche...
m_iContextId = gtk_statusbar_get_context_id(GTK_STATUSBAR(m_mainWidget), "ExitMsg");
@ -37,6 +38,7 @@ StatusBar::StatusBar(void) : MsgBroadcast("Status bar", EDN_CAT_GUI)
gtk_statusbar_push(GTK_STATUSBAR (m_mainWidget), GPOINTER_TO_INT(m_iContextId), "Edn Editeur de n'ours");
// Supression du précédent message :
//gtk_statusbar_pop(GTK_STATUSBAR(m_mainWidget), GPOINTER_TO_INT(m_iContextId));
*/
}
StatusBar::~StatusBar(void)

8
jni/edn/GuiTools/MainWindows/StatusBar.h
View File

@ -23,7 +23,7 @@
*******************************************************************************
*/
#include "MsgBroadcast.h"
#include <MsgBroadcast.h>
#ifndef __STATUS_BAR_H__
#define __STATUS_BAR_H__
@ -34,12 +34,12 @@ class StatusBar: public MsgBroadcast
// Constructeur
StatusBar(void);
~StatusBar(void);
GtkWidget * GetWidget(void) { return m_mainWidget; };
//GtkWidget * GetWidget(void) { return m_mainWidget; };
void OnMessage(int32_t id, int32_t dataID);
private:
GtkWidget * m_mainWidget;
guint m_iContextId;
//GtkWidget * m_mainWidget;
//guint m_iContextId;
};

16
jni/edn/GuiTools/MainWindows/ToolBar.cpp
View File

@ -23,10 +23,11 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "ToolBar.h"
#include "ClipBoard.h"
#include <tools_debug.h>
#include <ToolBar.h>
#include <ClipBoard.h>
/*
static void CB_menuGenerique(GtkMenuItem *menu_item, gpointer data)
{
//EDN_INFO("basic menue_event");
@ -34,11 +35,11 @@ static void CB_menuGenerique(GtkMenuItem *menu_item, gpointer data)
// broacast message :
GeneralSendMessage(msg->msgId, msg->dataId);
}
*/
ToolBar::ToolBar(void) : MsgBroadcast("Tool bar", EDN_CAT_GUI)
{
/*
m_mainWidget = gtk_toolbar_new();
# ifdef USE_GTK_VERSION_2_0
gtk_toolbar_set_orientation(GTK_TOOLBAR(m_mainWidget), GTK_ORIENTATION_VERTICAL);
@ -55,6 +56,7 @@ ToolBar::ToolBar(void) : MsgBroadcast("Tool bar", EDN_CAT_GUI)
Add(GTK_STOCK_SAVE_AS, "Enregistrer sous", EDN_MSG__CURRENT_SAVE_AS);
AddSeparator();
Add(GTK_STOCK_QUIT, "Quitter");
*/
}
ToolBar::~ToolBar(void)
@ -66,7 +68,7 @@ void ToolBar::OnMessage(int32_t id, int32_t dataID)
{
//EDN_INFO("ReceiveMessage");
}
/*
void ToolBar::AddSeparator(void)
{
# ifdef USE_GTK_VERSION_3_0
@ -87,7 +89,7 @@ void ToolBar::Add(const char * title, const char * labelHelp, messageType_te id,
gtk_toolbar_insert_stock(GTK_TOOLBAR(m_mainWidget), title, labelHelp, NULL, G_CALLBACK(CB_menuGenerique), message, -1);
# endif
}
*/

12
jni/edn/GuiTools/MainWindows/ToolBar.h
View File

@ -23,7 +23,7 @@
*******************************************************************************
*/
#include "MsgBroadcast.h"
#include <MsgBroadcast.h>
#ifndef __TOOL_BAR_H__
#define __TOOL_BAR_H__
@ -35,14 +35,14 @@ class ToolBar: public MsgBroadcast
// Constructeur
ToolBar(void);
~ToolBar(void);
GtkWidget * GetWidget(void) { return m_mainWidget; };
//GtkWidget * GetWidget(void) { return m_mainWidget; };
void OnMessage(int32_t id, int32_t dataID);
private:
void AddSeparator(void);
void Add(const char * title, const char * labelHelp, messageType_te id = EDN_MSG__NONE, bool enable = false);
GtkWidget * m_mainWidget;
Edn::VectorType<messageData_ts*> m_message;
//void AddSeparator(void);
//void Add(const char * title, const char * labelHelp, messageType_te id = EDN_MSG__NONE, bool enable = false);
//GtkWidget * m_mainWidget;
//etk::VectorType<messageData_ts*> m_message;
};

21
jni/edn/GuiTools/Search/Search.cpp
View File

@ -36,26 +36,28 @@
Search::Search(void)
: m_localDialog(NULL),
/*: m_localDialog(NULL),
m_searchLabel(NULL),
m_searchEntry(NULL),
m_replaceLabel(NULL),
m_replaceEntry(NULL),
m_CkMatchCase(NULL),
m_CkWrapAround(NULL)
m_CkWrapAround(NULL) */
{
// nothing to do ...
}
Search::~Search(void)
{
/*
if (NULL!=m_localDialog) {
gtk_widget_hide(m_localDialog);
gtk_widget_destroy(m_localDialog);
m_localDialog = NULL;
}
*/
}
/*
void Search::Display(GtkWindow *parent)
{
if(NULL == m_localDialog) {
@ -193,7 +195,7 @@ void Search::Display(GtkWindow *parent)
gtk_widget_set_sensitive(m_CkMatchCase, true);
}
// Remove data form the search
Edn::String myDataString = "";
etk::String myDataString = "";
SearchData::SetSearch(myDataString);
gtk_entry_set_text(GTK_ENTRY(m_searchEntry), myDataString.c_str());
if (0 == strlen(myDataString.c_str())) {
@ -228,21 +230,25 @@ void Search::Display(GtkWindow *parent)
gtk_widget_hide(m_CkRegularExpression);
}
}
*/
void Search::Destroy(void)
{
/*
if (NULL!=m_localDialog) {
gtk_widget_destroy(m_localDialog);
m_localDialog = NULL;
}
*/
}
void Search::Hide(void)
{
gtk_widget_hide(m_localDialog);
//gtk_widget_hide(m_localDialog);
}
/*
void Search::OnButtonPrevious(GtkWidget *widget, gpointer data)
{
//EDN_INFO("CALLBACK");
@ -315,7 +321,7 @@ void Search::OnEntrySearchChange(GtkWidget *widget, gpointer data)
// update research data
const char *testData = gtk_entry_get_text(GTK_ENTRY(widget));
if (NULL != testData) {
Edn::String myDataString = testData;
etk::String myDataString = testData;
SearchData::SetSearch(myDataString);
if (0 == strlen(testData)) {
self->m_haveSearchData = false;
@ -341,7 +347,7 @@ void Search::OnEntryReplaceChange(GtkWidget *widget, gpointer data)
// update replace data
const char *testData = gtk_entry_get_text(GTK_ENTRY(widget));
if (NULL != testData) {
Edn::String myDataString = testData;
etk::String myDataString = testData;
SearchData::SetReplace(myDataString);
if (0 == strlen(testData)) {
self->m_haveReplaceData = false;
@ -357,3 +363,4 @@ void Search::OnEntryReplaceChange(GtkWidget *widget, gpointer data)
}
}
}
*/

14
jni/edn/GuiTools/Search/Search.h
View File

@ -26,13 +26,13 @@
#ifndef __SEARCH_H__
#define __SEARCH_H__
#include "tools_debug.h"
#include "Singleton.h"
#include <tools_debug.h>
#include <etk/Singleton.h>
class Search: public Singleton<Search>
class Search: public etk::Singleton<Search>
{
friend class Singleton<Search>;
friend class etk::Singleton<Search>;
// specific for sigleton system...
private:
// Constructeur
@ -41,9 +41,9 @@ class Search: public Singleton<Search>
public:
void Destroy(void);
void Display(GtkWindow *parent);
//void Display(GtkWindow *parent);
void Hide(void);
/*
private:
GtkWidget * m_localDialog; //!< local dialog element
// entry
@ -75,7 +75,7 @@ class Search: public Singleton<Search>
static void OnCheckBoxEventRegExp(GtkWidget *widget, gpointer user_data);
static void OnEntrySearchChange(GtkWidget *widget, gpointer user_data);
static void OnEntryReplaceChange(GtkWidget *widget, gpointer user_data);
*/
};

17
jni/edn/GuiTools/Search/SearchData.cpp
View File

@ -23,22 +23,21 @@
*******************************************************************************
*/
#include "tools_globals.h"
#include "SearchData.h"
#include "Edn.h"
#include <tools_globals.h>
#include <SearchData.h>
#undef __class__
#define __class__ "SearchData"
static Edn::String m_findRequest = "";
static etk::String m_findRequest = "";
void SearchData::SetSearch(Edn::String &myData)
void SearchData::SetSearch(etk::String &myData)
{
m_findRequest = myData;
}
void SearchData::GetSearch(Edn::String &myData)
void SearchData::GetSearch(etk::String &myData)
{
myData = m_findRequest;
}
@ -50,12 +49,12 @@ bool SearchData::IsSearchEmpty(void)
return true;
}
static Edn::String m_replaceRequest = "";
void SearchData::SetReplace(Edn::String &myData)
static etk::String m_replaceRequest = "";
void SearchData::SetReplace(etk::String &myData)
{
m_replaceRequest = myData;
}
void SearchData::GetReplace(Edn::String &myData)
void SearchData::GetReplace(etk::String &myData)
{
myData = m_replaceRequest;
}

11
jni/edn/GuiTools/Search/SearchData.h
View File

@ -26,16 +26,15 @@
#ifndef __SEARCH_DATA_H__
#define __SEARCH_DATA_H__
#include "tools_debug.h"
#include "Edn.h"
#include <tools_debug.h>
namespace SearchData
{
void SetSearch(Edn::String &myData);
void GetSearch(Edn::String &myData);
void SetSearch(etk::String &myData);
void GetSearch(etk::String &myData);
bool IsSearchEmpty(void);
void SetReplace(Edn::String &myData);
void GetReplace(Edn::String &myData);
void SetReplace(etk::String &myData);
void GetReplace(etk::String &myData);
bool IsReplaceEmpty(void);
void SetCase(bool value);
bool GetCase(void);

26
jni/edn/GuiTools/WindowsManager/WindowsManager.cpp
View File

@ -24,12 +24,11 @@
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "WindowsManager.h"
#include "MainWindows.h"
#include "Edn.h"
#include "Search.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <WindowsManager.h>
#include <MainWindows.h>
#include <Search.h>
#undef __class__
@ -65,6 +64,7 @@ void WindowsManager::OnMessage(int32_t id, int32_t dataID)
{
switch (id)
{
/*
case EDN_MSG__BUFFER_CHANGE_CURRENT:
m_currentBufferID = dataID;
break;
@ -101,13 +101,13 @@ void WindowsManager::OnMessage(int32_t id, int32_t dataID)
if( -1 != m_currentBufferID
&& true == myBufferManager->Exist(m_currentBufferID) )
{
Edn::File fileName = myBufferManager->Get(m_currentBufferID)->GetFileName();
etk::File fileName = myBufferManager->Get(m_currentBufferID)->GetFileName();
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), fileName.GetFolder().c_str());
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), fileName.GetShortFilename().c_str());
}
if (gtk_dialog_run(GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
Edn::File myfilename;
etk::File myfilename;
myfilename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (dialog));
if (false == myBufferManager->Exist(myfilename) ) {
@ -131,7 +131,7 @@ void WindowsManager::OnMessage(int32_t id, int32_t dataID)
idSelected = dataID;
}
Buffer *myBuffer = BufferManager::getInstance()->Get(idSelected);
Edn::String tmpString = "Save as file : ";
etk::String tmpString = "Save as file : ";
tmpString += myBuffer->GetFileName().GetShortFilename().c_str();
GtkWidget *dialog = gtk_file_chooser_dialog_new( tmpString.c_str(), NULL,
GTK_FILE_CHOOSER_ACTION_SAVE,
@ -142,7 +142,7 @@ void WindowsManager::OnMessage(int32_t id, int32_t dataID)
gtk_window_set_skip_pager_hint(GTK_WINDOW(dialog), TRUE);
if (gtk_dialog_run(GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
Edn::String myfilename;
etk::String myfilename;
myfilename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER (dialog));
myBuffer->SetFileName(myfilename);
@ -311,10 +311,10 @@ void WindowsManager::OnMessage(int32_t id, int32_t dataID)
gtk_widget_destroy (p_dialog);
break;
}
}
break;
*/
default:
break;
}
}

10
jni/edn/GuiTools/WindowsManager/WindowsManager.h
View File

@ -26,13 +26,13 @@
#ifndef __WINDOWS_MANAGER_H__
#define __WINDOWS_MANAGER_H__
#include "Singleton.h"
#include "MsgBroadcast.h"
#include "MainWindows.h"
#include <etk/Singleton.h>
#include <MsgBroadcast.h>
#include <MainWindows.h>
class WindowsManager: public Singleton<WindowsManager>, public MsgBroadcast
class WindowsManager: public etk::Singleton<WindowsManager>, public MsgBroadcast
{
friend class Singleton<WindowsManager>;
friend class etk::Singleton<WindowsManager>;
// specific for sigleton system...
private:
// Constructeur

24
jni/edn/Highlight/Highlight.cpp
View File

@ -23,17 +23,17 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "Highlight.h"
#include "tinyxml.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <Highlight.h>
#include <tinyXML/tinyxml.h>
#undef __class__
#define __class__ "Highlight"
void Highlight::ParseRules(TiXmlNode *child, Edn::VectorType<HighlightPattern*> &mListPatern, int32_t level)
void Highlight::ParseRules(TiXmlNode *child, etk::VectorType<HighlightPattern*> &mListPatern, int32_t level)
{
// Create the patern ...
HighlightPattern *myPattern = new HighlightPattern();
@ -45,7 +45,7 @@ void Highlight::ParseRules(TiXmlNode *child, Edn::VectorType<HighlightPattern*>
Highlight::Highlight(Edn::String &xmlFilename)
Highlight::Highlight(etk::String &xmlFilename)
{
TiXmlDocument XmlDocument;
@ -72,7 +72,7 @@ Highlight::Highlight(Edn::String &xmlFilename)
const char *myData = child->ToElement()->GetText();
if (NULL != myData) {
//EDN_INFO(PFX"(l %d) node fined : %s=\"%s\"", child->Row(), child->Value() , myData);
Edn::String * myEdnData = new Edn::String(myData);
etk::String * myEdnData = new etk::String(myData);
m_listExtentions.PushBack(myEdnData);
}
} else if (!strcmp(child->Value(), "pass1")) {
@ -150,7 +150,7 @@ void Highlight::ReloadColor(void)
}
}
bool Highlight::HasExtention(Edn::String &ext)
bool Highlight::HasExtention(etk::String &ext)
{
int32_t i;
for (i=0; i<m_listExtentions.Size(); i++) {
@ -161,10 +161,10 @@ bool Highlight::HasExtention(Edn::String &ext)
return false;
}
bool Highlight::FileNameCompatible(Edn::File &fileName)
bool Highlight::FileNameCompatible(etk::File &fileName)
{
int32_t i;
Edn::String extention;
etk::String extention;
if (true == fileName.HasExtention() ) {
extention = "*.";
extention += fileName.GetExtention();
@ -206,7 +206,7 @@ void Highlight::Display(void)
// TODO : Celui qui appelle suprime des element pour rien ... Enfin c'est pas trègrave... Il suffirait juste de suprimer celuis d'avant si il n'est pas terminer...
void Highlight::Parse(int32_t start,
int32_t stop,
Edn::VectorType<colorInformation_ts> &metaData,
etk::VectorType<colorInformation_ts> &metaData,
int32_t addingPos,
EdnVectorBuf &buffer)
{
@ -270,7 +270,7 @@ void Highlight::Parse(int32_t start,
*/
void Highlight::Parse2(int32_t start,
int32_t stop,
Edn::VectorType<colorInformation_ts> &metaData,
etk::VectorType<colorInformation_ts> &metaData,
EdnVectorBuf &buffer)
{
//EDN_DEBUG("Parse element 0 => " << m_listHighlightPass2.size() << " ==> position search: (" << start << "," << stop << ")" );

29
jni/edn/Highlight/Highlight.h
View File

@ -23,7 +23,6 @@
*******************************************************************************
*/
#include "Edn.h"
#ifndef __HIGHLIGHT_H__
#define __HIGHLIGHT_H__
@ -43,35 +42,35 @@ extern "C" {
} colorInformation_ts;
}
#include "HighlightPattern.h"
#include "Colorize.h"
#include "EdnVectorBuf.h"
#include "tinyxml.h"
#include <HighlightPattern.h>
#include <Colorize.h>
#include <EdnVectorBuf.h>
#include <tinyXML/tinyxml.h>
class Highlight {
public:
// Constructeur
Highlight(Edn::String &xmlFilename);
Highlight(etk::String &xmlFilename);
~Highlight(void);
bool HasExtention(Edn::String &ext);
bool FileNameCompatible(Edn::File &fileName);
bool HasExtention(etk::String &ext);
bool FileNameCompatible(etk::File &fileName);
void Display(void);
void ReloadColor(void);
void Parse(int32_t start,
int32_t stop,
Edn::VectorType<colorInformation_ts> &metaData,
etk::VectorType<colorInformation_ts> &metaData,
int32_t addingPos,
EdnVectorBuf &buffer);
void Parse2(int32_t start,
int32_t stop,
Edn::VectorType<colorInformation_ts> &metaData,
etk::VectorType<colorInformation_ts> &metaData,
EdnVectorBuf &buffer);
private:
void ParseRules(TiXmlNode *child, Edn::VectorType<HighlightPattern*> &mListPatern, int32_t level);
Edn::String m_styleName; //!< curent style name (like "c++" or "c" or "script Bash")
Edn::VectorType<Edn::String*> m_listExtentions; //!< List of possible extention for this high-light, like : ".c", ".cpp", ".h"
Edn::VectorType<HighlightPattern*> m_listHighlightPass1; //!< List of ALL hightlight modules (pass 1 ==> when we load and wride data on the buffer)
Edn::VectorType<HighlightPattern*> m_listHighlightPass2; //!< List of ALL hightlight modules (pass 2 ==> When we display the buffer( only the display area (100 lines)) )
void ParseRules(TiXmlNode *child, etk::VectorType<HighlightPattern*> &mListPatern, int32_t level);
etk::String m_styleName; //!< curent style name (like "c++" or "c" or "script Bash")
etk::VectorType<etk::String*> m_listExtentions; //!< List of possible extention for this high-light, like : ".c", ".cpp", ".h"
etk::VectorType<HighlightPattern*> m_listHighlightPass1; //!< List of ALL hightlight modules (pass 1 ==> when we load and wride data on the buffer)
etk::VectorType<HighlightPattern*> m_listHighlightPass2; //!< List of ALL hightlight modules (pass 2 ==> When we display the buffer( only the display area (100 lines)) )
};

14
jni/edn/Highlight/HighlightManager.cpp
View File

@ -23,9 +23,9 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "HighlightManager.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <HighlightManager.h>
#undef __class__
#define __class__ "HighlightManager"
@ -65,7 +65,7 @@ void HighlightManager::OnMessage(int32_t id, int32_t dataID)
}
}
Highlight *HighlightManager::Get(Edn::File &fileName)
Highlight *HighlightManager::Get(etk::File &fileName)
{
int32_t i;
for (i=0; i<listHighlight.Size(); i++) {
@ -76,7 +76,7 @@ Highlight *HighlightManager::Get(Edn::File &fileName)
return NULL;
}
bool HighlightManager::Exist(Edn::File &fileName)
bool HighlightManager::Exist(etk::File &fileName)
{
if (NULL != Get(fileName) ) {
return true;
@ -87,14 +87,14 @@ bool HighlightManager::Exist(Edn::File &fileName)
void HighlightManager::loadLanguages(void)
{
Edn::String homedir;
etk::String homedir;
#ifdef NDEBUG
homedir = "/usr/share/edn/";
#else
homedir = "./data/";
#endif
Edn::String xmlFilename = homedir;
etk::String xmlFilename = homedir;
xmlFilename += "lang_c.xml";
Highlight *myHightline = new Highlight(xmlFilename);
listHighlight.PushBack(myHightline);

16
jni/edn/Highlight/HighlightManager.h
View File

@ -28,14 +28,14 @@
class HighlightManager;
#include "Singleton.h"
#include "MsgBroadcast.h"
#include "Highlight.h"
#include <etk/Singleton.h>
#include <MsgBroadcast.h>
#include <Highlight.h>
class HighlightManager: public Singleton<HighlightManager>, public MsgBroadcast
class HighlightManager: public etk::Singleton<HighlightManager>, public MsgBroadcast
{
friend class Singleton<HighlightManager>;
friend class etk::Singleton<HighlightManager>;
// specific for sigleton system...
private:
// Constructeur
@ -46,11 +46,11 @@ class HighlightManager: public Singleton<HighlightManager>, public MsgBroadcast
void OnMessage(int32_t id, int32_t dataID);
public:
void loadLanguages(void);
Highlight * Get(Edn::File &fileName);
bool Exist(Edn::File &fileName);
Highlight * Get(etk::File &fileName);
bool Exist(etk::File &fileName);
private:
Edn::VectorType<Highlight*> listHighlight; //!< List of ALL hightlight modules
etk::VectorType<Highlight*> listHighlight; //!< List of ALL hightlight modules
};
#endif

30
jni/edn/Highlight/HighlightPattern.cpp
View File

@ -22,10 +22,10 @@
*
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "HighlightPattern.h"
#include "ColorizeManager.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <HighlightPattern.h>
#include <ColorizeManager.h>
#undef __class__
@ -39,8 +39,8 @@ HighlightPattern::HighlightPattern(void)
m_multiline = false;
ColorizeManager *myColorManager = ColorizeManager::getInstance();
m_color = myColorManager->Get("normal");
m_regExpStart = new EdnRegExp<EdnVectorBuf>();
m_regExpStop = new EdnRegExp<EdnVectorBuf>();
m_regExpStart = new etk::RegExp<EdnVectorBuf>();
m_regExpStop = new etk::RegExp<EdnVectorBuf>();
m_escapeChar = 0;
}
@ -50,12 +50,12 @@ HighlightPattern::~HighlightPattern(void)
delete(m_regExpStop);
}
void HighlightPattern::SetPaternStart(Edn::String &regExp)
void HighlightPattern::SetPaternStart(etk::String &regExp)
{
m_regExpStart->SetRegExp(regExp);
}
void HighlightPattern::SetPaternStop(Edn::String &regExp)
void HighlightPattern::SetPaternStop(etk::String &regExp)
{
if (regExp.Size() != 0) {
m_regExpStop->SetRegExp(regExp);
@ -65,7 +65,7 @@ void HighlightPattern::SetPaternStop(Edn::String &regExp)
}
}
void HighlightPattern::SetEscapeChar(Edn::String &EscapeChar)
void HighlightPattern::SetEscapeChar(etk::String &EscapeChar)
{
if (EscapeChar.Size()>0) {
m_escapeChar = EscapeChar.c_str()[0];
@ -75,7 +75,7 @@ void HighlightPattern::SetEscapeChar(Edn::String &EscapeChar)
}
void HighlightPattern::SetColor(Edn::String &colorName)
void HighlightPattern::SetColor(etk::String &colorName)
{
m_colorName = colorName;
ColorizeManager *myColorManager = ColorizeManager::getInstance();
@ -140,7 +140,7 @@ void HighlightPattern::ParseRules(TiXmlNode *child, int32_t level)
//--------------------------------------------------------------------------------------------
// process attribute
const char *highLightName = child->ToElement()->Attribute("name");
Edn::String myEdnDataTmp = "???";
etk::String myEdnDataTmp = "???";
if (NULL != highLightName) {
myEdnDataTmp = highLightName;
}
@ -152,7 +152,7 @@ void HighlightPattern::ParseRules(TiXmlNode *child, int32_t level)
const char *myData = xChild->GetText();
if (myData) {
//EDN_INFO(PFX"(l %d) node fined : %s=\"%s\"", xChild->Row(), xChild->Value() , myData);
Edn::String myEdnData = myData;
etk::String myEdnData = myData;
SetColor(myEdnData);
}
}
@ -161,7 +161,7 @@ void HighlightPattern::ParseRules(TiXmlNode *child, int32_t level)
const char *myData = xChild->GetText();
if (myData) {
//EDN_INFO(PFX"(l %d) node fined : %s=\"%s\"", xChild->Row(), xChild->Value() , myData);
Edn::String myEdnData = myData;
etk::String myEdnData = myData;
SetPaternStart(myEdnData);
}
}
@ -170,7 +170,7 @@ void HighlightPattern::ParseRules(TiXmlNode *child, int32_t level)
const char *myData = xChild->GetText();
if (myData) {
//EDN_INFO(PFX"(l %d) node fined : %s=\"%s\"", xChild->Row(), xChild->Value() , myData);
Edn::String myEdnData = myData;
etk::String myEdnData = myData;
SetPaternStop(myEdnData);
}
}
@ -179,7 +179,7 @@ void HighlightPattern::ParseRules(TiXmlNode *child, int32_t level)
const char *myData = xChild->GetText();
if (myData) {
//EDN_INFO(PFX"(l %d) node fined : %s=\"%s\"", xChild->Row(), xChild->Value() , myData);
Edn::String myEdnData = myData;
etk::String myEdnData = myData;
SetEscapeChar(myEdnData);
}
}

38
jni/edn/Highlight/HighlightPattern.h
View File

@ -23,19 +23,19 @@
*******************************************************************************
*/
#include "Highlight.h"
#include <Highlight.h>
#ifndef __HIGHLIGHT_PATTERN_H__
#define __HIGHLIGHT_PATTERN_H__
class HighlightPattern;
#include "Edn.h"
#include "RegExp.h"
#include "Colorize.h"
#include "VectorType.h"
#include "tinyxml.h"
#include "EdnVectorBuf.h"
#include <etk/RegExp.h>
#include <Colorize.h>
#include <etk/VectorType.h>
#include <tinyXML/tinyxml.h>
#include <EdnVectorBuf.h>
typedef enum {
HLP_FIND_ERROR,
@ -51,13 +51,13 @@ class HighlightPattern {
HighlightPattern(void);
~HighlightPattern(void);
void SetName(Edn::String &name) { m_paternName = name;};
Edn::String GetName(void) { return m_paternName;};
void SetName(etk::String &name) { m_paternName = name;};
etk::String GetName(void) { return m_paternName;};
void SetPaternStart(Edn::String &regExp);
void SetPaternStop(Edn::String &regExp);
void SetColor(Edn::String &colorName);
void SetEscapeChar(Edn::String &EscapeChar);
void SetPaternStart(etk::String &regExp);
void SetPaternStop(etk::String &regExp);
void SetColor(etk::String &colorName);
void SetEscapeChar(etk::String &EscapeChar);
void SetMultiline(bool enable) { m_multiline = enable; };
void SetLevel(int32_t newLevel) { m_level = newLevel; };
@ -73,16 +73,16 @@ class HighlightPattern {
private:
int32_t m_level; //!< Level of the pattern ==> this is to overwrite next pattern when we create an higher ....
Edn::String m_paternName; //!< Current style name (like "c++" or "c" or "script Bash")
Edn::String m_colorName; //!< Current color name
etk::String m_paternName; //!< Current style name (like "c++" or "c" or "script Bash")
etk::String m_colorName; //!< Current color name
Colorize * m_color; //!< Link to the color manager
EdnRegExp<EdnVectorBuf> * m_regExpStart; //!< Start of Regular expression
EdnRegExp<EdnVectorBuf> * m_regExpStop; //!< Stop of Regular Expression
etk::RegExp<EdnVectorBuf> * m_regExpStart; //!< Start of Regular expression
etk::RegExp<EdnVectorBuf> * m_regExpStop; //!< Stop of Regular Expression
bool m_haveStopPatern; //!< Stop patern presence
bool m_multiline; //!< The patern is multiline
char m_escapeChar; //!< Escape char to prevent exeit of patern ....
Edn::VectorType<HighlightPattern *> m_subPatern; //!< Under patern of this one
// Edn::VectorType<HighlightPattern *> m_subColor; //!< Under Color in the start RegExp ...
etk::VectorType<HighlightPattern *> m_subPatern; //!< Under patern of this one
// etk::VectorType<HighlightPattern *> m_subColor; //!< Under Color in the start RegExp ...
};
#endif

93
jni/edn/ctags/CTagsManager.cpp
View File

@ -23,12 +23,11 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "Edn.h"
#include "CTagsManager.h"
#include "ClipBoard.h"
#include "BufferManager.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <CTagsManager.h>
#include <ClipBoard.h>
#include <BufferManager.h>
@ -61,16 +60,19 @@ CTagsManager::CTagsManager(void) : MsgBroadcast("C-Tags Manager", EDN_CAT_CTAGS)
*/
CTagsManager::~CTagsManager(void)
{
/*
if(0 != m_historyList.Size()) {
for (int32_t iii=0; iii< m_historyList.Size(); iii++) {
delete(m_historyList[iii]);
}
m_historyList.Clear();
}
*/
}
Edn::String CTagsManager::GetFolder(Edn::String &inputString)
etk::String CTagsManager::GetFolder(etk::String &inputString)
{
/*
char tmpVal[4096];
strncpy(tmpVal, inputString.c_str(), 4096);
tmpVal[4096-1] = '\0';
@ -78,17 +80,21 @@ Edn::String CTagsManager::GetFolder(Edn::String &inputString)
if (NULL == ptr) {
ptr = strrchr(tmpVal, '\\');
}
Edn::String out = "./";
etk::String out = "./";
if (NULL != ptr) {
*ptr = '\0';
out = tmpVal;
out+= '/';
}
return out;
*/
etk::String out = "./";
return out;
}
void CTagsManager::OnMessage(int32_t id, int32_t dataID)
{
/*
switch (id)
{
case EDN_MSG__BUFFER_CHANGE_CURRENT:
@ -136,13 +142,14 @@ void CTagsManager::OnMessage(int32_t id, int32_t dataID)
m_historyList.PopBack();
}
break;
}
*/
}
void CTagsManager::LoadTagFile(void)
{
/*
tagFileInfo info;
// close previous tag file
@ -161,10 +168,12 @@ void CTagsManager::LoadTagFile(void)
} else {
EDN_INFO("Error to open ctags file ...");
}
*/
}
void CTagsManager::AddToHistory(int32_t bufferID)
{
/*
// check tho history position : remove if needed
if (m_historyPos < edn_max(m_historyList.Size()-1, 0) ) {
for(int32_t iii= m_historyPos; iii < m_historyList.Size(); iii++) {
@ -174,16 +183,17 @@ void CTagsManager::AddToHistory(int32_t bufferID)
}
// add the current element
BufferManager *myBufferManager = BufferManager::getInstance();
Edn::File currentFilename = myBufferManager->Get(bufferID)->GetFileName();
etk::File currentFilename = myBufferManager->Get(bufferID)->GetFileName();
*/
}
/*
enum
{
CTAGS_COL_FILE = 0,
CTAGS_COL_LINE_NUMBER,
CTAGS_NUM_COLS
};
void CTagsManager::cb_row(GtkTreeView *p_treeview,
GtkTreePath * p_path,
GtkTreeViewColumn * p_column,
@ -219,9 +229,9 @@ void CTagsManager::cb_row(GtkTreeView *p_treeview,
}
}
}
*/
/*
GtkWidget * CTagsManager::CreateViewAndModel(void)
{
@ -260,18 +270,19 @@ GtkWidget * CTagsManager::CreateViewAndModel(void)
}
gtk_tree_view_set_model( GTK_TREE_VIEW(view), GTK_TREE_MODEL(m_listStore) );
g_signal_connect( G_OBJECT(view), "row-activated", G_CALLBACK(cb_row), /*(gpointer)p_model*/ this );
g_signal_connect( G_OBJECT(view), "row-activated", G_CALLBACK(cb_row), this );
//g_object_unref(GTK_TREE_MODEL(m_listStore));
return view;
}
*/
int32_t CTagsManager::MultipleJump(void)
{
/*
// dlg to confirm the quit event :
m_Dialog = gtk_dialog_new_with_buttons("C-Tags jump...",
NULL,
@ -294,34 +305,21 @@ int32_t CTagsManager::MultipleJump(void)
// Remove dialogue
gtk_widget_destroy(m_Dialog);
}
//GtkTreeIter *myIter;
//gtk_tree_selection_get_selected(selection, &model, myIter);
// Remove dialogue
//gtk_widget_destroy(myDialog);
*/
return 0;
}
/*
void BufferView::OnCtagsEventList(GtkWidget *menuitem, gpointer data)
{
//BufferView * self = reinterpret_cast<BufferView*>(data);
//self->SendMessage(EDN_MSG__GUI_SHOW_SAVE_AS, self->m_contectMenuSelectID);
//self->m_contectMenuSelectID = -1;
}
*/
void CTagsManager::JumpAtID(int32_t selectID)
{
/*
BufferManager *myBufferManager = BufferManager::getInstance();
Edn::File myFile = m_currentList[selectID].filename;
etk::File myFile = m_currentList[selectID].filename;
EDN_INFO("save curent filename and position : ");
int32_t currentSelected = myBufferManager->GetSelected();
Buffer* tmpBuf = myBufferManager->Get(currentSelected);
if (NULL != tmpBuf) {
Edn::File * bufferFilename = new Edn::File();
etk::File * bufferFilename = new etk::File();
*bufferFilename = tmpBuf->GetFileName();
bufferFilename->SetLineNumber(tmpBuf->GetCurrentLine());
m_historyList.PushBack(bufferFilename);
@ -334,28 +332,17 @@ void CTagsManager::JumpAtID(int32_t selectID)
} else {
SendMessage(EDN_MSG__CURRENT_CHANGE_BUFFER_ID, myBufferManager->GetId(myFile));
}
/*
int32_t localId = myBufferManager->GetId(myFile);
Edn::String pattern = entry.address.pattern;
EDN_DEBUG("try to find line with : \"" << pattern << "\"" );
if (pattern.Size() > 4) {
pattern.Remove(0,2);
pattern.Remove(pattern.Size()-1,2);
}
// TODO : remove '\' char when needed ...
EDN_DEBUG("try to find line with : \"" << pattern << "\"" );
int32_t destLine = myBufferManager->Get(localId)->FindLine(pattern);
SendMessage(EDN_MSG__CURRENT_GOTO_LINE, destLine);
*/
SendMessage(EDN_MSG__CURRENT_GOTO_LINE, m_currentList[selectID].lineID - 1);
*/
}
void CTagsManager::JumpTo(void)
{
/*
m_currentList.Clear();
if (NULL != m_ctagFile) {
Edn::VectorType<int8_t> data;
etk::VectorType<int8_t> data;
// get the middle button of the clipboard ==> represent the current selection ...
ClipBoard::Get(COPY_MIDDLE_BUTTON, data);
if (data.Size() == 0) {
@ -370,9 +357,9 @@ void CTagsManager::JumpTo(void)
// For all tags : Save in an internal Structure :
do {
Edn::String destinationFilename = m_tagFolderBase;
etk::String destinationFilename = m_tagFolderBase;
destinationFilename += entry.file;
Edn::File myfile = destinationFilename;
etk::File myfile = destinationFilename;
TagListFind_ts myStruct;
strncpy(myStruct.filename, myfile.GetCompleateName().c_str(), MAX_FILE_NAME);
myStruct.filename[MAX_FILE_NAME-1] = '\0';
@ -392,18 +379,13 @@ void CTagsManager::JumpTo(void)
// Open a choice windows...
int32_t SelectID = MultipleJump();
}
/*
// Display all the element :
do {
PrintTag(&entry, true);
} while (tagsFindNext (m_ctagFile, &entry) == TagSuccess);
*/
} else {
EDN_INFO("no tag find ...");
}
}
*/
}
/*
void CTagsManager::PrintTag (const tagEntry *entry, bool small)
{
if (small==true) {
@ -427,3 +409,4 @@ void CTagsManager::PrintTag (const tagEntry *entry, bool small)
}
}
}
*/

25
jni/edn/ctags/CTagsManager.h
View File

@ -27,10 +27,9 @@
#define __C_TAGS_MANAGER_H__
#include "Singleton.h"
#include <etk/Singleton.h>
#include "MsgBroadcast.h"
#include "readtags.h"
#include "Edn.h"
#define MAX_REG_EXP_SEARCH (1024)
@ -41,9 +40,9 @@ typedef struct{
} TagListFind_ts;
class CTagsManager: public Singleton<CTagsManager>, public MsgBroadcast
class CTagsManager: public etk::Singleton<CTagsManager>, public MsgBroadcast
{
friend class Singleton<CTagsManager>;
friend class etk::Singleton<CTagsManager>;
// specific for sigleton system...
private:
// Constructeur
@ -58,24 +57,26 @@ class CTagsManager: public Singleton<CTagsManager>, public MsgBroadcast
int32_t MultipleJump(void);
void JumpTo(void);
void PrintTag(const tagEntry *entry, bool small);
Edn::String GetFolder(Edn::String &inputString);
Edn::String m_tagFolderBase;
Edn::String m_tagFilename;
etk::String GetFolder(etk::String &inputString);
etk::String m_tagFolderBase;
etk::String m_tagFilename;
tagFile * m_ctagFile;
// history system
void AddToHistory(int32_t bufferID);
int32_t m_historyPos;
Edn::VectorType<Edn::File*> m_historyList;
Edn::VectorType<TagListFind_ts> m_currentList;
etk::VectorType<etk::File*> m_historyList;
etk::VectorType<TagListFind_ts> m_currentList;
void JumpAtID(int32_t selectID);
/*
GtkWidget * CreateViewAndModel(void);
static void cb_row (GtkTreeView *p_treeview,
GtkTreePath * p_path,
GtkTreeViewColumn * p_column,
gpointer p_data);
GtkTreePath * p_path,
GtkTreeViewColumn * p_column,
gpointer p_data);
// save data in the list :
GtkListStore * m_listStore;
GtkWidget * m_Dialog;
*/
};
#endif

70
jni/edn/init.cpp
View File

@ -23,43 +23,33 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "Display.h"
#include "BufferManager.h"
#include "ColorizeManager.h"
#include "HighlightManager.h"
#include "ClipBoard.h"
#include <string>
#include "WindowsManager.h"
#include "Search.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <Display.h>
#include <BufferManager.h>
#include <ColorizeManager.h>
#include <HighlightManager.h>
#include <ClipBoard.h>
#include <etk/String.h>
#include <WindowsManager.h>
#include <Search.h>
#include <unistd.h>
#include "readtags.h"
#include "CTagsManager.h"
#include "Edn.h"
#include <readtags.h>
#include <CTagsManager.h>
/**
* @brief Main start function of the system
*
* @param[in] argc number of argument when called
* @param[in] argv sus nomer arguments
*
* @return EXIT_SUCCESS, all time
*
* @brief main application function Initialisation
*/
int main (int argc, char *argv[])
void APP_Init(int argc, char *argv[])
{
EDN_INFO("Start Edn");
//Edn::TestUntaire_String();
//etk::TestUntaire_String();
//return 0;
// Use and remove GTK arguments from the application argument list.
gtk_init (&argc, &argv);
//gtk_init (&argc, &argv);
// init internal global value
globals::init();
@ -69,7 +59,7 @@ int main (int argc, char *argv[])
// init ALL Singleton :
(void)MsgBroadcastCore::getInstance();
(void)AccelKey::getInstance();
//(void)AccelKey::getInstance();
(void)WindowsManager::getInstance();
(void)CTagsManager::getInstance();
BufferManager *myBufferManager = BufferManager::getInstance();
@ -77,7 +67,7 @@ int main (int argc, char *argv[])
// set color and other trucs...
ColorizeManager *myColorManager = NULL;
myColorManager = ColorizeManager::getInstance();
Edn::String homedir;
etk::String homedir;
//homedir = getenv("HOME");
#ifdef NDEBUG
homedir = "/usr/share/edn/";
@ -99,7 +89,7 @@ int main (int argc, char *argv[])
// get the curent program folder
char cCurrentPath[FILENAME_MAX];
if (!getcwd(cCurrentPath, FILENAME_MAX)) {
return -1;
return ;
}
cCurrentPath[FILENAME_MAX - 1] = '\0';
//EDN_INFO("The current working directory is " << cCurrentPath);
@ -109,7 +99,7 @@ int main (int argc, char *argv[])
EDN_INFO("show list of files : ");
for( int32_t i=1 ; i<argc; i++) {
EDN_INFO("need load file : \"" << argv[i] << "\"" );
Edn::File myfile = (char *)argv[i];
etk::File myfile = (char *)argv[i];
if (false == myBufferManager->Exist(myfile) ) {
int32_t idBuffOpened = myBufferManager->Open(myfile);
@ -118,26 +108,30 @@ int main (int argc, char *argv[])
}
}
}
}
EDN_INFO("Start gtk main");
gtk_main();
EDN_INFO("Stop gtk main");
/**
* @brief main application function Un-Initialisation
*/
void APP_UnInit(void)
{
//Kill all singleton
EDN_INFO("Stop BufferManager");
BufferManager::kill();
//BufferManager::kill();
EDN_INFO("Stop ColorizeManager");
ColorizeManager::kill();
//ColorizeManager::kill();
EDN_INFO("Stop Search");
Search::kill();
//Search::kill();
EDN_INFO("Stop Accel key");
AccelKey::kill();
//AccelKey::kill();
EDN_INFO("Stop Display");
Display::UnInit();
EDN_INFO("Stop Edn");
return EXIT_SUCCESS;
//return EXIT_SUCCESS;
}

24
jni/edn/tools/ClipBoard/ClipBoard.cpp
View File

@ -23,19 +23,21 @@
*******************************************************************************
*/
#include "tools_globals.h"
#include "ClipBoard.h"
#include <tools_globals.h>
#include <ClipBoard.h>
#undef __class__
#define __class__ "ClipBoard"
#include <etk/VectorType.h>
/*
note: la copy dans le :
0 : copy standard
[1..9] : copy interne
10 : bouton du milieux
*/
static Edn::VectorType<int8_t> mesCopy[TOTAL_OF_CLICKBOARD];
static etk::VectorType<int8_t> mesCopy[TOTAL_OF_CLICKBOARD];
void ClipBoard::Init(void)
@ -47,7 +49,7 @@ void ClipBoard::Init(void)
}
void ClipBoard::Set(uint8_t clipboardID, Edn::VectorType<int8_t> &data)
void ClipBoard::Set(uint8_t clipboardID, etk::VectorType<int8_t> &data)
{
// check if ID is correct
if(clipboardID >= TOTAL_OF_CLICKBOARD) {
@ -55,35 +57,39 @@ void ClipBoard::Set(uint8_t clipboardID, Edn::VectorType<int8_t> &data)
} else if(0 == data.Size()) {
EDN_INFO("request a copy of nothing");
} else if (COPY_STD == clipboardID) {
GtkClipboard * clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
gtk_clipboard_set_text(clipboard, (const gchar*)&data[0], data.Size() );
//GtkClipboard * clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
//gtk_clipboard_set_text(clipboard, (const gchar*)&data[0], data.Size() );
} else if (COPY_MIDDLE_BUTTON == clipboardID) {
GtkClipboard * clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
gtk_clipboard_set_text(clipboard, (const gchar*)&data[0], data.Size() );
//GtkClipboard * clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
//gtk_clipboard_set_text(clipboard, (const gchar*)&data[0], data.Size() );
}
// Copy datas ...
mesCopy[clipboardID] = data;
}
void ClipBoard::Get(uint8_t clipboardID, Edn::VectorType<int8_t> &data)
void ClipBoard::Get(uint8_t clipboardID, etk::VectorType<int8_t> &data)
{
if(clipboardID >= TOTAL_OF_CLICKBOARD) {
EDN_WARNING("request ClickBoard id error");
} else if (COPY_STD == clipboardID) {
/*
GtkClipboard * clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD );
gchar *text = gtk_clipboard_wait_for_text(clipboard);
if (text != NULL) {
mesCopy[COPY_STD].Clear();
mesCopy[COPY_STD].PushBack((int8_t*)text, strlen(text) );
}
*/
} else if (COPY_MIDDLE_BUTTON == clipboardID) {
/*
GtkClipboard * clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY );
gchar *text = gtk_clipboard_wait_for_text(clipboard);
if (text != NULL) {
mesCopy[COPY_MIDDLE_BUTTON].Clear();
mesCopy[COPY_MIDDLE_BUTTON].PushBack((int8_t*)text, strlen(text) );
}
*/
}
// Copy datas ...
data = mesCopy[clipboardID];

22
jni/edn/tools/ClipBoard/ClipBoard.h
View File

@ -26,19 +26,19 @@
#ifndef __CLIP_BOARD_H__
#define __CLIP_BOARD_H__
#include "tools_debug.h"
#include "VectorType.h"
#include "tools_debug.h"
#include "etk/VectorType.h"
#define TOTAL_OF_CLICKBOARD (11)
#define COPY_MIDDLE_BUTTON (10)
#define COPY_STD (0)
#define TOTAL_OF_CLICKBOARD (11)
#define COPY_MIDDLE_BUTTON (10)
#define COPY_STD (0)
namespace ClipBoard
{
void Init(void);
void Set(uint8_t clipboardID, Edn::VectorType<int8_t> &data);
void Get(uint8_t clipboardID, Edn::VectorType<int8_t> &data);
}
namespace ClipBoard
{
void Init(void);
void Set(uint8_t clipboardID, etk::VectorType<int8_t> &data);
void Get(uint8_t clipboardID, etk::VectorType<int8_t> &data);
}
#endif

76
jni/edn/tools/Display/Display.cpp
View File

@ -23,12 +23,12 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "Display.h"
#include "ColorizeManager.h"
#include "charset.h"
#include <string>
#include <tools_debug.h>
#include <tools_globals.h>
#include <Display.h>
#include <ColorizeManager.h>
#include <charset.h>
#include <etk/String.h>
#undef __class__
#define __class__ "Display"
@ -59,9 +59,12 @@
static int32_t m_pangoFontHeight = 11;
static cairo_font_face_t * m_cairoFont[2][2] = {{NULL, NULL},{ NULL, NULL}};
*/
static cairo_font_face_t * m_cairoFont[2][2] = {{NULL, NULL},{ NULL, NULL}};
//static cairo_font_face_t * m_cairoFont[2][2] = {{NULL, NULL},{ NULL, NULL}};
void Display::Init(void)
{
/*
m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_NO] = cairo_toy_font_face_create(POLICE_NAME, CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
m_cairoFont[FONT_ITALIC_YES][FONT_BOLD_NO] = cairo_toy_font_face_create(POLICE_NAME, CAIRO_FONT_SLANT_ITALIC, CAIRO_FONT_WEIGHT_NORMAL);
m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_YES] = cairo_toy_font_face_create(POLICE_NAME, CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
@ -81,6 +84,7 @@ void Display::Init(void)
EDN_ERROR("Italic & Bold font error ... link with basic font");
m_cairoFont[FONT_ITALIC_YES][FONT_BOLD_YES] = m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_NO];
}
*/
}
@ -89,11 +93,13 @@ void Display::Init(void)
void Display::UnInit(void)
{
/*
// clean the builder...
cairo_font_face_destroy(m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_NO]);
cairo_font_face_destroy(m_cairoFont[FONT_ITALIC_YES][FONT_BOLD_NO]);
cairo_font_face_destroy(m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_YES]);
cairo_font_face_destroy(m_cairoFont[FONT_ITALIC_YES][FONT_BOLD_YES]);
*/
}
@ -109,8 +115,9 @@ int32_t Display::GetFontWidth(void)
cairo_font_face_t * Display::GetFont(bool bold, bool italic)
void * Display::GetFont(bool bold, bool italic)
{
/*
if( false == bold
&& false == italic) {
return m_cairoFont[FONT_ITALIC_NO][FONT_BOLD_NO];
@ -122,6 +129,8 @@ cairo_font_face_t * Display::GetFont(bool bold, bool italic)
return m_cairoFont[FONT_ITALIC_YES][FONT_BOLD_NO];
}
return m_cairoFont[FONT_ITALIC_YES][FONT_BOLD_YES];
*/
return NULL;
}
@ -140,7 +149,7 @@ cairo_font_face_t * Display::GetFont(bool bold, bool italic)
* @return ---
*
*/
DrawerManager::DrawerManager(GtkWidget * widget, int32_t x, int32_t y)
DrawerManager::DrawerManager(void * widget, int32_t x, int32_t y)
{
m_size.x = x;
@ -148,6 +157,7 @@ DrawerManager::DrawerManager(GtkWidget * widget, int32_t x, int32_t y)
m_haveWork = false;
m_nbElement = 0;
// Create the Cairo Element
/*
# if USE_GTK_VERSION_3_0
m_cairo = gdk_cairo_create(gtk_widget_get_window(widget));
# elif USE_GTK_VERSION_2_0
@ -157,20 +167,10 @@ DrawerManager::DrawerManager(GtkWidget * widget, int32_t x, int32_t y)
cairo_set_source_rgb(m_cairo, 0, 0, 0);
cairo_paint(m_cairo);
cairo_set_font_size(m_cairo, POLICE_SIZE);
*/
m_dataToDisplay[0] = '\0';
cairo_scale(m_cairo, 1.0, 1.0);
// http://cairographics.org/FAQ/#clear_a_surface
// http://gtk.developpez.com/faq/?page=gtkwidget#GTK_WIDGET_transparent
//cairo_set_source_rgba(m_cairo, 1, 1, 1, 0);
//cairo_set_operator(m_cairo, CAIRO_OPERATOR_SOURCE);
//cairo_paint(m_cairo);
//cairo_fill(m_cairo);
//cairo_stroke (m_cairo);
//cairo_scale(m_cairo, 1.0, 1.0);
}
@ -187,7 +187,7 @@ DrawerManager::DrawerManager(GtkWidget * widget, int32_t x, int32_t y)
*/
DrawerManager::~DrawerManager()
{
cairo_destroy(m_cairo);
//cairo_destroy(m_cairo);
}
@ -208,6 +208,7 @@ DrawerManager::~DrawerManager()
*/
void DrawerManager::Text(Colorize *SelectColor, int32_t x, int32_t y,const char *myUTF8Text, int32_t len)
{
/*
EDN_CHECK_INOUT(NULL!=SelectColor);
// check if flush is needed :
if (true == m_haveWork) {
@ -233,10 +234,12 @@ void DrawerManager::Text(Colorize *SelectColor, int32_t x, int32_t y,const char
} else {
m_nbElement+=strUtf8Len(myUTF8Text);
}
*/
}
void DrawerManager::Text(color_ts & SelectColorFg, color_ts & SelectColorBg, int32_t x, int32_t y,const char *myText)
{
/*
Flush();
cairo_set_font_face(m_cairo, Display::GetFont(false, false));
int32_t letterHeight = Display::GetFontHeight();
@ -247,10 +250,12 @@ void DrawerManager::Text(color_ts & SelectColorFg, color_ts & SelectColorBg, int
cairo_set_source_rgb(m_cairo, SelectColorFg.red, SelectColorFg.green, SelectColorFg.blue);
cairo_show_text(m_cairo, myText);
cairo_fill(m_cairo);
*/
}
void DrawerManager::Text(color_ts & SelectColorFg, int32_t x, int32_t y,const char *myText)
{
/*
Flush();
cairo_set_font_face(m_cairo, Display::GetFont(false, false));
int32_t letterHeight = Display::GetFontHeight();
@ -258,16 +263,18 @@ void DrawerManager::Text(color_ts & SelectColorFg, int32_t x, int32_t y,const ch
cairo_set_source_rgb(m_cairo, SelectColorFg.red, SelectColorFg.green, SelectColorFg.blue);
cairo_show_text(m_cairo, myText);
cairo_fill(m_cairo);
*/
}
void DrawerManager::SpaceText(color_ts & SelectColor, int32_t x, int32_t y,int32_t nbChar)
{
/*
Flush();
int32_t letterHeight = Display::GetFontHeight();
int32_t letterWidth = Display::GetFontWidth();
DirectRectangle(SelectColor, x, y, letterWidth*nbChar, letterHeight);
cairo_fill(m_cairo);
*/
}
@ -283,6 +290,7 @@ void DrawerManager::SpaceText(color_ts & SelectColor, int32_t x, int32_t y,int32
*/
void DrawerManager::Flush(void)
{
/*
if (true == m_haveWork) {
//EDN_WARNING("flush : \"" << m_dataToDisplay << "\"" << " bold=" << m_selectColor->GetBold() << " italic=" << m_selectColor->GetItalic());
m_haveWork = false;
@ -303,6 +311,7 @@ void DrawerManager::Flush(void)
m_dataToDisplay[0] = '\0';
m_nbElement = 0;
}
*/
}
@ -322,8 +331,8 @@ void DrawerManager::Flush(void)
*/
void DrawerManager::Rectangle(Colorize *SelectColor, int32_t x, int32_t y, int32_t width, int32_t height)
{
Flush();
DirectRectangle(SelectColor, x, y, width, height);
//Flush();
//DirectRectangle(SelectColor, x, y, width, height);
}
@ -341,6 +350,7 @@ void DrawerManager::Rectangle(Colorize *SelectColor, int32_t x, int32_t y, int32
*/
void DrawerManager::DirectRectangle(Colorize *SelectColor, int32_t x, int32_t y, int32_t width, int32_t height)
{
/*
EDN_CHECK_INOUT(NULL!=SelectColor);
//EDN_INFO("x="<< x <<" y="<< y <<" width="<< width <<" height="<< height);
//gdk_draw_rectangle( p_pixmap, SelectColor->GetColorBG(), TRUE, x, y, width, height);
@ -351,16 +361,18 @@ void DrawerManager::DirectRectangle(Colorize *SelectColor, int32_t x, int32_t y,
//cairo_stroke(m_cairo);
// flush
cairo_fill(m_cairo);
*/
}
void DrawerManager::DirectRectangle(color_ts &SelectColor, int32_t x, int32_t y, int32_t width, int32_t height)
{
/*
cairo_set_source_rgb(m_cairo, SelectColor.red, SelectColor.green, SelectColor.blue);
// set postion
cairo_rectangle(m_cairo, x, y, width, height);
//cairo_stroke(m_cairo);
// flush
cairo_fill(m_cairo);
*/
}
@ -374,8 +386,10 @@ void DrawerManager::DirectRectangle(color_ts &SelectColor, int32_t x, int32_t y,
*/
void DrawerManager::Clean(Colorize *SelectColor)
{
/*
m_haveWork = false;
DirectRectangle(SelectColor, 0, 0, m_size.x, m_size.y);
*/
}
/**
@ -388,8 +402,10 @@ void DrawerManager::Clean(Colorize *SelectColor)
*/
void DrawerManager::Clean(color_ts & SelectColor)
{
/*
m_haveWork = false;
DirectRectangle(SelectColor, 0, 0, m_size.x, m_size.y);
*/
}
/**
@ -406,6 +422,7 @@ void DrawerManager::Clean(color_ts & SelectColor)
#define CURSOR_WIDTH (4)
void DrawerManager::Cursor(int32_t x, int32_t y)
{
/*
Flush();
// get the cursor Color :
color_ts myColor = ColorizeManager::getInstance()->Get(COLOR_CODE_CURSOR);
@ -433,6 +450,7 @@ void DrawerManager::Cursor(int32_t x, int32_t y)
}
cairo_stroke(m_cairo);
cairo_fill(m_cairo);
*/
}
/**
@ -448,6 +466,7 @@ void DrawerManager::Cursor(int32_t x, int32_t y)
*/
void DrawerManager::EndOfLine(int32_t x, int32_t y)
{
#if 0
if (true == globals::IsSetDisplayEndOfLine() ) {
Flush();
// get the cursor Color :
@ -472,6 +491,7 @@ void DrawerManager::EndOfLine(int32_t x, int32_t y)
cairo_stroke(m_cairo);
cairo_fill(m_cairo);
}
#endif
}
@ -489,6 +509,7 @@ void DrawerManager::EndOfLine(int32_t x, int32_t y)
*/
void DrawerManager::Tabulation(Colorize *SelectColor, int32_t x, int32_t y, int32_t mbColomn)
{
/*
Flush();
int32_t letterWidth = Display::GetFontWidth();
int32_t letterHeight = Display::GetFontHeight();
@ -509,6 +530,7 @@ void DrawerManager::Tabulation(Colorize *SelectColor, int32_t x, int32_t y, int3
cairo_stroke(m_cairo);
cairo_fill(m_cairo);
*/
}
@ -526,6 +548,7 @@ void DrawerManager::Tabulation(Colorize *SelectColor, int32_t x, int32_t y, int3
*/
void DrawerManager::UTF8UnknownElement(Colorize *SelectColor, int32_t x, int32_t y, int8_t utf8Size, bool ValidUtf8)
{
#if 0
Flush();
int32_t letterWidth = Display::GetFontWidth();
int32_t letterHeight = Display::GetFontHeight();
@ -576,6 +599,7 @@ void DrawerManager::UTF8UnknownElement(Colorize *SelectColor, int32_t x, int32_t
}
cairo_stroke(m_cairo);
cairo_fill(m_cairo);
#endif
}

14
jni/edn/tools/Display/Display.h
View File

@ -26,9 +26,9 @@
#ifndef __TOOLS_DISPLAY_H__
#define __TOOLS_DISPLAY_H__
#include "tools_debug.h"
#include "Colorize.h"
#include "ColorizeManager.h"
#include <tools_debug.h>
#include <Colorize.h>
#include <ColorizeManager.h>
/**
@ -38,7 +38,8 @@ namespace Display
{
void Init(void);
void UnInit(void);
cairo_font_face_t * GetFont(bool bold, bool italic);
//cairo_font_face_t * GetFont(bool bold, bool italic);
void * GetFont(bool bold, bool italic);
int32_t GetFontHeight(void);
int32_t GetFontWidth(void);
};
@ -52,7 +53,8 @@ class DrawerManager;
class DrawerManager {
public:
// Constructeur
DrawerManager(GtkWidget * widget, int32_t x, int32_t y);
//DrawerManager(GtkWidget * widget, int32_t x, int32_t y);
DrawerManager(void * widget, int32_t x, int32_t y);
~DrawerManager();
void Rectangle(Colorize *SelectColor, int32_t x, int32_t y, int32_t width, int32_t height);
@ -84,7 +86,7 @@ class DrawerManager {
Colorize * m_selectColor; //!< curent color to display
position_ts m_size; //!< Total size
cairo_t * m_cairo; //!< Cairo Layout pointer
//cairo_t * m_cairo; //!< Cairo Layout pointer
};

42
jni/edn/tools/EdnBuf/EdnBuf.cpp
View File

@ -23,9 +23,9 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "EdnBuf.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <EdnBuf.h>
#undef __class__
@ -126,7 +126,7 @@ bool EdnBuf::DumpFrom(FILE *myFile)
}
void EdnBuf::GetAll(Edn::VectorType<int8_t> &text)
void EdnBuf::GetAll(etk::VectorType<int8_t> &text)
{
// Clean output vector
text.Clear();
@ -135,9 +135,9 @@ void EdnBuf::GetAll(Edn::VectorType<int8_t> &text)
}
void EdnBuf::SetAll(Edn::VectorType<int8_t> &text)
void EdnBuf::SetAll(etk::VectorType<int8_t> &text)
{
Edn::VectorType<int8_t> deletedText;
etk::VectorType<int8_t> deletedText;
// extract all data of the buffer :
GetAll(deletedText);
@ -155,7 +155,7 @@ void EdnBuf::SetAll(Edn::VectorType<int8_t> &text)
eventModification(0, m_data.Size(), deletedText);
}
void EdnBuf::GetRange(int32_t start, int32_t end, Edn::VectorType<int8_t> &output)
void EdnBuf::GetRange(int32_t start, int32_t end, etk::VectorType<int8_t> &output)
{
// Remove all data ...
output.Clear();
@ -189,7 +189,7 @@ int8_t EdnBuf::operator[] (int32_t pos)
* @return ---
*
*/
void EdnBuf::Insert(int32_t pos, Edn::VectorType<int8_t> &insertText)
void EdnBuf::Insert(int32_t pos, etk::VectorType<int8_t> &insertText)
{
// if pos is not contiguous to existing text, make it
pos = edn_average(0, pos, m_data.Size() );
@ -197,7 +197,7 @@ void EdnBuf::Insert(int32_t pos, Edn::VectorType<int8_t> &insertText)
insert(pos, insertText);
// Call the redisplay ...
Edn::VectorType<int8_t> deletedText;
etk::VectorType<int8_t> deletedText;
eventModification(pos, insertText.Size(), deletedText);
}
@ -212,9 +212,9 @@ void EdnBuf::Insert(int32_t pos, Edn::VectorType<int8_t> &insertText)
* @return ---
*
*/
void EdnBuf::Replace(int32_t start, int32_t end, Edn::VectorType<int8_t> &insertText)
void EdnBuf::Replace(int32_t start, int32_t end, etk::VectorType<int8_t> &insertText)
{
Edn::VectorType<int8_t> deletedText;
etk::VectorType<int8_t> deletedText;
GetRange(start, end, deletedText);
m_data.Replace(start, end-start, insertText);
// update internal elements
@ -234,7 +234,7 @@ void EdnBuf::Replace(int32_t start, int32_t end, Edn::VectorType<int8_t> &insert
void EdnBuf::Remove(int32_t start, int32_t end)
{
Edn::VectorType<int8_t> deletedText;
etk::VectorType<int8_t> deletedText;
// Make sure the arguments make sense
if (start > end) {
int32_t temp = start;
@ -265,7 +265,7 @@ int32_t EdnBuf::Indent(selectionType_te select)
// Get Range :
int32_t l_start = StartOfLine(SelectionStart);
int32_t l_end = EndOfLine(SelectionEnd);
Edn::VectorType<int8_t> l_tmpData;
etk::VectorType<int8_t> l_tmpData;
GetRange(l_start, l_end, l_tmpData);
l_tmpData.Insert(0, '\n');
@ -304,7 +304,7 @@ int32_t EdnBuf::UnIndent(selectionType_te select)
// Get Range :
int32_t l_start = StartOfLine(SelectionStart);
int32_t l_end = EndOfLine(SelectionEnd);
Edn::VectorType<int8_t> l_tmpData;
etk::VectorType<int8_t> l_tmpData;
GetRange(l_start, l_end, l_tmpData);
l_tmpData.Insert(0, '\n');
@ -346,7 +346,7 @@ int32_t EdnBuf::UnIndent(selectionType_te select)
* @return ---
*
*/
void EdnBuf::GetLineText(int32_t pos, Edn::VectorType<int8_t> &text)
void EdnBuf::GetLineText(int32_t pos, etk::VectorType<int8_t> &text)
{
GetRange( StartOfLine(pos), EndOfLine(pos), text);
}
@ -666,9 +666,9 @@ int32_t EdnBuf::CountLines(int32_t startPos, int32_t endPos)
* @return number of line found
*
*/
int32_t EdnBuf::CountLines(Edn::VectorType<int8_t> &data)
int32_t EdnBuf::CountLines(etk::VectorType<int8_t> &data)
{
Edn::VectorType<int8_t>::Iterator myPosIt = data.Begin();
etk::VectorType<int8_t>::Iterator myPosIt = data.Begin();
int32_t lineCount = 0;
while(myPosIt) {
@ -810,7 +810,7 @@ bool EdnBuf::charMatch(char first, char second, bool caseSensitive)
* @return false ==> not found data
*
*/
bool EdnBuf::SearchForward(int32_t startPos, Edn::VectorType<int8_t> &searchVect, int32_t *foundPos, bool caseSensitive)
bool EdnBuf::SearchForward(int32_t startPos, etk::VectorType<int8_t> &searchVect, int32_t *foundPos, bool caseSensitive)
{
int32_t position;
int32_t searchLen = searchVect.Size();
@ -851,7 +851,7 @@ bool EdnBuf::SearchForward(int32_t startPos, Edn::VectorType<int8_t> &searchVect
* @return false ==> not found data
*
*/
bool EdnBuf::SearchBackward(int32_t startPos, Edn::VectorType<int8_t> &searchVect, int32_t *foundPos, bool caseSensitive)
bool EdnBuf::SearchBackward(int32_t startPos, etk::VectorType<int8_t> &searchVect, int32_t *foundPos, bool caseSensitive)
{
int32_t position;
int32_t searchLen = searchVect.Size();
@ -977,7 +977,7 @@ bool EdnBuf::SelectAround(int32_t startPos, int32_t &beginPos, int32_t &endPos)
* @return number of element inserted.
*
*/
int32_t EdnBuf::insert(int32_t pos, Edn::VectorType<int8_t> &insertText)
int32_t EdnBuf::insert(int32_t pos, etk::VectorType<int8_t> &insertText)
{
// Insert data in buffer
m_data.Insert(pos, insertText);
@ -998,7 +998,7 @@ int32_t EdnBuf::insert(int32_t pos, Edn::VectorType<int8_t> &insertText)
* @return ---
*
*/
void EdnBuf::eventModification(int32_t pos, int32_t nInserted, Edn::VectorType<int8_t> &deletedText)
void EdnBuf::eventModification(int32_t pos, int32_t nInserted, etk::VectorType<int8_t> &deletedText)
{
if( 0 == deletedText.Size()
&& 0 == nInserted)

42
jni/edn/tools/EdnBuf/EdnBuf.h
View File

@ -31,10 +31,10 @@
class EdnBuf;
#include "EdnVectorBuf.h"
#include "EdnBufHistory.h"
#include "HighlightManager.h"
#include "charset.h"
#include <EdnVectorBuf.h>
#include <EdnBufHistory.h>
#include <HighlightManager.h>
#include <charset.h>
/*
@ -67,7 +67,7 @@ typedef enum{
typedef struct {
Edn::VectorType<colorInformation_ts> HLData;
etk::VectorType<colorInformation_ts> HLData;
int32_t idSequence;
int32_t posHLPass1;
int32_t posHLPass2;
@ -82,21 +82,21 @@ class EdnBuf {
// destructer
~EdnBuf(void);
// public function :
void GetAll( Edn::VectorType<int8_t> &text);
void SetAll( Edn::VectorType<int8_t> &text);
void GetRange( int32_t start, int32_t end, Edn::VectorType<int8_t> &output);
void GetAll( etk::VectorType<int8_t> &text);
void SetAll( etk::VectorType<int8_t> &text);
void GetRange( int32_t start, int32_t end, etk::VectorType<int8_t> &output);
bool DumpIn( FILE *myFile);
bool DumpFrom( FILE *myFile);
// replace with operator [] ...
int8_t operator[] (int32_t);
void Insert( int32_t pos, Edn::VectorType<int8_t> &insertText);
void Replace( int32_t start, int32_t end, Edn::VectorType<int8_t> &insertText);
void Insert( int32_t pos, etk::VectorType<int8_t> &insertText);
void Replace( int32_t start, int32_t end, etk::VectorType<int8_t> &insertText);
void Remove( int32_t start, int32_t end);
int32_t Indent( selectionType_te select);
int32_t UnIndent( selectionType_te select);
void GetLineText( int32_t pos, Edn::VectorType<int8_t> &text);
void GetLineText( int32_t pos, etk::VectorType<int8_t> &text);
int32_t StartOfLine( int32_t pos);
int32_t EndOfLine( int32_t pos);
@ -107,12 +107,12 @@ class EdnBuf {
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( Edn::VectorType<int8_t> &data);
int32_t CountLines( etk::VectorType<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, Edn::VectorType<int8_t> &searchVect, int32_t *foundPos, bool caseSensitive = true);
bool SearchBackward( int32_t startPos, Edn::VectorType<int8_t> &searchVect, int32_t *foundPos, bool caseSensitive = true);
bool SearchForward( int32_t startPos, etk::VectorType<int8_t> &searchVect, int32_t *foundPos, bool caseSensitive = true);
bool SearchBackward( int32_t startPos, etk::VectorType<int8_t> &searchVect, int32_t *foundPos, bool caseSensitive = true);
bool SearchForward( int32_t startPos, char searchChar, int32_t *foundPos);
bool SearchBackward( int32_t startPos, char searchChar, int32_t *foundPos);
bool SelectAround( int32_t startPos, int32_t &beginPos, int32_t &endPos);
@ -130,9 +130,9 @@ class EdnBuf {
void Unselect( selectionType_te select);
void RectSelect( selectionType_te select, int32_t start, int32_t end, int32_t rectStart, int32_t rectEnd);
bool GetSelectionPos( selectionType_te select, int32_t &start, int32_t &end, bool &isRect, int32_t &rectStart, int32_t &rectEnd);
void GetSelectionText( selectionType_te select, Edn::VectorType<int8_t> &text);
void GetSelectionText( selectionType_te select, etk::VectorType<int8_t> &text);
void RemoveSelected( selectionType_te select);
void ReplaceSelected( selectionType_te select, Edn::VectorType<int8_t> &text);
void ReplaceSelected( selectionType_te select, etk::VectorType<int8_t> &text);
private:
// current selection of the buffer
selection m_selectionList[SELECTION_SIZE]; //!< Selection area of the buffer
@ -148,15 +148,15 @@ class EdnBuf {
private:
bool m_isUndoProcessing;
bool m_isRedoProcessing;
Edn::VectorType<EdnBufHistory*> m_historyUndo;
Edn::VectorType<EdnBufHistory*> m_historyRedo;
etk::VectorType<EdnBufHistory*> m_historyUndo;
etk::VectorType<EdnBufHistory*> m_historyRedo;
// -----------------------------------------
// hightlight section :
// -----------------------------------------
private:
Highlight * m_Highlight; //!< internal link with the Highlight system
Edn::VectorType<colorInformation_ts> m_HLDataPass1; //!< colorisation position in the current buffer pass 1
etk::VectorType<colorInformation_ts> m_HLDataPass1; //!< colorisation position in the current buffer pass 1
int32_t m_HLDataSequence; //!< position of the start of line requested by the screen viewer
void RegenerateHighLightAt(int32_t pos, int32_t nbDeleted, int32_t nbAdded);
void GenerateHighLightAt(int32_t pos, int32_t endPos, int32_t addinPos=0);
@ -201,10 +201,10 @@ class EdnBuf {
void removeSelected( selection &sel);
void replaceSelected( selection &sel, const char *text);
void eventModification( int32_t pos, int32_t nInserted, Edn::VectorType<int8_t> &deletedText);
void eventModification( int32_t pos, int32_t nInserted, etk::VectorType<int8_t> &deletedText);
int32_t insert( int32_t pos, Edn::VectorType<int8_t> &insertText);
int32_t insert( int32_t pos, etk::VectorType<int8_t> &insertText);
bool charMatch( char first, char second, bool caseSensitive = true);
};

12
jni/edn/tools/EdnBuf/EdnBufHistory.cpp
View File

@ -24,9 +24,9 @@
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "EdnBufHistory.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <EdnBufHistory.h>
#undef __class__
@ -39,7 +39,7 @@ EdnBufHistory::EdnBufHistory(void)
m_nInserted = 0;
}
EdnBufHistory::EdnBufHistory(int32_t pos, int32_t nInserted, Edn::VectorType<int8_t> &deletedText)
EdnBufHistory::EdnBufHistory(int32_t pos, int32_t nInserted, etk::VectorType<int8_t> &deletedText)
{
//EDN_INFO("EdnBufHistory new + data");
m_pos = pos;
@ -47,7 +47,7 @@ EdnBufHistory::EdnBufHistory(int32_t pos, int32_t nInserted, Edn::VectorType<int
m_deletedText = deletedText;
}
void EdnBufHistory::Set(int32_t pos, int32_t nInserted, Edn::VectorType<int8_t> &deletedText)
void EdnBufHistory::Set(int32_t pos, int32_t nInserted, etk::VectorType<int8_t> &deletedText)
{
//EDN_INFO("EdnBufHistory new + data");
m_pos = pos;
@ -75,7 +75,7 @@ int32_t EdnBufHistory::getnbInserted(void)
return m_nInserted;
}
void EdnBufHistory::getData(Edn::VectorType<int8_t> &deletedText)
void EdnBufHistory::getData(etk::VectorType<int8_t> &deletedText)
{
deletedText = m_deletedText;
}

10
jni/edn/tools/EdnBuf/EdnBufHistory.h
View File

@ -27,22 +27,22 @@
#define __EDN_BUFFER_HISTORY_H__
#include "VectorType.h"
#include <etk/VectorType.h>
class EdnBufHistory{
public:
EdnBufHistory(void);
EdnBufHistory(int32_t pos, int32_t nInserted, Edn::VectorType<int8_t> &deletedText);
EdnBufHistory(int32_t pos, int32_t nInserted, etk::VectorType<int8_t> &deletedText);
~EdnBufHistory(void);
void Set(int32_t pos, int32_t nInserted, Edn::VectorType<int8_t> &deletedText);
void Set(int32_t pos, int32_t nInserted, etk::VectorType<int8_t> &deletedText);
int32_t getPos(void);
int32_t getnbDeleted(void);
int32_t getnbInserted(void);
void getData(Edn::VectorType<int8_t> &deletedText);
void getData(etk::VectorType<int8_t> &deletedText);
private:
int32_t m_pos;
int32_t m_nInserted;
Edn::VectorType<int8_t> m_deletedText;
etk::VectorType<int8_t> m_deletedText;
};
#endif

32
jni/edn/tools/EdnBuf/EdnBuf_HighLight.cpp
View File

@ -23,9 +23,9 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "EdnBuf.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <EdnBuf.h>
#undef __class__
@ -43,8 +43,8 @@ void EdnBuf::SetHLSystem(Highlight * newHLSystem)
// 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);
//GTimeVal timeStart;
//g_get_current_time(&timeStart);
// remove display HL...
m_HLDataSequence++;
@ -64,7 +64,7 @@ void EdnBuf::RegenerateHighLightAt(int32_t pos, int32_t nbDeleted, int32_t nbAdd
int32_t i;
/*
for (i=0; i< (int32_t)m_HLDataPass1.Size(); i++) {
Edn::String ploppp;
etk::String ploppp;
if (NULL != m_HLDataPass1[i].patern ) {
ploppp = ((HighlightPattern*)m_HLDataPass1[i].patern)->GetName();
}
@ -108,7 +108,7 @@ void EdnBuf::RegenerateHighLightAt(int32_t pos, int32_t nbDeleted, int32_t nbAdd
//EDN_DEBUG("new size=" << (int32_t)m_HLDataPass1.Size()-1);
/*
for (i=0; i< (int32_t)m_HLDataPass1.Size(); i++) {
Edn::String ploppp;
etk::String ploppp;
if (NULL != m_HLDataPass1[i].patern ) {
ploppp = ((HighlightPattern*)m_HLDataPass1[i].patern)->GetName();
}
@ -151,16 +151,16 @@ void EdnBuf::RegenerateHighLightAt(int32_t pos, int32_t nbDeleted, int32_t nbAdd
}
/*
for (i=0; i< (int32_t)m_HLDataPass1.Size(); i++) {
Edn::String ploppp;
etk::String ploppp;
if (NULL != m_HLDataPass1[i].patern ) {
ploppp = ((HighlightPattern*)m_HLDataPass1[i].patern)->GetName();
}
EDN_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);
EDN_DEBUG("HL General = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s");
//GTimeVal timeStop;
//g_get_current_time(&timeStop);
//EDN_DEBUG("HL General = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s");
}
void EdnBuf::FindMainHighLightPosition(int32_t startPos, int32_t endPos, int32_t &startId, int32_t &stopId, bool backPreviousNotEnded)
@ -296,8 +296,8 @@ void EdnBuf::HightlightGenerateLines(displayHLData_ts & MData, int32_t HLStart,
return;
}
if (MData.idSequence != m_HLDataSequence) {
GTimeVal timeStart;
g_get_current_time(&timeStart);
//GTimeVal timeStart;
//g_get_current_time(&timeStart);
MData.idSequence = m_HLDataSequence;
HLStart = StartOfLine(HLStart);
MData.HLData.Clear();
@ -350,9 +350,9 @@ void EdnBuf::HightlightGenerateLines(displayHLData_ts & MData, int32_t HLStart,
}
}
GTimeVal timeStop;
g_get_current_time(&timeStop);
EDN_DEBUG("Display reAnnalyse = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s");
//GTimeVal timeStop;
//g_get_current_time(&timeStop);
//EDN_DEBUG("Display reAnnalyse = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s");
}
}

10
jni/edn/tools/EdnBuf/EdnBuf_History.cpp
View File

@ -23,9 +23,9 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "EdnBuf.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <EdnBuf.h>
#undef __class__
@ -53,7 +53,7 @@ int32_t EdnBuf::Undo(void)
int32_t pos = m_historyUndo[nbElement]->getPos();
int32_t nbDeleted = m_historyUndo[nbElement]->getnbDeleted();
int32_t nbInserted = m_historyUndo[nbElement]->getnbInserted();
Edn::VectorType<int8_t> deletedText;
etk::VectorType<int8_t> deletedText;
m_historyUndo[nbElement]->getData(deletedText);
m_isUndoProcessing = true;
if (0 == nbInserted) {
@ -101,7 +101,7 @@ int32_t EdnBuf::Redo(void)
int32_t pos = m_historyRedo[nbElement]->getPos();
int32_t nbDeleted = m_historyRedo[nbElement]->getnbDeleted();
int32_t nbInserted = m_historyRedo[nbElement]->getnbInserted();
Edn::VectorType<int8_t> deletedText;
etk::VectorType<int8_t> deletedText;
m_historyRedo[nbElement]->getData(deletedText);
m_isRedoProcessing = true;
if (0 == nbInserted) {

10
jni/edn/tools/EdnBuf/EdnBuf_Selection.cpp
View File

@ -23,9 +23,9 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "EdnBuf.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <EdnBuf.h>
#undef __class__
@ -136,7 +136,7 @@ bool EdnBuf::GetSelectionPos(selectionType_te select, int32_t &start, int32_t &e
* @return ---
*
*/
void EdnBuf::GetSelectionText(selectionType_te select, Edn::VectorType<int8_t> &text)
void EdnBuf::GetSelectionText(selectionType_te select, etk::VectorType<int8_t> &text)
{
int32_t start, end, rectStart, rectEnd;
bool isRect;
@ -198,7 +198,7 @@ void EdnBuf::RemoveSelected(selectionType_te select)
* @return ---
*
*/
void EdnBuf::ReplaceSelected(selectionType_te select, Edn::VectorType<int8_t> &text)
void EdnBuf::ReplaceSelected(selectionType_te select, etk::VectorType<int8_t> &text)
{
int32_t start, end, rectStart, rectEnd;
bool isRect;

17
jni/edn/tools/EdnTemplate/EdnVectorBuf.cpp
View File

@ -23,11 +23,10 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "toolsMemory.h"
#include "EdnVectorBuf.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <toolsMemory.h>
#include <EdnVectorBuf.h>
#undef __class__
#define __class__ "EdnEdnVectorBuf"
@ -227,7 +226,7 @@ int8_t& EdnVectorBuf::Get(int32_t pos)
* @return ---
*
*/
void EdnVectorBuf::Get(int32_t pos, int32_t nbElement, Edn::VectorType<int8_t> &tmpBuffer)
void EdnVectorBuf::Get(int32_t pos, int32_t nbElement, etk::VectorType<int8_t> &tmpBuffer)
{
tmpBuffer.Clear();
if (pos < m_gapStart) {
@ -399,7 +398,7 @@ void EdnVectorBuf::Insert(int32_t pos, const int8_t& item)
* @return ---
*
*/
void EdnVectorBuf::Insert(int32_t pos, Edn::VectorType<int8_t>& items)
void EdnVectorBuf::Insert(int32_t pos, etk::VectorType<int8_t>& items)
{
if( pos > Size()
|| pos < 0 ) {
@ -455,7 +454,7 @@ void EdnVectorBuf::Replace(int32_t pos, const int8_t& item)
* @return ---
*
*/
void EdnVectorBuf::Replace(int32_t pos, int32_t nbRemoveElement, Edn::VectorType<int8_t>& items)
void EdnVectorBuf::Replace(int32_t pos, int32_t nbRemoveElement, etk::VectorType<int8_t>& items)
{
if( pos > Size()
|| pos < 0 ) {
@ -652,7 +651,7 @@ void TestEdnVectorBuf(void)
myBufferTmp.Display();
plop='m';
Edn::VectorType<int8_t> items;
etk::VectorType<int8_t> items;
items.PushBack('i');
items.PushBack('j');
items.PushBack('k');

10
jni/edn/tools/EdnTemplate/EdnVectorBuf.h
View File

@ -26,8 +26,8 @@
#ifndef __EDN_VECTOR_BUF_H__
#define __EDN_VECTOR_BUF_H__
#include "toolsMemory.h"
#include "VectorType.h"
#include <toolsMemory.h>
#include <etk/VectorType.h>
#undef __class__
#define __class__ "EdnVectorBuf"
@ -272,14 +272,14 @@ class EdnVectorBuf
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, Edn::VectorType<int8_t> &tmpBuffer);
void Get( int32_t pos, int32_t nbElement, etk::VectorType<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, Edn::VectorType<int8_t>& items);
void Insert( int32_t pos, etk::VectorType<int8_t>& items);
// Remove and insert functions
void Replace( int32_t pos, const int8_t& item);
void Replace( int32_t pos, int32_t nbRemoveElement, Edn::VectorType<int8_t>& items);
void Replace( int32_t pos, int32_t nbRemoveElement, etk::VectorType<int8_t>& items);
// Revove fonctions
void Remove( int32_t pos, int32_t nbRemoveElement = 1);
void PopBack( void);

85
jni/edn/tools/EdnTemplate/Singleton.h
View File

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

8
jni/edn/tools/MsgBroadcast/AccelKey.cpp
View File

@ -23,9 +23,9 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "AccelKey.h"
#include <tools_debug.h>
#include <AccelKey.h>
#if 0
AccelKey::AccelKey(void)
{
m_accelGroup = gtk_accel_group_new();
@ -94,4 +94,4 @@ void AccelKey::LinkCommonAccel(GtkWindow * widget)
gtk_window_add_accel_group(GTK_WINDOW(widget), m_accelGroup);
}
#endif

8
jni/edn/tools/MsgBroadcast/AccelKey.h
View File

@ -26,9 +26,9 @@
#ifndef __ACCEL_KEY_H__
#define __ACCEL_KEY_H__
#include "tools_debug.h"
#include "Singleton.h"
#include <tools_debug.h>
#include <etk/Singleton.h>
/*
// need to create a syngleton ...
class AccelKey: public Singleton<AccelKey>
{
@ -50,7 +50,7 @@ class AccelKey: public Singleton<AccelKey>
private:
GtkAccelGroup * m_accelGroup;
};
*/
#endif

10
jni/edn/tools/MsgBroadcast/MsgBroadcast.cpp
View File

@ -23,9 +23,9 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "MsgBroadcast.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <MsgBroadcast.h>
#undef __class__
#define __class__ "MsgBroadcast"
@ -33,7 +33,7 @@
MsgBroadcast::MsgBroadcast(const char * className, messageCat_te cat)
{
m_messageSystem = MsgBroadcastCore::getInstance();
m_messageSystem = MsgBroadcastCore::Get();
m_className = className;
m_cat = cat;
// add on listner
@ -282,5 +282,5 @@ void MsgBroadcastCore::RmReceiver(MsgBroadcast * pointerOnReceiver)
void GeneralSendMessage(messageType_te id, int32_t dataID)
{
MsgBroadcastCore::getInstance()->SendMessage(NULL, id, dataID);
MsgBroadcastCore::Get()->SendMessage(NULL, id, dataID);
}

22
jni/edn/tools/MsgBroadcast/MsgBroadcast.h
View File

@ -26,9 +26,9 @@
#ifndef __MSG_BROADCAST_H__
#define __MSG_BROADCAST_H__
#include "tools_debug.h"
#include "Edn.h"
#include "Singleton.h"
#include <tools_debug.h>
#include <etk/Singleton.h>
#include <etk/String.h>
@ -163,7 +163,7 @@ class MsgBroadcastCore;
class MsgBroadcast
{
private:
Edn::String m_className;
etk::String m_className;
MsgBroadcastCore * m_messageSystem;
messageCat_te m_cat;
public:
@ -171,7 +171,7 @@ class MsgBroadcast
virtual ~MsgBroadcast(void);
// caul when a message is send
virtual void OnMessage(int32_t id, int32_t dataID);
Edn::String& GetName(void) { return m_className; };
etk::String& GetName(void) { return m_className; };
messageCat_te GetCat(void) { return m_cat; };
protected :
void SendMessage(messageType_te id, int32_t dataID = -1);
@ -186,9 +186,9 @@ typedef struct {
}messageElement_ts;
// need to create a syngleton ...
class MsgBroadcastCore: public Singleton<MsgBroadcastCore>
class MsgBroadcastCore: public etk::Singleton<MsgBroadcastCore>
{
friend class Singleton<MsgBroadcastCore>;
friend class etk::Singleton<MsgBroadcastCore>;
// specific for sigleton system...
private:
// Constructeur
@ -200,17 +200,13 @@ class MsgBroadcastCore: public Singleton<MsgBroadcastCore>
void RmReceiver(MsgBroadcast * pointerOnReceiver);
private:
Edn::VectorType<MsgBroadcast*> m_listMessage;
etk::VectorType<MsgBroadcast*> m_listMessage;
uint32_t m_messageID;
Edn::VectorType<messageElement_ts> m_listOfMessage;
etk::VectorType<messageElement_ts> m_listOfMessage;
};
void GeneralSendMessage(messageType_te id, int32_t dataID = -1);
#endif

36
jni/edn/tools/NameSpaceEdn/Edn.h
View File

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

246
jni/edn/tools/NameSpaceEdn/File.cpp
View File

@ -1,246 +0,0 @@
/**
*******************************************************************************
* @file File.cpp
* @brief Editeur De N'ours : File folder and name abstraction (Sources)
* @author Edouard DUPIN
* @date 16/07/2011
* @par Project
* Edn
*
* @par Copyright
* Copyright 2010 Edouard DUPIN, all right reserved
*
* This software is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY.
*
* Licence summary :
* You can modify and redistribute the sources code and binaries.
* You can send me the bug-fix
* You can not earn money with this Software (if the source extract from Edn
* represent less than 50% of original Sources)
* Term of the licence in in the file licence.txt.
*
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "Edn.h"
#undef __class__
#define __class__ "Edn::File"
std::ostream& Edn::operator <<(std::ostream &os, const Edn::File &obj)
{
os << obj.m_folder;
os << "/";
os << obj.m_shortFilename;
return os;
}
Edn::File::File(Edn::String &filename, int32_t LineNumber)
{
m_lineNumberOpen = LineNumber;
SetCompleateName(filename);
}
Edn::File::File(const char *filename, int32_t LineNumber)
{
Edn::String tmpString = filename;
m_lineNumberOpen = LineNumber;
SetCompleateName(tmpString);
}
Edn::File::File(Edn::String &filename, Edn::String &folder, int32_t lineNumber)
{
Edn::String tmpString = folder;
tmpString += '/';
tmpString += filename;
SetCompleateName(tmpString);
m_lineNumberOpen = lineNumber;
}
Edn::File::~File(void)
{
// nothing to do ...
}
Edn::String Edn::File::GetFolder(void) const
{
return m_folder;
}
Edn::String Edn::File::GetShortFilename(void) const
{
return m_shortFilename;
}
Edn::String Edn::File::GetCompleateName(void) const
{
Edn::String out;
out = m_folder;
out += '/';
out += m_shortFilename;
return out;
}
const Edn::File& Edn::File::operator= (const Edn::File &ednF )
{
if( this != &ednF ) // avoid copy to itself
{
m_folder = ednF.m_folder;
m_shortFilename = ednF.m_shortFilename;
m_lineNumberOpen = ednF.m_lineNumberOpen;
}
return *this;
}
/**
* @brief
*
* @param[in,out]
*
* @return
*
*/
bool Edn::File::operator== (const Edn::File &ednF) const
{
if( this != &ednF ) {
if (ednF.GetCompleateName() == GetCompleateName() ) {
return true;
} else {
return false;
}
return true;
}
return true;
}
/**
* @brief
*
* @param[in,out]
*
* @return
*
*/
bool Edn::File::operator!= (const Edn::File &ednF) const
{
return !(*this == ednF);
}
void Edn::File::SetCompleateName(Edn::String &newFilename)
{
char buf[MAX_FILE_NAME];
memset(buf, 0, MAX_FILE_NAME);
char * ok;
// Reset ALL DATA :
m_folder = "";
m_shortFilename = "";
m_lineNumberOpen = 0;
EDN_DEBUG("1 :Set Name : " << newFilename );
Edn::String destFilename;
if (newFilename.Size() == 0) {
destFilename = "no-name";
} else {
destFilename = newFilename;
}
EDN_DEBUG("2 : Get file Name : " << destFilename );
if ('/' != *destFilename.c_str()) {
// Get the command came from the running of the program :
char cCurrentPath[FILENAME_MAX];
if (!getcwd(cCurrentPath, FILENAME_MAX)) {
return;
}
cCurrentPath[FILENAME_MAX - 1] = '\0';
Edn::String tmpFilename = destFilename;
destFilename = cCurrentPath;
destFilename += '/';
destFilename += tmpFilename;
}
EDN_DEBUG("3 : Get file Name : " << destFilename );
// Get the real Path of the current File
ok = realpath(destFilename.c_str(), buf);
if (!ok) {
int32_t lastPos = destFilename.FindBack('/');
if (-1 != lastPos) {
// Get the FileName
Edn::String tmpFilename = destFilename.Extract(lastPos+1);
destFilename.Remove(lastPos, destFilename.Size() - lastPos);
EDN_DEBUG("try to find :\"" << destFilename << "\" / \"" << tmpFilename << "\" ");
ok = realpath(destFilename.c_str(), buf);
if (!ok) {
EDN_ERROR("Can not find real Path name of \"" << destFilename << "\"");
m_shortFilename = tmpFilename;
m_folder = destFilename;
} else {
// ALL is OK ...
m_shortFilename = tmpFilename;
m_folder = destFilename;
}
} else {
EDN_WARNING("file : \"" << destFilename << "\" ==> No data???");
// Basic ERROR ...
m_shortFilename = destFilename;
}
} else {
destFilename = buf;
int32_t lastPos = destFilename.FindBack('/');
if (-1 != lastPos) {
m_shortFilename = destFilename.Extract(lastPos+1);
m_folder = destFilename.Extract(0, lastPos);
} else {
// Basic ERROR ...
EDN_WARNING("file : \"" << destFilename << "\" ==> No data???");
m_shortFilename = destFilename;
}
}
EDN_DEBUG("Set FileName :\"" << m_folder << "\" / \"" << m_shortFilename << "\" ");
}
int32_t Edn::File::GetLineNumber(void)
{
return m_lineNumberOpen;
}
void Edn::File::SetLineNumber(int32_t newline)
{
m_lineNumberOpen = newline;
}
bool Edn::File::HasExtention(void)
{
int32_t lastPos = m_shortFilename.FindBack('.');
if( -1 != lastPos // not find the .
&& 0 != lastPos // Find a . at the fist position .jdlskjdfklj ==> hiden file
&& m_shortFilename.Size() != lastPos ) // Remove file ended with .
{
return true;
} else {
return false;
}
}
Edn::String Edn::File::GetExtention(void)
{
Edn::String tmpExt = "";
int32_t lastPos = m_shortFilename.FindBack('.');
if( -1 != lastPos // not find the .
&& 0 != lastPos // Find a . at the fist position .jdlskjdfklj ==> hiden file
&& m_shortFilename.Size() != lastPos ) // Remove file ended with .
{
// Get the FileName
tmpExt = m_shortFilename.Extract(lastPos+1);
}
return tmpExt;
}

66
jni/edn/tools/NameSpaceEdn/File.h
View File

@ -1,66 +0,0 @@
/**
*******************************************************************************
* @file File.h
* @brief Editeur De N'ours : File folder and name abstraction (header)
* @author Edouard DUPIN
* @date 16/07/2011
* @par Project
* Edn
*
* @par Copyright
* Copyright 2010 Edouard DUPIN, all right reserved
*
* This software is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY.
*
* Licence summary :
* You can modify and redistribute the sources code and binaries.
* You can send me the bug-fix
* You can not earn money with this Software (if the source extract from Edn
* represent less than 50% of original Sources)
* Term of the licence in in the file licence.txt.
*
*******************************************************************************
*/
#ifndef __EDN__FILE_H__
#define __EDN__FILE_H__
#define MAX_FILE_NAME (10240)
namespace Edn
{
class File
{
public:
File(void) { m_lineNumberOpen=0; }
File(Edn::String &filename, int32_t LineNumber = 0);
File(const char *filename, int32_t LineNumber = 0);
File(Edn::String &filename, Edn::String &folder, int32_t lineNumber = 0);
~File(void);
Edn::String GetFolder(void) const;
Edn::String GetShortFilename(void) const;
Edn::String GetCompleateName(void) const;
bool HasExtention(void);
Edn::String GetExtention(void);
int32_t GetLineNumber(void);
void SetLineNumber(int32_t newline);
void SetCompleateName(Edn::String &newFilename);
const Edn::File& operator= (const Edn::File &ednF );
bool operator== (const Edn::File &ednF ) const;
bool operator!= (const Edn::File &ednF ) const;
friend std::ostream& operator <<( std::ostream &os,const Edn::File &obj);
private :
Edn::String m_folder;
Edn::String m_shortFilename;
int32_t m_lineNumberOpen;
};
std::ostream& operator <<(std::ostream &os, const Edn::File &obj);
}
#endif

488
jni/edn/tools/NameSpaceEdn/RegExp.cpp
View File

@ -1,488 +0,0 @@
/**
*******************************************************************************
* @file RegExp.cpp
* @brief Editeur De N'ours : Regular expression annalyser (sources)
* @author Edouard DUPIN
* @date 04/04/2011
* @par Project
* Edn
*
* @par Copyright
* Copyright 2010 Edouard DUPIN, all right reserved
*
* This software is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY.
*
* Licence summary :
* You can modify and redistribute the sources code and binaries.
* You can send me the bug-fix
* You can not earn money with this Software (if the source extract from Edn
* represent less than 50% of original Sources)
* Term of the licence in in the file licence.txt.
*
*******************************************************************************
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "toolsMemory.h"
#include "RegExp.h"
const convertionTable_ts constConvertionTable[] = {
// haveBackSlash, inputValue, newValue
{ false , '(' , OPCODE_PTHESE_IN},
{ true , '(' , (int16_t)'('},
{ false , ')' , OPCODE_PTHESE_OUT},
{ true , ')' , (int16_t)')'},
{ false , '[' , OPCODE_BRACKET_IN},
{ true , '[' , (int16_t)'['},
{ false , ']' , OPCODE_BRACKET_OUT},
{ true , ']' , (int16_t)']'},
{ false , '{' , OPCODE_BRACE_IN},
{ true , '{' , (int16_t)'{'},
{ false , '}' , OPCODE_BRACE_OUT},
{ true , '}' , (int16_t)'}'},
{ false , '-' , OPCODE_TO},
{ true , '-' , (int16_t)'-'},
{ false , '*' , OPCODE_STAR},
{ true , '*' , (int16_t)'*'},
{ false , '.' , OPCODE_DOT},
{ true , '.' , (int16_t)'.'},
{ false , '?' , OPCODE_QUESTION},
{ true , '?' , (int16_t)'?'},
{ false , '+' , OPCODE_PLUS},
{ true , '+' , (int16_t)'+'},
{ false , '|' , OPCODE_PIPE},
{ true , '|' , (int16_t)'|'},
{ false , '^' , OPCODE_START_OF_LINE},
{ true , '^' , (int16_t)'^'},
{ false , '$' , OPCODE_END_OF_LINE},
{ true , '$' , (int16_t)'$'},
{ true , 'd' , OPCODE_DIGIT},
{ true , 'D' , OPCODE_DIGIT_NOT},
{ true , 'l' , OPCODE_LETTER},
{ true , 'L' , OPCODE_LETTER_NOT},
{ true , 's' , OPCODE_SPACE},
{ true , 'S' , OPCODE_SPACE_NOT},
{ true , 'w' , OPCODE_WORD},
{ true , 'W' , OPCODE_WORD_NOT},
{ true , 'a' , (int16_t)'\a'},
{ true , 'b' , (int16_t)'\b'},
{ true , 'e' , 0x001B}, // Escape character <Esc>
{ true , 'f' , (int16_t)'\f'},
{ true , 'n' , (int16_t)'\n'},
{ true , 'r' , (int16_t)'\r'},
{ true , 't' , (int16_t)'\t'},
{ true , 'v' , (int16_t)'\v'},
{ true , '\\' , (int16_t)'\\'},
{ true , '&' , (int16_t)'&'},
{ true , '0' , (int16_t)'\0'},
{ true , '@' , OPCODE_NO_CHAR},
};
const int32_t constConvertionTableSize = sizeof(constConvertionTable) / sizeof(convertionTable_ts) ;
/**
* @brief Display the internal data of a node
*
* @param[in] data element do display in the console
*
* @return ---
*
*/
void DisplayData(Edn::VectorType<char> &data)
{
int32_t i;
for (i=0; i<(int32_t)data.Size() ; i++) {
std::cout<< (char)(data[i]&0x00FF );
}
}
/**
* @brief Display of a part of the Regexp element
*
* @param[in] data Vector where data is constain
* @param[in] start Position where the display might start
* @param[in] stop Position where the display might stop
*
* @return ---
*
*/
void DisplayElem(Edn::VectorType<int16_t> &data, int32_t start, int32_t stop)
{
int32_t i;
std::cout<< COLOR_NORMAL;
for (i=start; i<(int32_t)data.Size() && i<stop ; i++) {
switch(data[i])
{
case OPCODE_PTHESE_IN: std::cout<<COLOR_RED << (char*)"(" << COLOR_NORMAL; break;
case OPCODE_PTHESE_OUT: std::cout<<COLOR_RED << (char*)")" << COLOR_NORMAL; break;
case OPCODE_BRACKET_IN: std::cout<<COLOR_YELLOW << (char*)"[" << COLOR_NORMAL; break;
case OPCODE_BRACKET_OUT: std::cout<<COLOR_YELLOW << (char*)"]" << COLOR_NORMAL; break;
case OPCODE_TO: std::cout<<COLOR_YELLOW << (char*)"-" << COLOR_NORMAL; break;
case OPCODE_BRACE_IN: std::cout<<COLOR_GREEN << (char*)"{" << COLOR_NORMAL; break;
case OPCODE_BRACE_OUT: std::cout<<COLOR_GREEN << (char*)"}" << COLOR_NORMAL; break;
case OPCODE_STAR: std::cout<<COLOR_BLUE << (char*)"*" << COLOR_NORMAL; break;
case OPCODE_DOT: std::cout<<COLOR_BLUE << (char*)"." << COLOR_NORMAL; break;
case OPCODE_QUESTION: std::cout<<COLOR_BLUE << (char*)"?" << COLOR_NORMAL; break;
case OPCODE_PLUS: std::cout<<COLOR_BLUE << (char*)"+" << COLOR_NORMAL; break;
case OPCODE_PIPE: std::cout<<COLOR_BLUE << (char*)"|" << COLOR_NORMAL; break;
case OPCODE_NO_CHAR: std::cout<<COLOR_MAGENTA << (char*)"@" << COLOR_NORMAL; break;
case OPCODE_START_OF_LINE: std::cout<<COLOR_MAGENTA << (char*)"^" << COLOR_NORMAL; break;
case OPCODE_END_OF_LINE: std::cout<<COLOR_MAGENTA << (char*)"$" << COLOR_NORMAL; break;
case OPCODE_DIGIT: std::cout<<COLOR_MAGENTA << (char*)"\\d" << COLOR_NORMAL; break;
case OPCODE_DIGIT_NOT: std::cout<<COLOR_MAGENTA << (char*)"\\D" << COLOR_NORMAL; break;
case OPCODE_LETTER: std::cout<<COLOR_MAGENTA << (char*)"\\l" << COLOR_NORMAL; break;
case OPCODE_LETTER_NOT: std::cout<<COLOR_MAGENTA << (char*)"\\L" << COLOR_NORMAL; break;
case OPCODE_SPACE: std::cout<<COLOR_MAGENTA << (char*)"\\s" << COLOR_NORMAL; break;
case OPCODE_SPACE_NOT: std::cout<<COLOR_MAGENTA << (char*)"\\S" << COLOR_NORMAL; break;
case OPCODE_WORD: std::cout<<COLOR_MAGENTA << (char*)"\\w" << COLOR_NORMAL; break;
case OPCODE_WORD_NOT: std::cout<<COLOR_MAGENTA << (char*)"\\W" << COLOR_NORMAL; break;
case '\n': std::cout<<COLOR_MAGENTA << (char*)"\\n" << COLOR_NORMAL; break;
case '\t': std::cout<<COLOR_MAGENTA << (char*)"\\t" << COLOR_NORMAL; break;
default: std::cout<< (char)(data[i]&0x00FF ); break;
}
}
}
char * levelSpace(int32_t level)
{
switch(level)
{
case 0: return (char*)"";
case 1: return (char*)" ";
case 2: return (char*)" ";
case 3: return (char*)" ";
case 4: return (char*)" ";
case 5: return (char*)" ";
case 6: return (char*)" ";
case 7: return (char*)" ";
case 8: return (char*)" ";
case 9: return (char*)" ";
case 10: return (char*)" ";
case 11: return (char*)" ";
case 12: return (char*)" ";
case 13: return (char*)" ";
case 14: return (char*)" ";
case 15: return (char*)" ";
case 16: return (char*)" ";
default: return (char*)" ";
}
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
int32_t GetLenOfPTheseElem(Edn::VectorType<int16_t> &data, int32_t startPos)
{
int32_t pos = startPos;
int32_t nbOpen = 0;
// special case of the (...) or | ==> we search '|' or ')'
if( OPCODE_PTHESE_OUT == data[pos]
|| OPCODE_PIPE == data[pos]) {
return 0;
}
// find size ...
while (pos < (int32_t)data.Size() ) {
if(OPCODE_PTHESE_IN == data[pos]) {
// find a sub section :
nbOpen++;
} else if(0 < nbOpen) {
if (OPCODE_PTHESE_OUT == data[pos])
{
nbOpen--;
if (0 > nbOpen) {
EDN_ERROR("Error in the (...) find element at "<< pos);
return -1;
}
}
} else if( OPCODE_PTHESE_OUT == data[pos]
|| OPCODE_PIPE == data[pos])
{
// Find the end of the (...)
// just return the size inside
int32_t sizeInside = pos - startPos;
if (0 >= sizeInside) {
EDN_ERROR("Error in the (...) no data at "<< pos-1);
return -1;
} else {
return sizeInside;
}
}
pos++;
}
return pos - startPos;
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
int32_t GetLenOfPThese(Edn::VectorType<int16_t> &data, int32_t startPos)
{
int32_t pos = startPos;
int32_t nbOpen = 0;
// special case of the (...) or | ==> we search '|' or ')'
if( OPCODE_PTHESE_OUT == data[pos]) {
return 0;
} else if( OPCODE_PTHESE_IN == data[pos])
{
pos++;
// find size ...
while (pos < (int32_t)data.Size() ) {
if(OPCODE_PTHESE_IN == data[pos]) {
// find a sub section :
nbOpen++;
} else if(0 < nbOpen) {
if (OPCODE_PTHESE_OUT == data[pos])
{
nbOpen--;
if (0 > nbOpen) {
EDN_ERROR("Error in the (...) find element at "<< pos);
return -1;
}
}
} else if( OPCODE_PTHESE_OUT == data[pos])
{
// Find the end of the (...)
// just return the size inside
int32_t sizeInside = pos - startPos-1;
if (0 >= sizeInside) {
EDN_ERROR("Error in the (...) no data at "<< pos-1);
return -1;
} else {
return sizeInside;
}
}
pos++;
}
} else {
return -1;
}
return 0;
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
int32_t GetLenOfBracket(Edn::VectorType<int16_t> &data, int32_t startPos)
{
int32_t pos = startPos;
// special case of the (...) or | ==> we search '|' or ')'
if( OPCODE_BRACKET_OUT == data[pos]) {
return 0;
} else if( OPCODE_BRACKET_IN == data[pos]) {
pos++;
// find size ...
while (pos < (int32_t)data.Size() ) {
if(OPCODE_BRACKET_OUT == data[pos]) {
// Find the end of the [...]
// just return the size inside
int32_t sizeInside = pos - startPos -1 ;
if (0 >= sizeInside) {
EDN_ERROR("Error in the [...] no data at "<< pos-1);
return sizeInside;
} else {
return sizeInside;
}
} else if( OPCODE_TO != data[pos]
&& ( 0 > data[pos]
|| 0xFF < data[pos]) )
{
EDN_ERROR("Error in the [...] not permited element at "<< pos << " '" << (char)data[pos] << "'");
return false;
}
pos++;
}
} else {
return -1;
}
return 0;
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
int32_t GetLenOfBrace(Edn::VectorType<int16_t> &data, int32_t startPos)
{
int32_t pos = startPos;
// special case of the (...) or | ==> we search '|' or ')'
if( OPCODE_BRACE_OUT == data[pos]) {
return 0;
} else if( OPCODE_BRACE_IN == data[pos]) {
pos++;
// find size ...
while (pos < (int32_t)data.Size() ) {
if(OPCODE_BRACE_OUT == data[pos]) {
// Find the end of the [...]
// just return the size inside
int32_t sizeInside = pos - startPos -1 ;
if (0 >= sizeInside) {
EDN_ERROR("Error in the {...} no data at "<< pos-1);
return sizeInside;
} else {
return sizeInside;
}
} else if( ',' != data[pos]
&& ( '0' > data[pos]
|| '9' < data[pos]) )
{
EDN_ERROR("Error in the {...} not permited element at "<< pos << " '" << (char)data[pos] << "'");
return false;
}
pos++;
}
} else {
return -1;
}
return 0;
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
int32_t GetLenOfNormal(Edn::VectorType<int16_t> &data, int32_t startPos)
{
int32_t pos = startPos;
// find size ...
while (pos < (int32_t)data.Size() ) {
switch(data[pos])
{
case OPCODE_PTHESE_IN:
case OPCODE_PTHESE_OUT:
case OPCODE_BRACKET_IN:
case OPCODE_BRACKET_OUT:
case OPCODE_BRACE_IN:
case OPCODE_BRACE_OUT:
case OPCODE_TO:
case OPCODE_STAR:
case OPCODE_DOT:
case OPCODE_QUESTION:
case OPCODE_PLUS:
case OPCODE_PIPE:
case OPCODE_START_OF_LINE:
case OPCODE_END_OF_LINE:
case OPCODE_DIGIT:
case OPCODE_DIGIT_NOT:
case OPCODE_LETTER:
case OPCODE_LETTER_NOT:
case OPCODE_SPACE:
case OPCODE_SPACE_NOT:
case OPCODE_WORD:
case OPCODE_WORD_NOT:
{
// just return the size inside
int32_t sizeInside = pos - startPos;
if (0 >= sizeInside) {
EDN_ERROR("Error in the normal data : no data ...");
}
return sizeInside;
}
break;
default :
// nothing to do ...
break;
}
pos++;
}
return pos - startPos ;
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
bool ParseBrace(Edn::VectorType<int16_t> &data, int32_t &min, int32_t &max)
{
//EDN_INFO("parse {...} in "; DisplayElem(data); );
int32_t k=0;
int32_t firstElement = 0;
int32_t SecondElement = 0;
while(k<data.Size()) {
if (',' == (char)data[k]) {
k++;
break;
} if ('}' == (char)data[k]) {
SecondElement = firstElement;
goto allIsSet;
} else if ('0' <= (char)data[k] && '9' >= (char)data[k]) {
firstElement *=10;
firstElement += (char)data[k] - '0';
} else {
EDN_ERROR("Can not parse this element " << (char)data[k] << " at pos " << k);
return false;
}
k++;
}
if (k==data.Size()) {
SecondElement = firstElement;
}
while(k<data.Size()) {
if (',' == (char)data[k]) {
EDN_ERROR("Can not find a second , in {} at pos " << k);
return false;
} if ('}' == (char)data[k]) {
goto allIsSet;
} else if ('0' <= (char)data[k] && '9' >= (char)data[k]) {
SecondElement *=10;
SecondElement += (char)data[k] - '0';
} else {
EDN_ERROR("Can not parse this element " << (char)data[k] << " at pos " << k);
return false;
}
k++;
}
allIsSet:
if (SecondElement == 0 && firstElement != 0) {
min = 0;
max = firstElement;
} else {
min = firstElement;
max = SecondElement;
}
if (min > max) {
EDN_ERROR("Minimum=" << min << " can not be < maximum=" << max );
return false;
}
return true;
}

2113
jni/edn/tools/NameSpaceEdn/RegExp.h
View File

File diff suppressed because it is too large Load Diff

718
jni/edn/tools/NameSpaceEdn/String.cpp
View File

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

92
jni/edn/tools/NameSpaceEdn/String.h
View File

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

506
jni/edn/tools/NameSpaceEdn/Vector.h
View File

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

671
jni/edn/tools/NameSpaceEdn/VectorType.h
View File

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

24
jni/edn/tools/charset/charset.cpp
View File

@ -25,10 +25,10 @@
// cf : http://unicode.org/fr/charts/symbols.html#CombiningDiacriticalMarks
#include "tools_debug.h"
#include "tools_globals.h"
#include "charsetTable.h"
#include "charset.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <charsetTable.h>
#include <charset.h>
// /usr/include/gtk-3.0/gdk/gdkkeysyms.h
@ -101,14 +101,14 @@ void convertUnicodeToIso(charset_te inputCharset, int32_t input_Unicode, char &
}
int32_t convertIsoToUnicode(charset_te inputCharset, Edn::VectorType<char>& input_ISO, Edn::VectorType<int32_t>& output_Unicode)
int32_t convertIsoToUnicode(charset_te inputCharset, etk::VectorType<char>& input_ISO, etk::VectorType<int32_t>& output_Unicode)
{
EDN_WARNING("TODO : not coded...");
return 0;
}
int32_t convertUnicodeToIso(charset_te inputCharset, Edn::VectorType<int32_t>& input_Unicode, Edn::VectorType<char>& output_ISO)
int32_t convertUnicodeToIso(charset_te inputCharset, etk::VectorType<int32_t>& input_Unicode, etk::VectorType<char>& output_ISO)
{
EDN_WARNING("TODO : not coded...");
return 0;
@ -204,14 +204,14 @@ void convertUtf8ToUnicode(char * input_UTF8, int32_t &output_Unicode)
}
int32_t convertUnicodeToUtf8(Edn::VectorType<int32_t>& input_Unicode, Edn::VectorType<char>& output_UTF8)
int32_t convertUnicodeToUtf8(etk::VectorType<int32_t>& input_Unicode, etk::VectorType<char>& output_UTF8)
{
EDN_WARNING("TODO : not coded...");
return 0;
}
int32_t convertUtf8ToUnicode(Edn::VectorType<char>& input_UTF8, Edn::VectorType<int32_t>& output_Unicode)
int32_t convertUtf8ToUnicode(etk::VectorType<char>& input_UTF8, etk::VectorType<int32_t>& output_Unicode)
{
EDN_WARNING("TODO : not coded...");
return 0;
@ -239,14 +239,14 @@ void convertUtf8ToIso(charset_te inputCharset, char * input_UTF8, char & output
}
int32_t convertIsoToUtf8(charset_te inputCharset, Edn::VectorType<char>& input_ISO, Edn::VectorType<char>& output_UTF8)
int32_t convertIsoToUtf8(charset_te inputCharset, etk::VectorType<char>& input_ISO, etk::VectorType<char>& output_UTF8)
{
EDN_WARNING("TODO : not coded...");
return 0;
}
int32_t convertUtf8ToIso(charset_te inputCharset, Edn::VectorType<char>& input_UTF8, Edn::VectorType<char>& output_ISO)
int32_t convertUtf8ToIso(charset_te inputCharset, etk::VectorType<char>& input_UTF8, etk::VectorType<char>& output_ISO)
{
EDN_WARNING("TODO : not coded...");
return 0;
@ -567,7 +567,7 @@ iconv -c --from-code=ISO-8859-15 --to-code=UTF-8 -o fichierUTF8_iso-15 fichierIs
#endif
#if 0
void ConvertInput(GdkEventKey *event, char* Utf8Out, bool &controlKey, bool &moveKey, int32_t &key)
{
@ -1170,3 +1170,5 @@ void ConvertInput(GdkEventKey *event, char* Utf8Out, bool &controlKey, bool &mov
}
}
#endif

28
jni/edn/tools/charset/charset.h
View File

@ -26,7 +26,7 @@
#ifndef __CHARSET_H__
#define __CHARSET_H__
#include "VectorType.h"
#include <etk/VectorType.h>
typedef enum {
EDN_CHARSET_UTF8,
@ -47,20 +47,20 @@ typedef enum {
} charset_te;
// transform ISO <==> Unicode
void convertIsoToUnicode(charset_te inputCharset, char input_ISO, int32_t & output_Unicode);
void convertUnicodeToIso(charset_te inputCharset, int32_t input_Unicode, char & output_ISO);
int32_t convertIsoToUnicode(charset_te inputCharset, Edn::VectorType<char>& input_ISO, Edn::VectorType<int32_t>& output_Unicode);
int32_t convertUnicodeToIso(charset_te inputCharset, Edn::VectorType<int32_t>& input_Unicode, Edn::VectorType<char>& output_ISO);
void convertIsoToUnicode(charset_te inputCharset, char input_ISO, int32_t & output_Unicode);
void convertUnicodeToIso(charset_te inputCharset, int32_t input_Unicode, char & output_ISO);
int32_t convertIsoToUnicode(charset_te inputCharset, etk::VectorType<char>& input_ISO, etk::VectorType<int32_t>& output_Unicode);
int32_t convertUnicodeToIso(charset_te inputCharset, etk::VectorType<int32_t>& input_Unicode, etk::VectorType<char>& output_ISO);
// Transform UTF-8 <==> Unicode
void convertUnicodeToUtf8( int32_t input_Unicode, char * output_UTF8);
void convertUtf8ToUnicode( char * input_UTF8, int32_t& output_Unicode);
int32_t convertUnicodeToUtf8( Edn::VectorType<int32_t>& input_Unicode, Edn::VectorType<char>& output_UTF8);
int32_t convertUtf8ToUnicode( Edn::VectorType<char>& input_UTF8, Edn::VectorType<int32_t>& output_Unicode);
void convertUnicodeToUtf8( int32_t input_Unicode, char * output_UTF8);
void convertUtf8ToUnicode( char * input_UTF8, int32_t& output_Unicode);
int32_t convertUnicodeToUtf8( etk::VectorType<int32_t>& input_Unicode, etk::VectorType<char>& output_UTF8);
int32_t convertUtf8ToUnicode( etk::VectorType<char>& input_UTF8, etk::VectorType<int32_t>& output_Unicode);
// Transform ISO <==> UTF-8
void convertIsoToUtf8( charset_te inputCharset, char input_ISO, char * output_UTF8);
void convertUtf8ToIso( charset_te inputCharset, char * input_UTF8, char & output_ISO);
int32_t convertIsoToUtf8( charset_te inputCharset, Edn::VectorType<char>& input_ISO, Edn::VectorType<char>& output_UTF8);
int32_t convertUtf8ToIso( charset_te inputCharset, Edn::VectorType<char>& input_UTF8, Edn::VectorType<char>& output_ISO);
void convertIsoToUtf8( charset_te inputCharset, char input_ISO, char * output_UTF8);
void convertUtf8ToIso( charset_te inputCharset, char * input_UTF8, char & output_ISO);
int32_t convertIsoToUtf8( charset_te inputCharset, etk::VectorType<char>& input_ISO, etk::VectorType<char>& output_UTF8);
int32_t convertUtf8ToIso( charset_te inputCharset, etk::VectorType<char>& input_UTF8, etk::VectorType<char>& output_ISO);
void Utf8_SizeElement(const char * data, int32_t lenMax , uint8_t &size, bool &baseValid);
int32_t strUtf8Len(const char *input_UTF8);
@ -79,7 +79,7 @@ int32_t strUtf8Len(const char *input_UTF8);
#endif
//# define GDK_Retur (65516)
void ConvertInput(GdkEventKey *event, char* Utf8Out, bool &controlKey, bool &moveKey, int32_t &key);
//void ConvertInput(GdkEventKey *event, char* Utf8Out, bool &controlKey, bool &moveKey, int32_t &key);
void testDisplayConvChar(void);

18
jni/edn/tools/charset/charsetTable.cpp
View File

@ -24,9 +24,9 @@
*/
#include "tools_debug.h"
#include "tools_globals.h"
#include "charsetTable.h"
#include <tools_debug.h>
#include <tools_globals.h>
#include <charsetTable.h>
extern "C" {
@ -296,17 +296,5 @@ extern "C" {
0x000000F0, 0x000000F1, 0x000000F2, 0x000000F3, 0x000000F4, 0x000000F5, 0x000000F6, 0x000000F7, 0x000000F8, 0x000000F9, 0x000000FA, 0x000000FB, 0x000000FC, 0x000000FD, 0x000000FE, 0x000000FF
};
}

37
jni/edn/tools/debug/tools_debug.cpp
View File

@ -23,40 +23,5 @@
*******************************************************************************
*/
#include "tools_debug.h"
#include "time.h"
// Max string size : (wide screan console nb caractere)
#define EDN_LOG_MAX_LENGTH 250
#define FUNCTION_NAME_SIZE (50)
void TOOLS_DisplayFuncName(int32_t ligne, const char* className, const char* funcName)
{
char tmpName[FUNCTION_NAME_SIZE] = "";
if (NULL == className) {
snprintf(tmpName, FUNCTION_NAME_SIZE, "(l=%5d) %s ",ligne, funcName);
} else {
snprintf(tmpName, FUNCTION_NAME_SIZE, "(l=%5d) %s::%s ",ligne, className, funcName);
}
tmpName[FUNCTION_NAME_SIZE-4] = ' ';
tmpName[FUNCTION_NAME_SIZE-3] = '|';
tmpName[FUNCTION_NAME_SIZE-2] = ' ';
tmpName[FUNCTION_NAME_SIZE-1] = '\0';
std::cout << tmpName;
}
void TOOLS_DisplayTime(void)
{
time_t rawtime;
struct tm * timeinfo;
char tmpdata[50];
time ( &rawtime );
timeinfo = localtime ( &rawtime );
sprintf(tmpdata, " %2dh %2dmin %2ds | ", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
std::cout << tmpdata ;
}
const char * ednLog = "edn ";

121
jni/edn/tools/debug/tools_debug.h
View File

@ -26,130 +26,53 @@
#ifndef __TOOLS_DEBUG_H__
#define __TOOLS_DEBUG_H__
#include <iostream>
#include "types_generique.h"
#include <etk/Types.h>
#include <etk/Debug.h>
// Log Message System For EDN
void TOOLS_DisplayFuncName(int32_t ligne, const char* className, const char* funcName);
void TOOLS_DisplayTime(void);
extern const char * ednLog;
//regular colors
#define COLOR_BLACK "\e[0;30m"
#define COLOR_RED "\e[0;31m"
#define COLOR_GREEN "\e[0;32m"
#define COLOR_YELLOW "\e[0;33m"
#define COLOR_BLUE "\e[0;34m"
#define COLOR_MAGENTA "\e[0;35m"
#define COLOR_CYAN "\e[0;36m"
#define COLOR_WHITE "\e[0;37m"
//emphasized (bolded) colors
#define COLOR_BOLD_BLACK "\e[1;30m"
#define COLOR_BOLD_RED "\e[1;31m"
#define COLOR_BOLD_GREEN "\e[1;32m"
#define COLOR_BOLD_YELLOW "\e[1;33m"
#define COLOR_BOLD_BLUE "\e[1;34m"
#define COLOR_BOLD_MAGENTA "\e[1;35m"
#define COLOR_BOLD_CYAN "\e[1;36m"
#define COLOR_BOLD_WHITE "\e[1;37m"
//background colors
#define COLOR_BG_BLACK "\e[40m"
#define COLOR_BG_RED "\e[41m"
#define COLOR_BG_GREEN "\e[42m"
#define COLOR_BG_YELLOW "\e[43m"
#define COLOR_BG_BLUE "\e[44m"
#define COLOR_BG_MAGENTA "\e[45m"
#define COLOR_BG_CYAN "\e[46m"
#define COLOR_BG_WHITE "\e[47m"
// Return to the normal color setings
#define COLOR_NORMAL "\e[0m"
//go to the Top of bash
#define GO_TOP "\e[0;0f"
#undef __class__
#define __class__ (NULL)
/*
#define DEFINE_CLASS_NAME(name) #undef __class__ \
#define __class__ (#name)
at the start of the class :
#undef __class__
#define __class__ ""
*/
#define EDN_DBG_COMMON(color, info, data) do { \
std::cout << color; \
TOOLS_DisplayTime(); \
TOOLS_DisplayFuncName(__LINE__, __class__, __func__); \
std::cout << "[" << info << "] " << data; \
std::cout << COLOR_NORMAL <<std::endl; \
}while(0)
#define EDN_CRITICAL(data) EDN_DBG_COMMON(COLOR_BOLD_RED, "CC", data)
#define EDN_CRITICAL(data) ETK_CRITICAL(ednLog, data)
// General
#if EDN_DEBUG_LEVEL > 0
# define EDN_WARNING(data) EDN_DBG_COMMON(COLOR_MAGENTA, "WW", data)
# define EDN_ERROR(data) EDN_DBG_COMMON(COLOR_BOLD_RED, "EE", data)
# define EDN_WARNING(data) ETK_WARNING(ednLog, data)
# define EDN_ERROR(data) ETK_ERROR(ednLog, data)
#else
# define EDN_WARNING(data) do {}while(0)
# define EDN_ERROR(data) do {}while(0)
# define EDN_WARNING(data) do {}while(0)
# define EDN_ERROR(data) do {}while(0)
#endif
#if EDN_DEBUG_LEVEL > 1
# define EDN_INFO(data) EDN_DBG_COMMON(COLOR_CYAN, "II", data)
# define EDN_INFO(data) ETK_INFO(ednLog, data)
#else
# define EDN_INFO(data) do {}while(0)
# define EDN_INFO(data) do {}while(0)
#endif
#if EDN_DEBUG_LEVEL > 2
# define EDN_DEBUG(data) EDN_DBG_COMMON(COLOR_YELLOW, "DD", data)
# define EDN_DEBUG(data) ETK_DEBUG(ednLog, data)
#else
# define EDN_DEBUG(data) do {}while(0)
# define EDN_DEBUG(data) do {}while(0)
#endif
#if EDN_DEBUG_LEVEL > 0
# define EDN_ASSERT(cond, format, ...) \
do { \
if (!(cond)) { \
EDN_CRITICAL(format, ##__VA_ARGS__); \
assert(!#cond); \
} \
} while (0)
#if EDN_DEBUG_LEVEL > 3
# define EDN_VERBOSE(data) ETK_VERBOSE(ednLog, data)
#else
# define EDN_ASSERT(cond, format, ...) \
do { \
assert(cond); \
} while (0)
# define EDN_VERBOSE(data) do {}while(0)
#endif
#define EDN_TODO(data) DRAW_WARNING("TODO : " << data)
#define EDN_ASSERT(cond, data) ETK_ASSERT(ednLog, cond, data)
#if EDN_DEBUG_LEVEL > 1
# define EDN_CHECK_INOUT(cond) EDN_ASSERT((cond), "Internal input error : "#cond)
# define EDN_CHECK_INOUT(cond) ETK_CHECK_INOUT_ASSERT(ednLog, cond)
#elif EDN_DEBUG_LEVEL > 0
// Critical warning mode
# define EDN_CHECK_INOUT(cond) \
do { \
if (!(cond)) { \
EDN_CRITICAL("Internal input error : "#cond);\
} \
} while (0)
# define EDN_CHECK_INOUT(cond) ETK_CHECK_INOUT_WARNING(ednLog, cond)
#else
// Default : No check
# define EDN_CHECK_INOUT(cond) do { } while (0)
#endif
// Enable or disable the magic element checking...
#if EDN_DEBUG_LEVEL > 0
#define CHECK_MAGIC(cond) EDN_ASSERT((cond), "MAGIC check error : "#cond)
#define EDN_ENABLE_CHECK_MAGIC (1)
#else
#define CHECK_MAGIC(cond) do {}while(0)
# define EDN_CHECK_INOUT(cond) do { } while (0)
#endif
#endif

6
jni/edn/tools/globals/tools_globals.cpp
View File

@ -23,9 +23,9 @@
*******************************************************************************
*/
#include "tools_globals.h"
#include "ColorizeManager.h"
#include "MsgBroadcast.h"
#include <tools_globals.h>
#include <ColorizeManager.h>
#include <MsgBroadcast.h>
#undef __class__
#define __class__ "globals"

4
jni/edn/tools/globals/tools_globals.h
View File

@ -26,7 +26,9 @@
#ifndef __TOOLS_GLOBALS_H__
#define __TOOLS_GLOBALS_H__
#include "tools_debug.h"
#include <tools_debug.h>
#include <types_generique.h>
namespace globals
{

5
jni/edn/tools/memory/toolsMemory.h
View File

@ -1,6 +1,6 @@
/**
*******************************************************************************
* @file toolsmemory.h
* @file toolsMemory.h
* @brief Editeur De N'ours : Memory implementation (headers)
* @author Edouard DUPIN
* @date 12/01/2011
@ -27,9 +27,8 @@
#define __TOOLS_MEMORY_H__
// General
#if EDN_MEMORY_CHECKER > 0
#ifdef EDN_MEMORY_CHECKER
void EDN_MemFree( void * pointerData, const char * variableName, const char * functionName, int32_t line, const char * fileName );
void * EDN_MemMalloc( size_t num, size_t size, uint8_t init, const char * variableName, const char * functionName, int32_t line, const char * fileName );
void EDN_MemShowLogs( void );

116
jni/edn/tools/tinyXML/tinystr.cpp
View File

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

319
jni/edn/tools/tinyXML/tinystr.h
View File

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

1839
jni/edn/tools/tinyXML/tinyxml.cpp
View File

File diff suppressed because it is too large Load Diff

1799
jni/edn/tools/tinyXML/tinyxml.h
View File

File diff suppressed because it is too large Load Diff

52
jni/edn/tools/tinyXML/tinyxmlerror.cpp
View File

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

1635
jni/edn/tools/tinyXML/tinyxmlparser.cpp
View File

File diff suppressed because it is too large Load Diff

58
jni/file.mk Normal file
View File

@ -0,0 +1,58 @@
###############################################################################
### Files Listes ###
###############################################################################
# ExuberantCtags reading file tools (extern OPEN Sources) :
FILE_LIST+= edn/ctags/readtags.cpp \
edn/ctags/CTagsManager.cpp
# Globals debug tool:
FILE_LIST+= edn/tools/debug/tools_debug.cpp \
edn/tools/globals/tools_globals.cpp \
edn/tools/memory/toolsMemory.cpp
# Buffers internal:
FILE_LIST+= edn/tools/EdnTemplate/EdnVectorBuf.cpp \
edn/tools/EdnBuf/EdnBuf.cpp \
edn/tools/EdnBuf/EdnBuf_HighLight.cpp \
edn/tools/EdnBuf/EdnBuf_History.cpp \
edn/tools/EdnBuf/EdnBuf_Selection.cpp \
edn/tools/EdnBuf/EdnBufHistory.cpp
# Tools internal:
FILE_LIST+= edn/tools/Display/Display.cpp \
edn/tools/ClipBoard/ClipBoard.cpp \
edn/tools/MsgBroadcast/MsgBroadcast.cpp \
edn/tools/MsgBroadcast/AccelKey.cpp \
edn/tools/charset/charsetTable.cpp \
edn/tools/charset/charset.cpp
# Gui:
FILE_LIST+= edn/CustumWidget/BufferView/BufferView.cpp \
edn/CustumWidget/CodeView/CodeView.cpp \
edn/GuiTools/WindowsManager/WindowsManager.cpp \
edn/GuiTools/MainWindows/MainWindows.cpp \
edn/GuiTools/MainWindows/StatusBar.cpp \
edn/GuiTools/MainWindows/MenuBar.cpp \
edn/GuiTools/MainWindows/ToolBar.cpp \
edn/GuiTools/Search/Search.cpp \
edn/GuiTools/Search/SearchData.cpp
# Basic Interface :
FILE_LIST+= edn/Buffer/Buffer.cpp \
edn/Buffer/BufferText.cpp \
edn/Buffer/BufferEmpty.cpp \
edn/Buffer/BufferManager.cpp \
edn/Colorize/Colorize.cpp \
edn/Colorize/ColorizeManager.cpp \
edn/Highlight/HighlightPattern.cpp \
edn/Highlight/Highlight.cpp \
edn/Highlight/HighlightManager.cpp
# Main entry file :
FILE_LIST+= edn/init.cpp